summaryrefslogtreecommitdiff
Commit message (Collapse)AuthorAge
* canim: the introduction's decode caption in two linesGabriel Schneider5 days
| | | | | | | Wrapped at 80 characters its second line was "compiled to." Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: hex offsets with 0x stay the introduction'sGabriel Schneider5 days
| | | | | Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the introduction's storyboard as builtGabriel Schneider6 days
| | | | | | | | | | | | | The storyboard and catalogue follow what the introduction became after its review: the plain build, chapter II's six beats with the stack's convention said and the call before the push, the regroup's bytes flying one at a time over their row, the dump folding into its tag, the Eiffel visit at x2 with the 128 bytes marked, hex offsets, names only after the things. The aim's head is 10; a beat's link fades its head as it draws back. Mocks 29, 30, 31 and 37 redrawn. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: the introduction, from the reviewGabriel Schneider6 days
| | | | | | | | | | | | | | | The introduction records the plain build (clang -O0, no instrumentation), so reverse's frame is the compiler's own push, mov and sub. The stack chapter says its convention once and keeps four free words over rsp so a push moves the pin and nothing else; reverse's rows stand under main's and are stepped, each touching its word, the call before the push, the aim drawn head first to the row it returns to. The close-up frames the bytes and the stack together with their 128 bytes marked. Nothing is named before it is shown; offsets are written in hex as the operands are; the dump folds into its tag; the map is announced before it is shown. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: the ASan pair finished; a run's crossfade lasts its stepGabriel Schneider6 days
| | | | | | | | | | | | | The ASan run is recorded --until __asan_report_store1 and the scene finds its moments by what they are, not by count. The pair's tags name their run, ASan's stopped call reads never returned, and both disassemblies start level on their line. At a run a row's crossfade now lasts the whole advance and a chain crossfades when its memory changed: the pair's fast pass had thirteen one-frame changes and has none. Stale videos re-exported. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: the introduction, three chaptersGabriel Schneider6 days
| | | | | | | | | | | | | | | From the user: a first-principles showcase that builds the views. I, memory: the stack's bytes, words read low byte first, the address space to true scale with each cluster enlarged and every band's addresses and size, the bytes tied to their place, ink and chains. II, the stack: the words become the stack panel, a real push, the return address aimed at the row it returns to, rbp and the frame, the registers. III, code: an instruction's bytes decoded into one listing of lines and addresses, then two columns, then the working frame assembled and the map. Recorded from main's call of reverse with record --until. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* record: --until ends the recording at a placeGabriel Schneider6 days
| | | | | | | | The ASan scene cut its run by a count of steps, which moves with the compiler; --until __asan_report_store1 ends it where the report begins. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: relations as one data-oriented subsystem; aim; the ASan pair; the ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | | | | | | | introduction's chapters From the user. Relations between panes are one subsystem: per-frame tables of places and values in struct-of-arrays, owned by the frame; the kinds one table of data; a resolver of pure passes (join, filter, priority, cut) unit-tested on hand-written tables. Ported kinds draw byte-identical frames; a synthetic map of 4000 places and 6000 values resolves in 0.56 ms against the old table's 5.7. aim, a word holding a code address tied to its row, is the first new kind, off unless a scene turns it on. The ASan pair: one overflow built plain and with ASan, recorded by instruction; the frame as bytes eight a row; the plain run goes on alone in the column, its return address aimed at main's row until the letters reach it; the fault at ret. The introduction's three chapters are built and tested, not yet exported. Annotations, rows and scrolls that changed in one frame now fade; captions stand twelve seconds at most. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: aim, a word holding a code address joined to its row; relations as ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | one data model From the user. aim joins a value on screen that is a code address (a return address, a function pointer, a GOT slot) to its row in the disassembly, off unless the scene's author turns it on; when the word is overwritten the head glides to the new row, or frays when it no longer points at code. Every relation is now one model, as data: tables per frame of places, values that may be addresses and the step's events; the kinds as one table of their joins, knobs, priority, ink, route and timing; a resolver of six passes over those tables, one budget, and no kind drawn because the budget has room. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the column as a form of the language; the ASan pair and the ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | introduction storyboarded From the user: the column style is a tool a scene's author can use. It is a standard form beside the working frame (which stays the default): for stories of rows going down and back. A scene changes form in a rest, in a fixed order, about 70 frames each way. Bubbles fit their reading in their lead and steps; panes change only when the subject moves. The ASan pair (112 s) uses the pair, then the column while plain runs on alone, then the pair for the fault; the introduction (123 s) mixes the frame at x2, the column for the address space and the stack, and text above the aligned code. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: a column of text as an experiment; the disassembly tied to the stackGabriel Schneider6 days
| | | | | | | | | | | | | | | | | | From the user. A scene may set its text in a column beside the panes a beat is about: col.beat names the panes and their rows, where the text is placed (beside, below, above, or on a drawing) and what it is level with; panes the beat leaves out fold to their title bars on a shelf, their changes struck there. Tried as two scenes beside the originals: the call followed down (column) and a bubble on sort's rings (column_sort). annotation = .tied names the word an instruction touched and draws a touch to its stack row; offsets count from the frame's base; rsp's pin travels with its amount before the stack follows; .whole keeps the full chain. carry = .arrow draws a value's way between memory and a register. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* trace: what push, call and ret touch; names for data; the stack's roles, sharperGabriel Schneider6 days
| | | | | | | | | | | | | | For a disassembly that points at the stack word it touched. The stack's own instructions have touches (push, call and enter write at rsp-8; pop and ret read at rsp; leave at rbp), and a rep string instruction its whole range. An address a global or static object holds is named (head+0, libc.so.6!main_arena+96). The saved rbp has its role at the push that makes it; every local in a shared word is given; the stack protector's copy is found by seeing its store; ztrace show labels each stack word. Six bytes a moment and 3% slower on the list by instruction. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the disassembly tied to the stack; rsp's moves seen; a column of ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | | text as an experiment From the user. A fact is printed once, in the pane that holds it: under annotation = .tied a row names the word it touched and a touch line ties it to its stack row while a step is walked; .whole keeps the full chain. An instruction that moves rsp or rbp says the amount, and the pin travels row to row with the rows it gains or releases marked, the stack following only after it lands. Every strip is ordered cause before effect and numbered. carry is an optional arrow from memory to a register. An experiment sets a column of text bubbles beside the panes a beat is about, each bubble level with what it speaks of, tried on the call followed down; text may also stand below, above or on a drawing. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: the disassembly under the source everywhere; ringsGabriel Schneider6 days
| | | | | | | | | | | | | | | | From the user. In every split the disassembly stays under the source; registers a scene never changes fold three to a row, and the stack takes the room: nine to twenty slots where it had six. The graph's first form is rings: a loop a ring its blocks sit on, an inner loop a smaller ring touching its parent, a way out leaving along the tangent; layers stay for functions without loops. Its layout comes from the code alone and it shows nothing from after the moment: a block not reached yet is quiet and is reached, a fold of what is not reached yet opens when the run arrives. A pane unrolls from its strip into its whole column and rolls back. The sqlite scene's strips move before their panes. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: a minimap in each pane; source wherever it can be had, libc's includedGabriel Schneider6 days
| | | | | | | | | | | | | | | | From the user. Each pane with more than it shows carries a strip of its whole column at its right edge, the pane's window outlined and what happens off it marked there; the corner minimap is gone and the dive folds each column of the map into its pane's strip. The source panel follows the pc into any file the build has: glibc's own, from the distro's debuginfod by an optional step that caches them by build id (zig build sources; nothing else touches the network), and musl's, from Zig's lib directory. The syscalls scene shows open64.c on the way down, and a new scene follows the same call through a Zig-built musl. A graph's counts and inks are as of the moment shown. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: rings; nothing from after the moment shownGabriel Schneider6 days
| | | | | | | | | | | | | | | From the user. A loop is a ring its blocks sit on, upright, an inner loop a smaller ring touching its parent, a way out leaving along the tangent; layers stay for functions that are trees of branches; the track is withdrawn. A graph shows only what the run has done by the moment shown: counts so far, a block or edge not reached yet drawn quiet, a fold of what is not reached yet that opens when the run arrives (reach, unfold); the rule stands in Forbidden for every block. A pane unrolls from its strip into its whole column and rolls back, so the whole function or the whole stack can be shown for a beat and a far jump is travelled. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the disassembly stays under the source; the graph as a trackGabriel Schneider6 days
| | | | | | | | | | | | | | | From the user, on the sort render. Registers a scene never changes fold three to a row, so the stack is twelve to fifteen slots and the disassembly keeps its place under the source with eleven to seventeen rows; a blocks lens has no view. The graph leaves the layered picture of the reverse-engineering tools: blocks are pills on one line in the order they run, a loop an arch over its blocks with the turn count at its centre, every bend a quarter circle; sort's eleven blocks and both loops are seen whole across the band. Sheets 42 and 43 set the layouts and the graph's forms side by side. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the return address overwritten a byte a stepGabriel Schneider6 days
| | | | | | | | | | 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
* canim: the graph of a function's blocksGabriel Schneider6 days
| | | | | | | | | | | | | | | | | | From the user. A blocks lens draws a function's basic blocks as boxes with their offsets and visit counts, loops in their lanes with the turn count, the path's last edges gold, the pc's block gold, and the disassembly as its view; leave and turn carry the mark along an edge, with the compare's flags framed for the edge chosen. On the map the graph takes the disassembly's place with its rows. The layout is a pure function, tested on sort, reverse and libc's open (twelve blocks the run never reached fold into six boxes). The sort scene walks one trip of its inner loop block by block and sprints the middle on the map. Every scene's linear rows carry a rule and a count at each block's head. The stack's panel no longer reads registers from the file on every draw: a frame is 20 ms where it was 57. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the overflow as bytes; a minimap in each paneGabriel Schneider6 days
| | | | | | | | | | | | | | From the user. In the pair a frame is a dump of eight bytes a row read by its own fields, so each turn of the loop is one more letter and the letters are seen to cross from buf into the saved rbp and the return address, which reads as code until they reach it. Each pane with more than it shows carries its own minimap, a strip of its column of the map at four units a row with the pane's window outlined and what happens off the window marked there; the corner minimap is gone, and in the dive each column of the map folds into its pane's strip. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the address space said with less; a word read low byte first; ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | aligned in two forms From the user. The address space is a slim bar to true scale with its two ends written, each cluster enlarged once beside it, and every band carrying the addresses where it starts and stops and its size; no rulers, no factors. The stack's bytes on screen are tied to their place in it. regroup is drawn: a word's eight bytes fly out low byte first and land reversed as its sixteen digits. aligned has two forms a scene asks for by name: interleaved, a line as the head of its instructions, and columns, the source beside them with each line as tall as its run. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the address space to true scale, magnified beside itself (a draft)Gabriel Schneider6 days
| | | | | | | | | | | From the user: the view's worth is the feel of the space's size, with its ends in the picture. The whole user half is one rectangle to linear scale, the mappings hairlines where they are, and what cannot be read is enlarged beside it with the magnification's lines and its factor. The mocks are rough: lines through labels, the program's bands unnamed. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the address space as one tall rectangle; aligned as a listingGabriel Schneider6 days
| | | | | | | | | | | | | From the user. segments is the textbook picture: one rectangle, high addresses on top, each mapping a band in its ink (heights by the log of their size, holes folded with their size beside them), labels outside on leaders, a file's mappings bracketed as one, the stack's and the heap's growth as arrows, rsp and rip pinned in their bands. aligned is one panel: a line as the head of its instructions, line numbers and addresses in one column since both say where, a rule over every head. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* trace: an instruction's bytes are in the recording; show prints a mapping's ↵Gabriel Schneider6 days
| | | | | | | | | | permissions For an introduction that shows bytes becoming an instruction, and the address space as segments. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: an introduction that builds the views; segments; source and ↵Gabriel Schneider6 days
| | | | | | | | | | | | | | | | | disassembly aligned From the user. Three short chapters teach the frame by assembling it: bytes become words, words that are addresses take the ink of the mapping they point into, the stack's conventions are shown on those same rows by a real push and call, an instruction's bytes decode into its row beside its source line, and the working frame stands at the end. segments is the process's mappings as rows, the legend's long form. aligned is a split a scene chooses: each source line level with the first row of its instructions. Verbs for building a view: regroup, ink, column, frame up, decode, align. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* symbols: a library's separate debug info, when it is of the same buildGabriel Schneider6 days
| | | | | | | | | | | | | | | The system glibc stays dynamically linked and is symbolized from the debug file in the debuginfod client's cache or under /usr/lib/debug, used only when its own build id equals the mapped library's; nothing is downloaded. Static functions get names (the loader's resolver is _dl_runtime_resolve_xsavec; main_arena is found by symbol), libc's frames their file and line as the build saw them, and locals, blocks and parameter counts follow. A recording says of each module its build id and where its names came from; ztrace show prints it. Read only when an address in the module needs a name: 44 ms and 25 MB at the first one. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the graph of a function's blocks; two runs as a pairGabriel Schneider6 days
| | | | | | | | | | | | | | | | | | | From the user. The disassembly's alternate form at a larger scale is the graph of its basic blocks: a block a box of rows with its offset, lines and visit count; execution flows down and a back edge is the one thing that climbs, in its loop's lane with the turn count; what the run never reached folds away. On the map it takes the disassembly's place; in the working frame a blocks lens draws its shape and the rows are its view. Verbs leave and turn carry the mark along an edge. Two runs of one program share a frame as a pair: the seam is the gutter, the source shared above, rows only one run has and values that differ marked at the seam. The scene it is made for sets a plain build against an ASan one in a stack overflow: the frame beside its shadow bytes, the store beside its check, and the step where they part. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* trace: a function's basic blocks; ASan's shadow memoryGabriel Schneider6 days
| | | | | | | | | | | | | | | | | For a graph of a function's blocks: at the first stop inside it a function's blocks are recorded once (bounds, how each ends, where its edges go), with every instruction's text up to 2048 of them; telescope.blocks reads them, and a branch event ties a run to the edge it took. Stripped libraries get blocks from their unwind bounds. For a plain build seen against an ASan one: record --asan keeps the shadow of every region it records, the offset found from the process; telescope.shadow gives an address's shadow byte. The report functions are named and the chain holds from inside the report to main. Tested on an overflowing target built plain, with gcc's ASan and with clang's. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: what the verification review found, fixedGabriel Schneider6 days
| | | | | | | | | | | | | | | | A register's chain reads memory as its panel shows it, and follows again only after the bytes land: rsi no longer shows what read returns before the kernel writes it. Bytes keep their old value through the arm and change at their own strike, in every dump, stack word and loupe. The dive lands once. Captions lead what they name: the longest still in the syscalls scene is 2.8 s where it was 13. Pins hold through a sprint; a row of a view carries the pin of the register that points at it; a left child's badge sits on its left shoulder; a log scrolls with the row that arrives. The zoom scene's camera holds the disassembly's rows and the stack in one view. Six programs, the title says now. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: nothing changes in one frame; the map's space is used; the heap scene ↵Gabriel Schneider7 days
| | | | | | | | | | | | | | | | | | | | at its storyboard's length The motion check counts a third of the one-frame changes it did: the minimap's changes fade, and a register's value, a flag, a role, a pin's names, a tag's note, a backtrace row, a call tree's node and a dump row crossfade where they changed at once. What still fires is named in the README; an encoder's keyframe and the gallery's cuts are exempt by name. No caption stands over twelve seconds or under its reading time. The heap scene is 78 s: what the storyboard does not narrate runs, and each free's line cascades onto its call row (line stepping stops at a breakpoint for that). On the map, leftover space holds the stack continued, dumps round what the registers and the stack point at, open loupes and the key: between 1% and 13% of a map is page, where it was 14% to 42%. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: what the second review found, fixedGabriel Schneider7 days
| | | | | | | | | | | | | | | | | | A system call stepped over plays in order: the registers set, the crossing from the call row with the kernel's window under it, the stores after rax. A strike covers the bytes that changed. The band's view changes with the argument framing. In the descent a callee sits under its caller's return row, and rows fade before others glide. The heap scene follows the storyboard's nine captions: pushes at a run without marks, each free and the malloc that takes the head back walked, the tcache's loupe over the stack and closed with each advance, a chunk in neither list drawn, the freed node travelling to malloc's row. In the dive the map falls into the corner and becomes the minimap; on the map boxes are as long as their rows. A narrow read is shown at its width. The chart checks captions and one-frame changes. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: what the second review found, placedGabriel Schneider7 days
| | | | | | | | | | | | | | | | | A caller keeps one row after its call and its callee sits under it; opening and closing fade what is given up before what is kept glides, and nothing changes in one frame. A system call stepped over is three parts: the registers set, the crossing from the call row, the stores after it. A loupe never covers a row its step changes, hangs over the stack when opened from a view, and closes with the advance. A run draws no strikes and no arcs, and a caption never names what the pace veils; the heap scene's captions have landing and leaving frames. The map's boxes are as tall as their rows. The veiled map travels into the minimap. The motion instrument checks captions and fires POP on any one-frame change after stillness. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: a call followed down to the kernel; rows that say what they do; the ↵Gabriel Schneider7 days
| | | | | | | | | | | | | | | | | | | | | heap from the inside From the user. The disassembly can descend: the syscalls scene is glibc's hello by instruction, and open is followed from main through its PLT stub, whose jmp reads the GOT, into libc's wrapper to the syscall row, which crosses to the kernel's window under it, and back up. The band keeps the calls so far as strace writes them. Operands lose their size words and show a width as byte cells only where nothing else says it. A compare shows its values and the flags it leaves, a jump the flags it reads, lea its result, an indirect jump its target and the slot it read, a call that has run its C form. The backtrace has its newest frame at the bottom. A new scene shows glibc 2.44's heap from blocks that exist: chunks read by fields (a size with its bits, a protected pointer), the free list as arcs, the tcache in a loupe, the program's list over malloc's own. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* trace: names for PLT stubs and GOT slots; a call followed down; the vDSO is ↵Gabriel Schneider7 days
| | | | | | | | | | | | | | | | | | | | run through For a disassembly that follows a call into libc. A stub is open@plt and a slot open@got, from the relocations (libc's own, IFUNC and nameless, by the function they resolve to); telescope.got says what a slot holds and whether it is still lazy. A library function's entry is named even when its mapping was not known yet, by the alias the program imports. The chain holds through the stub's jump, the callee's first instruction, the syscall and the loader's resolver: ld.so's unwind section lacks the entry that ends it, which lost every frame there. A syscall is tied to its instruction's moment, and each frame's call is recorded with the row before it. Stepped by instruction, a call into the vDSO is one moment and its return the next: its clock loop, single-stepped, made three million moments of three reads. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* canim: quieter marks, the stack's roles, the loupe, arcs, the minimap, the ↵Gabriel Schneider7 days
| | | | | | | | | | | | | | | | | | map and the dive From the user's notes on the second videos. The current row is a white wash, a strike a softened vermilion, held a turned corner. A stack row has its offset from rsp and its role from the tracer (a saved register, a local by name, argc and argv). The loupe is the telescope as a floating panel: the memory round what a pointer leads to, a pointer inside it opening the next. A pointer to a row of its own panel is an arc in a lane, in dumps, loupes and the stack. Every scene has the minimap; the map is the same moment with every panel at full length on 3840 by 2160, and the list opens on it and dives to the working frame, each panel travelling to its place. Recordings hold more round each stop. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* record: --steps counts from the --from placeGabriel Schneider7 days
| | | | | | | | The loader's syscalls on the way to main used up the count: --steps 120 on a dynamic program left ninety instructions. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: down is deeper; a call followed down; operands without size words; ↵Gabriel Schneider7 days
| | | | | | | | | | | | | | | | | | | | | | the heap as a scene From the user. Direction and nearness are rules: the idea, the source, its instructions, the callee and the kernel go down the frame, a call goes down and a return comes up, and every tie runs one of those ways. The disassembly can descend: a window a call depth, the caller keeping three rows with its call waiting, a PLT stub its jump, the kernel at the bottom on vellum, with verbs descend, cross and ascend. The kernel leaves the band, which keeps the calls so far as strace writes them; the backtrace has its newest frame at the bottom. Size words are dropped from operands and a width is shown as byte cells where nothing else says it; a compare shows its values and flags, a jump the flags it reads, an indirect call its target and the slot it was read from. libc's heap is a scene of blocks that exist (a dump by fields with a size and a protected pointer read, arcs as the free list, a loupe into the tcache, the list drawn over malloc's own), storyboarded on glibc 2.44. Mocks 16 to 18. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* trace: glibc's heap, read from a recording at any momentGabriel Schneider7 days
| | | | | | | | | | | | | | | | | record --heap keeps the arena, the tcache and, of every chunk, its size word and the links of those on a list: free chunks stay readable, which --alloc dropped at the free. zt.heap.glibc gives the chunks in address order, the tcache's and the bins' chains (safe-linking as the stored value and the pointer it protects), the top; each with the address of the word it was read from, each chain saying how it ended. ztrace show prints it. Layouts for glibc 2.44 (no fastbins; a tcache made at the first free, counting the slots left) and 2.40; the arena found by symbol or by the struct whose next points at itself. Against pwndbg on 2.40: the same at every stop. Three bytes a moment and a sixth slower on the list by instruction. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* trace: the call chain by the unwind tables; what each word of the stack isGabriel Schneider7 days
| | | | | | | | | | | | | | | | | | | backtrace and frames follow .debug_frame or .eh_frame where there is one (PLT entries expanded into exact rows) and the frame pointer where there is none: the caller is no longer lost in a prologue, in a function that keeps no frame, in a PLT entry or inside libc's syscall wrappers. Against gdb: the same chains on fib and on SQLite, where the old walk lost __sbrk and unixSync. A recording holds, once a function, its unwind rows and its locals on the stack (DW_OP_fbreg, with the block each lives in), and the process's first stack pointer. telescope.slots says of each word what it is: a saved register and which, a return address, a local by name, argc, argv, envp, auxv. Four bytes a moment on the list by instruction, and no slower. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: arc, a pointer to a row of its own panel is drawnGabriel Schneider7 days
| | | | | | | | | | | | | From the user, on the loupe's mock: a pointer in memory named a row two above it and nothing showed it. In a dump, a loupe and the stack a pointer whose target is a row of the same panel is an arc in a lane at the panel's edge, as a jump is in the disassembly: quiet while it stands, full ink in the step that writes or reads it, a stub when the target is just off the window. A chain shares a lane. A loupe carries the arcs among its own rows; the stack's frame chain gets one only when touched. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the dive's sheet, which was too large for the snapshot's limitGabriel Schneider7 days
| | | | | Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* design: the dense stage is a map; the frame keeps its layout and gains a minimapGabriel Schneider7 days
| | | | | | | | | | | | | | | | From the user, on the 4K mocks: the space was not well used, and the dense view is better as where a scene starts or as a minimap than as the frame it works in. The map is the same moment with every panel at full length on 3840 by 2160, packed by content. The working frame is the 1920 stage again, each panel a window on its column of the map, with the map at a twentieth in the caption band: windows outlined, marks no window shows flashing there. dive and surface carry a scene between the two, each window travelling to its panel's place. The loupe hangs from its pointer in the working frame. Mocks 16 to 18 are withdrawn; 19 is the map, 20 the dive in four instants, 21 a loupe with the minimap. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
* debugger: the red zone, and the region round what an instruction touchesGabriel Schneider7 days
| | | | | | | | | The 128 bytes under the stack pointer are recorded with the stack; what an instruction reads or writes is recorded with --around bytes each side of it, as what a pointer leads to is: a viewer's memory panel shows the neighbourhood, not the word. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* design: four times the context on a 4K stage; the loupe; quieter marksGabriel Schneider7 days
| | | | | | | | | | | | | | | From the user, after the second videos. The stage is 3840 by 2160 at the same type size: four columns (source, disassembly, state, stack), 69 lines, rows and slots with no lens, 43 with a lens as subject, dumps of 32 rows. Code reads at 1440p and up; the caption, the clock and a lens's drawing are doubled, and the camera at x2 is the old frame. The stack's rows carry their offset from rsp and a role. A loupe is the telescope as a floating panel: the memory round what a pointer leads to, lifted over the context, a pointer inside it opening the next. The current row is a white wash, a strike a softened vermilion, held a turned corner; sheet 15 sets the alternatives side by side. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: a continue is a wave; what arrives after a fade is plain; a pin only ↵Gabriel Schneider7 days
| | | | | | | | | | | | | | | | | where its register points From the designer's review of the SQLite scene. Between far stops the changed registers strike two frames apart in pwndbg's order, and links and pins set off with memory. A stack window or a dump that fades in carries no marks of changes the viewer did not see. At rest a moved register kept a pin at its old place as well, in every scene: gone. The kernel's answer is filled before the return arrow leaves, and rax strikes as it lands. Every dump has one reading, by type (a char quoted, a bool by name); line numbers are as wide as the program's largest; pins' names keep the side they came to. Names and measures follow the catalogue (.loose, theme.metric.calls, time.pin, time.continue_wave). Co-Authored-By: Claude Fable 5.2 <[email protected]>
* record: how much of the context a stop keeps is asked forGabriel Schneider7 days
| | | | | | | | | --around BYTES of memory each side of what a pointer leads to, for a viewer that shows the region and not the word; --disasm ROWS above and below the pc; and every word of the --stack bytes is followed as a pointer, not the first sixteen. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* design: what a real program asked of the languageGabriel Schneider7 days
| | | | | | | | | | | | | | | | The SQLite scene needed blocks the catalogue had no name for; each is placed. A dump is read by its type or by fields a scene gives it, rows without one folding into a row that counts them; bytes that are no field are loose; what a stop did not read is unread and what the kernel took is given. Addresses and line numbers are as wide as the program needs. The backtrace can be a lens's drawing, and a lens can change in place. A continue is a verb of its own: registers strike in a wave, far windows fade through and arrive without marks, frames two stops share slide. The kernel's answer is filled before it travels. The calls tree has sizes past ten leaves and folds past thirteen. Mocks 13 and 14 are two stops of the SQLite recording. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* backtrace: an outer frame is on its call's lineGabriel Schneider7 days
| | | | | | | | The debugger records the call each frame returns from, as an instruction with its line; canim reads it. main is at list.c:41 while reverse() runs, not at 42, and the rows of a stop deep in SQLite have their lines. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* debugger: what a write gives the kernel is memory too; --from passes other stopsGabriel Schneider7 days
| | | | | | | | | | A write's buffer was recorded as the syscall's payload only: a reader of the moment's memory found there what an earlier stop had seen of it (zeros, in SQLite's page). And record --from with --by syscall took the loader's first syscall for the place and gave up its breakpoint. Both found by the first animation of a real program. Co-Authored-By: Claude Fable 5.2 <[email protected]>
* canim: a scene from a real program: SQLite's row on its way to diskGabriel Schneider7 days
| | | | | | | | | | | | | | | | | | | Three inserts stopped at sqlite3BtreeInsert with their payloads read off the caller's stack, the commit's backtrace from unixWrite up to main, the pwrite64 crossing into the kernel, and page 2 as the kernel took it: its header, its cell pointers and the three rows, read by field. The scene is built only where SQLite's source is (-Dsqlite=DIR); its recording is 181 moments, 95 KB. What a real program asked of the blocks: a dump read by the fields a scene gives it, with the rows between collapsed; addresses of twelve digits and line numbers of six; the backtrace as a lens's drawing; a continue's motion (shared frames slide, a far window fades); memory drawn only where the stop read it. In the kernel lens a register is framed as carrying an argument only while it holds it at the stop shown, and an allocator row is read only where an allocation follows the word. Co-Authored-By: Claude Fable 5.2 <[email protected]>