summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 13:26:44 -0300
committerGabriel Schneider <[email protected]>2026-11-11 13:26:54 -0300
commit5941372c6c153ad595236193e61ea027a40a9950 (patch)
tree969bd50e4060341180f31e8c3c2e384088acf488
parent2f27fbe0aa2da0f85d599c1e5f3ac14d025f590c (diff)
downloadcomputeranim-5941372c6c153ad595236193e61ea027a40a9950.tar.gz
computeranim-5941372c6c153ad595236193e61ea027a40a9950.zip
design: the return address overwritten a byte a step
From the user: the pair read best with the return half written. Its eight stores are walked one at a time, each turning the reading a step stranger, with a rest at the half-written word while the ASan side stands on its report. Mock 38 is the scene's poster. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
-rw-r--r--design/README.md9
-rw-r--r--design/motion.md28
2 files changed, 28 insertions, 9 deletions
diff --git a/design/README.md b/design/README.md
index 3ac5fb6..027a1b5 100644
--- a/design/README.md
+++ b/design/README.md
@@ -1462,7 +1462,12 @@ and the steps go on in the other alone.
runs do different things (one stores, the other branches to a report).
That step is walked; its two sides' first different rows are framed
`attention`, one each side, and nothing else moves until both have
-struck.
+struck. What one run then does alone, if it is the harm the other
+prevented, is walked too, never at a run: in the ASan scene, the plain
+build's return address overwritten a byte a step, its reading turning
+stranger each time, the half-written word held under its own caption
+while the other side stands stopped on its report (mock 38, the scene's
+poster).
A run that writes to stderr (ASan's report) shows it in its own column, in
place of its registers and its disassembly's lower rows once it has
@@ -1798,7 +1803,7 @@ python3 -B gen.py # 1 to 8, then resvg the same way
| [26](mock/26-pair-rest.png) | the `pair` at the loop, i = 15: plain and ASan builds of `overflow.c` | the shared source with each run's mark on its side; two disassemblies aligned by line, ASan's `only here` rows; the line's registers; each frame as bytes (`hexdump` `eight`): plain's `i`, `buf` (`41`s and their `"AAAAAAA"`), the saved rbp and the return address under the span; ASan's fake frame, its header's fields and shadow beside each row, the real stack's way back under a rule; `buf` facing `buf`, the saved rbp facing the redzone (`differs`) |
| [27](mock/27-pair-store.png) | one turn of the loop, row by row: plain's eight instructions each facing its counterpart among ASan's seventeen | `only here` bars; the page facing the check; the check's values (`0 : 0 ZF`, `taken`); the partial check and the report's call faint, off the path at 00; under each, its `buf` as bytes, the turn's one byte struck and the reading a letter longer, ASan's shadow framed as read |
| [28](mock/28-pair-part.png) | i = 16, the step in which they part | plain's store struck on the saved rbp's first byte, `41` among its stack-ink bytes, its reading `→ 7fffffffed41`; ASan's shadow load framed reading `f3`, its compare and the branch not taken, its redzone still `00`; `differs` on the facing rows |
-| [38](mock/38-pair-ret.png) | i = 27, plain alone: the return address half overwritten | the saved rbp all letters, reading `0x4141414141414141`; the return address `41 41 41 41 00 00 00 00`, held on three bytes and struck on the fourth, reading `0x41414141`, no arrow, no name; ASan stopped: its disassembly down to `call __asan_report_store1`, `never returned`; its stderr panel, the report's lines cut at the edge, four framed; its frame's last picture |
+| [38](mock/38-pair-ret.png) | i = 27, plain alone: the return address half overwritten; the ASan scene's poster | the saved rbp all letters, reading `0x4141414141414141`; the return address `41 41 41 41 00 00 00 00`, held on three bytes and struck on the fourth, reading `0x41414141`, no arrow, no name; ASan stopped: its disassembly down to `call __asan_report_store1`, `never returned`; its stderr panel, the report's lines cut at the edge, four framed; its frame's last picture |
| [29](mock/29-intro-bytes.png) | the introduction's first picture, the camera at x2: 128 bytes of the stack, nothing else | a raw hexdump, before any ink |
| [30](mock/30-intro-words.png) | the `ink` beat: the words, eight bytes a row, where the stack will be; the address space in the program column | `regroup` landed, each word ranged right; `segments` at 108 wide, no pins; a dump's place, the `link` standing; `ink`'s echo: the return address and list's code band, with its row |
| [31](mock/31-intro-stack.png) | the same words as the stack panel, the registers built over it, at x1.25 | the stack's conventions: rsp and rbp pins, offsets, roles, spans |
diff --git a/design/motion.md b/design/motion.md
index 9cfaa53..90da023 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -1207,7 +1207,7 @@ default, and with it the plain build dies in `__stack_chk_fail` instead of
at `ret`), each recorded by instruction from `fill`. The program is
[`mock/overflow.c`](mock/overflow.c): `char buf[16]; for (int i = 0; i <
32; i++) buf[i] = 'A';` in a function of its own. Every figure here is
-those two recordings' (mocks 26 to 28 and 38).
+those two recordings' (mocks 26 to 28, and 38, the scene's poster).
**The program and its frame.** The tracer's tested `targets/overflow.c`
(a bound `n`, gcc's layout) keeps `i` and `n` above the buffer at -O0: the
@@ -1290,13 +1290,27 @@ loop; inside it each side walks its own rows (README, `pair`).
| 3136 | 3528 | i = 16, one past buf. Plain writes 41, an 'A', into the saved rbp; ASan reads f3, a redzone. | i = 16, they part, 3196 | the chart below (mock 28) |
| 3546 | 3967 | ASan's branch to the store is not taken: it calls the report, which names buf and the write. | the report, 3606 | ASan's partial check and its call walked; its run stops: its registers give way to its stderr, the report's lines, the three the caption names framed |
| 3985 | 4320 | Plain goes on alone, a byte a turn: the A's fill the saved rbp. | i = 17 to 23, a run, 4045 | plain alone at a run, 18 f a turn: each turn's byte changes in place (8 f), a letter crossing the saved rbp's bytes one by one, its reading changing with them; settled at `0x4141414141414141`, `differs` on the row; ASan's side holds its last picture |
-| 4338 | 4706 | i = 24: the first A reaches the return address. It reads fill+1: still code. | i = 24, walked, 4398 | the store struck on the return address's first byte, `34` to `41`; its reading crossfades from `→ 401134 main+20` to `→ 401141 fill+1` (12 f), still code's ink |
-| 4724 | 5060 | Three turns on it is half A's: 41414141, no longer an address. | i = 25 to 27, walked, 72 f a turn, 4784 | each store struck; the reading `→ 404141`, then `0x414141`, then `0x41414141`: the arrow and the ink gone when it stops being an address (mock 38) |
-| 5078 | 5366 | The rest at a run: it ends as 4141414141414141. | i = 28 to 31, a run, 5138 | the last four bytes change in place; settled at `0x4141414141414141` |
-| 5384 | 5774 | The loop ends; pop rbp, then ret to 4141414141414141: the CPU faults. SIGSEGV. | the loop's exit, `pop`, `ret`, 5444 | walked: rbp struck; `ret` faults: the `fault` mark on its row, hazard bands round an ink plaque, `SIGSEGV`; rip stays |
+| 4338 | 4706 | i = 24: the first A reaches the return address. It reads fill+1: still code. | i = 24, walked, 4398 | the return address's eight stores are the plain side's climax, each walked as its own step (the chart below), never at a run: the first struck, `34` to `41`; the reading `→ 401134 main+20` crossfades to `→ 401141 fill+1`, still code's ink |
+| 4724 | 5042 | Each turn makes it stranger: 404141 is data, 414141 is nowhere. | i = 25 and 26, walked, 4784 and 4880 | `→ 404141` in data's ink, no name; then `0x414141`: the arrow and the ink gone, a number |
+| 5060 | 5506 | Half written: 41414141, no longer an address. On the right, ASan stopped at the first byte past buf. | i = 27, walked, 5120 | its store struck, the reading `0x41414141`; then the step's hold runs on to the caption's end (5216 to 5506, 4.8 s): the half-written word held, the struck byte solid, the plaque on the store, ASan's side standing stopped on its report. The scene's poster, mock 38 |
+| 5524 | 6016 | Four more turns: the last A lands, and it reads 4141414141414141. | i = 28 to 31, walked, 5584 | four steps of 96 f, to 5968: `0x4141414141`, `0x414141414141`, `0x41414141414141`, `0x4141414141414141` |
+| 6034 | 6424 | The loop ends; pop rbp, then ret to 4141414141414141: the CPU faults. SIGSEGV. | the loop's exit, `pop`, `ret`, 6094 | walked: rbp struck; `ret` faults: the `fault` mark on its row, hazard bands round an ink plaque, `SIGSEGV`; rip stays |
-The cut at 5894, 98.2 s, after 2 s on the two last pictures: a fault on
-the left, a report on the right.
+The cut at 6544, 109.1 s, after 2 s on the two last pictures: a fault on
+the left, a report on the right. The scene's poster (the thumbnail, the
+still that stands for it) is mock 38: the return address half written,
+the report beside it.
+
+**A store into the return address**, walked (i = 24 to 31), from its fire:
+
+| Frames | |
+| --- | --- |
+| 0 to 12 | fire on line 4; plain's turn walks its rows 6 f apart to the store |
+| 12 to 24, 24 | arm, strike the store's one byte, `41`, in a string's ink among the return address's code-ink bytes |
+| 30 to 42 | the field's reading crossfades to what the bytes now make: an address in its region's ink and its name; or, once it is none, the number, the arrow and the name fading with the old reading |
+| 42 to 78 | hold, the struck byte solid (at i = 27 the hold runs on under its own caption, 290 f) |
+| 78 to 90 | advance: the strike cools to its held corner, the plaque goes on through `i++` |
+| 90 to 96 | rest: 1.6 s a store |
**The step in which they part** (i = 16), from its fire: