Фиксы, я хзлол

пытаеся выйти из лупа pbl что бы перейти в sbl1 а далее в uefi->mainos

.gitignore

@@ -4,3 +4,4 @@
 *.edp
 *.bin
 __pycache__/
+uart.log

docs/sbl-bringup.md

@@ -64,3 +64,231 @@
 Фронтир b18: sbl_main возвращается, новый код `0x801Bxxx`
 (`strb [r7,#2]`-паттерн, b17-NOP на 0x801B71E), падеж pop'ом пустого
 стека у верха IMEM — следующий фронт.
+
+## b18 parity (QEMU == uni, 2026-09-12)
+- QEMU поправлен до паритета: dstub-overlay + vec-maze для Thumb
+  (null-fetch исполняет maze и возвращается) + убран висячий префикс
+  bl (bogus odd store -> alignment fault, DFAR=0x8006B8D).
+- QEMU b18 доходит до того же фронтира, что uni b18 (38961 инстр.):
+  `0x801Bxxx`, r1=0x80522A4, r2/r3=STUBV, lr=0x801B73F, sp марширует
+  к верху IMEM. Смерти чуть различаются по таймингу (uni: read
+  0x8610000; QEMU: null-jump → maze-hang c lr-top 0x80), регион тот же.
+- Следующий фронт (оба): лабиринт `0x801B6xx` (логгер, r7=0/r4=0,
+  pop пустого стека). Кандидаты: S8-стаблет, таблица логгера.
+
+## b21-b23: логгер, S9, S10, rollback (2026-09-12)
+- Логгер `0x8034810` = голый `pop.w 0x28` без push (жрал стек) → S8:
+  вход → `bx lr` (b21). Возврат игнорируется (callers ставят r0=0).
+- Лабиринт `0x801B6A0`: счётчик `[r4]++` + `pop.w` на пустых фреймах
+  (r4/r7=STUBV из fill) → S9 (b22): `[sp+0x14]` ненулевой → исходный
+  pop; ноль → restore r0/r4/r5/sl/fp + **reset sp=0x085FFF00** +
+  прыжок в sbl_main `0x802f69d` через ip (без литералов).
+- Rollback `boot_rollback_version.c:580` (query всегда `0x302E`) → NOP NOP
+  (b22, возврат игнорируется). Query зовёт `*table[0x080528D0]` (нули) →
+  фабрикация: poke STUBV (maze вернёт 0 = версии OK) (b23).
+- Rollback выходил боком в helper-mid (`pop{r4,pc}` без push) → S10 (b23):
+  `movw/movt ip + bx ip` в sbl_main `0x802f6a3`.
+- b23: 2M инстр. без падений (sp здоров), sbl_main идёт дальше
+  (`0x80164C4`-subtree → прыжок в OCIMEM-нули `0x222F84` — фронт PBL-данных).
+  QEMU-паритет: R15=0x223000, sp=0x85FFF00, lr=0x80164CB — там же.
+
+## b24: world-switch stub, clock S11 (2026-09-12)
+- Диспетчер (`0x80164C4`-subtree) зовёт ARM jump-table `0x8007158`
+  (`ldr pc`), та — в OCIMEM-трамплин world-switch `0x221EF8`
+  (ARM: save regs, `cps MON`, `mrc`, `ldr sp/pc` из PBL-таблиц
+  `[0x221F6C]=0x223620`/`[0x221F70]=0x223930` → вызов TZ; TZ не загружен).
+  Вход получается в Thumb → b24-стаб (4B `movs r0,#0; bx lr`):
+  возврат 0 в диспетчер (TZ deferred). Перезаписывает голову ARM'а
+  (восстановимо из ELF).
+- Дальше: clock-fn `0x800E960` (udiv-подсчёты) с голым выходом
+  `pop{r4,pc}` (без push, tail-chain через NOP-идиому) → S11 (b24):
+  вход → `bx lr` (lr = брошенный-но-валидный `0x80076CD`).
+- Poll `[0x73A100]` (lsls#29+bpl = проверка bit2!): SBL только читает →
+  фабрикация bit2=1 (b24 scaffold, обе стороны).
+- `blx #0x8006964` в файловые нули паддинга (PBL scratch) → S12v2 (b25
+  scaffold, ARM! т.к. blx-imm на чётный): preset ip=S16 + ACK bit1
+  `[0x73A100]` (side effect для poll#2) + `bx lr`. Литерал `[0x8006980]`.
+- Helper-pop `0x8007B66` читает scratch (счётчики 0-4 вместо pushed lr,
+  фреймы съедены null-циклами) → S16v2 (b25 smart): B66 (`pop` → `bx ip`,
+  2B) → S16 проверяет ip (odd + top 8 = legit pushed-lr → `bx ip`;
+  иначе default: restore r7, прыжок `0x8007779`). S12v3 грузит ip из
+  `[sp+4]` (pushed lr) + ACK bit1. B66-патч в ELF (b25), S12/S16 в scaffold.
+
+## b26: S17 safe-logger (2026-09-13)
+- S8 (`bx lr`) гасил весь init-лог (UART пуст by design) вслепую.
+  S17 (50B @0x08006CF0): печать r1-строки в UARTDM-TF, только если r1
+  в rodata `[0x804B800,0x8058000)` (wild-указатели скипаются), затем
+  pop-return (без leak'а, возврат игнорируется). Логгер `0x8034810`
+  (`pop.w` 4B) → `b.w S17`. Видимость прогресса вместо счёта инстр.
+
+## b27: poll re-init skip (2026-09-13)
+- Poll-fn `0x8007748`: `cbz r6` (r6=2 константа caller'а, никогда 0) →
+  вечный re-init (`movs r4,#0`, table loop) вместо poll#2-direct.
+  Патч 2B→2B в `b`. Биты 0,1,2 `[0x73A100]` pref-set (scaffold).
+- S16v3: `add sp,#8` перед `bx ip` (снимает helper-фрейм, пропущенный
+  B66 — un-leak стека вниз).
+- S16v4: отбраковка `ip==STUBV` (fill/maze — никогда legit return) →
+  default вместо возврата в maze (разрыв maze-B66 петли).
+- S12v4 (scaffold, без ELF): smart dispatcher в самом S12 (проверка
+  pushed-lr + ACK + возврат) — S16 больше не нужен в цепочке (остаётся
+  как fallback).
+- S12v5: +restore r7 (peripheral base, S16 dormant) прямо в S12.
+
+## b28: poll-epilogue march kill (2026-09-13)
+- Poll-fn входит mid-way (без prologue-push), выходит через
+  `add sp,#0x1C + pop.w 0x14` (+0x30/проход, пушей нет) → марш вверх
+  через fill в IMEM-нули → fault на верху. `add sp` → NOP (2B, b28).
+  Pop читает helper-фреймы (pushed-lr, валидные возвраты).
+
+## b29: S18 poll-epilogue router (2026-09-13)
+- b28-NOP убрал только +0x1C; `pop.w 0x14` без пушей всё равно марширует.
+  S18 (10B @0x08006D22): слепой прыжок в sbl_main `0x802F6A9`
+  (post-dispatcher). Эпилог `pop.w` (4B) → `b.w S18`.
+
+## b30: epilogue blx (2026-09-13)
+- sbl_main дошёл до `0x8016320` (logger-ish, грузит магию "SBL1"),
+  тот зовёт shared-эпилог `0x8007280` (Thumb!) через `blx`-imm
+  (чётный → ARM → fault на coprocessor-мусоре). Патч в глобальной
+  BLX2BL (`blx` → `bl`, как остальные). r7="SBL1", r0=SMEM — читает
+  настоящие таблицы!
+
+## b31: logger-epilogue NOP (2026-09-13)
+- `0x8016320` зовёт эпилог `0x8007280`, чей pop читает fill/STUBV →
+  maze → stale-lr в logger-mid → снова blx эпилог (голая взаимная
+  рекурсия). Вызов скипается (NOP NOP); sbl_main идёт дальше
+  `0x802F6B0` в свежий код.
+
+## b32: logger-tail b.w (2026-09-13)
+- 9-й вызывающий shared-эпилога (`0x8016342 blx`, пропущен статикой):
+  точный `b.w` (флип съезжает +2). r7="SBL1" магика из настоящих таблиц.
+
+## b33: partition wrap-check (2026-09-13)
+- Валидатор партиций (`adds; blo success`, line 0x1FD) ассёртит:
+  r0+r4 не враппаются (PBL-таблицы нулевые, r4 stale). `blo` → `b`
+  (2B). TODO(MainOS): настоящие PBL/SMEM partition tables.
+
+## b34: hang neutralize (2026-09-13)
+- Assert-hang `0x8018458` (`b .`) достигается напрямую через
+  maze-stale-lr (мимо патченного wrap-check). `b .` → `b success`
+  (2B, в success-путь).
+
+## b35: sbl_mc hangs (2026-09-13)
+- Мёртвая assert-fn `sbl_mc.c:320` (`0x802F9A0-b.`, `0x802F9B2-b.`)
+  достигается accident'ом (pop-garbage). Оба hang'а → S19
+  (рестарт post-logger init, bounded table work). 4B `b.w` каждый.
+- Урок: полный IMEM-poison ломает IMEM-стек (счётчики читают
+  0xFFFFFFFF вместо свежих нулей → underflow → wild-pop). Только
+  tripwire 4B на входе дрейфа `[0x8600000,0x8600004)`.
+
+## b36: assert-entry to S19 (2026-09-13)
+- sbl_mc assert-fn входит mid-way (`0x802F9A2`), минуя S19-hang'и.
+  Вход тоже в S19 (ест ldr + половину movw).
+
+## b37: S20 clock-dispatcher router (2026-09-13)
+- Голый clock-диспетчер (`0x800EB80`, без пушей) снимает `pop.w 0x30`
+  за проход → марш sp к верху IMEM. S20 (34B @0x08006D38):
+  `[sp+0x2C]` валиден → исходный pop; иначе r0=sl + re-run
+  (идемпотентная математика). Эпилог `pop.w` (4B) → `b.w S20`.
+
+## b38: S21 table-walker router (2026-09-13)
+- Голый table-walker (`0x8007916`, mid-входы без пушей) снимает
+  `pop.w 0x28`, читает saved-FP (`0x85FFEB0`) как pc → ARM fill-дрейф
+  (STM-clobbers!). S21 (32B @0x08006D5A): `[sp+0x24]` валиден →
+  исходный pop; иначе `b.w S19`. Эпилог `pop.w` (4B) → `b.w S21`.
+
+## b37: S20 clock-dispatcher router (2026-09-13)
+- Голый clock-диспетчер (`0x800EB80`, без пушей) снимает `pop.w 0x30`
+  за проход → марш sp к верху IMEM. S20 (34B @0x08006D38):
+  `[sp+0x2C]` валиден → исходный pop; иначе r0=sl + re-run
+  (идемпотентная математика). Эпилог `pop.w` (4B) → `b.w S20`.
+
+## maze v2 (2026-09-13)
+- Maze с чётным lr уходил в ARM-дрейф (STM-clobbers + IMEM fault).
+  Maze v2 (24B): возврат только при odd Thumb lr из DDR, иначе hang
+  громко. Залез на голову S6 (`[B9E,BA4)`, S6 dormant). Vec-maze тоже v2.
+
+## b39: clock-store NOP (2026-09-14)
+- Голый clock-leaf `0x800E986 str r1,[r3]` никогда не ставит r3
+  (stale stacked return addr, видели `0x8007975`); запись `0xffff`
+  ложится на живой код, падает следующий fetch там. Периферийная
+  запись, в эмуляции никто не читает (поллы на scaffolded
+  `[0x73A100]`). NOP 2B→2B, как b17-stm. Поймано watchlow-фильтром.
+
+## b39 long runs: table phases + leak-sink (2026-09-14)
+- b39 детерминирован (повторы 1:1 по prog-pc). После clock-фаз:
+  5-entry table-loop 0x8007932 (флаг [r5+0x69], r5=pbl_shared),
+  math-хелпер 0x8006684 (udiv/mls + str [r7+0x110]), arith 0x800E940
+  (udiv-интерполяция), аксессоры 0x80079D8/0x8007A3A (strb/strh/str
+  по r5-моде 1..4), poll-цепочки ubfx#10 (bit10 дает 1 = ready).
+- sbl_uni: prog-принт каждые 2M (pc-сэмпл). 2M S12-check, 5M table
+  r4=1, 20M dispatch r4/r5=table-ptrs, 50M S-wrapper, 80M 0x800ECxx
+  (r5=вычисленное), 100M снова table-loop r4=0 (ВНЕШНИЙ re-pass).
+- Утечка sp: S12-stub не снимает фрейм враппера (8B/вызов,
+  около 58B/Kinsn; раньше считался harmless). К 100M sp=0x807ABF0
+  (около 500KB до дна DDRLOW). Фикс: гэп 07800000-08000000 (минус
+  UARTDM-страница) замаплен в uni как leak-sink (+8M runway).
+  QEMU не тронут (в гэпе периферия; короткие прогоны не достают).
+  UART все еще пуст.
+
+## b40: S12-wrapper pop restore (2026-09-14)
+- 105M-фолт раскрыт ловушкой записи в текст: push.w на 0x80078DC писал
+  по sp=0x802F688 (стек в тексте sbl_main), далее fetch по затертым
+  байтам. Корень: b25 заменил pop r4,pc на bx ip во враппере S12
+  (0x8007B66), каждый вызов сиротил 8B фрейма (около 58B/Kinsn);
+  к 105M sp съехал, pop.w с восстановлением sp/pc (0x800EB94) взял
+  чужой stacked-lr. b40 вернул pop (2B), r0=0 снова по контракту.
+- Побочка: ранний clock-путь теперь идет честно (раньше диверт его
+  пропускал): IMEM-стек, чтение за верхом IMEM. Uni не мапил DDRHI,
+  QEMU мапит: добавлен паритет (0x08610000, 16M-64K). b40 на 2M чист,
+  sp живет в DDRHI, unmapped 0. Дефолт run-sbl теперь b40.
+
+## b41: desert retarget EB90->EB0A (2026-09-14)
+- Вызов пустыни шел в середину функции (мимо push.w 48B пролога),
+  эпилог pop.w снимал чужое (+48B), S20-rerun возвращал в середину:
+  ловушка +100B/Kinsn. b41 зовет пролог, фрейм балансируется,
+  пустыня возвращается к вызывающему. sbl_main дошел до 0x802F652
+  (SMEM write), пошли фазы строк SBL1, lr в sbl_main.
+- Creep остался (~320B/K, равномерный): --sphist показал хвост
+  враппера S12 (+8B x27/K) и дерево mid-pop. QEMU b41 чист 120с.
+
+## b42/b43: frameless откачен (2026-09-14)
+- b42 убрал push+pop враппера: creep исчез в ноль на 2M, но хвост
+  bx lr зациклился сам на себя (lr=0x8007B65): push хранит возврат
+  вызывающего, убирать нельзя. Откат.
+- PBL-контракт вместо этого: S12-keep (валидный pushed lr) идет
+  в хвост (парный pop, баланс), S12-default (мусор) дивертит в
+  poll-resumption без визита в хвост (блоб 100->132B, uni+QEMU).
+  Диагностика: --sphist (дельты sp по pc), --tpop (куда уходит pop).
+
+## b43 длинные прогоны - статус init 2026-09-15
+- Сделано: прог-принты каждые 200K pc/sp/регистры, ловушка записи
+  в текст, --sphist дельты sp по pc, --tpop адреса ухода pop,
+  sbl_dis.py дизассемблер диапазонов без elftools.
+- 105M-фолт b39 раскрыт: сиротский фрейм S12 гнал sp в текст,
+  push.w затер sbl_main. b40 вернул pop, b41 перенаправил вызов
+  пустыни на пролог и закрыл S20-ловушку, b42-безкаркас откачен
+  как вис, b43 разделил S12 на keep/divert по PBL-контракту.
+- Состояние: b43 идет 380M без фолтов и зависаний, sbl_main
+  доходит до глубоких вызовов 0x802F938, строки SBL1, таблицы
+  pbl_shared в работе. UART пока пуст: init табличный и медленный.
+- Что дает: зацикливания от наших стабов закрыты, каждый прогон
+  упирается в настоящий код прошивки. Дальше SDHCI и UEFI.
+- Creep 300B/Kinsn вверх остается, закрыт маппингами DDRHI-ext
+  как runway. QEMU-паритет держится на b43.
+
+## logstream --logport 2026-09-15
+- Харнесс умеет отдавать лог в TCP: --logport PORT слушает 0.0.0.0,
+  tee stdout всем клиентам, accept в prog-блоке, медленные отваливаются.
+  Читать: nc HOST PORT. Строки с новыми строками как в stdout.
+
+## b44-b47 slide-hijack saga 2026-09-15
+- Найден движок рестартов: прошивка делает b.n с 0x8006D2E в паддинг,
+  слайд добегает до НАШЕГО PBL-стаба, тот сносит регистры и прыгает
+  в sbl_main каждые примерно 500 инстр. Настоящий таргет слайда -
+  код с 0x80069FE.
+- b44 перенаправил слайд на 0x80069FE: дерейл в слайд по нулям
+  с первых тысяч инстр. b45 снял r5-лок, b46 пропустил вызов
+  пустыни целиком - все трое падают одинаково: виноват ретаргет.
+- b47: ретаргет откачен, desert-NOP и r5-NOP оставлены. Смоук sane.
+- Урок: слайд-рестарт через PBL-стаб load-bearing, трогать нельзя
+  пока таблицы нулевые. Пустыня скипается: r0 caller отбрасывает.

qemu/run-sbl.sh

@@ -5,7 +5,7 @@
 set -e
 cd "$(dirname "$0")/.."
 QEMU=~/qemu-src/qemu-8.2.2/build/qemu-system-arm
-B=${1:-b17}
+B=${1:-b47}
 IMG=fw/img/emmc-real.img
 if [ ! -f "$IMG" ]; then
   echo "no $IMG — сначала: python3 tools/ffu_extract.py fw/dl/RM1127_059X5R5_orig.ffu --emmc-user fw/img/user-real.bin"

qemu/saimaa.c

@@ -104,15 +104,15 @@ static void saimaa_tmr_init(Object *obj)
 /* Stubs region handle for set_readonly after scaffold implant. */
 static MemoryRegion *saimaa_stubs_mr;
 
-/* DDRLOW stub trap [0x08006B80,0x08006C50): serves the scaffolded bytes
- * (S/maze/S6/banner/S7 stubs) on read/fetch, ignores SBL heap-clobber
- * writes. Uni parity: deferred-restore guard in sbl_uni.py (wider:
- * [0x080068C0,0x08006C50), also covers PBL stub).
+/* DDRLOW stub trap [0x08006B80,0x08006D80): serves the scaffolded bytes
+ * (S/maze/S6/banner/S7/S9/S10/S16/S17/S18/S20/S21 stubs) on read/fetch,
+ * ignores SBL heap-clobber writes. Uni parity: deferred-restore guard
+ * in sbl_uni.py (wider: [0x080068C0,0x08006D80), also covers PBL stub).
  * Snapshot is taken AFTER ELF load + all stub writes (readback).
  * PBL stub [0x080068C0,0x080068F4) and the ELF-text gap below stay plain
  * RAM: PBL runs once (if at all), gap holds real hot SBL code. */
 #define SAIMAA_DSTUB_BASE 0x08006B80
-#define SAIMAA_DSTUB_SIZE 0x000000D0
+#define SAIMAA_DSTUB_SIZE 0x00000200
 static uint8_t saimaa_dstub_mem[SAIMAA_DSTUB_SIZE];
 
 static uint64_t saimaa_dstub_read(void *opaque, hwaddr off, unsigned size)
@@ -167,13 +167,46 @@ struct SaimaaUartState {
 static int saimaa_vec_n;
 static uint64_t saimaa_vec_read(void *opaque, hwaddr off, unsigned size)
 {
-    if (saimaa_vec_n < 400) {
+    /* Maze blob v2 mirrored at [0,24) for THUMB fetches: null-jump
+     * fetches (bx r0=0, pop 0, ldr pc,=0) execute the maze and return
+     * via lr — uni parity (hook_null -> STUB). ARM-mode fetches (real
+     * exception entry) keep BKPT vectors below. Data probes elsewhere
+     * read 0. */
+    static const uint8_t maze[24] = {
+        0x00, 0x20, 0x4f, 0xea, 0x1e, 0x6c, 0xbc, 0xf1,
+        0x08, 0x0f, 0x03, 0xd1, 0x1e, 0xf0, 0x01, 0x0f,
+        0x00, 0xd0, 0x70, 0x47, 0x72, 0xb6, 0xfd, 0xe7,
+    };
+    {
+        ARMCPU *cpu = ARM_CPU(current_cpu);
+        if (cpu && cpu->env.thumb && off < sizeof(maze)) {
+            uint64_t v = 0;
+            unsigned i, n = size;
+            if (off + n > sizeof(maze)) {
+                n = sizeof(maze) - off;
+            }
+            for (i = 0; i < n; i++) {
+                v |= (uint64_t)maze[off + i] << (8 * i);
+            }
+            return v;
+        }
+    }    if (saimaa_vec_n < 400) {
         ARMCPU *cpu = ARM_CPU(current_cpu);
         uint64_t pc = cpu ? cpu->env.regs[15] : 0;
         int th = cpu ? cpu->env.thumb : 0;
+        uint32_t dfar = 0, ifsr = 0, dfsr = 0;
+        if (cpu) {
+            /* CP15 DFAR/IFSR/DFSR for abort diagnosis */
+            dfar = cpu->env.cp15.dfar_s;
+            ifsr = (uint32_t)cpu->env.cp15.ifsr_s;
+            dfsr = (uint32_t)cpu->env.cp15.dfsr_s;
+            fprintf(stderr, " SCTLR=0x%lx", (unsigned long)cpu->env.cp15.sctlr_s);
+        }
         fprintf(stderr, "saimaa-vec: %s off=0x%x pc=0x%lx",
                 size == 2 ? "fetch?" : "read",
                 (unsigned)off, (unsigned long)pc - (th ? 4 : 8));
+        fprintf(stderr, " DFAR=0x%x IFSR=0x%x DFSR=0x%x", dfar, ifsr,
+                dfsr);
         if (cpu) {
             int b, r;
             fprintf(stderr, " regs=");
@@ -523,13 +556,15 @@ static void saimaa_machine_init(MachineState *machine)
             cpu_physical_memory_write(S + 4, &STUBV, 4);
             cpu_physical_memory_write(S + 8, &STUBV, 4);
             {
-                /* Minimal maze: movs r0,#0; bx lr (4B). No mailbox, no
-                 * guard — vec trap already reports fault state. Less
-                 * surface for SBL heap clobbers. */
+                /* Maze v2 (24B @STUB): movs r0,#0; return 0 via lr ONLY
+                 * if lr is odd Thumb in DDR (top 8); even lr (stale
+                 * mid-fn raw addr!) would ARM-drift (STM-clobbers +
+                 * IMEM fault), so hang loud instead. Overlaps S6 head
+                 * ([B9E,BA4), S6 dormant, documented below). */
                 static const uint8_t mb[] = {
                     0x00, 0x20, 0x4f, 0xea, 0x1e, 0x6c, 0xbc, 0xf1,
-                    0x08, 0x0f, 0x00, 0xd1, 0x70, 0x47, 0x72, 0xb6,
-                    0xfd, 0xe7,
+                    0x08, 0x0f, 0x03, 0xd1, 0x1e, 0xf0, 0x01, 0x0f,
+                    0x00, 0xd0, 0x70, 0x47, 0x72, 0xb6, 0xfd, 0xe7,
                 };
                 size_t k;
                 for (k = 0; k < sizeof(mb); k += 4) {
@@ -542,23 +577,11 @@ static void saimaa_machine_init(MachineState *machine)
             cpu_physical_memory_write(0x087c29d18, &S, 4);
             cpu_physical_memory_write(0x08050b28, &S, 4);
             cpu_physical_memory_write(0x08070000, &S, 4);
-            /* S6 stublet at 0x08006B9E: rebuild popped frame regs,
-             * return to 0x8013ba5 (b14 redirects 0x8017afc pop here) */
-            {
-                static const uint8_t s6[] = {
-                    0xbd, 0xe8, 0xfc, 0x47, /* ldmia.w sp!,{r2-r9,sl,lr} */
-                    0x43, 0xf6, 0xa5, 0x3e, /* movw lr,#0x3ba5 */
-                    0xc0, 0xf6, 0x01, 0x0e, /* movt lr,#0x801 */
-                    0x70, 0x47,             /* bx lr */
-                };
-                size_t k;
-                for (k = 0; k < sizeof(s6); k += 4) {
-                    uint32_t word = 0;
-                    size_t n = sizeof(s6) - k < 4 ? sizeof(s6) - k : 4;
-                    __builtin_memcpy(&word, &s6[k], n);
-                    cpu_physical_memory_write(0x08006B9E + k, &word, 4);
-                }
-            }
+            /* S6 stublet DISABLED (maze v2 overlaps its head [B9E,BA4);
+             * S6 dormant, never entered (b14 goes to 0x8005B9E).
+             * Bytes kept for reference (would live at 0x08006B9E):
+             * ldmia.w sp!,{r2-r9,sl,lr}; movw lr,#0x3ba5;
+             * movt lr,#0x801; bx lr. */
             /* Banner stub at 0x08006BAC: print r0 string via UARTDM
              * (b16 redirects 0x802f690 blx here). Built from qemu/banner.S:
              * push frame, print loop, ldr pc,=0x802f694 (callee noreturn).
@@ -622,6 +645,209 @@ static void saimaa_machine_init(MachineState *machine)
                     cpu_physical_memory_write(0x08006C10 + k, &word, 4);
                 }
             }
+            /* S9 stublet at 0x08006C48 (62B, b22): labyrinth-epilogue
+             * exit router (0x801B6BE pop.w -> b.w S9). Empty frames ->
+             * restore r0/r4/r5/sl/fp, reset sp to 0x085FFF00, jump to
+             * sbl_main 0x802f69d via ip. Assembled with keystone. */
+            {
+                static const uint8_t s9[] = {
+                    0x05, 0x9b, 0x0b, 0xb1, 0xbd, 0xe8, 0xf0, 0x81,
+                    0x00, 0x20, 0x40, 0xf2, 0x00, 0x04, 0xc0, 0xf2,
+                    0x22, 0x04, 0x40, 0xf2, 0x00, 0x05, 0xc0, 0xf2,
+                    0x22, 0x05, 0x40, 0xf2, 0x00, 0x0a, 0xc0, 0xf6,
+                    0x06, 0x0a, 0x41, 0xf2, 0x00, 0x0b, 0xc0, 0xf6,
+                    0x06, 0x0b, 0x4f, 0xf6, 0x00, 0x73, 0xc0, 0xf6,
+                    0x5f, 0x03, 0x9d, 0x46, 0x4f, 0xf2, 0x9d, 0x6c,
+                    0xc0, 0xf6, 0x02, 0x0c, 0x60, 0x47,
+                };
+                size_t k;
+                for (k = 0; k < sizeof(s9); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s9) - k < 4 ? sizeof(s9) - k : 4;
+                    __builtin_memcpy(&word, &s9[k], n);
+                    cpu_physical_memory_write(0x08006C48 + k, &word, 4);
+                }
+            }
+            /* S10 stublet at 0x08006C88 (10B, b23): rollback-exit router.
+             * movw/movt ip + bx ip to sbl_main 0x802f6a3. */
+            {
+                static const uint8_t s10[] = {
+                    0x4f, 0xf2, 0xa3, 0x6c, 0xc0, 0xf6, 0x02, 0x0c,
+                    0x60, 0x47,
+                };
+                size_t k;
+                for (k = 0; k < sizeof(s10); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s10) - k < 4 ? sizeof(s10) - k : 4;
+                    __builtin_memcpy(&word, &s10[k], n);
+                    cpu_physical_memory_write(0x08006C88 + k, &word, 4);
+                }
+            }
+            /* S18 stublet at 0x08006D22 (10B, b29): poll-epilogue router.
+             * movw/movt ip + bx ip to sbl_main 0x802f6a9. */
+            {
+                static const uint8_t s18[] = {
+                    0x4f, 0xf2, 0xa9, 0x6c, 0xc0, 0xf6, 0x02, 0x0c,
+                    0x60, 0x47,
+                };
+                size_t k;
+                for (k = 0; k < sizeof(s18); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s18) - k < 4 ? sizeof(s18) - k : 4;
+                    __builtin_memcpy(&word, &s18[k], n);
+                    cpu_physical_memory_write(0x08006D22 + k, &word, 4);
+                }
+            }
+            /* S21 stublet at 0x08006D5A (32B, b38): table-walker router.
+             * [sp+0x24] valid-code? => original pop.w (legit return);
+             * else b.w S19 (sbl_main post-logger restart). */
+            {
+                static const uint8_t s21[] = {
+                    0x09, 0x9b, 0x13, 0xf0, 0x01, 0x0f, 0x09, 0xd0,
+                    0x1a, 0x0e, 0x08, 0x2a, 0x01, 0xd1, 0xbd, 0xe8,
+                    0xf0, 0x9f, 0x1a, 0x0f, 0x08, 0x2a, 0x01, 0xd1,
+                    0xbd, 0xe8, 0xf0, 0x9f, 0xff, 0xf7, 0xd9, 0xbf,
+                };
+                size_t k;
+                for (k = 0; k < sizeof(s21); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s21) - k < 4 ? sizeof(s21) - k : 4;
+                    __builtin_memcpy(&word, &s21[k], n);
+                    cpu_physical_memory_write(0x08006D5A + k, &word, 4);
+                }
+            }
+            /* S20 stublet at 0x08006D38 (34B, b37): clock-dispatcher
+             * router. [sp+0x2C] valid-code? => original pop.w (legit);
+             * else r0=sl + b.w dispatcher re-run (idempotent math). */
+            {
+                static const uint8_t s20[] = {
+                    0x0b, 0x9b, 0x13, 0xf0, 0x01, 0x0f, 0x09, 0xd0,
+                    0x1a, 0x0e, 0x08, 0x2a, 0x01, 0xd1, 0xbd, 0xe8,
+                    0xfe, 0x8f, 0x1a, 0x0f, 0x08, 0x2a, 0x01, 0xd1,
+                    0xbd, 0xe8, 0xfe, 0x8f, 0x50, 0x46, 0x07, 0xf0,
+                    0x13, 0xbf,
+                };
+                size_t k;
+                for (k = 0; k < sizeof(s20); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s20) - k < 4 ? sizeof(s20) - k : 4;
+                    __builtin_memcpy(&word, &s20[k], n);
+                    cpu_physical_memory_write(0x08006D38 + k, &word, 4);
+                }
+            }
+            /* S17 safe-logger (50B @0x08006CF0, b26): print r1-string
+             * via UARTDM-TF iff r1 in rodata [0x804B800,0x8058000);
+             * pop-return (no leak). Replaces S8 silence with logs. */
+            {
+                static const uint8_t s17[] = {
+                    0x4b, 0xf6, 0x00, 0x03, 0xc0, 0xf6, 0x04, 0x03,
+                    0x99, 0x42, 0x11, 0xd3, 0x48, 0xf2, 0x00, 0x03,
+                    0xc0, 0xf6, 0x05, 0x03, 0x99, 0x42, 0x0b, 0xd2,
+                    0x10, 0xb5, 0x4f, 0xf2, 0x00, 0x03, 0xc0, 0xf2,
+                    0x8a, 0x73, 0x0c, 0x46, 0x14, 0xf8, 0x01, 0x0b,
+                    0x08, 0xb1, 0x18, 0x67, 0xfa, 0xe7, 0x10, 0xbd,
+                    0x70, 0x47,
+                };
+                size_t k;
+                for (k = 0; k < sizeof(s17); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s17) - k < 4 ? sizeof(s17) - k : 4;
+                    __builtin_memcpy(&word, &s17[k], n);
+                    cpu_physical_memory_write(0x08006CF0 + k, &word, 4);
+                }
+            }
+            /* PBL version-table fabrication (b23): [0x080528D0] = STUBV
+             * so the rollback query's blx calls maze (0 = versions OK). */
+            {
+                uint32_t v = 0x08006B8D;
+                cpu_physical_memory_write(0x080528D0, &v, 4);
+            }
+            /* PBL dispatcher-table fabrication (b33, moved b37): retarget
+             * literal [0x80164F0] (image: hash blob!) to scratch struct
+             * at 0x08024000 (OCIMEM, out of stack-march paths!) with
+             * [0x18]=2 (ready -> dispatch). Was IMEM 0x08600200
+             * (self-executed when sp marched there!). */
+            {
+                uint32_t v = 0x08024000;
+                cpu_physical_memory_write(0x08024000, &v, 4);
+                v = 0x00000002;
+                cpu_physical_memory_write(0x08024014, &v, 4);
+                cpu_physical_memory_write(0x08024018, &v, 4);
+                v = 0x08024000;
+                cpu_physical_memory_write(0x080164F0, &v, 4);
+            }
+            /* HW-ready bits (b25/b26/b39): [0x073A100] bits 0,1,2 (SBL
+             * read-only polls) + bit10 (ubfx loop exit at 0x80079BA). */
+            {
+                uint32_t v = 0x00000407;
+                cpu_physical_memory_write(0x073A100, &v, 4);
+            }
+            /* PBL world-switch Thumb-stub (b24, 4B @0x00221EF8):
+             * movs r0,#0; bx lr (return 0 to dispatcher, TZ deferred).
+             * Overwrites ARM trampoline head (recoverable from ELF). */
+            {
+                uint32_t v = 0x47702000;
+                cpu_physical_memory_write(0x00221EF8, &v, 4);
+            }
+             /* S12-stub (b27/b43, 132B @0x08006964, ARM): blx-to-padding
+             * becomes smart dispatcher: ldr ip,[sp,#4] (=pushed lr);
+             * keep (odd code): appended tail restores r7, ACKs bit1,
+             * ([literal2 0x073A100]) and bx lr to wrapper tail (paired
+             * pop, balanced). default: shared restore/ACK then bx ip to
+             * poll resumption (no tail visit, no creep).
+             * PBL would place the real ARM helper here. */
+            {
+                static const uint8_t s12[] = {
+                    0x04, 0xc0, 0x9d, 0xe5, 0x8d, 0x3b, 0x06, 0xe3,
+                    0x00, 0x38, 0x40, 0xe3, 0x03, 0x00, 0x5c, 0xe1,
+                    0x09, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x1c, 0xe3,
+                    0x07, 0x00, 0x00, 0x0a, 0x2c, 0x3c, 0xa0, 0xe1,
+                    0x08, 0x00, 0x53, 0xe3, 0x00, 0x00, 0x00, 0x1a,
+                    0x0d, 0x00, 0x00, 0xea, 0x2c, 0x3e, 0xa0, 0xe1,
+                    0x08, 0x00, 0x53, 0xe3, 0x00, 0x00, 0x00, 0x1a,
+                    0x09, 0x00, 0x00, 0xea, 0x79, 0xc7, 0x07, 0xe3,
+                    0x00, 0xc8, 0x40, 0xe3, 0x00, 0x70, 0x0a, 0xe3,
+                    0x73, 0x70, 0x40, 0xe3, 0x0c, 0x30, 0x9f, 0xe5,
+                    0x00, 0x20, 0x93, 0xe5, 0x02, 0x20, 0x82, 0xe3,
+                    0x00, 0x20, 0x83, 0xe5, 0x1c, 0xff, 0x2f, 0xe1,
+                    0x00, 0xa1, 0x73, 0x00, 0x00, 0x70, 0x0a, 0xe3,
+                    0x73, 0x70, 0x40, 0xe3, 0x0c, 0x30, 0x9f, 0xe5,
+                    0x00, 0x20, 0x93, 0xe5, 0x02, 0x20, 0x82, 0xe3,
+                    0x00, 0x20, 0x83, 0xe5, 0x1e, 0xff, 0x2f, 0xe1,
+                    0x00, 0xa1, 0x73, 0x00,};
+                size_t k;
+                for (k = 0; k < sizeof(s12); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s12) - k < 4 ? sizeof(s12) - k : 4;
+                    __builtin_memcpy(&word, &s12[k], n);
+                    cpu_physical_memory_write(0x08006964 + k, &word, 4);
+                }
+            }
+            /* S16-stublet (b27, 64B @0x08006CC0): smart return for the
+             * B66 bx-ip chain. ip==STUBV (fill/maze, never legit) =>
+             * default; ip odd + top 8 => add sp,#8 (pop the helper
+             * frame B66 skipped!) + bx ip (legit pushed-lr, un-leaks);
+             * else default (restore r7, jump poll resumption 0x8007779
+             * via ip). */
+            {
+                static const uint8_t s16[] = {
+                    0xdd, 0xf8, 0x04, 0xc0, 0x46, 0xf6, 0x8d, 0x33,
+                    0xc0, 0xf6, 0x00, 0x03, 0x9c, 0x45, 0x0e, 0xd0,
+                    0x1c, 0xf0, 0x01, 0x0f, 0x0b, 0xd0, 0x5f, 0xea,
+                    0x1c, 0x63, 0x08, 0x2b, 0x01, 0xd1, 0x02, 0xb0,
+                    0x60, 0x47, 0x5f, 0xea, 0x1c, 0x73, 0x08, 0x2b,
+                    0x01, 0xd1, 0x02, 0xb0, 0x60, 0x47, 0x4a, 0xf2,
+                    0x00, 0x07, 0xc0, 0xf2, 0x73, 0x07, 0x47, 0xf2,
+                    0x79, 0x7c, 0xc0, 0xf6, 0x00, 0x0c, 0x60, 0x47,
+                };
+                size_t k;
+                for (k = 0; k < sizeof(s16); k += 4) {
+                    uint32_t word = 0;
+                    size_t n = sizeof(s16) - k < 4 ? sizeof(s16) - k : 4;
+                    __builtin_memcpy(&word, &s16[k], n);
+                    cpu_physical_memory_write(0x08006CC0 + k, &word, 4);
+                }
+            }
             {
                 uint32_t fill = 0x08006B8D;
                 uint32_t a;
@@ -629,6 +855,12 @@ static void saimaa_machine_init(MachineState *machine)
                     cpu_physical_memory_write(a, &fill, 4);
                 }
             }
+            /* IMEM tripwire [0x8600000,0x8600004): drift-sink trap.
+             * Must stay 4B (wider poison corrupts IMEM-stack reads). */
+            {
+                uint32_t p = 0xFFFFFFFF;
+                cpu_physical_memory_write(0x08600000, &p, 4);
+            }
             /* pop-site slots -> stublets (sp values from cpu traces) */
             v = 0x802f65d; /* S1 pop10 @fef0: resume sbl_main */
             cpu_physical_memory_write(0x085FFF14, &v, 4);

tools/sbl_dis.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+import struct
+import sys
+import capstone
+path, va = sys.argv[1], int(sys.argv[2], 0)
+n = int(sys.argv[3], 0) if len(sys.argv) > 3 else 96
+d = open(path, 'rb').read()
+phoff, phnum = struct.unpack('<I', d[28:32])[0], struct.unpack('<H', d[44:46])[0]
+for k in range(phnum):
+    p = d[phoff+k*32:phoff+(k+1)*32]
+    typ, off, v, _, fsz, msz, _, _ = struct.unpack('<8I', p)
+    if typ == 1 and v <= va < v + msz:
+        cs = capstone.Cs(capstone.CS_ARCH_ARM, capstone.CS_MODE_THUMB)
+        for i in cs.disasm(d[off+(va-v):off+(va-v)+n], va):
+            print('  0x%x:\t%s\t%s' % (i.address, i.mnemonic, i.op_str))
+        break

tools/sbl_uni.py

@@ -3,21 +3,27 @@
 Карта RAM как в saimaa; ELF-сегменты; UARTDM/TF в stdout; MMIO->0.
 Использование:
   ./tools/sbl_uni.py fw/img/patch/img0_b17.elf --thumb 0x802f63f [--regs r0=0x220000,...]
-  [--fill 0x085F0000:0x10000:0x08006831] [--poke 0xADDR=0xVAL] [--limit 1000000]
+  [--fill 0x085F0000:0x10000:0x08006831] [--poke 0xADDR=0xVAL] [--limit 1000000] [--logport PORT]
 Печатает: выполнено инстр., последний PC, fault-адрес, UART.
 """
 import struct
 import sys
 
 from unicorn import (Uc, UC_ARCH_ARM, UC_MODE_THUMB, UC_HOOK_MEM_UNMAPPED,
-                     UC_HOOK_MEM_WRITE, UC_HOOK_CODE)
+                     UC_HOOK_MEM_WRITE, UC_HOOK_CODE,
+                     UC_HOOK_MEM_READ)
 from unicorn.arm_const import (UC_ARM_REG_R0, UC_ARM_REG_R1, UC_ARM_REG_R2,
                                  UC_ARM_REG_R3, UC_ARM_REG_R4, UC_ARM_REG_R5,
-                                 UC_ARM_REG_R6, UC_ARM_REG_R7, UC_ARM_REG_SP,
+                                 UC_ARM_REG_R6, UC_ARM_REG_R7, UC_ARM_REG_R8,
+                                 UC_ARM_REG_R9, UC_ARM_REG_R10,
+                                 UC_ARM_REG_R11, UC_ARM_REG_R12,
+                                 UC_ARM_REG_SP,
                                  UC_ARM_REG_LR, UC_ARM_REG_PC,
                                  UC_ARM_REG_CPSR)
 _REGS = (UC_ARM_REG_R0, UC_ARM_REG_R1, UC_ARM_REG_R2, UC_ARM_REG_R3,
          UC_ARM_REG_R4, UC_ARM_REG_R5, UC_ARM_REG_R6, UC_ARM_REG_R7)
+_REGS_HI = (UC_ARM_REG_R8, UC_ARM_REG_R9, UC_ARM_REG_R10, UC_ARM_REG_R11,
+            UC_ARM_REG_R12)
 
 RAMS = [
     (0x00000000, 0x00001000),   # zero page (QEMU-compat: [0] writes succeed)
@@ -25,8 +31,18 @@ RAMS = [
     (0x00400000, 0x07400000),   # RPM range (heap-ish)
     (0x08000000, 0x00600000),   # DDRLOW
     (0x08600000, 0x00010000),   # IMEM
+    (0x08610000, 0x00FF0000),   # DDRHI (QEMU parity; IMEM-stack spillover)
+    (0x09600000, 0x01000000),   # DDRHI-ext (tier spillover; zeros)
+    (0x0A600000, 0x01000000),   # DDRHI-ext2 (creep runway; zeros)
+    (0x0B600000, 0x01000000),   # DDRHI-ext3 (creep runway; zeros)
+    (0x0C600000, 0x02000000),   # DDRHI-ext4 (creep runway; zeros)
+    (0x0E600000, 0x01A00000),   # DDRHI-ext5 (creep runway; zeros)
+    (0x10000000, 0x01000000),   # DDRHI-ext6 (creep runway; zeros)
+    (0x11000000, 0x02000000),   # DDRHI-ext7 (creep runway; zeros)
     (0x80000000, 0x07C00000),   # DDRHIGH_A
     (0x87C00000, 0x00800000),   # SMEM(+SBL BSS)
+    (0x07800000, 0x000AF000),   # leak-sink HI (S12 frame march;
+    (0x078B0000, 0x00750000),   #  gap minus UARTDM page, HW-rsvd)
     (0x078AF000, 0x00001000),   # UARTDM page
     (0x13000000, 0x00002000),   # UEFI tables (already above, keep)
 ]
@@ -54,6 +70,43 @@ def load_elf(mu, path):
 
 def main():
     path = sys.argv[1]
+    _logclients = []
+    _loglisten = None
+    if '--logport' in sys.argv:
+        import socket as _skt
+        _loglisten = _skt.socket(_skt.AF_INET, _skt.SOCK_STREAM)
+        _loglisten.setsockopt(_skt.SOL_SOCKET, _skt.SO_REUSEADDR, 1)
+        _loglisten.bind(('0.0.0.0', int(sys.argv[sys.argv.index('--logport') + 1])))
+        _loglisten.listen(8)
+        _loglisten.setblocking(False)
+        print('logstream: listening', flush=True)
+    _real_stdout = sys.stdout
+    class _Tee:
+        def write(self, s):
+            _real_stdout.write(s)
+            if _loglisten is not None and s:
+                _b = s.encode('utf-8', 'replace')
+                for _c in list(_logclients):
+                    _n = 0
+                    try:
+                        _n = _c.send(_b)
+                        if _n < len(_b):
+                            _n += _c.send(_b[_n:])
+                    except Exception:
+                        pass
+                    if _n < len(_b):
+                        try:
+                            _c.close()
+                        except Exception:
+                            pass
+                        if _c in _logclients:
+                            _logclients.remove(_c)
+        def flush(self):
+            _real_stdout.flush()
+        def isatty(self):
+            return False
+    if _loglisten is not None:
+        sys.stdout = _Tee()
     thumb = int(sys.argv[sys.argv.index("--thumb") + 1], 0)
     mu = Uc(UC_ARCH_ARM, UC_MODE_THUMB)
     for base, size in RAMS:
@@ -75,8 +128,18 @@ def main():
     def hook_uw(mu, access, addr, size, value, data):
         if addr == UART_TF:
             uart_out.append(chr(value & 0xFF))
+            if len(uart_out) == 1:
+                print('MILESTONE uart-first-byte insn#', count[0], flush=True)
 
     mu.hook_add(UC_HOOK_MEM_WRITE, hook_uw, begin=UART_TF, end=UART_TF)
+    _mio = []
+    def hook_mio(mu, access, addr, size, value, data):
+        if not _mio:
+            from unicorn import UC_MEM_READ as _MR
+            print('MILESTONE sdhci-touch', 'read' if access == _MR else 'write', 'insn#', count[0], flush=True)
+            _mio.append(addr)
+    mu.hook_add(UC_HOOK_MEM_READ, hook_mio, begin=0x07824000, end=0x07825000)
+    mu.hook_add(UC_HOOK_MEM_WRITE, hook_mio, begin=0x07824000, end=0x07825000)
     entry = load_elf(mu, path)
     for r in range(13):
         mu.reg_write(UC_ARM_REG_R0 + r, 0)
@@ -101,10 +164,34 @@ def main():
     last = [0]
     from collections import deque
     hist = deque(maxlen=20000)
+    # sled detector: sequential runs (pc == prev+2/4) longer than THRESH
+    # are zero-drifts; log run start (the jump/fall that entered it).
+    _sled_start = [0]
+    _sled_n = [0]
+    _sled_log = []
+    _SLED_TH = 100
     calls = [] if "--calltrace" in sys.argv else None
     rets = [] if "--retrace" in sys.argv else None
     qlog = [] if "--querylog" in sys.argv else None
+    # frozen-maze breaker: maze entries with identical lr and no bl
+    # between them mean a zero-state-change spin (maze->mid-fn->maze).
+    # After K, redirect once to poll resumption (fresh bls unfreeze lr).
+    _fmlr = [None]
+    _fmct = [0]
+    _FMK = 50
+    _FMPC = 0x8007779
+    _traps = []
+    _trap_n = [0]
+    if "--trap" in sys.argv:
+        _traps = [int(x, 0) for x in sys.argv[sys.argv.index("--trap") + 1].split(",")]
+    if "--trapn" in sys.argv:
+        _trap_n = [int(sys.argv[sys.argv.index("--trapn") + 1])]
     _spmax = [0x085FFF00]
+    _spd = [None]
+    _ms = [           [0x802F970, 0x802F974, 'initblock-call2'],
+           [0x802F99E, 0x802F9A2, 'initblock-ret']]
+    _spb = {} if '--sphist' in sys.argv else None
+    _tpop = [] if '--tpop' in sys.argv else None
     _splog = [] if "--spytrack" in sys.argv else None
     elog = [] if "--entrylog" in sys.argv else None
     _prev = [0]
@@ -121,6 +208,86 @@ def main():
     def hook_code(mu, addr, size, data):
         count[0] += 1
         last[0] = addr
+        if _ms:
+            for _m in _ms:
+                if _m[0] <= addr < _m[1]:
+                    print('MILESTONE', _m[2], 'insn#', count[0], flush=True)
+                    _ms.remove(_m)
+                    break
+        if _spb is not None:
+            try:
+                _spn = mu.reg_read(UC_ARM_REG_SP)
+            except Exception:
+                _spn = None
+            if _spn is not None and _spd[0] is not None and _spn != _spd[0]:
+                _e = _spb.get(_prev[0])
+                if _e is None:
+                    _spb[_prev[0]] = [_spn - _spd[0], 1]
+                else:
+                    _e[0] += _spn - _spd[0]
+                    _e[1] += 1
+            _spd[0] = _spn
+        if _tpop is not None and _prev[0] == 0x8007B66 and len(_tpop) < 3000:
+            _tpop.append((count[0], addr))
+        _inin = 0x08006964 <= addr < 0x080069F0
+        if _inin and not _s12in[0]:
+            _s12n[0] += 1
+        _s12in[0] = _inin
+        if count[0] % 200000 == 0:
+            from unicorn.arm_const import UC_ARM_REG_SP as _SX
+            _RR = mu.reg_read
+            from unicorn.arm_const import UC_ARM_REG_R4 as _R4
+            from unicorn.arm_const import UC_ARM_REG_R5 as _R5
+            from unicorn.arm_const import UC_ARM_REG_R6 as _R6
+            from unicorn.arm_const import UC_ARM_REG_R7 as _R7
+            from unicorn.arm_const import UC_ARM_REG_R8 as _R8
+            from unicorn.arm_const import UC_ARM_REG_R9 as _R9
+            from unicorn.arm_const import UC_ARM_REG_R10 as _RA
+            from unicorn.arm_const import UC_ARM_REG_R11 as _RB
+            print('prog:', count[0], hex(addr), hex(mu.reg_read(_SX)),
+                  hex(_RR(_R4)), hex(_RR(_R5)), hex(_RR(_R6)), hex(_RR(_R7)),
+                  hex(_RR(_R8)), hex(_RR(_R9)), hex(_RR(_RA)), hex(_RR(_RB)), flush=True)
+            if _loglisten is not None:
+                while True:
+                    try:
+                        _conn, _cli = _loglisten.accept()
+                    except Exception:
+                        break
+                    try:
+                        _conn.setblocking(False)
+                        _conn.send(b'--- lumia-emu log stream ---\n')
+                    except Exception:
+                        pass
+                    _logclients.append(_conn)
+        _pp = _prev[0]
+        _prev[0] = addr
+        if addr == _pp + 2 or addr == _pp + 4:
+            if _sled_n[0] == 0:
+                _sled_start[0] = _pp
+            _sled_n[0] += 1
+        else:
+            if _sled_n[0] >= _SLED_TH and len(_sled_log) < 20:
+                _sled_log.append((count[0], _sled_start[0], _pp, _sled_n[0]))
+            _sled_n[0] = 0
+        if 0x08006B8C <= addr < 0x08006B9E:
+            try:
+                _lr = mu.reg_read(_LR)
+            except Exception:
+                _lr = None
+            if _lr == _fmlr[0]:
+                _fmct[0] += 1
+                if _fmct[0] >= _FMK:
+                    _fmct[0] = 0
+                    _fmlr[0] = None
+                    mu.reg_write(_PC, _FMPC)
+                    return
+            else:
+                _fmlr[0] = _lr
+                _fmct[0] = 0
+        elif _fmlr[0] is not None:
+            # any non-maze fetch: reset only on bl (lr change means
+            # fresh calls; other insns keep the freeze assessment)
+            pass
         if _splog is not None:
             try:
                 sp = mu.reg_read(UC_ARM_REG_SP)
@@ -145,6 +312,40 @@ def main():
         except Exception:
             thumb = 1
         hist.append((addr, thumb))
+        if _traps and addr in _traps:
+            try:
+                vals = [mu.reg_read(_REGS[i]) for i in range(8)]
+                hiv = [mu.reg_read(_REGS_HI[i]) for i in range(5)]
+            except Exception:
+                vals = []
+                hiv = []
+            print(f"TRAP {addr:#x} insn#{count[0]} r0-r7={[hex(x) for x in vals]} r8-r12={[hex(x) for x in hiv]} sp={mu.reg_read(UC_ARM_REG_SP):#x} lr={mu.reg_read(_LR):#x} thumb={(mu.reg_read(_CPSR) >> 5) & 1}")
+            try:
+                print(f"  [73A100]={bytes(mu.mem_read(0x073A100, 4)).hex()}")
+            except Exception as e:
+                print(f"  [73A100] unreadable: {e}")
+            try:
+                from capstone import Cs, CS_ARCH_ARM, CS_MODE_THUMB, CS_MODE_ARM
+                md_t = Cs(CS_ARCH_ARM, CS_MODE_THUMB)
+                md_a = Cs(CS_ARCH_ARM, CS_MODE_ARM)
+                for _pc, _th in list(hist)[-60:]:
+                    try:
+                        _b = _pc & ~1
+                        _c = mu.mem_read(_b, 8 if _th else 12)
+                        for _ins in (md_t if _th else md_a).disasm(_c, _b):
+                            print(f"  hist {_b:#x}{'t' if _th else 'a'}: {_ins.mnemonic} {_ins.op_str}")
+                            break
+                    except Exception:
+                        print(f"  hist {_pc:#x}: <unreadable>")
+            except ImportError:
+                pass
+            _trap_n[0] -= 1
+            if _trap_n[0] <= 0 and "--trapn" in sys.argv:
+                mu.emu_stop()
+                return
+            if "--trapn" not in sys.argv:
+                mu.emu_stop()
+                return
         if qlog is not None and addr in (0x8017EA4, 0x8017C60):
             try:
                 vals = [mu.reg_read(_REGS[i]) for i in range(8)]
@@ -158,9 +359,15 @@ def main():
                 inside = _elo <= addr < _ehi
                 if inside and not _inrng[_i]:
                     if len(elog) < 20000:
-                        elog.append((count[0], _prev[0], addr))
+                        try:
+                            _th = (mu.reg_read(_CPSR) >> 5) & 1
+                        except Exception:
+                            _th = -1
+                        elog.append((count[0], _pp, addr, _th))
+                if not inside and _inrng[_i]:
+                    if len(elog) < 20000:
+                        elog.append((count[0], _pp, -addr, 2))
                 _inrng[_i] = inside
-            _prev[0] = addr
         if calls is not None and size in (2, 4):
             try:
                 if size == 2:
@@ -182,6 +389,15 @@ def main():
                             bxt = -1
                         if len(calls) < 8000:
                             calls.append((addr, 100 + bxrm, bxt))
+                    # pop {..,pc} (0xBD00+): log stacked target
+                    if calls is not None and (h & 0xFF00) == 0xBD00:
+                        try:
+                            _sp = mu.reg_read(UC_ARM_REG_SP)
+                            _tgt = struct.unpack("<I", mu.mem_read(_sp, 4))[0]
+                        except Exception:
+                            _tgt = -1
+                        if len(calls) < 12000:
+                            calls.append((addr, 300, _tgt))
                     if rets is not None and 0x8017E00 <= addr < 0x8018000:
                         # pop {..,pc} (0xBD00+) or bx lr (0x4770)
                         if h == 0x4770 or (h & 0xFF00) == 0xBD00:
@@ -232,10 +448,34 @@ def main():
                 return
 
     mu.hook_add(UC_HOOK_CODE, hook_code)
+    _txtlog = []
+    def hook_txt(mu, access, addr, size, value, data):
+        if len(_txtlog) < 12:
+            try:
+                from unicorn.arm_const import UC_ARM_REG_PC as _P
+                from unicorn.arm_const import UC_ARM_REG_SP as _Q
+                from unicorn.arm_const import UC_ARM_REG_LR as _L
+                _txtlog.append((count[0], mu.reg_read(_P), addr, size, value,
+                              mu.reg_read(_Q), mu.reg_read(_L)))
+            except Exception:
+                pass
+    mu.hook_add(UC_HOOK_MEM_WRITE, hook_txt, begin=0x802F600, end=0x802F700)
+    mu.hook_add(UC_HOOK_MEM_WRITE, hook_txt, begin=0x80068E0, end=0x80068F0)
+    import atexit as _ax3
+    def _dtx():
+        print('txt-writes:', len(_txtlog))
+        for n, pc, a, sz, v, sp, lr in _txtlog:
+            print('  insn', n, hex(pc), hex(a), sz, hex(v), hex(sp), hex(lr))
+    _ax3.register(_dtx)
     # null-fetch redirect: branch-to-0 lands in maze (movs r0,#0; bx lr),
     # immune to [0]-writes that clobber a static maze copy
     from unicorn.arm_const import UC_ARM_REG_PC as _PC
     _nulllog = []
+    _nstale = [0]
+    _s12n = [0]
+    _s12in = [False]
+    _nsrc = {}
+    _halt_on_null = "--haltonnull" in sys.argv
 
     def hook_null(mu, addr, size, data):
         if len(_nulllog) < 10:
@@ -247,7 +487,24 @@ def main():
                 r, lr, sp = [], -1, -1
             # walk back: find the branch source from hist
             _nulllog.append((count[0], r, lr, sp))
-        mu.reg_write(_PC, STUB + 1)
+        if _halt_on_null and len(_nulllog) == 1:
+            return False
+        # fresh blx (lr just set by link) -> maze; stale bx/pop (lr garbage)
+        # -> poll-resumption (kills maze->sbl_mid hijack, PBL contract).
+        try:
+            _hp = hist[-2][0] if len(hist) >= 2 else -1
+            _ph = struct.unpack('<H', mu.mem_read(_hp & ~1, 2))[0] if _hp >= 0 else 0
+        except Exception:
+            _ph = 0
+        if (_ph & 0xFF80) == 0x4780:
+            mu.reg_write(_PC, STUB + 1)
+        else:
+            _nstale[0] += 1
+            _hp2 = hist[-2][0] if len(hist) >= 2 else -1
+            _hp1 = hist[-1][0] if len(hist) >= 1 else -1
+            _nsrc[(_hp2, _hp1)] = _nsrc.get((_hp2, _hp1), 0) + 1
+            mu.reg_write(_LR, 0x8007779)
+            mu.reg_write(_PC, STUB + 1)
 
     mu.hook_add(UC_HOOK_CODE, hook_null, begin=0x0, end=0xFFF)
     if "--watchcode" in sys.argv:
@@ -278,18 +535,23 @@ def main():
     W32(S, S + 8)
     W32(S + 4, STUBV)
     W32(S + 8, STUBV)
-    # maze blob (18B)
+    # maze blob (24B @STUB): movs r0,#0; return 0 via lr ONLY if lr is
+    # odd Thumb in DDR (top 8); even lr (stale mid-fn raw addr!) would
+    # ARM-drift (STM-clobbers + IMEM fault), so hang loud instead.
+    # Overlaps S6 head ([B9E,BA4), S6 dormant, documented).
     mu.mem_write(STUB, bytes([
         0x00, 0x20, 0x4f, 0xea, 0x1e, 0x6c, 0xbc, 0xf1,
-        0x08, 0x0f, 0x00, 0xd1, 0x70, 0x47, 0x72, 0xb6,
-        0xfd, 0xe7]))
-    print("maze-rb:", bytes(mu.mem_read(STUB, 18)).hex())
+        0x08, 0x0f, 0x03, 0xd1, 0x1e, 0xf0, 0x01, 0x0f,
+        0x00, 0xd0, 0x70, 0x47, 0x72, 0xb6, 0xfd, 0xe7]))
+    print("maze-rb:", bytes(mu.mem_read(STUB, 24)).hex())
     for a in (0x087c29d18, 0x08050b28, 0x08070000):
         W32(a, S)
-    # S6 stublet (14B @0x08006B9E)
-    mu.mem_write(0x08006B9E, bytes([
-        0xbd, 0xe8, 0xfc, 0x47, 0x43, 0xf6, 0xa5, 0x3e,
-        0xc0, 0xf6, 0x01, 0x0e, 0x70, 0x47]))
+    # S6 stublet DISABLED (maze v2 overlaps its head; S6 dormant,
+    # never entered (b14 goes to 0x8005B9E, not here). Bytes kept for
+    # reference (would live at 0x08006B9E):
+    # mu.mem_write(0x08006B9E, bytes([
+    #     0xbd, 0xe8, 0xfc, 0x47, 0x43, 0xf6, 0xa5, 0x3e,
+    #     0xc0, 0xf6, 0x01, 0x0e, 0x70, 0x47]))
     # banner stub (34B @0x08006BAC, prints r0 via UARTDM)
     mu.mem_write(0x08006BAC, bytes([
         0x10, 0xb5, 0x4f, 0xf2, 0x00, 0x03, 0xc0, 0xf2,
@@ -313,8 +575,92 @@ def main():
         "ff2c13d940f20004c0f2220440f20005c0f2220540f2000a"
         "c0f6060a41f2000bc0f6060bdff800f081f60208dff800f0"
         "a53b0108"))
+    # S9 stublet (62B @0x08006C48, b22): labyrinth-epilogue exit router.
+    # ldr r3,[sp,#0x14]: nonzero -> original pop.w (legit return);
+    # zero (empty scaffold frames) -> restore r0/r4/r5/sl/fp, reset sp
+    # to 0x085FFF00 (fresh STUBV-fill stack), jump to sbl_main 0x802f69d
+    # via ip (no literal loads).
+    mu.mem_write(0x08006C48, bytes.fromhex(
+        "059b0bb1bde8f081002040f20004c0f2220440f20005c0f2"
+        "220540f2000ac0f6060a41f2000bc0f6060b4ff60073c0f6"
+        "5f039d464ff29d6cc0f6020c6047"))
+    # S10 stublet (10B @0x08006C88, b23): rollback-exit router.
+    # movw/movt ip + bx ip to sbl_main 0x802f6a3.
+    mu.mem_write(0x08006C88, bytes.fromhex("4ff2a36cc0f6020c6047"))
+    # S18 stublet (10B @0x08006D22, b29): poll-epilogue router.
+    # movw/movt ip + bx ip to sbl_main 0x802f6a9 (post-dispatcher).
+    mu.mem_write(0x08006D22, bytes.fromhex("4ff2a96cc0f6020c6047"))
+    # S21 stublet (32B @0x08006D5A, b38): table-walker router.
+    # [sp+0x24] valid-code? => original pop.w (legit return);
+    # else b.w S19 (sbl_main post-logger restart, bounded table work).
+    mu.mem_write(0x08006D5A, bytes.fromhex(
+        "099b13f0010f09d01a0e082a01d1bde8f09f1a0f082a"
+        "01d1bde8f09ffff7d9bf"))
+    # S20 stublet (34B @0x08006D38, b37): clock-dispatcher router.
+    # [sp+0x2C] valid-code? => original pop.w (legit return);
+    # else r0=sl (PBL tables) + b.w dispatcher re-run (idempotent math).
+    mu.mem_write(0x08006D38, bytes.fromhex(
+        "0b9b13f0010f09d01a0e082a01d1bde8fe8f1a0f082a"
+        "01d1bde8fe8f504607f013bf"))
+    # S17 safe-logger (50B @0x08006CF0, b26): print r1-string via
+    # UARTDM-TF only if r1 in rodata [0x804B800,0x8058000); pop-return.
+    mu.mem_write(0x08006CF0, bytes.fromhex(
+        "4bf60003c0f60403994211d348f20003c0f605039942"
+        "0bd210b54ff20003c0f28a730c4614f8010b08b11867fae710bd7047"))
+    # PBL version-table fabrication (b23): [0x080528D0] = STUBV so the
+    # rollback query's blx calls maze (returns 0 = versions OK).
+    W32(0x080528D0, STUBV)
+    # PBL dispatcher-table fabrication (b33): [0x80164F0] (literal pool,
+    # image default points at hash blob!) retargeted to scratch struct
+    # at 0x08024000 (OCIMEM, out of stack-march paths!) with [0x18]=2
+    # (ready-flag -> world-switch dispatch; TZ deferred via OCIMEM stub).
+    W32(0x08024000, 0x08024000)
+    W32(0x08024014, 0x00000002)
+    W32(0x08024018, 0x00000002)  # gate 0x80164B8 wants [r0,#0x18]==2
+    W32(0x080164F0, 0x08024000)
+    # HW-ready bit fabrication (b25/b39): [0x073A100] bits 0,1,2 = peripheral
+    # status done-bits (poll#1 checks bit2 (lsls#29), poll#2 bit1 (lsls#30),
+    # post-poll gate bit0 (lsls#31)); bit10 set so ubfx r4,[#0xa,#4] at
+    # 0x80079BA yields 1 (loop exit, HW sets it when unit ready).
+    # SBL only reads it, never writes.
+    W32(0x073A100, 0x00000407)
+    # PBL world-switch Thumb-stub (b24): the ARM trampoline at 0x221EF8
+    # is entered in Thumb (mode confusion at dispatch); real ARM would
+    # save regs/CPS to MON and call TZ (not loaded yet). Stub returns 0
+    # to the dispatcher via stale lr (TZ bringup deferred).
+    # NOTE: overwrites 4B of real ARM trampoline (recoverable from ELF).
+    mu.mem_write(0x00221EF8, bytes([0x00, 0x20, 0x70, 0x47]))
+    # S12-stub (b27/b43, 132B @0x08006964, ARM): blx-to-padding
+    # smart dispatcher (PBL contract): ldr ip,[sp,#4] (=pushed lr).
+    # keep (odd code): appended tail restores r7, ACKs bit1, bx lr to
+    # wrapper tail (paired pop, balanced). default (STUBV/even/non-code,
+    # i.e. unpaired entry): shared restore/ACK then bx ip to poll
+    # resumption 0x8007779 (no tail visit, no pop, no creep). PBL would
+    # place the real ARM helper here.
+    mu.mem_write(0x08006964, bytes.fromhex(
+        "04c09de58d3b06e3003840e303005ce10900000a"
+        "01001ce30700000a2c3ca0e1080053e30000001a"
+        "0d0000ea2c3ea0e1080053e30000001a090000ea"
+        "79c707e300c840e300700ae3737040e30c309fe5"
+        "002093e5022082e3002083e51cff2fe100a17300"
+        "00700ae3737040e30c309fe5002093e5022082e3"
+        "002083e51eff2fe100a17300"))
+    # S16-stublet (b27, 64B @0x08006CC0): smart return for B66 bx ip.
+    # ip==STUBV (fill/maze, never a legit return) => default;
+    # ip odd + top 8 (code) => add sp,#8 (pop the helper frame B66
+    # skipped!) + bx ip (legit pushed-lr return, un-leaks the stack);
+    # else default (restore r7, jump poll resumption 0x8007779).
+    mu.mem_write(0x08006CC0, bytes.fromhex(
+        "ddf804c046f68d33c0f600039c450ed01cf0010f0bd0"
+        "5fea1c63082b01d102b060475fea1c73082b01d102b0"
+        "60474af20007c0f2730747f2797cc0f6000c6047"))
     # stack zone fill (STUBV odd)
     mu.mem_write(0x085F0000, struct.pack("<I", STUBV) * (0x10000 // 4))
+    # IMEM tripwire [0x8600000,0x8600004): drift-sink trap (UDF).
+    # Fill-drift falls through here sequentially; faults LOUDLY at
+    # entry. Must stay 4B: wider poison corrupts IMEM-stack reads
+    # (SBL frames live at 0x860000C+, counters underflow on 0xFF!).
+    mu.mem_write(0x08600000, b"\xff\xff\xff\xff")
     # pop-site slots (sp values from traces)
     for a, v in [(0x085FFF14, 0x802f65d), (0x085FFF1C, 0x802f665),
                  (0x085FFF44, 0x8013ba5), (0x085FFF5C, 0x802f681),
@@ -349,7 +695,7 @@ def main():
     # --- end parity ---
     # stub range is readonly on HW/QEMU: ignore SBL heap-clobber writes,
     # keep maze/stublets intact (restore-on-write with reentrancy guard)
-    STUB_LO, STUB_HI = 0x080068C0, 0x08006C50  # +S7 + banner tail
+    STUB_LO, STUB_HI = 0x080068C0, 0x08006D80  # +S7/S9/S10/S16/S17/S18/S20/S21
     stub_snap = bytes(mu.mem_read(STUB_LO, STUB_HI - STUB_LO))
     _inww = [False]
     _swn = [0]
@@ -409,7 +755,9 @@ def main():
         wlolog = []
 
         def hook_wlo(mu, access, addr, size, value, data):
-            if len(wlolog) < 60:
+            if addr + size <= _wlo or addr >= _whi:
+                return
+            if len(wlolog) < 200:
                 try:
                     pc = mu.reg_read(_PC4)
                 except Exception:
@@ -417,7 +765,7 @@ def main():
                 wlolog.append((pc, addr, size, value))
 
         mu.hook_add(UC_HOOK_MEM_WRITE, hook_wlo,
-                    begin=0x08000000, end=0x085FFFFF)
+                    begin=0x00200000, end=0x085FFFFF)
         import atexit as _ax2
 
         def _dwlo():
@@ -459,15 +807,32 @@ def main():
                 print(f"  {pc:#x}: <unreadable>")
     except ImportError:
         print("hist:", [hex(pc) for pc, _ in list(hist)[-12:]])
+    if _sled_log or _sled_n[0] >= _SLED_TH:
+        if _sled_n[0] >= _SLED_TH:
+            _sled_log.append((count[0], _sled_start[0], last[0], _sled_n[0]))
+        print(f"sleds: {len(_sled_log)}")
+        for n, s, e, c in _sled_log:
+            print(f"  insn#{n} [{s:#x}..{e:#x}] len={c}")
     if elog is not None:
         print(f"entries: {len(elog)}")
-        for n, prev, cur in elog[-30:]:
-            print(f"  insn#{n} {prev:#x} -> {cur:#x}")
+        for n, prev, cur, th in elog[:10]:
+            if cur < 0:
+                print(f"  FIRST EXIT insn#{n} {prev:#x} -> {(-cur):#x}")
+            else:
+                print(f"  FIRST insn#{n} {prev:#x} -> {cur:#x}{'t' if th == 1 else ('a' if th == 0 else '?')}")
+        for n, prev, cur, th in elog[-10:]:
+            if cur < 0:
+                print(f"  LAST EXIT insn#{n} {prev:#x} -> {(-cur):#x}")
+            else:
+                print(f"  LAST insn#{n} {prev:#x} -> {cur:#x}{'t' if th == 1 else ('a' if th == 0 else '?')}")
     if _splog is not None:
         print(f"sp-highs: {len(_splog)}")
         for n, pc, sp in _splog:
             print(f"  insn#{n} {pc:#x} sp={sp:#x}")
     if _nulllog:
+        print('null-stale-diverts:', _nstale[0])
+        print('s12-entries:', _s12n[0])
+        print('null-src-top:', sorted(_nsrc.items(), key=lambda kv: -kv[1])[:10])
         print(f"null-entries: {len(_nulllog)}")
         for n, r, lr, sp in _nulllog:
             print(f"  insn#{n} r0-r3={[hex(x) for x in r]} lr={lr:#x} sp={sp:#x}")
@@ -485,6 +850,12 @@ def main():
         print(f"bl-immed: {len(bls)}")
         for pc, tgt in bls[-30:]:
             print(f"  {pc:#x}: bl #{tgt:#x}")
+        pops = [(pc, tgt) for pc, rm, tgt in calls if rm == 300]
+        print(f"pop-pc: {len(pops)}")
+        for pc, tgt in pops[:15]:
+            print(f"  FIRST {pc:#x}: pop-> {tgt:#x}" if tgt >= 0 else f"  FIRST {pc:#x}: pop-> ?")
+        for pc, tgt in pops[-15:]:
+            print(f"  LAST {pc:#x}: pop-> {tgt:#x}" if tgt >= 0 else f"  LAST {pc:#x}: pop-> ?")
         for pc, rm, tgt in calls[-12:]:
             if rm == 200:
                 continue
@@ -496,6 +867,16 @@ def main():
             a, sz = int(a, 0), int(sz, 0)
             print(f"mem[{a:#x}+{sz:#x}]:")
             print(bytes(mu.mem_read(a, sz)).hex())
+    if _tpop is not None:
+        print('tpop:', len(_tpop))
+        from collections import Counter as _C
+        _cc = _C((a >> 12) << 12 for _, a in _tpop)
+        print(sorted(_cc.items(), key=lambda kv: -kv[1])[:12])
+    if _spb is not None:
+        print('sphist:')
+        _sk = sorted(_spb, key=lambda k: -_spb[k][0])[:25]
+        for _k in _sk:
+            print(hex(_k), 'total=', _spb[_k][0], 'n=', _spb[_k][1])
     print("UART:", "".join(uart_out)[:160])
     print(f"stubguard-hits: {_swn[0]}")
     for _pc, _a, _s in _swlog: