summaryrefslogtreecommitdiff
path: root/design/README.md
diff options
context:
space:
mode:
Diffstat (limited to 'design/README.md')
-rw-r--r--design/README.md448
1 files changed, 397 insertions, 51 deletions
diff --git a/design/README.md b/design/README.md
index d50d8c1..60e6cea 100644
--- a/design/README.md
+++ b/design/README.md
@@ -66,7 +66,7 @@ this table.
| 2 row | [`chain`](#chain) | a telescope: this, which points to that, which holds this | `room`, marks per hop; opens a `loupe` |
| | [`reg`](#reg) | a register and its chain | `rip` (with `flags`) |
| | [`slot`](#slot) | a word of the stack and its chain | pins; `free` |
-| | [`insn`](#insn) | an instruction and its annotation | `current`, `ran`, `ahead`, `outside`, `waiting`, `pass` |
+| | [`insn`](#insn) | an instruction and its annotation | `current`, `ran`, `ahead`, `outside`, `waiting`, `pass`; the annotation `tied` (the default) or `whole` |
| | [`line`](#line) | a line of source | `current`, `trail`, `waiting`; wide numbers |
| | [`bytes`](#bytes) | sixteen bytes of a dump and what they read as | field runs (`size`, `protected` among them), marks per byte; wide address |
| | [`call`](#call) | one frame of the call chain | `row`, `span`; `newest` |
@@ -84,6 +84,8 @@ this table.
| | [`link`](#4-ties) | this register points at that | for a step; rests as a `pin`; a stub when that is out of view |
| | [`projection`](#4-ties) | these bytes are that part of the drawing | for a step |
| | [`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 |
| 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 |
@@ -91,10 +93,12 @@ this table.
| | [`map`](#the-map-and-the-minimap) | the working frame unfolded, every panel whole: 3840 by 2160 | the key |
| | [`minimap`](#the-map-and-the-minimap) | a pane's whole column of the map, small, in a strip at its right | its window, marks, `flash` |
| | [`clock`](#clock-and-caption) | where in the recording | |
+| | [`column`](#column-an-experiment) | an experiment: the panes a beat is about in one column, its narration in the other | the `shelf` of folded panes |
+| | [`bubble`](#column-an-experiment) | a piece of narration placed in the frame, level with what it speaks of | `beside`, `below`, `above`, `on`; newest, older; its `stem` |
| | [`caption`](#clock-and-caption) | the narrator | |
| | [`veil`](#clock-and-caption) | page over what a beat does not touch, or a pace cannot show | |
| | [`card`](#clock-and-caption) | a title, the legend: no program running | |
-| 6 verb | [`fire` `arm` `strike` `cool` `read` `extend` `link` `project` `travel` `advance`](#6-verbs) | what one block does | |
+| 6 verb | [`fire` `arm` `strike` `cool` `read` `extend` `link` `project` `touch` `carry` `travel` `follow` `advance`](#6-verbs) | what one block does | |
| | [`open` `close`](#6-verbs) | what a loupe does | |
| | [`descend` `cross` `ascend`](#6-verbs) | what a descent does: a call followed down, a system call, a return | |
| | [`regroup` `ink` `enlarge` `column` `frame up` `decode` `align`](#6-verbs) | what building a view does (the introduction) | |
@@ -430,10 +434,10 @@ 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 | from rsp, hex, `+18`, faint, ranged right in four characters (`-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 |
| 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`); at the process's start `argc`, `argv[0]`, `argv end`, `envp end`, `auxv` (dim) |
+| 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
@@ -442,9 +446,11 @@ 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 → …`).
-`free`: a word above rsp, which the stack has not reached. Shown only
-while the window is held still for the camera ([`visit`](#6-verbs)): its
-address at 60%, its word in faint, no chain, no pin. A push fills it.
+`free`: a word above rsp, which the stack has not reached: the window's
+headroom, the words a pop or a return has just released, and every word over
+rsp while the window is held still for the camera ([`visit`](#6-verbs)). Its
+address at 60%, its word in faint, no chain, no role. A push fills it; rsp's
+pin reaching it makes it the frame's.
### insn
@@ -458,7 +464,7 @@ An instruction, pwndbg's way: what it is, and what its operands are now.
| 134 | line | the source line this run of instructions came from, ranged right in three characters, faint; on the first row of each run only; gold and bold for the current line. Wide numbers (see [`line`](#line)) widen it, and every column right of it moves by the extra: mnemonic, operands and annotation, the row's room 12 characters less for six digits |
| 180 | mnemonic | keyword, bold; `nop` and `endbr64` faint, with their operands: padding, which touches nothing |
| 264 | operands | as the disassembler writes them, whole, less the size words (`qword ptr `): a [`width`](#width) after the bracket where no register says the size. A jump's or call's target is an `address` in code ink; a PLT stub's, named by the stub: `401070 open@plt` |
-| 564 | annotation | from 564 (540 in a pane with a [minimap](#the-map-and-the-minimap), whose strip takes 48 of the row), or a character after operands that run past it; a chain, cut at its far end by the chain's rule |
+| 564 | annotation | from 564 (540 in a pane with a [minimap](#the-map-and-the-minimap), whose strip takes 48 of the row), or a character after operands that run past it: what the instruction did, in the form the scene chose (below); a chain is cut at its far end by the chain's rule |
**Wide addresses.** An address of more than seven digits (a library's
twelve, `7ffff7d10fc5`) moves every column right of it by the extra, 12 a
@@ -485,21 +491,64 @@ whole annotation do not fit, in this order:
| `waiting` | a call whose callee's window is open under it, in a descent: the plaque's place ringed (a 2-unit primary frame 24 by 24, a primary head in it), as a waiting call node is; no wash. Its annotation is the call in C's form: `open("note", O_RDONLY)` |
| `pass` | a stub's jump, gone through on the way down: a trail bar; the call lane runs on from it |
+**The annotation's form** is a scene's knob, `annotation`, with two values. A scene that says nothing gets
+`tied`; one asks for the other with `annotation = .whole`, for the scene or from a beat on.
+
+- **`tied`** (the default). Every fact is printed once, in the pane that holds it, and the row names it there.
+ A word of memory the instruction reads or writes is named, not spelled out: the annotation is the word's
+ name and the value that moved, one hop, and the word's own row holds its address and the rest of its chain.
+ The name is the word's role in the stack ([`slot`](#slot): a local `next`, `n` for the high half it lives
+ in, `saved rbp`, `argv[0]`) or a global's symbol (`head`), bold, in the ink of the region it lives in, as a
+ variable's [`pin`](#pin) is; the grammar is the chain's, the name standing where the address would:
+ `next → 405010`, `prev ◂ 0`, `saved rbp → 7fffffffed00`. A register the instruction sets is the small `reg`
+ cut after its first value, `rax 405010`: the chain is the registers pane's, where it is struck in the same
+ frame. With `tied` the stack counts its offsets from the frame's base, so the operand's displacement and
+ the word's offset are one number (`[rbp - 0x18]`, `-18`), and a walked step draws its
+ [`touch`](#4-ties) from the row to the word. The row is half as long (`next → 405010` for
+ `7fffffffecc8 → 405010 ◂ 7`), and the value it wrote is never the part cut off: beside a minimap the whole
+ chain of a stack store is cut to `7fffffffecc8 → …` (mock 44).
+- **`whole`**: the annotation as pwndbg prints it, a chain from the address the instruction computes
+ (`7fffffffecc8 → 405010 ◂ 7`), and the stack's offsets from rsp. For a scene whose story is the address
+ itself (where a store lands in the ASan pair, a heap scene reading the allocator's words, the introduction
+ before the stack has a pane), and for a frame with no stack pane at all.
+
+Under `tied`, where the word has no name or no pane holds it, the row falls back, that row alone:
+
+| The word | Its annotation under `tied` |
+| --- | --- |
+| a slot in the stack's window, with a role | its name and the value: `next → 405010` |
+| a slot in the window with no role (a spill, a temporary, the canary's copy) | its address and the value, one hop: `7fffffffecd0 ◂ 1`; the slot's offset says where it is |
+| a slot outside the window | the window scrolls to it first, in memory's slot of the step before the row fires ([`scroll`](#6-verbs)), so it is never outside when it is touched; where the window cannot go (held still for a camera [`visit`](#6-verbs), another thread's stack) the whole chain, its name in place of the address |
+| a word a dump or a loupe on screen shows (the band's view, a loupe) | its address and the value, one hop: `405038 → 405010`; the run's mark is the [`echo`](#4-ties); no touch, the view being far |
+| a word no pane shows (a global, the heap with no view) | the whole chain, as `whole` draws it, its name in place of the address where it has one: `head → 405050 ◂ 9` |
+
+**The operand** is the encoding and stays as the disassembler writes it, less its size word: `[rbp - 0x18]`,
+primary. The name is the annotation's and is never written into the brackets: IDA's `[rbp+next]` (way C of
+[mock 48](mock/48-tied-ways.png)) reads well but hides the displacement the stack's offset column matches, and
+asks the viewer to know that `next` is −0x18.
+
+**What stays in the row** under either form, because no pane holds it: a compare's two values and the flags
+it leaves; a conditional's `taken` and the flags it reads; a call's arguments, its result, and the call in
+C's form; `lea`'s sum; an indirect target and the slot it was read through; a `rep`'s count; a system call's
+name, number and arguments; a return's destination.
+
**The annotation**, by what the instruction does:
| It | Annotation |
| --- | --- |
-| reads memory | a chain from the address it computes: `28b41098 → 28b41070 ◂ 9`. Before the step, where it will look; in the step its first hop is `read`. The value is read at the access's width: a 4-byte load of `n` is `7fffffffecc4 ◂ 15`, not the word round it |
-| writes memory | the same chain; the value after `holds` is `struck` |
-| only sets a register | a small `reg`: `rax 28b41090 ◂ 4` |
+| reads memory | `tied`: the word's name and the value read, `prev → 405050`; `whole`: a chain from the address it computes, `28b41098 → 28b41070 ◂ 9`. Before the step, where it will look; in the step the name (the chain's first hop) is `read`, an [`echo`](#4-ties) of the word's own frame. The value is read at the access's width: a 4-byte load of `n` is `n ◂ 15` (`7fffffffecc4 ◂ 15`), not the word round it |
+| writes memory | the same; the value is `struck`, in the frame the word is |
+| only sets a register | a small `reg`: `rax 28b41090` (`tied`), `rax 28b41090 ◂ 4` (`whole`) |
+| moves rsp or rbp | the move in its own terms, first: the amount, `rsp -8`, `rsp -0x18 3 words`, `rsp +0x18`, `rbp = rsp`; then the word it writes or reads, by its role (the value is the pushed or popped register's, in the registers): `push rbp` is `rsp -8 · saved rbp`, `pop rbp` `rsp +8 · saved rbp`, `leave` `rsp +0x20 · saved rbp`, a `call` `reverse() · rsp -8`, a `ret` `→ 401272 main+50 · rsp +8`. The amount is struck with rsp's strike (an echo); the stack's answer is the [stack's own instructions](motion.md#the-stacks-own-instructions) |
+| computes the address of a named word (`lea rsi, [rbp - 0x30]`) | `= &buf`, the name in its ink; the register's pin lands on the word's row (a [`link`](#4-ties) to a slot) |
| compares or tests | the two values it compares, ` : ` between, faint: `3 : -4096`; then the flags it leaves, those the conditional after it reads (CF ZF SF OF when none follows): set on a chip as rip's are, clear in dim lower case: `3 : -4096 CF zf` |
| jumps on a condition | `taken` in primary, or `not taken` in dim, then `· reads` and the flags it reads, as the compare drew them; taken, and its target is in the window: the line in the jump lane; outside it: `taken → 1001935 reverse+37`. While it is current, the chips on the row that set them are framed as read with it (an `echo`), and rip's |
| computes an address (`lea`) | `=` and what it made: an address and its chain (`= 402004 "note"`), or a number. With room, the sum first, each register's value in its ink: `rbp 7fffffffed00 - 0x30 = 7fffffffecd0` |
-| calls | the callee's name, bright; its arguments hang under it in the annotation column, a small `reg` a row (`rdi …`, `rsi …`), as many as the prototype has, three when there is none. The rows they cover are ahead and have nothing there. Through a PLT stub: the function the stub reaches, `open` (or `the resolver` while its GOT slot is still lazy). Once it has run: the call in C's form and its result, `open("note", O_RDONLY) = 3` |
+| calls | the callee's name, bright; its arguments hang under it in the annotation column, a small `reg` a row (`rdi …`, `rsi …`), as many as the prototype has, three when there is none. The rows they cover are ahead and have nothing there. Through a PLT stub: the function the stub reaches, `open` (or `the resolver` while its GOT slot is still lazy). A direct call whose operand already names its callee (`4011a0 reverse`) says the call in C's form instead, `reverse()`, `push(9)`. Once it has run: the call in C's form and its result, `open("note", O_RDONLY) = 3`. The word it pushes is the stack's: the call's [`touch`](#4-ties) goes to it |
| calls or jumps through memory or a register | where it goes: `→ 7ffff7d10ec0 open`; then, faint, where that was read: `· read from open@got, 403fd8`. Out of room, the slot goes first, then the target's digits; its name stays: `→ __pwrite64` |
| reads a place the C library's layout names | the name, then the value: `fs:[0x28]` is `the stack's canary 191a6a1f012bed00` |
| repeats (`rep stosq`, `rep movsb`) | the count and the step: `rcx 12 · 8 bytes each`, the destination's chain after. Stepped by instruction a `rep` stays current while rcx counts down, an iteration a step |
-| returns | `→ 10018b0 main+80` |
+| returns | `→ 10018b0 main+80`: the value of the word it reads, which is framed `read` on the stack with its touch |
| makes a system call | its name and number, `openat nr 257`; its arguments hang under it by name, as a call's; in a [`descent`](#descent) the kernel's window opens under its window |
Mocks 9 to 11 show the read, the register-setter, the taken jump and
@@ -507,7 +556,9 @@ Mocks 9 to 11 show the read, the register-setter, the taken jump and
than 24 characters with the annotation moved right of them; 14 an
indirect call by name; 16 a call through the PLT, `waiting`, `pass`, a
system call; 17 a compare and the conditionals reading it, a `lea`, a
-named place. A `rep`, and the flags' echo, are not drawn.
+named place; 44 and 45 a store and a load under `whole` and `tied`; 46 a
+call's push and 47 a prologue under `tied`; 48 three ways of tying the row
+to its word. A `rep`, and the flags' echo, are not drawn.
### line
@@ -692,25 +743,49 @@ prologue's pushes), the locals' names and places (the debug info at the
pc), and the first stack pointer (argc, argv, envp, auxv).
**The window** is on the newest frame: the words from rsp to its return
-address, `[rsp, rbp+16)`. It is a window onto the map's stack column, which
-runs from 16 words above rsp to the stack's top.
+address, `[rsp, rbp+16)`, and over rsp its **headroom**, two words drawn
+`free`: the room a push, a call or a `sub rsp` will take, there before they
+take it. In a leaf whose locals lie under rsp (the red zone, at -O0 without a
+`sub rsp`) the window starts at the lowest of them instead, rsp's pin on a row
+inside it, since those words are the frame's and its instructions touch them.
+It is a window onto the map's stack column, which runs from 16 words above rsp
+to the stack's top.
-- Where the frame is no longer than the window, the window's top is rsp
- and the caller's words fill the rest.
+- Where the frame is no longer than the window, the window's top is the
+ headroom's and the caller's words fill the rest.
- Where it is longer, the window scrolls down it by whole slots
([`scroll`](#6-verbs)) to keep the slot a step touches in its middle
half (the fourth to ninth of twelve), and stays there until a step
- touches a slot outside it. Its top never passes above rsp.
-- A push or a call moves the top with rsp: the rows slide one slot (18 f,
- as rows making room), at the memory level, before the new word is
- armed. A window going farther than its height fades through instead
- ([`scroll`](#6-verbs)).
+ touches a slot outside it.
+- **When rsp or rbp moves, the rows hold and the pin travels** ([`travel`](#6-verbs)):
+ the move of a stack pointer is the event of its step, and is seen as a
+ move. rsp's pin climbs (a push, a call, a `sub rsp`) or falls (a pop, a
+ `ret`, an `add rsp`, a `leave`) row by row along the pin lane, the amount
+ on it as it goes (`rsp -18`, in write's vermilion); each row it reaches
+ is gained (it brightens from `free` to the frame's, and its role arrives)
+ or released (it goes quiet, `free`); a 3-unit vermilion bracket in the
+ outer arc lane spans the rows it crossed; the newest frame's span
+ stretches or shrinks with it; its register is struck as it lands. rbp's
+ pin flies the same way to where rsp is (`mov rbp, rsp`), the two meeting
+ on one row in pwndbg's order; rsp's to rbp's (`leave`).
+- **Then the window follows** ([`follow`](#6-verbs)), never with the travel:
+ once the pin has landed, if fewer than two free words stand over rsp, or
+ the newest frame's return address has gone under the window's foot, the
+ rows glide by whole slots to give the headroom back (the pin riding its
+ row). Where the climb is longer than the room over the pin, the pin
+ travels to the top of the window and the rows slide under it for the rest,
+ one move on one curve. Where it is longer than the window (a `sub rsp` of
+ a page, an `alloca`), the pane [`unroll`s](#6-verbs) to its column and the
+ pin travels along it at the column's scale, the region gained marked on
+ 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.
-Tag: `twelve words from rsp`, or the range when scrolled (`rsp+20 to
-rsp+78`), and `· the frames they belong to`.
+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
+changes with the frame, a crossfade of 12 f) or `· offsets from rsp`; and
+`· the frames they belong to`.
### backtrace
@@ -1260,7 +1335,9 @@ one pane a thing in another is.
| `thread` | this line is these instructions, and the machine is here | the source's current line; every run of its instructions in the disassembly | standing; moves with the current mark | gold, 3 units: a `tie` bracket on the line, one on each run, a line in the left margin (x 54) between them. On the map, where source and disassembly are side by side, across their gutter (x 1008) |
| `link` | this register now points at that; these bytes are there | the `reg` just struck; the row or node whose address it holds. In the introduction, a dump's rows and their place in [`segments`](#segments) | for the step that set it; a dump's place stands while both are on screen | 3 units, in the ink of the region pointed into, head on the target; ends in the target's `pin` and leaves it behind. From a dump, from a `tie` bracket on its rows |
| `projection` | these bytes are that part of the drawing | a run a step read or wrote, in the dump; or the return address of a frame made or ended, on the stack; the part of the drawing made of them (a node's address, a cell, a call's node) | for that step | 2 units in the mark's colour (read, write): a `tie` bracket on the row, a line, a bracket at the part (over a node's address; under a call's node); and the mark itself on the run and on the part |
-| `echo` | these are one event | the same mark at the same instant in two panels: the annotation's address and the dump's run | for that step | no line |
+| `echo` | these are one event | the same mark at the same instant in two panels: the annotation's address (or, `tied`, its name) and the dump's run or the stack's word | for that step | no line |
+| `touch` | this instruction reads or writes that word | the current `insn`; the stack word it reads or writes (a push's, a call's and a return's included), in the stack beside it. `tied` only | a walked step, from just after the fire until the advance | 2 units in the mark's colour (read, or write's vermilion): out of the disassembly's right rule level with the row, into the gutter's middle lane (x 956), up or down it to the word's height, and onto the stack's rule, a head 7 by 8 on the rule; the word's own mark is the end, so the line never crosses the pin lane's names |
+| `carry` | this value went from that word into this register, or from this register into that word | the source and the destination of a load or a store (a stack word, a dump's run or a loupe's row; a register's row); a push's register and its word, a pop's word and its register, a call's return row and its word. A scene's knob, `carry`: `off` (the default), `arrow` | a walked step, from the source's read to the destination's strike | 2 units in **primary** (a value has no region), its head an **open chevron** 7 by 8 drawn in two strokes: never a `link`, which is 3 units in the region's ink with a filled head and a pin riding it, and says "points at", not "went to". From the source's panel rule level with its row, along the gutter's right lane (x 962), onto the destination's rule. No digits travel on it |
| ink, digits | these are one thing | an address anywhere and its row, node or name; a call's arguments on its span, its backtrace row and its node | always | no line |
`call` spans and `pin`s are ties too, the kind that need no line because
@@ -1272,11 +1349,18 @@ made of them, which is what a projection says. A node and its frame are
also tied by digits, standing, through the arguments on the span.
**Budget.** One `thread`, always. For a step, one `link` and one
-`projection`, or the stems of two [`loupe`s](#loupe) (a stem is a link).
-Never more than three drawn lines in the frame; a second pointer or a
-second run in the same step gets `echo` and pins. rsp never takes a link:
-its pin is on the window's top row by construction.
-[`establish`](#6-verbs) draws no lines.
+`projection`, or the stems of two [`loupe`s](#loupe) (a stem is a link), and
+a `touch` or a `carry` (with both knobs on, a load's touch draws back as its
+carry leaves the word, so the two are one gesture, one line at a time: the row
+reaches into memory and the value comes back; a store draws only its carry,
+the row having named the word). Never more than three drawn lines in the frame; a second pointer or
+a second run in the same step gets `echo` and pins. The touch is the first to
+give way: where a step draws a link and a projection it is an echo (the word's
+mark with the row's, at the same frame), its two ends being side by side and
+the name and the digits saying already that they are one. rsp never takes a
+link: its pin is on the window's top row by construction.
+[`establish`](#6-verbs) draws no lines. In the [`column`](#column-an-experiment)
+a bubble's stem stands only in the rest before a step, never with its ties.
**Off the window.** A link whose target is outside its panel's window (a
slot past the stack's last row) comes down its lane to the panel's
@@ -1293,6 +1377,8 @@ projection):
| the left margin, x 54 | the thread |
| the gutter's left lane, x 950 | what climbs into the band from the state column: a link from a register to a pin under a node; a projection from a frame's return address to its call node |
| the gutter's right lane, x 962 | what keeps to its own height or goes down: a projection from the band's view to the drawing; a link from a register down to a slot |
+| the gutter's right lane, x 962, between the stack and the registers | a carry: up from a word to a register, or down from a register to a word, both in the state column; its legs into the panels are level with the rows |
+| the gutter's middle lane, x 956 | a touch, from a row of the disassembly to a word of the stack, within the height the two share (under the registers, so it never meets a link climbing into the band); where a link down to a slot holds the right lane over the same rows, the touch gives way to its echo rather than cross it |
| a lens's bottom lane, 8 above its edge | what arrives from below: a link to the pin under its node; a projection to a call node |
| a lens's top lane, 4 under its tag | a projection from the view, to the bracket over its node's address |
| a panel's pin lane | a link's last leg to a `row` pin, or its stub |
@@ -1301,7 +1387,7 @@ projection):
Ties that climb from the state column take the left lane and arrive from
below; the view's projections keep to the band in the right lane and
-arrive from above. A link down to a slot takes the right lane under the
+arrive from above; a touch keeps to the context's height in the middle. A link down to a slot takes the right lane under the
band and ends above the frame's return address, where a calls
projection leaves for the left lane: so the ties of one step cannot
cross. A tie may cross a panel's rule; it never crosses a letter, a digit
@@ -1310,9 +1396,29 @@ under a node that has just been made there is only room for its own
children. The map draws the thread and no other tie: a link or a
projection is a step's, and steps are told in the working frame.
+**The carry, a knob.** A scene says `carry = .arrow` to draw the value's way
+between memory and the registers; it is `off` unless a scene asks. Off by
+default because at -O0 nearly every step is a load or a store, and with the
+`touch`, the names, the offsets' digits and the strikes the move is already
+said: the carry is for a scene whose subject is where values go (the calling
+convention, the arguments of a call made, a value read back after a
+`syscall`), or a beat that names it. Register to register (`mov rax, rdi`)
+nothing is drawn: both rows are in one panel, and the strike says it. A
+narrower access (a 4-byte load of a word's high half) draws the same arrow;
+the source's read frame covers the bytes read, as the `width` cells of the
+operand say. A source or destination out of its window: the window scrolls
+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)).
+
**Order.** A tie arrives before the thing it points to reacts: see
-[`link` and `project`](#6-verbs). Mock 9 shows the standing ties; 10 and
-11 all four; 12 the projection to a call; 21 a loupe's stem.
+[`link`, `project` and `touch`](#6-verbs). Mock 9 shows the standing ties; 10 and
+11 all four; 12 the projection to a call; 21 a loupe's stem; 44 to 47 the
+touch, 48 the touch against an echo alone and against a name in the operand.
## 5. The frame
@@ -1429,7 +1535,9 @@ map.
about.
- **Every tie runs one of those ways.** In the context down or right (the
thread, a link to a slot, a loupe's stem, the call lane and the
- crossing); into the band up, then left (a link to a pin, a projection).
+ crossing, a touch: across the gutter, its leg in it going to its word's
+ height whichever way that is, since the two columns are one level, the
+ machine); into the band up, then left (a link to a pin, a projection).
None runs against them.
**What sits together.** Things that act on each other are neighbours,
@@ -1439,6 +1547,7 @@ each pair in one place:
| --- | --- |
| a line and its instructions | the source over the disassembly; the thread between |
| an instruction and what it changes | the change in its own row's annotation; the register across the gutter |
+| an instruction and the stack word it reads or writes | across the gutter at about one height (layout A puts the disassembly and the stack level); the word's role is the annotation's name, its offset the operand's displacement; a walked step's touch between them |
| a pointer and its target | the target's pin; in one panel the `arc`; a `loupe` hung under the pointer |
| a call and its callee | the callee's window under the call row ([`descent`](#descent)) |
| a system call's arguments and the kernel's side | the arguments under the `syscall` row, the kernel's window under them |
@@ -1771,6 +1880,140 @@ caption's and the clock's.
band), x2 (896 by 420: sixteen rows), x4 (448 by 210: one chain). It is
for reading, and always comes back.
+### column (an experiment)
+
+A second way to compose a scene, beside the working frame, to be tried on one
+scene and judged against it (the trial: [`open` followed down in the
+column](motion.md#a-scene-in-the-column-open-followed-down); mocks 49 to 55).
+It is not the language's default. The working frame shows the whole context
+and a caption under it; the column shows, beat by beat, the panes the beat is
+about and says what they do beside them, where they do it. It is an author's
+instrument: the scene says for every beat which panes stand, where each bubble
+sits and what it is tied to; the defaults below only spare typing, and never
+decide against what the scene wrote.
+
+**The frame.** Two columns of 880, the working frame's own: the panes on the
+left (x 64), where the program column is in the working frame, so that a scene
+going between the two keeps its source and disassembly where they were; the
+text on the right (x 976), as an assembler's comment and the row's annotation
+sit right of the code they speak of. The gutter between keeps its lanes.
+
+| Part | Where | |
+| --- | --- | --- |
+| `shelf` | the panes' column, y 48, 24 high | every pane the beat leaves out, folded to its tag, side by side in the frame's order (the drawing, its view, source, disassembly, registers, stack, backtrace). A tag's note says what the pane holds of the beat (`registers rax 3 rcx r11`, `stack main+45 pushed`), and a value struck in a folded pane is struck on its tag, in the frame its row would be: an `echo` of a row not drawn. Nothing is hidden: everything is on the shelf, and folded is acme's own way to keep a window |
+| panes | from 84 to 1032, 12 apart, each its block as specified (880 wide, rows of 24) | the beat's panes in the frame's order, the program over what it acts on: source, disassembly (or a descent), registers, stack; the drawing over them all when a lens is in the beat |
+| the floor | 888 to 1032 | under a player's controls when it is paused, as the caption band is. Panes run into it, but only with rows that continue a window (the stack's deeper words, the disassembly's later rows, a register panel's folded rows): a row a beat narrates or a step changes, and rip's, stand above 888 |
+| bubbles | the text column, 48 to 888 | below |
+| `clock` | under the text column, y 900, its count at 1856 | as [`clock`](#clock-and-caption), 880 long |
+
+**Which panes stand.** The author's list, per beat, each with its rows or
+`rest`. The default, when a beat names none: the pane of its cause (the
+disassembly, or the descent; the source over it, three lines round the
+current one, when the beat changes line) and the pane where its effect lands
+(the registers for a register, the stack for a stack word or a call's push,
+the drawing when the idea changes); the cause's pane gets the rows its window
+needs (a descent all its windows, the disassembly 11), the effect's the rest.
+A beat about the idea shows its drawing as large as the column lets it, or
+across both columns with its text above, below or on it (placements, below).
+
+**Panes between beats.** What persists slides; nothing appears or vanishes in
+one frame. In the rest between two beats, in this order: the last bubble
+dims; the panes that leave fold (their rows fade, 12 f, then the panel
+closes to its tag as the tag travels to its place on the shelf, 24 f,
+`glide`); the panes that stay glide to their new boxes (24 f); the panes that
+come unfold (the tag travels from the shelf to its box as the panel opens,
+24 f, then the rows fade in, 12 f); then an older bubble in the way glides out
+of it (24 f) and the next arrives. Never a fold and an unfold in one place at
+once: what leaves has left. About 70 f for the panes, 96 f more than a
+caption's change in all, and only in a rest (motion.md has the frames).
+
+**`bubble`.** A piece of narration: one to three lines of at most 40
+characters, Go 40 on 54 as the caption is, code in mono 35; 16 of padding,
+812 wide at most. 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 arrival makes the oldest leave first (12 f, `exit`).
+All leave at a chapter's end.
+
+- **Where it sits**: its first line level with the thing it speaks of (the
+ row's centre on the line's), so that the eye crosses on one line. The
+ author may name another level; the default is the row of the beat's first
+ step. Where the newest needs a place an older one holds, the older one
+ glides out of its way (24 f, before the newest arrives): above it, or below
+ where there is no room above. An older bubble rides with its row while the
+ row moves (a window closing round its call row) and stays where it was once
+ the row has gone.
+- **What the position says.** Level with its row, a bubble is where the story
+ is: down the column as a call goes down, the kernel's lowest; back up as it
+ returns, the account then lying below it; a loop's turns at one height,
+ each turn's bubble pushing the last up, stacked as bars are.
+- **Its stem**: a 2-unit line in `dim` from the bubble's first line across
+ the gutter onto the pane's right rule level with the row, a head 7 by 8 on
+ the rule (the row's own end is the pane's minimap). It draws as the bubble
+ arrives (12 f) and back as the step fires (12 f): the bubble points while it
+ is read, and the step's own ties have the gutter while it plays. A bubble
+ about a folded pane points at its tag on the shelf. The author may give a
+ bubble no stem; its level is then the tie.
+- **The caption's rules, restated**: it arrives (18 f, rising 8) in a rest,
+ 60 f before the step it describes fires (120 f for a scene's first); it is
+ the newest at least 90 f + 3.6 f a character and at most 720 f; nothing
+ arrives, moves or dims under a moving thing; it names only what is on
+ screen at the pace it plays.
+
+**Placements.** Where a beat's text is, chosen per beat (or per scene):
+
+| Placement | Where | For |
+| --- | --- | --- |
+| `beside` | the text column; the panes in one column | a subject made of rows, or tall: the disassembly, a descent, the stack, the source and its instructions. The experiment's main form |
+| `below` | the caption band under the working frame (the present frame, every pane as it is) | a beat that needs the program and the state side by side: the scene's opening, which establishes everything; a `continue`; a step whose effects land in both columns at once |
+| `above` | a band of 120 over a wide subject at the stage's top, the subject under it | a wide drawing whose story runs down it (a calls tree growing, a graph in `layers`): the text leads the eye in at the top |
+| `on` | in the subject's own free space | a wide drawing with room inside it (a ring's interior, the corners round the rings, the gaps of the map's columns); tied by a stem to the part it speaks of |
+
+The choice follows the subject's shape (rows: `beside`; wide: `above`, `below`
+or `on`), where its free space is, and the way the story moves (text leads:
+above when it runs down, below when the result arrives at the foot). A bubble
+`on` a drawing keeps 16 clear of every element, every edge's path and every
+path a mark will travel while it stands (the renderer knows the beat's
+steps); its stem crosses nothing, going round the drawing's outside where it
+must (mock 55); where no such place holds it, the beat is `above`. A bubble
+never travels between placements: the last leaves (12 f), the frame changes
+(a [`relayout`](#6-verbs), 48 f), the next arrives (18 f). A scene that
+otherwise uses the column may stand the working frame as it is, both columns
+of panes, with its text below or above, for the beats that need both; the
+change is that relayout, between beats.
+
+**Ties and paces in the column.** The step's ties are the frame's: the
+thread, a link, a projection, a touch. A touch from the disassembly to the
+stack under it leaves the row's right rule, goes down the gutter's middle lane
+and ends on the stack's right rule, its head pointing left (mock 49). At a
+run the panes keep their places and only the newest bubble stands; at a
+sprint the scene surfaces to the map as ever, and a bubble set `on` the map
+is the sprint's caption.
+
+**Reaching the whole context.** "We don't want to hide info" holds by three
+means: the shelf (every pane's tag, and each change in it struck there); a
+beat the author spends on the whole (`below`, the working frame), which the
+scene's opening is by default; and the map and `unroll`, as in the working
+frame.
+
+**What it costs and gains**, measured on the trial (the working frame's
+`beside` against the column at the same instant, mock 54):
+
+| | The working frame | The column |
+| --- | --- | --- |
+| the descent at the crossing | 17 rows (main 3, the stub 1, open 8, the kernel 2, heads 3) | 24 (main 5, open 13), and up to 27 with its floor above 888 |
+| source | 8 lines | 3 (the line and its neighbours) |
+| registers, stack, the log, its bytes | on screen, 14 rows, 11 words, 152, 152 | on the shelf, a tag each; rax 3 struck on its tag |
+| narration | 2 lines of 64 under the stage, 1792 by 120 | up to three bubbles of three lines of 40 beside the rows, 880 by 840 |
+| height for panes | 840 (48 to 888), shared by both columns' seven panes | 948 (84 to 1032), shared by the beat's two or three; 144 of it the floor |
+
+The caption band is not gained as narrated rows: it is under a paused
+player's controls in either form, and the column keeps narrated rows above
+888. What is gained is the right column (the state panes' 880 by 840) given
+to the narration and the left one given to fewer panes: a descent half again
+as tall, a stack of nineteen words beside a call, and text that says where it
+speaks.
+
## 6. Verbs
Frames at 60 a second. `s` is the frame a strike lands. Curves:
@@ -1787,16 +2030,19 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves:
| `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 |
| `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 |
-| `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 |
+| `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 |
+| `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 |
| `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) |
| `surface` | from the working frame to the map | the dive backwards, a little quicker: 0 to 12 the tags, rules and lanes fade out and each strip's strokes become its column's text; 12 to 84, `glide`, each pane shrinks into its window on the map as its strip unfolds into the column round it, the map's other parts fading in where they are; 84 to 96 the veil lifts; then the map is still 36 f before anything plays on it |
| `flash` | a pane's minimap, at a mark its window does not show | a ring 8 across in the mark's colour, on the mark's row in the strip, draws out to 14 and is gone, 12 f, with the mark's own strike or read |
| `unroll` | a pane, to its whole column, for a beat, without leaving the frame ("the whole function", "the whole stack") | the strip's column grows out of the strip over the pane and the panes under it (veiled, 18 f), to the stage's height or the column's, a row of the map's 4 units scaling up on the logarithm to as many as fit (sort's 79 rows of text in 840: 10 a row, shapes and inks; a 22-line file at 24, readable), `glide`, 36 f; the window's outline rides from the strip to its place in the column; the pane's own rows are that window, so nothing appears or vanishes: they are the column's rows round the outline. Held while the caption needs it (60 f at least). `roll` is the reverse, 36 f: the column shrinks back into the strip, the outline lands as the strip's window, the panes under it unveil. A far jump in the same column is `unroll`, the window travelling to its new place along the column (24 f, `glide`), and `roll` |
-| `descend` | a call the narration follows down | 0 to 12 fire on the call row; rsp struck (24); the stack slides and the return address is struck (30 to 60), as for any call; then the caller's window closes round its call row, in two moves and never both at once: 66 to 78 the rows it gives up fade (those after its return row, and from its top as many as the callee needs), then 78 to 96 the rows it keeps glide up to their places (`glide`), where they move at all; 84 to 96 the call row's plaque becomes the ring; 96 to 114 the call lane draws down from the ring, head first, `standard`; 108 to 120 the callee's head fades in rising 8 as the lane reaches it; 114 to 138 its rows, top down, 2 f apart, 12 f each; 138 to 150 the advance: the plaque lands on the callee's first row, and the source line goes `waiting` (6 f) where the callee has none. Through a stub's `jmp`: the stub's other rows fade (12 f), then its `jmp` row, `pass`, glides to its place (18 f, `glide`), the lane runs on to the next head (18 f), the next window comes in the same way. A label that changes with it (the stack span's name, the source's tag) crossfades, 12 f |
+| `descend` | a call the narration follows down | 0 to 12 fire on the call row; then the call's push, as for any call ([stack's own instructions](motion.md#the-stacks-own-instructions)): the touch to the free word over rsp (18 to 30), the return address armed and struck (30 to 42), rsp's pin climbing onto it and rsp struck as it lands (48 to 72), the window following (78 to 102); then the caller's window closes round its call row, in two moves and never both at once: 108 to 120 the rows it gives up fade (those after its return row, and from its top as many as the callee needs), then 120 to 138 the rows it keeps glide up to their places (`glide`), where they move at all; 126 to 138 the call row's plaque becomes the ring; 138 to 156 the call lane draws down from the ring, head first, `standard`; 150 to 162 the callee's head fades in rising 8 as the lane reaches it; 156 to 180 its rows, top down, 2 f apart, 12 f each; 180 to 192 the advance: the plaque lands on the callee's first row, and the source line goes `waiting` (6 f) where the callee has none. Through a stub's `jmp`: the stub's other rows fade (12 f), then its `jmp` row, `pass`, glides to its place (18 f, `glide`), the lane runs on to the next head (18 f), the next window comes in the same way. A label that changes with it (the stack span's name, the source's tag) crossfades, 12 f |
| `cross` | a `syscall` row, in a descent | 0 to 12 fire; 18 to 36 the registers that carry the call framed as read, 6 f apart, the argument rows under the row with them (`echo`); 48 to 72 the crossing lane draws down, 3 units, vellum; 66 to 78 the kernel's window opens as it lands, the vellum filling down from the lane's head; 78 to 90 its head and the call fade in, 6 f apart; the work (bytes given or filled, motion.md's chart); `returns` struck; then the answer climbs the lane (24 f) and rax is struck as it lands, the clobbered registers 6 f apart after it, the log's new row fading in (secondary); hold 36; the advance: the kernel's window draws back up into the lane (12 f) and the lane into the plaque (12 f) as the plaque moves on |
-| `ascend` | a `ret` out of a descent's window | 0 to 12 fire; 18 to 24 the return address framed as read on the stack; rsp struck (36); 48 to 72 the window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; 72 to 84 the lane draws back up into the ring; the caller's window opens in the reverse order of its closing: 84 to 102 the rows it kept glide back down (`glide`), then 102 to 114 the rows it gave up fade in; 114 to 126 the ring becomes a trail bar, the call row's annotation takes the result (6 f), and the plaque lands on the row after the call; the source line from `waiting` to `current` |
+| `ascend` | a `ret` out of a descent's window | 0 to 12 fire; 18 to 30 the touch (read) to the return address, framed 30 to 36; 42 to 66 rsp's pin falls past it, the word released, the callee's span shrinking away, rsp struck as the pin lands (66); 72 to 96 the stack's window follows; then 96 to 120 the descent's window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; 120 to 132 the lane draws back up into the ring; the caller's window opens in the reverse order of its closing: 132 to 150 the rows it kept glide back down (`glide`), then 150 to 162 the rows it gave up fade in; 162 to 174 the ring becomes a trail bar, the call row's annotation takes the result (6 f), and the plaque lands on the row after the call; the source line from `waiting` to `current` |
| `leave` | a block of a graph, along an edge | 0 to 12 fire on its last row (in the disassembly under the source; in the lens its pill's gold frame pulses with it); a conditional's compare row has its chips framed as read (18 to 24): the cause; 24 to 42 the edge it takes draws gold (3 units) from the source pill's frame to the target's, head first, `standard`; then the mark travels it: the gold plaque (22, its point the way it goes) leaves the pill along the edge, round an arc of the ring or along a way out, `glide`, 12 f and 2 f a 100 units, 12 f at least and 42 f at most (sort's steps round a ring, 58 to 72 units, 12 f; its inner loop's way out, 318, 18 f), the pill cooling to the trail as it goes; it lands on the target (the advance) and 6 f after, the target's count is armed and struck; with the landing the oldest of the three trail edges cools to `dim` (18 f). The first time an edge or a block is reached it is also a `reach`. At a walk, 1.5 s |
| `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 |
@@ -1810,7 +2056,7 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves:
| `align` | the stacked program column to `aligned`, and back (`stack`); one form of `aligned` to the other | the band and the state column fade out (12 f); the panel widens to both columns (24 f, `glide`); the source's lines glide to their heads and the instructions glide in under them (36 f, rows making room), each instruction from its row in the disassembly to its row under its line; the heads' paper and rules fade in last (12 f). `stack` is the reverse. `interleaved` to `columns`: the addresses and instructions glide right into the instruction column (24 f, `glide`), then every row glides to its height in the new form, each line level with its run's first row (24 f, `glide`); the rules move with their groups; the lines with no code fade into the room made for them (12 f). Back, the same in reverse, the no-code lines first |
| `arc` | a pointer to a row of its panel | written: with the arm (s−12) the old arc goes dashed; from s+6 it fades (12 f) while the new one draws from the pointer's row along its lane to the target, head first, 12 f, `standard`, at full ink; with the cool at the advance it quiets to standing (24 f). Read: to full ink with the read (6 f), back with the advance. Overwritten with a target off the panel or NULL: it fades from s+6 (12 f). A lane change glides 12 f. Scrolled: it rides its rows, fading as its target leaves. At a run 8 f, at a sprint none |
| `advance` | the current marks | last. The thread, the plaques and rip move together: 12 f to an adjacent row, 24 f up to eight rows, `standard`; farther, out and in over 6 f. A taken jump's line draws in the jump lane with it |
-| `cascade` | a step | `fire` (12); then its effects a level at a time, 18 f apart: CPU (`reg`s, the pc's annotation), memory (`slot`s, `bytes`), the idea (the drawing, by `project`); each armed, then struck; hold 36 f after the last strike and 12 f a further value, 84 at most; `advance`; rest 24 f. A level with nothing on screen to change gives up its slot |
+| `cascade` | a step | `fire` (12); then its effects a level at a time, 18 f apart: CPU (`reg`s, the pc's annotation), memory (`slot`s, `bytes`; under `tied` the touch first), the idea (the drawing, by `project`); each armed, then struck; hold 36 f after the last strike and 12 f a further value, 84 at most; `advance`; rest 24 f. A level with nothing on screen to change gives up its slot. A read is a cause, not an effect, and goes before what it fills: a load's word is reached and framed in the first slot (18), the register it fills struck in the next (36). Under `tied` the order is the instruction's own, cause to effect, and nothing downstream is armed or marked while what is upstream of it has not shown: the row fires; the touch leaves it; the word reacts on its landing; then what follows from the word (a register filled, rsp's pin onto a pushed word, the span, a role); then the window follows. A step that moves rsp or rbp and touches no word (`sub rsp`, `mov rbp, rsp`) has the pin's travel as its effect, the register struck as the pin lands |
| `continue` | a stop far from the last: a breakpoint, not a step. Where the windows' new places are farther than their own heights (another function, another file), it is told on the map: `surface`, the jump there, `dive` | `fire` on the line it leaves from; then the levels as in a `cascade`, but CPU is a wave: every register that changed is struck 2 f after the one above it, in pwndbg's order, the fill in over 6 f, no arm and no pulse (a dozen pulses at once are a flash, and a dozen arms a crowd); memory: the stack's window scrolls or fades to its new place, and the [backtrace](#backtrace)'s frames leave, slide and arrive; the idea; hold 36 f after the last strike; `advance`, the source and disassembly fading through if far; rest. Its marks are only on what was on screen to change |
| `run` | steps that need not be read | over a graph, the mark goes from block to block in 8 f, round the rings, each edge taken flashes to gold and cools in 8 f, counts change in place; at a sprint (on the map) the gold moves only when the block changes, 4 f at most each, the trail's three edges following and the loops' counts ticking at their centres, and the picture settles at the phrase's end. Elsewhere: 18 f a step; no fire, arm or pulse; the mark, cards, nodes and pins ease in 8 f; no strikes, no held corners and no arcs drawing: a value changes in place under an 8 f crossfade, unmarked, and what the run changed is shown settled when it ends (its arcs fade in, 8 f, standing; no corners); no ties but the thread. A caption never names what a run veils. Registers, stack and disassembly are veiled from the first shortened step to the last; the source, the band and the clock are not. 24 steps at most. A run longer than a phrase may `surface` and play on the map |
| `sprint` | steps to be got through | 4 f a step. The drawing grows and the clock sweeps; the source and the band's view are veiled as well; the mark and the pins move only at a phrase's end. Each change of pace ramps at 0.6 of the step before. A sprint plays on the map: `surface` before it, `dive` after it, at the stop it reaches; the windows glide with the pc, the marks flash and fade |
@@ -1827,9 +2073,10 @@ value written is struck; a window going far fades through. The
instruments' POP finds any one-frame change after stillness.
A step is as long as its content: 0.8 s when only the line moves, 1.5 s
-for one register, 2.0 s for a register and memory, 3.0 s for a call and 3.1 s
-for a return across three levels, 2.7 s for a swap; 2.9 s to follow a
-call down, 3.6 s for a crossing (4.9 s when it moves bytes), 2.5 s back up.
+for one register, 2.0 s for a register and memory, 3.7 s for a call and 3.6 s
+for a return across three levels, 2.7 s for a swap; 3.6 s to follow a
+call down (its push walked in cause order), 3.6 s for a crossing (4.9 s when
+it moves bytes), 3.3 s back up.
## Composition
@@ -1914,8 +2161,10 @@ from `sort-clang.dis` (sort as the scene builds it, clang -O0),
`mock/heap.py` draws the heap scene's storyboard (18) from a
recording of `mock/heap.c`; `mock/intro.py` draws the introduction and
its blocks (29 to 37) from the same list recording and its mappings;
-`mock/gen.py` draws 1 to 8. Each working frame
-has a `-480.png` beside it; the map has its 1080p (`19-map-1080.png`).
+`mock/gen.py` draws 1 to 8; `mock/touch.py` draws the disassembly tied to the
+stack (44 to 48) and the carry (56) from a fresh recording of `reverse` and its call; `mock/column.py`
+the column experiment (49 to 55) from a fresh recording of `hello`. Each working
+frame has a `-480.png` beside it; the map has its 1080p (`19-map-1080.png`).
```sh
cd design/mock
@@ -1935,6 +2184,8 @@ python3 -B map.py && for n in 09-context 10-context-step 11-context-lens 21-loup
resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done # 20-dive.png it composes itself
resvg -w 1920 19-map.svg 19-map-1080.png
python3 -B gen.py # 1 to 8, then resvg the same way
+python3 -B touch.py # 44 to 48 and 56 (it runs resvg and composes its sheets itself)
+python3 -B column.py # 49 to 55 (the same)
```
| Mock | Is | Blocks it shows |
@@ -1942,6 +2193,19 @@ python3 -B gen.py # 1 to 8, then resvg the same way
| [40](mock/40-frame-beside.png) | 9 in the reworked frame: `beside`, at rest | the registers `quiet`: rax rcx rdi rbp rsp as rows with their chains, the eleven others three to a row under a rule, rip last; fifteen stack slots and the three frames they belong to; the source's eight lines over seventeen instructions; each pane's minimap |
| [41](mock/41-frame-subject.png) | 11 in the reworked frame: `subject`, mid-step | the band as before (296, a view of seven); eight lines over eleven instructions; ten rows of registers, rdi struck and its link climbing the gutter from its new row; thirteen stack slots |
| [42](mock/42-frame-layouts.png) | the frame three ways, at a third of their size: A (recommended), B, C, each as 41's moment and as 25's | A folds the quiet registers; B keeps all seventeen and gives the source's rows to the disassembly (the stack stays six); C sets the registers in two columns (chains cut to a hop); under each tile its rows |
+| [44](mock/44-tied-store.png) | `next = cur->next` stored (`mov [rbp - 0x18], rax`, the loop's second turn), mid-step, in layout A as `subject`: `whole` over `tied` | `whole`: each row's chain from its address, the store's own cut to `7fffffffecc8 → …` beside the minimap, so its strike is off the row; offsets from rsp. `tied`: `cur → 405030`, `405038 → 405010` (the heap word the view holds), `next → 405010` struck with the stack's word; offsets from rbp, `-18` the operand's `0x18`; the `touch` from the row up the gutter's middle lane to `next`'s word |
+| [45](mock/45-tied-load.png) | the next step, `mov rcx, [rbp - 8]`: `prev` read into rcx | `prev` framed `read` with its word (echo) and the touch in read's colour; rcx struck and its link climbing to its pin under 9's node (the touch, the link and the thread: the three lines) |
+| [46](mock/46-tied-call.png) | `call reverse`, five instants of the step, numbered in their order | 1 the fire alone, the row saying `reverse() · rsp -8`, two free words over rsp; 2 the touch to the free word rsp − 8, nothing else moved; 3 the word armed and struck, `main+50`, rsp not moved; 4 rsp's pin climbing onto it (its path a few frames apart), `-8` on it, the bracket, reverse's span arriving, rsp struck as it lands; 5 the window following by a row |
+| [47](mock/47-tied-prologue.png) | reverse's prologue, six instants numbered in their order | `push rbp`: 1 the touch to the free word, 2 the word written (rbp's own value: the arm's frame, no strike), 3 rsp's pin onto it, `saved rbp` arriving; `mov rbp, rsp`: 4 rbp's pin flown from main's saved rbp to rsp's row, the two meeting, the base to rbp; `sub rsp, 0x18`: 5 the climb at its first row, `-8`, 6 landed at `-18`, three words gained, the rows slid under the pin for the last of it |
+| [48](mock/48-tied-ways.png) | the sheet: three ways to say the row and its word are one thing, on 44's instant | A, names and the echo alone, pwndbg's offsets; B (recommended, `tied`), names, offsets from the frame's base and the touch; C, the name in the operand as IDA writes it, the row saying only what moved |
+| [56](mock/56-carry.png) | `carry = .arrow` with `tied`, six instants numbered in their order: the load `mov rcx, [rbp - 8]`, then the store `mov [rbp - 0x18], rax` | the load: 1 the touch and `prev` read, rcx untouched; 2 the touch withdrawn as the carry climbs the gutter's right lane to rcx, its open chevron landing, rcx armed; 3 rcx struck, the carry gone, rcx's link to its pin. The store: 4 rax framed read, memory unmoved; 5 the carry down to `next`'s word, armed on its landing; 6 struck |
+| [49](mock/49-column-call.png) | the column: `open`'s call (`hello`, moments 37 to 38), mid-step | the `shelf` (the log, its bytes, the registers with rsp struck on their tag); source 3, main's window, a stack of nineteen words; the touch down the gutter onto the stack's right rule; the newest bubble on its paper, level with the call row, the older one dimmed above it |
+| [50](mock/50-column-stub.png) | the stub's `jmp` (38), the rest before its step | the descent in the column with the stack kept under it, the return address held on its top; the bubble's stem across the gutter to the jmp row |
+| [51](mock/51-column-args.png) | libc's `open`, its last three walked (61 to 64), mid-step of `mov eax, 0x101` | the registers unfolded under the descent, rip's row above 888; the bubble level with the first of the three |
+| [52](mock/52-column-cross.png) | the crossing (64 to 65), mid-step | the descent 24 rows, the kernel's window at its floor; rax 3 struck on the registers' tag; the newest bubble at the kernel's height, the lowest |
+| [53](mock/53-column-back.png) | back up and stored (74 to 76) | main's window whole, the call ran with its result; `f ◂ 3` struck and its touch; the newest bubble climbed back to the call row, the crossing's below it |
+| [54](mock/54-column-present.png) | the crossing in the present frame (`beside`) over the column | what each shows of one instant: 17 rows of descent against 24, the state panes against their tags, the caption against the bubbles |
+| [55](mock/55-column-graph.png) | a wide subject: sort's rings (25's stop) across the stage, twice their size, the program and state on the shelf | a bubble `on` the drawing, in the free corner over the outer ring, its stem round the drawing's top onto `+56` |
| [9](mock/09-context.png) | `beside`, at rest, in the frame before this round's rework (40 is it reworked): `targets/list` stopped at the load in `reverse` (`mock/list-dbg.txt`, moment 2) | every panel; the band as two panels; `address` with `lead`; `chain` cut by `more`; `reg`, rip with flags; `slot` with offsets and roles, `pin` row; `call` spans; `insn` current, ahead, outside under a rule and its name; `line`; `bytes` by fields with number, pointer, loose; an `arc` standing in the view; `nodes` with pins under, two names on one; `thread`; marks current, held; each pane's minimap (source, disassembly, stack, the view), its window, the current row; the registers and the drawing without |
| [10](mock/10-context-step.png) | the same, mid-step: the load done (moment 3) | `struck` on rdi; `read` on the annotation, the run and the node's half (`echo`); `link` ending in rdi's pin; `projection`; the read pointer's `arc` at full ink; the minimaps: the pc gold and the read cyan on the disassembly's, the read row on the view's; the annotation at 540, whole |
| [11](mock/11-context-lens.png) | `subject`, mid-step, in the frame before the rework (41 is it reworked) | the band at 296 and 200, the drawing a size up, a dump of seven, nine instructions, six slots; the minimaps at the subject's window sizes, the disassembly's and the stack's scrolled round their windows |
@@ -2020,7 +2284,16 @@ the band.
of `segments` at their own sizes (the sheet has them as frames); `align`
between `interleaved` and `columns`; `columns` with a pc in a long run,
away from its line's row.
-- A local's name as a slot's role (the recording has none at these pcs).
+- A local's name as a slot's role in the working frame's -O2 recording (none at those pcs; 44 to 53 have them).
+- Under `tied`: `pop`, `ret`, `leave`, `enter` and `add rsp` (motion.md's charts only); a touch to a word the
+ window scrolls to first; the leaf's window over its red zone; a touch giving way to its echo in a step that
+ draws a link and a projection; `= &buf`; the offsets' base going back to rsp at `pop rbp`; the pins' travel at
+ a run over the veil and at a sprint on the map; a climb longer than the window (`unroll`); the follow's
+ one move under a climbing pin (47's sixth instant shows where it ends, not the move); a carry to a folded
+ register or off a window (a stub); `carry = .value`.
+- The column: a fold and an unfold between beats (charts only); a beat `above`; a loop's bubbles stacking;
+ the scene's opening `below` and its relayout into the column; the column at a run; the floor holding a
+ window's continuation under a narrated pane (49 and 53 have the stack's there).
- `pin` with a count; `rwx`.
- Every verb: the mocks are stills. `establish`, `link` and `project`
have no chart from a render yet.
@@ -2198,6 +2471,63 @@ is not checked here. The tokens are under [Token changes](#token-changes).
window resizing with its pane in a `relayout`; every strip change 6 f
after the primary onset it follows.
+14. **The disassembly tied to the stack** ([`insn`](#insn), [`slot`](#slot),
+ [`touch`](#4-ties)), the scene's knob `annotation` (`.tied`, the default;
+ `.whole`, today's rows), settable per beat. Under `tied`: an access's
+ annotation as the touched word's name (its slot's role, a global's
+ symbol) and its value, one hop, the name bold in its region's ink; a
+ register-setter cut after its first value; the fallbacks of the
+ annotation's table (an unnamed slot by its address, a word a dump holds
+ by its address, a word no pane holds whole); a direct call as
+ `reverse()`; `= &buf` for a `lea` of a named word; pushes and pops named
+ by the word's role. The stack's offset column from the frame's base, the
+ CFA's register at the newest frame's pc (rbp in a body; rsp at entry, in
+ a prologue before `mov rbp, rsp`, after `pop rbp` or `leave`, in a
+ function without a frame pointer), crossfading (12 f) when the base
+ changes, the tag saying which; the window over a leaf's red-zone locals.
+ The `touch`: 2 units in the mark's colour, out of the disassembly's
+ right rule at the row, the gutter's middle lane (x 956), onto the stack's
+ rule at the word; drawn in memory's slot before the word reacts (12 f,
+ 18 past six rows), back with the advance; the first line to give way to
+ its echo. A load's read before the register it fills. A store of an
+ unchanged value: the arm's frame without a strike. The order of every
+ step cause to effect (the row, its touch, the word, then what follows
+ from it), nothing downstream armed early. **The stack pointers' moves**
+ ([stack](#stack), [`travel`](#6-verbs), [`follow`](#6-verbs)): the
+ window's headroom of two `free` words over rsp; the rows holding while
+ rsp's or rbp's pin travels (24 f, 6 f a further row, 48 at most), its
+ amount counting on it, the rows it crosses gained or released, the
+ vermilion bracket over them, the span riding it, the register struck as
+ it lands; the window following only after, or under the pin in one move
+ for a climb longer than the room, or by `unroll` past the window; the
+ instruction's own annotation saying the move (`rsp -0x18 3 words`,
+ `rbp = rsp`, `rsp +8 · saved rbp`); at a run the pins over the veil.
+
+16. **The carry** ([`carry`](#4-ties)), a scene's knob `carry` (`.off`,
+ the default; `.arrow`; `.value` for the introduction's one walked load):
+ 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
+ no touch; nothing for a move between registers; a stub to a folded or
+ off-window end.
+
+15. **The column, an experiment** ([column](#column-an-experiment); the trial's
+ storyboard in [motion.md](motion.md#a-scene-in-the-column-open-followed-down)),
+ built for the trial scene beside its present form, not in place of it:
+ the stage as two columns of 880 (panes at 64, text at 976); the `shelf`
+ of folded tags at y 48 with each tag's note and its strikes; the beat's
+ panes from 84, narrated rows and rip above 888; the clock under the text
+ column; the `bubble` (Go 40 on 54, three lines of 40 at most, the newest
+ on raised paper, older ones dim, three at most) placed level with what it
+ speaks of, older ones gliding out of its way and riding with their rows;
+ its stem in the rest only; the placements `beside`, `below`, `above` and
+ `on`, a relayout between them; the fold and unfold of panes between beats
+ in the order the section gives; the touch in the column down the gutter
+ onto the stack's right rule. And a scene API in which the author says, per
+ beat, the panes (with rows or `rest`), the bubble's text, its placement,
+ its level and its stem, every one optional and defaulted as the section
+ says (motion.md has a beat written that way).
+
**What the recordings must hold**, with the tracer's options:
- For the map, as before: `--stack 1024`, `--disasm 69`, `--around 256`;
@@ -2221,6 +2551,15 @@ is not checked here. The tokens are under [Token changes](#token-changes).
- `ztrace record --by insn --from main` began in the loader with the
ReleaseFast build used here (`hello`, 120 moments, all in `ld.so`):
`--from` did not take; `dbg` with a breakpoint was used instead.
+- **For `tied`**: the touches of the stack's own instructions, which the recording leaves out today
+ (`push`, `pop`, `call`, `ret`, `leave`, `enter`: the word, its size, read or write; the explicit operands'
+ touches are there, `ztrace dump`'s `touch` events); data symbols by name (`head` at 404018), for a
+ global's annotation; the roles at every pc of a prologue and an epilogue (today a local is found only
+ where the frame base is the CFA's register, so `prev` and `cur` come after `mov rbp, rsp`: right, but the
+ saved rbp's role must be there from the `push`); a local's own offset and size where two share a word
+ (`f, low half` and the return-value slot beside it); the canary's copy named as the place it is
+ (`the stack's canary`, from the `fs:[0x28]` load that stored it). `ztrace show` prints none of the roles;
+ `telescope.slots` has them.
- For the heap scene: see [the scene](motion.md#a-scene-libcs-heap-from-the-inside).
- For a pair (the ASan scene): see [the scene](motion.md#a-scene-asan-against-a-plain-build).
- For the introduction: the mappings with their permissions and their
@@ -2274,16 +2613,23 @@ and `metric.bytes` and `metric.slot`'s new columns are in, as asked.
| `metric.insn.wide` | none | 12 a digit past seven, per window: libc's mnemonic at 240, its annotation at 624 |
| `metric.descent` | none | callers' windows 3 rows; a head a row (rule 2, name at 40 in Go Medium 18, what it is ranged right in Go 18); the call lane at x 14, 2 in primary, head 7 by 8 into the name; into the kernel 3 in vellum, its head in ink; three windows of code, then a fold row; the kernel's window a head and two rows |
| `metric.node.two_rows`, `metric.bin` | none | rows 110 apart, nodes 136 wide; the bin box 160 by 44 at the row's left, its count on a 30 square on the shoulder; a free node's outline dashed 12 on 8 |
-| `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; the step 2.90 |
+| `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 0.80; the lane back 0.20; the caller's kept rows 0.30 (`glide`), then the given-back rows 0.20; the step 2.50 |
+| `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 |
->>>
-
| `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 |
+| `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 |
+| `time.touch` | none | 0.20 (0.30 past six rows), `standard`, in memory's slot before the word's arm or frame; back 0.20 with the advance; none at a run |
+| `metric.stack.headroom` | none (the window's top is rsp) | two `free` words over rsp at rest |
+| `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.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 |
+| `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` |
Unchanged and already there: the 1920 stage (its splits change, above), each pane's `strip`, the palette