diff options
Diffstat (limited to 'design/README.md')
| -rw-r--r-- | design/README.md | 86 |
1 files changed, 54 insertions, 32 deletions
diff --git a/design/README.md b/design/README.md index 0899e50..b51f057 100644 --- a/design/README.md +++ b/design/README.md @@ -86,7 +86,7 @@ this table. | | [`echo`](#4-ties) | the same mark in two panels at once | for a step | | | [`touch`](#4-ties) | this instruction reads or writes that word | for a walked step, while the row is current; `tied` only | | | [`carry`](#4-ties) | this value went from that word to this register, or back | a scene's knob, off by default; for a walked step | -| | [`aim`](#4-ties) | this word holds the address of that instruction | the author's knob, off by default; for a step, or standing through a beat | +| | [`aim`](#4-ties) | this word holds the address of that instruction | the author's knob, off by default; for a step, or standing through a beat, or drawn on its beat and then standing | | 5 frame | [`stage`](#5-the-frame) | the working frame: the band and the two columns | split `none`, `beside`, `subject`, `blocks` | | | [`segments`](#segments) | the process's address space to scale, each end enlarged, its bands' addresses at their edges | treatments A (default), B, C; the ink's source: a band framed when a word is inked; a dump's place | | | [`aligned`](#aligned) | the source and its instructions in one panel, each line level with its code | `interleaved`, `columns`; a split a scene chooses | @@ -435,14 +435,16 @@ A word of the stack, pwndbg's way and a little more. | --- | --- | --- | | 4, 10 | arcs | the [`arc`](#arc) lanes: a word holding the address of another slot in the window | | 16 | pins | the `row` pin's lane, to 112: every register whose value is this word's address | -| 172 | offset | hex, faint, ranged right in four characters, from the newest frame's base: the register its code addresses its words by (the call frame information's CFA register: rbp in a body that keeps a frame pointer, rsp at a function's entry, in its prologue before `mov rbp, rsp`, after its `pop rbp` or `leave`, and in a function that keeps none), so that `[rbp - 0x18]` and its word's `-18` are one number. The base's row is `+0`. Under [`whole`](#insn) pwndbg's: from rsp, `+18`, and `-8` above rsp | +| 172 | offset | hex, faint, ranged right in four characters, from the newest frame's base: the register its code addresses its words by (the call frame information's CFA register: rbp in a body that keeps a frame pointer, rsp at a function's entry, in its prologue before `mov rbp, rsp`, after its `pop rbp` or `leave`, and in a function that keeps none), so that `[rbp - 0x18]` and its word's `-18` are one number. The base's row is `+0`. Under [`whole`](#insn) pwndbg's: from rsp, `+18`, and `-8` above rsp. In the introduction, from 0x10 up with `0x` (`-8`, `+0x10`, `-0x18`), as the operands and the values are written: beside a symbol's decimal offset (`main+50`) a bare `-10` after `-8` reads as ten | | 184 | address | stack ink, `lead`; then the chain, its first hop the word's content | | 88 | shadow | in a run built with AddressSanitizer: the shadow byte that stands for this word's eight bytes, a `byte` cell in the pin lane's end, before the address it stands for (a fake frame's words have no offset from rsp, and no pins). `00`, addressable: faint, no paper. `f1` `f2` `f3`, the stack's left, middle and right redzones: bright on the `freed` hatch, the poison's sign. `01` to `07`, the first k bytes addressable: bright, the hatch over the other 8 − k eighths of its cell. The panel's tag gives where the shadow is, `shadow at addr >> 3 + 7fff8000` | | right | role | what the word is, where the recording knows it, ranged right where the chain's room ends: `saved rbp`, `saved rbx` (dim); a local's name (primary), and which part of the word when it is narrower (`n, high half`, `f, low half`); at the process's start `argc`, `argv[0]`, `argv end`, `envp end`, `auxv` (dim). It is the name a `tied` annotation gives the word ([`insn`](#insn)) | | 14 from the right | span | the [`call`](#call) bracket, its name left of it | A return address needs no word: its chain is code, named (`10018b0 -main+80`), and its frame's bracket ends on it. Room runs out from the +main+80`), and its frame's bracket ends on it. The introduction, which +leaves nothing to the eye, gives it the role `the way back` (its caption's +words; `return address` would cut the name beside it). Room runs out from the right: a span's name is never cut, a role is never cut, and the chain on the rows they sit on ends 12 before them, cut by its own rule (`sqlite3BtreeInsert` beside `7fffffffe980 → 7fffffffeb90 → …`). @@ -593,7 +595,7 @@ bytes and a pointer 8, never two fields and never a store's width. | 24 | bracket | `quiet`, on a row that holds a drawn thing; `tie` when a projection ends here | | 34 | address | region ink, `lead`; at 60% on a row that holds no drawn thing | | 132 | sixteen `byte`s | on a pitch of 30, 12 more after the eighth | -| 640 | reading | what the runs read as, left to right, a character apart: a number in decimal (in its byte order); a pointer as `points` and its `address`, `NULL` dim; text in quotes, C's escapes, in a string's ink; a run left to the eye, or `loose`, as nothing; the chunk's size word before an allocation as a note in Go 18, faint (`malloc's: a chunk of 32`). Cut at the panel's edge with a faint `…` | +| 640 | reading | what the runs read as, left to right, a character apart, but no space before a pointer's arrow, which has its own room as in a chain (`9 → 407030`): a number in decimal (in its byte order); a pointer as `points` and its `address`, `NULL` dim; text in quotes, C's escapes, in a string's ink; a run left to the eye, or `loose`, as nothing; the chunk's size word before an allocation as a note in Go 18, faint (`malloc's: a chunk of 32`). Cut at the panel's edge with a faint `…` | **Wide address.** The bytes begin 12 after the address ends, and at 132 at least: an address of up to seven digits leaves them at 132; the stack's @@ -732,7 +734,10 @@ the stack gains. ### stack -`slot`s from rsp, low addresses on top: as many as the state column has +`slot`s from rsp, low addresses on top (where it first stands beside a +drawing with high addresses on top, as the introduction's address space, +the scene says so: "lower addresses are drawn higher: down a word is up a +row"): as many as the state column has under the registers ([the frame](#5-the-frame): twelve as the subject beside eleven rows of registers, fourteen beside a lens, fifteen with none, twenty with the `blocks` lens). `call` spans down its right edge for every frame in view: the @@ -781,7 +786,10 @@ to the stack's top. it, and the pane rolls back in at the new place. - While the camera is on the stack the window holds still ([`visit`](#6-verbs)): pushes fill `free` slots in the middle of the - frame, and rsp's pin climbs to them. + frame, and rsp's pin climbs to them. A scene may hold it the same way + while a frame is made: the introduction's chapter II holds it from its + first picture with four `free` words over rsp, enough for `push rbp` and + `sub rsp, 0x18`, so that only pins move and no row. Tag: `twelve words`, or the range when scrolled (`rsp+20 to rsp+78`); what the offsets count from, `· offsets from rbp` (`tied`: the frame's base, which @@ -1358,8 +1366,8 @@ page while a beat lasts), `active` (full ink, for the step that causes it). | `thread` | this line is these instructions, and the machine is here | the current `line` ⋈ the `insn` rows of that line | none · always | 0: never gives way | gold, 3; a `tie` bracket on the line and on each run | the left margin, x 54 (on the map, the gutter at x 1008) | standing; moves with `advance` | | `link` | this register now points at that | a struck `reg`'s value ⋈ `places` by address, where the target has a pin lane (a node, a slot) | `link`: `off`, `step` · `step` | 2 | the target region's ink, 3; a filled head; the pin rides it | the gutter's left lane up into the band, the right lane down to a slot | `link`: s+6, 24 f (36 over 400 units), back 18 | | `projection` | these bytes are that part of the drawing | a read or write `event`'s run ⋈ the drawing's part made of those bytes | `projection`: `off`, `step` · `step` where a lens with a view is up | 3 | the mark's colour, 2; a bracket at each end | the gutter's right lane; a lens's top or bottom lane | `project`: bracket 6 f, line 18 (30 over 600), back 18 | -| `aim` | this word holds the address of that instruction | `values` of region code ⋈ `insn` rows (or a graph's pills) by address | `aim`: `off`, `step`, `standing` · `off` | 4 | code's ink, 2; a filled head; the row's address framed | the gutter's left lane, x 950 | `aim`: after its word's mark, 18 f (24 past ten rows); glide 24 to a new row; fray 12 + 18 | -| `carry` | this value went from there to here | a load, store, push or pop `event`'s source ⋈ its destination | `carry`: `off`, `arrow`, `value` · `off` | 5 | primary, 2; an open chevron | the gutter's right lane, x 962 | `carry`: after the source's read, 18 f (24 past eight rows), back 18 with the strike | +| `aim` | this word holds the address of that instruction | `values` of region code ⋈ `insn` rows (or a graph's pills) by address | `aim`: `off`, `step`, `standing`, `drawn` · `off` | 4 | code's ink, 2; a filled head 10 by 10; the row's address framed | the gutter's left lane, x 950 | `aim`: after its word's mark, 18 f (24 past ten rows); glide 24 to a new row; fray 12 + 18 | +| `carry` | this value went from there to here | a load, store, push or pop `event`'s source ⋈ its destination | `carry`: `off`, `arrow`, `value`, `after_touch` · `off` | 5 | primary, 2; an open chevron | the gutter's right lane, x 962 | `carry`: after the source's read, 18 f (24 past eight rows), back 18 with the strike | | `touch` | this instruction reads or writes that word | a read or write `event`'s `insn` row ⋈ the `slot` by address | `touch`: `off`, `step` · `step` under `annotation = .tied` | 6 | the mark's colour, 2; a head on the stack's rule | the gutter's middle lane, x 956 | `touch`: 12 f (18 past six rows), before the word reacts; back with the advance | | `arc` | this word points at that row of its own panel | `values` in a panel ⋈ `places` in the same panel by address | `arcs`: `off`, `standing` · `standing`, active in the step that writes or reads it | its panel's: lanes, not the frame's budget | the target region's ink, 2, 60%; full when touched | the panel's left lanes (three; the stack two) | `arc` | | `stem` | this text speaks of that | a bubble ⋈ the row or tag it is level with | `stems`: `off`, `rest` · `rest` in the [column](#column) | rests only: never with a step's lines | `dim`, 2 | across the gutter, level | in 12 f with the bubble, back 12 f with the fire | @@ -1492,9 +1500,12 @@ first (the stack, a dump), or the arrow ends in a stub on the panel's rule with a count, as a link's does; a folded register (`quiet`) takes it on its cell. A second value, `carry = .value`, sends the value's digits along the arrow on a chip of `raised`, landing as the destination's strike: for the -introduction's one walked load, where the viewer first learns that a -register can hold what memory holds; never in a scene's ordinary steps -([mock 56](mock/56-carry.png)). +one walked load where the viewer first learns that a register can hold +what memory holds; never in a scene's ordinary steps +([mock 56](mock/56-carry.png)). A third, `carry = .after_touch`, draws a +store's touch first and then its carry, the row naming the word before the +value goes there: for the introduction's `push rbp`, where the push is the +lesson ([motion.md](motion.md#a-word-touched)). **The aim.** Off unless the author turns it on (`aim = .step` or `.standing`, for a scene or a beat). On, it finds every value on screen that @@ -1513,9 +1524,14 @@ a row shown, the head glides to that row (24 f, `glide`) after the strike; code with no row shown, the head goes to the rule as a stub with the row's name; no longer code, the aim **frays**: it goes dashed (12 on 8) over 12 f and fades over 18 f. Standing, it rides its rows when they scroll, and a word -that leaves its window takes it away. Route: out of the word's panel's left -rule level with it, the gutter's left lane (x 950), onto the disassembly's -right rule level with the row ([mock 57](mock/57-aim.png)). +that leaves its window takes it away. `drawn` is a standing aim the beat +itself introduces, with no step to draw it: it draws as a step's does, head +first at full ink (18 f), the row's address framed as the head lands (6 f), +and falls to the standing 60% only when the next step begins (the +introduction's return address, II3 to II4). Route: out of the word's panel's +left rule level with it, the gutter's left lane (x 950), onto the +disassembly's (or a descent window's) right rule level with the row, its head +10 by 10 ([mock 57](mock/57-aim.png)). **Order.** A tie arrives before the thing it points to reacts: see [`link`, `project`, `touch`, `carry` and `aim`](#6-verbs). Mock 9 shows the standing ties; 10 and @@ -1702,7 +1718,7 @@ named band carry their addresses, and the bands their sizes. | the names | right of the box, from 64 past it (the leaders' room). A row for each edge of a named band: its address in mono 20, in the ink of the band it bounds, and a leader (2, `rule`) from the edge, 8 out, straight to 20 short of the address, 12 in. Between two edges a row for the band, indented 24: its permissions and its size (`dim`, ranged right 132 in), and its file in primary at 252 (`[stack]`, `libc.so.6`); a file of several named bands once, on a `quiet` bracket over their rows. Rows 24 apart, each as near its edge as the others let it (crowded rows pooled round their mean), inside the box's share of the stage; a leader never crosses another, as the rows keep the edges' order | | what is named | the program by segment: each of its mappings a band with its two addresses, permissions and size, under a bracket with its name, because the scenes point into them (its code, its data). Every other file once: its mappings as one (an anonymous mapping after a file's data, its bss, with it; the vDSO with its data), its start, stop, size and name, its permissions where they are one (`rw-` for the stack and the heap), and where they differ, each part's written inside its band, centred, where the band is 28 tall. A band under 6 tall is drawn and not named (an anonymous page; in mock 34 the vDSO) | | live | rsp an `under` pin in the stack's band; rip a row pin at the end of its band's row (`◂ rip`). In the introduction's first chapter neither: there are no registers yet | -| a dump's place | in the introduction, where the dump the scene has built stands beside it: a `tie` bracket on the dump's rows, and a [`link`](#4-ties) in the stack's ink from the bracket's top, up into the stage's top margin (y 56), across, and down onto the stack's box at the dump's address, its head on it. It draws in its own beat and then stands, quiet (60% toward the page), while both are on screen | +| a dump's place | in the introduction, where the dump the scene has built stands beside it: a `tie` bracket on the dump's rows, and a [`link`](#4-ties) in the stack's ink from the bracket's top, up into the stage's top margin (y 56), across, and down onto the stack's box at the dump's address, its head on it. It draws in its own beat (the dump's addresses take the stack's ink as its head lands, never before) and then stands, quiet (60% toward the page), while both are on screen. For a camera's visit, where the dump is still far thinner than a unit, its place is marked on the box: a 2-unit tick across it in the stack's ink at the dump's address, the dump's size over it (`128 bytes`) left of the link's head | | `ink`'s echo | the band a word points into, framed as read inside the box (2 units, 4 in from its sides, 6 over and under the band), and that band's row of names framed with it | The physical comparison is the caption's, worked from the recording: if @@ -1968,7 +1984,7 @@ caption's and the clock's. | before the first step it describes fires | 60 f after it has arrived; 120 f for a scene's first | | a scene's first | arrives at 1.0 s; the first step fires by 4.0 s (5.0 s when the scene opens on the map and dives) | | changes | only in a rest, never under a moving thing | - | names | only what is on screen at the pace it plays: no register a run veils, no step that has not happened or that played more than its 60 f lead ago | + | names | only what is on screen at the pace it plays: no register a run veils, no step that has not happened or that played more than its 60 f lead ago; and nothing before it has been shown, in a caption or a label (a dump's header, a tag): the introduction's first bytes are `128 bytes at 7fffffffebc8`, not the stack's, until the stack is on screen | | checked | by the instruments' CAPTION ([motion.md](motion.md#the-instruments)) | | longer than two lines | two captions, split at a phrase rest | | the last | its reading time before the cut, and 2 s on the finished picture; the scene grows to fit | @@ -2017,7 +2033,11 @@ glide and resize to their boxes (24 f), their rows riding with them; the text column opens and the first bubble arrives (18 f). Back to the working frame: the bubbles leave together (12 f); the panes glide to their working frame's boxes (24 f); the folded panes unfold from the shelf in their places -(18 f, rows in 6 f); the caption arrives. About 70 f each way. A drawing that +(18 f, rows in 6 f); the caption arrives. About 70 f each way. A part with +no panel round it (the introduction's dump: a header over its rows) folds by +its own rows: they glide up into its header (24 f, `glide`), the header +becomes the tag where it stands, and the tag slides to the shelf (24 f, +`glide`); back, the reverse. Nothing goes out in a few frames. A drawing that changes size between the forms keeps its labels inside its box at every frame: it scales as one (24 f) and its tag's note crossfades if it no longer fits. @@ -2064,7 +2084,9 @@ it); it is never drawn empty, not for a frame (the built scene emptied its descent for 40 f while it grew). **`bubble`.** A piece of narration: Go 40 on 54 as the caption is, code in -mono 35, lines of at most 40 characters, 16 of padding, 812 wide at most. The +mono 35, lines of at most 40 characters (80 for a text `above` a subject +that spans both columns: two lines in its band of 120), 16 of padding, 812 +wide at most at 40. The newest is on `raised` paper, primary: the one being said. An older one loses its paper and dims to `dim` (18 f, as the next arrives), and stays as the account the viewer can glance back at. Three stand at most; a fourth's @@ -2167,13 +2189,13 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `cool` | a struck value | starts with the advance: 24 f, `glide`, the paper to nothing, and the turned corner of `held` fades in over its last 6 f, for three steps (then out over 36 f); the same in a lens's cell. The digits go to their ordinary face at its middle | | `read` | a value read | in over 6 f; held to the advance; out over 18 f. No arm, no pulse | | `extend` | a chain whose first hop was struck | each later hop is followed again, 4 f apart, fading in over 6 f | -| `link` | a `reg` just struck, and its target | s+6: the old pin fades (12 f) and the line draws from the register's row, head first, 24 f (36 f over 400 units), `standard`, the pin riding its head; the pin lands with the head and settles (12 f); held; at the advance the line draws back into the pin over 18 f. A target out of the window: the line ends in its stub, and the pin waits for the window | +| `link` | a `reg` just struck, and its target | s+6: the old pin fades (12 f) and the line draws from the register's row, head first, 24 f (36 f over 400 units), `standard`, the pin riding its head; the pin lands with the head and settles (12 f); held; at the advance the line draws back into the pin over 18 f. A target out of the window: the line ends in its stub, and the pin waits for the window. **On a beat** the caption names, with no step (rsp in the introduction's II2, rax in its III3): the register framed as read (6 f), the line 6 f after (36 f, `standard`, the name riding its head), held as the beat says, then drawn back toward its head over 18 f with the register's frame, the head fading over the draw-back's last third: never gone in one frame | | `project` | a run read or struck, and its part of the drawing | on the run's mark: the bracket on the row (6 f), the line draws from the bytes to the drawing (18 f; 30 f over 600 units; `standard`); only when it arrives does the part react (its own `read`, or `arm` and `strike`; a new call's node fades in, 6 f); out with the advance, 18 f | -| `touch` | the current row and the stack word it reads or writes (`tied`) | right after the fire, before anything the word causes: the line draws from the row's end across the gutter to the word's row, head first, 12 f (18 f when its leg is longer than six rows), `standard`; only when the head has landed is the word armed (a write: 12 f, then struck) or framed (a read, 6 f); only after that does what follows from the word move (a register it fills, rsp's pin climbing onto a pushed word, a span, a role). Held to the advance; drawn back into the row with it, 12 f, or (with `carry` on, for a load) as the carry leaves the word. A store of the value the word already held: the head lands, the arm's frame comes and goes and nothing is struck. A word the window must scroll to: the scroll first, then the touch. At a run and a sprint none: the names stand, and the marks are the run's | -| `carry` | a value's way from its source to its destination (`carry = .arrow`) | the source framed `read` first (a register 6 f; a word by its touch); then the arrow draws from it to the destination, head first, 18 f (24 f past eight rows), `standard`; on its landing the destination is armed (12 f) and struck; the arrow draws back as the strike lands (18 f); only then what follows (a link from the register filled, a pin's travel). At a run and a sprint none | -| `aim` | a code address and its row (`aim = .step` or `.standing`, the author's) | after the word's own strike or read: the line draws from the word to the row, head first, 18 f (24 past ten rows), `standard`, the row's address framed in code's ink as it lands (6 f); held to the advance, or standing at 60% through the beat; a word written again: the head glides to the new row (24 f, `glide`), goes to the rule as a stub with the row's name, or frays (dashed 12 f, then out 18 f) when the value is no longer code; at a `ret`, the plaque jumps where it points and the aim draws back as it lands. At a run and a sprint none | +| `touch` | the current row and the stack word it reads or writes (`tied`) | right after the fire, before anything the word causes: the line draws from the row's end across the gutter to the word's row, head first, 12 f (18 f when its leg is longer than six rows), `standard`; only when the head has landed is the word armed (a write: 12 f, then struck) or framed (a read, 6 f); only after that does what follows from the word move (a register it fills, rsp's pin climbing onto a pushed word, a span, a role). Held to the advance; drawn back into the row with it, 12 f, or (with `carry` on, for a load) as the carry leaves the word. A store of the value the word already held: the head lands, the arm's frame comes and goes and nothing is struck (in the introduction, where the push is the lesson, it is struck: [motion.md](motion.md#a-word-touched)). A word the window must scroll to: the scroll first, then the touch. At a run and a sprint none: the names stand, and the marks are the run's | +| `carry` | a value's way from its source to its destination (`carry = .arrow`; `.after_touch`: a store's touch first, then its carry) | the source framed `read` first (a register 6 f; a word by its touch); then the arrow draws from it to the destination, head first, 18 f (24 f past eight rows), `standard`; on its landing the destination is armed (12 f) and struck; the arrow draws back as the strike lands (18 f); only then what follows (a link from the register filled, a pin's travel). At a run and a sprint none | +| `aim` | a code address and its row (`aim = .step`, `.standing` or `.drawn`, the author's) | after the word's own strike or read: the line draws from the word to the row, head first, 18 f (24 past ten rows), `standard`, the row's address framed in code's ink as it lands (6 f); held to the advance, or standing at 60% through the beat (`drawn`: drawn so on its beat, at full ink, falling to 60% (18 f) as the next step begins); a word written again: the head glides to the new row (24 f, `glide`), goes to the rule as a stub with the row's name, or frays (dashed 12 f, then out 18 f) when the value is no longer code; at a `ret`, the plaque jumps where it points and the aim draws back as it lands. At a run and a sprint none | | `follow` | the stack's window, after rsp's pin | only once the pin has landed and never with it: where the headroom over rsp is under two free words, or the newest frame's return address under the window's foot, the rows glide by whole slots, 24 f and 2 f a further slot, 36 f at most, `glide`, the pins riding their rows, the strip's window with them. A climb longer than the room over the pin is one move: the pin travels to the window's top, and the rows take the rest of the distance under it on the same curve. Farther than the window: `unroll`, the pin along the column, `roll` | -| `travel` | a value, a card or a pin going from one place to another | `glide`. A value or card: 30 f to 200 units, 36 f to 400, 48 f beyond. A pin goes along its lane, 18 f after the strike that moved it: in a drawing 30 f to the next node or cell, 36 f to one farther; in the stack's lane 24 f to the next row and 2 f a further row, 36 f at most. A pin that comes fades in over 12 f rising 8 units; one that goes fades out over 12 f; a name joining or leaving a pin cross-fades over 12 f. On a `link` the pin rides the line's head instead. 8 f at a run; at a sprint only at a phrase's end. **rsp's and rbp's pins** are the stack's event and are given time: 24 f to the next row and 6 f a further row, 48 f at most, `glide`; the amount on the pin from its first frame, counting as it crosses each row (`rsp -8`, `-10`, `-18`, in write's vermilion, bold), held to the advance and then crossfading to the bare name (12 f); each row it reaches gained (brightening from `free`, 12 f, from the frame the pin's head reaches it, its role fading in with it) or released (to `free`, 12 f); the bracket over the rows crossed drawing with it; the newest span's end riding it; the register struck as the pin lands, and the row's amount with it. rbp's flight to rsp's row: the same, the names meeting in pwndbg's order (rsp slides aside, 12 f, before rbp lands). At a run: 8 f and 2 f a row, 16 f at most, drawn over the veil (the pins, the bracket, the span and the rows' gain or release stand clear of it; the rest of the stack stays veiled), no amount; at a sprint, on the map, rsp is the edge of the stack column's newest frame, moving with each moment (4 f), the spans growing and shrinking with it | +| `travel` | a value, a card or a pin going from one place to another | `glide`. A value or card: 30 f to 200 units, 36 f to 400, 48 f beyond. A pin goes along its lane, 18 f after the strike that moved it: in a drawing 30 f to the next node or cell, 36 f to one farther; in the stack's lane 24 f to the next row and 2 f a further row, 36 f at most. A pin that comes fades in over 12 f rising 8 units; one that goes fades out over 12 f; a name joining or leaving a pin cross-fades over 12 f. On a `link` the pin rides the line's head instead. 8 f at a run; at a sprint only at a phrase's end. **rsp's and rbp's pins** are the stack's event and are given time: 24 f to the next row and 6 f a further row, 48 f at most, `glide`; the amount on the pin from its first frame, counting as it crosses each row (`rsp -8`, `-10`, `-18`, in write's vermilion, bold; in the introduction `-0x10`, `-0x18`, as its offsets are written: [slot](#slot)), held to the advance and then crossfading to the bare name (12 f); each row it reaches gained (brightening from `free`, 12 f, from the frame the pin's head reaches it, its role fading in with it) or released (to `free`, 12 f); the bracket over the rows crossed drawing with it; the newest span's end riding it; the register struck as the pin lands, and the row's amount with it. rbp's flight to rsp's row: the same, the names meeting in pwndbg's order (rsp slides aside, 12 f, before rbp lands). At a run: 8 f and 2 f a row, 16 f at most, drawn over the veil (the pins, the bracket, the span and the rows' gain or release stand clear of it; the rest of the stack stays veiled), no amount; at a sprint, on the map, rsp is the edge of the stack column's newest frame, moving with each moment (4 f), the spans growing and shrinking with it | | `open` | a loupe, from a pointer | the pointer's hop framed `read` (6 f); the stem draws from it to the loupe's place, head first, 18 f (30 f over 600 units), `standard`; the loupe rises with the stem's head: it fades in over 12 f from 8 units lower, its shadow growing from nothing to its offset (18 f, `standard`); the target's bright frame lands 6 f after. From a pointer inside a loupe the same, over it, and a third closes the first as it starts. In the slot of the level that read the pointer, or on a beat the caption names | | `close` | a loupe | the deepest first: its stem draws back into its pointer (12 f) and the loupe sinks, fading out over 12 f as it falls 8 units and its shadow shrinks; with the advance of the step it opened in. A loupe the narration keeps across steps closes at each advance and opens again in the idea's slot of the next step that concerns it (36 f, as `open`): the steps between are not drawn under it. Open 120 f without a change is the most | | `dive` | from the map to the working frame | one continuous move in which the windows become the panels and each pane's column of the map becomes its minimap. 0 to 6: the windows' outlines go bright. 6 to 24: the rest of the map takes the veil (50%). 24 to 96, `glide`: each window goes from its place on the map to its panel's place, its scale on a logarithm from the map's (half, filling the frame) to the frame's (whole), so its rows grow from 10 units to 20 under the eye, the panels 6 f apart in the frame's reading order (drawing, view, source, registers, disassembly, stack), each drawn over those before; on the same move the rest of each window's column (the map's panel it is a window on) squeezes into its pane's strip: from its place at half size to the strip's rect, its width and its height each on its logarithm (to 36 of 880, and 4 of 24 a row), so the text thins to strokes as it lands, the window's outline riding on it to become the strip's window; the map's parts no pane takes (the backtrace, the key, the memory round pointers, a loupe's panel) fade where they are, 24 to 72. On the same move the registers' window (the panel whole on the map, every chain) folds as it lands: each quiet register's row glides into its cell, three to a row, its chain past the first hop fading over the move's first 24 f, so that the panel arrives at its height in the frame. 72 to 96: the drawing, whose sizes may differ between the two, crossfades from the map's to the frame's within its box. 84 to 96: each squeezed column crossfades into its strip's strokes; the frame's tags, rules and lanes fade in; the veil goes with the last of the map. 96 to 132: still (mock 20) | @@ -2187,7 +2209,7 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves: | `turn` | a loop's back edge | `leave` round the ring's foot from the latch up into the header at 9 o'clock: an arc, the mark at its speed (sort's inner, 58 units, and outer, 50, 12 f each); the count at the ring's centre is armed as the mark leaves the latch and struck as it lands. The mark going round the ring, step by step and then this, is the picture of iteration; at a run the whole loop goes round in one sweep of 8 f a step | | `reach` | a block or an edge of a graph the run reaches for the first time | the edge draws gold under the mark, from `rule` (the `leave`'s own draw); as the mark lands, the pill fills from the page to `raised` (12 f), its offset brightening from faint to primary, and `×1` fades in (6 f) and is struck. Its counts begin here, never before | | `unfold` | a fold of blocks not reached yet, when the run reaches one of them | as the mark sets off along the edge into the fold: the pills beyond the fold make room along the layout's own way (round the ring, or down the layers), 24 f, `glide`; the dashed pill splits into its blocks' quiet pills in their places (12 f, 2 f apart in address order); then the mark lands on the one reached (`reach`). A fold only opens | -| `regroup` | bytes into a word (the introduction) | walked, on one word ([chart](motion.md#a-word-read), mock 37): the dump goes from sixteen bytes a row to eight (each right half down a row, then left); the other rows are veiled; the word's offsets fade in under its bytes, `low byte` under the first, `high byte` under the last; then the bytes themselves fly, the low byte first, 6 f apart, 36 f each, `glide`: straight up, over on nested arcs a quarter as high as they are long (34 to 120), straight down onto their pair's place in the word's field, 30 apart and ranged right, so that they land reversed, each offset and label going with its byte, and a faint copy fading into each one's place in the dump once it has left; the gaps close to sixteen digits (12 f); the zeros in front are bracketed, `zeros in front`, and fade (12 f). At a run (the other fifteen): each row's word fades in (8 f) as its bytes dim, rows 6 f apart. The word field is eight pairs wide, so a word is always ranged right, its low byte last | +| `regroup` | bytes into a word (the introduction) | walked, on the dump's first word, the return address at a function's first instruction ([chart](motion.md#a-word-read), mock 37): the dump goes from sixteen bytes a row to eight (each right half down a row, then left); the other rows are veiled and the dump's header goes; the word's offsets fade in over its bytes, in the header's row, `low byte` left of the first and `high byte` right of the last, outside the run; then the bytes themselves fly, the low byte first, one at a time (24 f each, 18 f apart: the next lifts as one comes down, so none crosses another): straight up to 40 over the row, clear of the offsets, over, and straight down onto their pair's place in the word's field, 30 apart and ranged right, so that they land reversed; each bright and bold in the air on its own ground, its offset riding over it and landing over it; a label goes as its byte lifts (`high byte` as the byte that lands under it lifts) and comes back on the far side as it lands; a faint copy fades into each one's place in the dump once it has left: no row of memory is crossed or printed over; the gaps close to sixteen digits (12 f), the offsets and labels going with them; the zeros in front are bracketed, `zeros in front` on a ground only as wide as its label, and fade (12 f). At a run (the other fifteen): each row's word fades in (8 f) as its bytes dim, rows 6 f apart, each written as the stack will write it (an address bare, a number as [`value`](#value) writes it). The word field is eight pairs wide, so a word is always ranged right, its low byte last | | `ink` | a word becoming an address | its digits go from primary to its region's ink (12 f), and the band it points into in `segments` is framed as read inside its box, with the band's row of names (6 f): an echo, no line. The first walked, held 60 f; the rest at a run, 2 f apart, each band framed 12 f | | `enlarge` | a box of `segments`, out of its line on the whole | 0 to 6 the cluster's line on the whole framed bright; 6 to 78, `glide`, the box rides out along the magnification: its left corners travel the two lines from the line to their places, the lines drawn behind them, the box as tall as they are apart and as wide as the ride is far (the bar's 20 to its 180), its bands drawn at its scale all the way (a mapping a 2-unit line until it is taller; the gaps opening); 78 to 90 its page lines fade in and the frame on the line goes; then its names, rows top down, 2 f apart: an edge's leader draws from the box (6 f), then its address fades in (12 f); a band's row fades in (12 f). The clusters in address order, each riding out as the one before lands ([chart](motion.md#the-address-space-enlarged)) | | `column` | rows gaining a column (offsets, roles, pins, lines) | the rows make room (18 f, as rows do), then the column's values fade in top down, 2 f apart, 12 f each | @@ -2370,15 +2392,15 @@ python3 -B column.py # 49 to 55 (the same) | [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 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 | +| [29](mock/29-intro-bytes.png) | the introduction's first picture, the camera at x2: 128 bytes, nothing else | a raw hexdump, before any ink, its header naming only what is shown (`128 bytes at 7fffffffece0`) | | [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 | +| [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 (the introduction's, `0x` from 0x10 up), roles (`the way back` on a return address), spans | | [32](mock/32-intro-code.png) | the code chapter: `aligned` with each instruction's bytes between its address and mnemonic | an instruction as bytes, decoded, level with its line | | [33](mock/33-aligned.png) | the `aligned` split, `interleaved`: reverse and its neighbours, the pc at the load | a line with two runs (20), lines with no code, rows of no line, the band as the thread | | [34](mock/34-segments.png) | `segments` as a frame, treatment A: the list recording's mappings (`ztrace show`) | the whole with its ends and size; three boxes; the program by segment under its bracket, every other file once; addresses at the edges, sizes, permissions in a row or inside a band; leaders pooled; rsp and rip | | [35](mock/35-segments-abc.png) | the three treatments as frames, saying less and less | A as 34; B every file once; C the whole alone | | [36](mock/36-aligned-columns.png) | the `aligned` split, `columns`, on 33's data and `_init` after it | the seam after the longest line; places at each column's start; line 20's cell eight rows tall; its second run; lines 23 to 25 with no code; rows of no line; the pc's wash across both columns | -| [37](mock/37-regroup.png) | `regroup` walked on the return address, `b0 18 00 01 00 00 00 00`: eight instants with their frames | the reflow to eight a row; the offsets and the low and high byte; the flight on nested arcs; landed reversed; the gaps closed; the zeros gone; the run; the ink | +| [37](mock/37-regroup.png) | `regroup` walked on the return address, `b0 18 00 01 00 00 00 00`: eight instants with their frames | the reflow to eight a row; the offsets over the row, the low and high byte beside them; the flight one at a time over the offsets, the landed offsets over their pairs; landed reversed; the gaps closed; the zeros gone; the run, the numbers as `value` writes them; the ink | | [1](mock/01-fib-recursion.png) | first pass | `calls` at camera scale | | [2](mock/02-list-insert.png) | first pass | `nodes` at camera scale; `allocated` | | [3](mock/03-syscall-write.png) | first pass | `syscalls`; `kernel` (the kernel's side is now the descent's floor, 16) | @@ -2666,7 +2688,7 @@ is not checked here. The tokens are under [Token changes](#token-changes). for it: the ASan pair and the introduction. 16. **The carry** ([`carry`](#4-ties)), a scene's knob `carry` (`.off`, - the default; `.arrow`; `.value` for the introduction's one walked load): + the default; `.arrow`; `.value` for a walked load; `.after_touch` for the introduction's push): 2 units in primary, an open chevron, the gutter's right lane, from the source's read to the destination's strike; with `tied`, a load's touch withdrawing as its carry leaves the word, a store drawing its carry and @@ -2769,9 +2791,9 @@ and `metric.bytes` and `metric.slot`'s new columns are in, as asked. | `time.descend` | none | `close` 0.20 then 0.30 (`glide`), `ring` 0.20, `lane` 0.30, `head` 0.20, `rows` 0.20 a row 0.03 apart, from 1.10 after the fire, the given-up rows fading before the kept glide, never both; from 1.80 after the fire once the push is in cause order (touch, word, rsp's pin, the window following); the step 3.60 | | `time.cross` | none | the registers framed 0.10 apart from 0.30; `lane` 0.40 from 0.80; the kernel's window 0.20; the answer up 0.40; the step 3.60, 4.90 when it moves bytes | | `time.ascend` | none | `close` 0.20 a row, 0.03 apart, from 1.60 (after the touch, the read, rsp's pin falling and the window following); the lane back 0.20; the caller's kept rows 0.30 (`glide`), then the given-back rows 0.20; the step 3.30 | -| `metric.segments` | none | the whole 20 wide, the stage's height, its labels 12 left of it; a box 180 wide (108 in a column of 880), framed 2 out, 48 apart; bands 30% over the page, named from 6 tall, permissions inside from 28; the names 64 past the box, rows 24, a band's row indented 24, sizes ranged right 132 in, files at 252 on a bracket at 240; leaders 8 out, 20 short, 12 in; the magnification 2 `rule`; a dump's place: its link 3 in the stack's ink over y 56, standing at 60% toward the page | +| `metric.segments` | none | the whole 20 wide, the stage's height, its labels 12 left of it; a box 180 wide (108 in a column of 880), framed 2 out, 48 apart; bands 30% over the page, named from 6 tall, permissions inside from 28; the names 64 past the box, rows 24, a band's row indented 24, sizes ranged right 132 in, files at 252 on a bracket at 240; leaders 8 out, 20 short, 12 in; the magnification 2 `rule`; a dump's place: its link 3 in the stack's ink over y 56, standing at 60% toward the page; for a visit, a 2-unit tick across the box and its size in Go 20, the stack's ink | | `time.enlarge` | none | the line framed 0.10; the ride 1.20 (`glide`); page lines 0.20; names 0.20 each, 0.033 apart, a leader 0.10 before its address; the next cluster as one lands | -| `time.regroup` | none | rows making room 0.30, down 0.20, left 0.30; veil 0.30; offsets 0.20 each, 0.033 apart; a byte's flight 0.60, 0.10 apart; the gaps 0.20; the zeros 0.20; at a run a word 0.133, rows 0.10 apart | +| `time.regroup` | none | the rows in 0.30 each, 0.30 apart; rows making room 0.30, down 0.20, left 0.30; veil 0.30; offsets 0.20 each, 0.033 apart; a byte's flight 0.40, 0.30 apart (one in the air at a time), 40 over its row, its offset 22 over it; the gaps 0.20; the zeros 0.20; at a run a word 0.133, rows 0.10 apart; the dump's fold 0.40 and 0.40 | | `insn.annotation` | none (the chain always) | `tied` (the default) or `whole`, a scene's, settable per beat | | `metric.slot.offset` | from rsp | from the frame's base (the CFA's register at the newest frame's pc) under `tied`; the tag's note names it; a change of base crossfades 0.20 | | `metric.touch` | none | 2, in the mark's colour; the gutter's middle lane at 956; a head 7 by 8 on the stack's rule (on its right rule, pointing left, in the column); corners 6 | @@ -2780,10 +2802,10 @@ and `metric.bytes` and `metric.slot`'s new columns are in, as asked. | `time.sp_travel` | `time.pin` (24 f, 2 f a row, 36 at most) for every pin | rsp's and rbp's: 0.40, 0.10 a further row, 0.80 at most (`glide`); the amount's crossfade 0.20 at the advance; a row's gain or release 0.20; at a run 0.13, 0.03 a row, 0.27 at most | | `time.follow` | none | after the landing: 0.40, 0.03 a further slot, 0.60 at most (`glide`) | | `metric.carry`, `time.carry` | none | 2 in primary, an open chevron 7 by 8 in two strokes; the gutter's right lane, 962; the source's read 0.10, the arrow 0.30 (0.40 past eight rows), the destination's arm 0.20 and strike, back 0.30 with it; `carry = .value`: a chip of `raised`, mono 20, on the head | -| `metric.aim`, `time.aim` | none | 2 in code's ink, a filled head 7 by 8 on the disassembly's right rule, the row's address framed 2 in code's ink; the gutter's left lane, 950; 0.30 (0.40 past ten rows), `standard`; a new row 0.40 (`glide`); fraying: dashed 0.20, out 0.30; standing at 60% | +| `metric.aim`, `time.aim` | none | 2 in code's ink, a filled head 10 by 10 on the disassembly's right rule, the row's address framed 2 in code's ink; the gutter's left lane, 950; 0.30 (0.40 past ten rows), `standard`; a new row 0.40 (`glide`); fraying: dashed 0.20, out 0.30; standing at 60% | | `relations` | each kind its own | the kinds' table ([ties](#4-ties)); the budget: the thread, two active, one standing across panes; the pass within 1 ms on the map | | `metric.column` | none | the panes at 64 and the text at 976, 880 each; the shelf at 48, 24 high, its tags 12 apart; the panes from 84, narrated rows above 888, the floor to 1032; the clock under the text column at 900 | -| `metric.bubble` | none | Go 40 on 54, code mono 35; 40 characters and three lines at most; padding 16, 812 wide at most; the newest on `raised`, older ones `dim` and bare; three at most; 12 between bubbles; the stem 2 in `dim`, a head 7 by 8 | +| `metric.bubble` | none | Go 40 on 54, code mono 35; 40 characters and three lines at most (80 and two `above` a subject across both columns); padding 16, 812 wide at most; the newest on `raised`, older ones `dim` and bare; three at most; 12 between bubbles; the stem 2 in `dim`, a head 7 by 8 | | `time.bubble` | none | in 0.30 rising 8 (`enter`), out 0.20; dim 0.30; out of the newest's way 0.40 (`glide`); the stem 0.20 in with the bubble, 0.20 back with the fire; between beats: fold 0.20 then 0.40 (the panel closing as its tag travels to the shelf), the stayers 0.40, unfold 0.40 (the tag back as the panel opens) then 0.20 | | `metric.aligned` | `interleaved` only | `columns`: the seam 48 after the longest line in the window; each column's place ranged right 132 into it, its text 24 after; a line's first row `raised` | |
