#!/usr/bin/env python3 """The frame: the machine's whole context, pwndbg's way, a lens over it, and the ties between them. python3 -B context.py # writes 09-context.svg, 10-context-step.svg, 11-context-lens.svg, 12-calls-subject.svg Every function here is a block of design/README.md, under the block's name. The moment is real: `ztrace record --by line -- targets/list`, moments 71 and 72 (`ztrace show FILE 71`): every register and its chain, the stack, and the instructions of `reverse` with their lines (objdump -dl). The dump's node bytes are what those chains and the program say the heap holds. Its header rows are drawn the way glibc lays a chunk out, with the word no one reads shown as never read: a recording made under ptrace has seen neither. 12 is the fib scene's recording (anim/zig-out/recordings/steps.ztrace), moments 752 and 753: `fib(4)` calling `fib(2)`; its lines from the binary by addr2line. """ import re import gen from gen import (PAGE, RAISED, RULE, VELLUM, BRIGHT, DIM, FAINT, INK, GOLD, VERM, READ, EMBER, TRAIL, STACK, HEAP, CODE, DATA, KW, LIT, COMMENT, W, Svg, tw, mix) S = 20 # the context's mono size: an advance of 12 A = 12 ROW = 24 TAG = 24 PAD = 4 # above and below a panel's rows MONO, BOLD, ITAL = "monom", "monob", "monoi" LX, RX, CW = 64, 976, 880 # the two columns; the gutter between them is the ties' channel TOP, BOTTOM = 48, 888 # the stage LANE_LINK, LANE_VIEW = 950, 962 # the gutter's lanes: a link comes up the first, a projection down the second WELL = "#101a48" # a node's pointer half def b(y): """Baseline of a row at y.""" return y + ROW / 2 + 0.36 * S def ph(rows): """A panel's height.""" return TAG + 2 * PAD + rows * ROW # ---- marks: the forms of `current`, `struck` and `held`. A is the first videos'; B the catalogue's now; C the # other readings of "white, with less opacity" (mock 15 sets them side by side). STYLE = {"current": "B", "struck": "B", "held": "B"} WASH = mix(BRIGHT, PAGE, 0.10) # the current row: a white wash, opaque, a tenth of the way to bright SOFT = mix(VERM, PAGE, 0.70) # a strike's paper, B def band(): """The paper across the current row.""" return EMBER[GOLD] if STYLE["current"] == "A" else WASH def current_row(g, x, y, w, plaque): """The current mark on a row: the band across it and the plaque on its label. Returns the plaque's letters' ink.""" g.rect(x, y, w, ROW, band()) g.rect(x, y, plaque, ROW, BRIGHT if STYLE["current"] == "C" else GOLD) return INK def struck(g, x, y, w, h=ROW): """A struck value's paper (x, w: the value's, 5 out each side). Returns its digits' ink.""" st = STYLE["struck"] if st == "A": g.rect(x, y + 1, w, h - 2, VERM) return INK if st == "B": g.rect(x, y + 1, w, h - 2, SOFT) return BRIGHT g.rect(x, y + 1, w, h - 2, mix(BRIGHT, PAGE, 0.18)) g.frame(x, y + 1, w, h - 2, VERM, 2) return BRIGHT def held(g, x, y, w, h=ROW): """Changed within three steps, at the value whose left is x (w wide) on the row at y.""" st = STYLE["held"] if st == "A": g.rect(x - 9, y + 3, 4, h - 6, VERM) elif st == "B": # a dog-ear: the corner of the value turned down g.path(f"M{x - 4},{y + 2} h9 l-9,9 Z", fill=VERM) else: # a bar under it, half strength g.rect(x - 2, y + h - 4, w + 4, 2, mix(VERM, PAGE, 0.6)) def held_cell(g, x, y, w, h, k=1): """`held` on a lens's cell (k: the drawing's scale).""" st = STYLE["held"] if st == "A": g.rect(x, y + h - 4 * k, w, 4 * k, VERM) elif st == "B": g.path(f"M{x},{y} h{12 * k} l{-12 * k},{12 * k} Z", fill=VERM) else: g.rect(x, y + h - 3 * k, w, 3 * k, mix(VERM, PAGE, 0.6)) def tag(g, x, y, w, h, title, focus=False, note=None): """A panel's frame and its one-row tag. note: a string, or runs (text, ink, underlined) for a legend.""" g.rect(x, y, w, TAG, RAISED) g.frame(x, y, w, h, DIM if focus else RULE, 2) if focus: g.rect(x + 8, y + 6, 12, 12, GOLD) else: g.frame(x + 8, y + 6, 12, 12, FAINT, 2) g.t(x + 28, y + 18, title, 20, VELLUM if focus else DIM, "sansm") if isinstance(note, str): g.t(x + w - 10, y + 18, note, 18, FAINT, "sans", "end") elif note: nx = x + w - 10 - sum(tw(s, 18, "sansm") + 14 for s, _, _ in note) + 14 for s, ink, under in note: g.t(nx, y + 18, s, 18, ink, "sansm") if under: g.rect(nx, y + 21, tw(s, 18, "sansm"), 2, ink) nx += tw(s, 18, "sansm") + 14 def panel(g, x, y, w, rows, title, focus=False, note=None): """Returns the y of the first row.""" tag(g, x, y, w, ph(rows), title, focus, note) return y + TAG + PAD # ---- atoms ---------------------------------------------------------------------- def addr_w(n): return len("%x" % n) * A def shared(ns): """How many leading digits a column of addresses has in common: drawn dim, so the eye reads the rest.""" ds = ["%x" % n for n in ns] k = 0 while all(len(d) == len(ds[0]) and d[:k + 1] == ds[0][:k + 1] for d in ds) and k < len(ds[0]) - 2: k += 1 return k def addr(g, x, y, n, ink, face=MONO, under=False, lead=0): """An address: its digits, unbroken, in its region's ink.""" d = "%x" % n if lead: g.t(x, b(y), d[:lead], S, mix(ink, PAGE, 0.6), face) g.t(x + lead * A, b(y), d[lead:], S, ink, face) if under: # writable and executable g.rect(x, y + ROW - 3, len(d) * A, 2, ink) return x + len(d) * A def link_arrow(g, x, y, ink=FAINT): """Points to: 30 wide.""" g.rect(x + 6, y + 11, 11, 2, ink) g.path(f"M{x + 24},{y + 12} l-8,-5 v10 Z", fill=ink) return x + 30 def value_arrow(g, x, y, ink=FAINT): """Holds: 30 wide, pointing back.""" g.path(f"M{x + 6},{y + 12} l8,-5 v10 Z", fill=ink) g.rect(x + 13, y + 11, 11, 2, ink) return x + 30 def more(g, x, y): """The chain goes on: an arrow and three dots.""" x = link_arrow(g, x, y) for d in range(3): g.rect(x + 2 + d * 8, y + 14, 3, 3, FAINT) def integer(g, x, y, v, ink=VELLUM): """A number that is not an address: one digit as it is; more, hex with 0x and its decimal after, faint.""" if v < 10: g.t(x, b(y), str(v), S, ink, MONO) return x + A s = "0x%x" % v g.t(x, b(y), s, S, ink, MONO) x += len(s) * A if v <= 0xffff: g.t(x + 8, b(y), str(v), S, FAINT, MONO) x += 8 + len(str(v)) * A return x def chain(g, x, y, links, end, marks=None, room=None, lead=0): """A telescope: links are (address, ink[, name]); end is ("int", v), ("str", s) or None. marks: {index: "strike" | "tick" | "read"} on a link. Cut at its far end where the row ends. Returns each link's (x, width).""" marks = marks or {} where = [] for i, link in enumerate(links): n, ink = link[0], link[1] w = addr_w(n) named = (10 + len(link[2]) * A) if len(link) > 2 else 0 if i: if room is not None and x + 30 + w + named + 40 > room: more(g, x, y) return where x = link_arrow(g, x, y) m = marks.get(i) if m == "strike": addr(g, x, y, n, struck(g, x - 5, y, w + 10), BOLD) else: if m == "tick": held(g, x, y, w) if m == "read": g.frame(x - 6, y, w + 12, ROW, READ, 2) addr(g, x, y, n, ink, lead=lead if i == 0 else 0) where.append((x, w)) x += w if named: # code: its name is what a reader reads g.t(x + 10, b(y), link[2], S, VELLUM, MONO) x += named if end is None: return where if end[0] == "int" and links and room is not None and x + 30 + len("%x" % end[1]) * A + 24 > room: more(g, x, y) # the value does not fit: the chain ends early, and says so return where x = value_arrow(g, x, y) if links else x if marks.get("end") == "tick": # the value it holds changed within three steps held(g, x + 2, y, len(str(end[1])) * A if end[0] == "int" else 3 * A) if end[0] == "int": integer(g, x, y, end[1]) else: s = end[1] if room is not None and len(s) + 2 > (room - x) // A: g.t(x, b(y), '"' + s[:max(int((room - x) // A) - 2, 1)] + "…", S, LIT, MONO) else: g.t(x, b(y), '"' + s + '"', S, LIT, MONO) return where def pin(g, x, y, names, ink): """A register's name where it points, in a row: the names, and a head on what they point at.""" s = " ".join(names) g.t(x, b(y), s, S, VELLUM, BOLD) x += len(s) * A + 5 g.path(f"M{x + 9},{y + 12} l-9,-6 v12 Z", fill=ink) def pin_up(g, cx, y, names, ink, size, link=None, sw=3): """A register's name under what it points at: a stub with its head on the thing, the names either side. link: the points the stub is the end of, when this is the step that set the register.""" rise = size + 10 gen.arrow(g, (link or []) + [(cx, y + rise), (cx, y + 1)], ink, sw, r=8, hl=10 + 2 * (sw - 3), hw=10 + 2 * (sw - 3)) face = BOLD by = y + 8 + size * 0.86 if names and names[0]: # names keep their side: None holds a side that was left g.t(cx - 9, by, names[0], size, VELLUM, face, "end") if len(names) > 1: g.t(cx + 9, by, " ".join(names[1:]), size, VELLUM, face) def bracket(g, x, y0, y1, ink, sw=2, serif=5, side=1): """A span of rows, marked at its edge: the end of a projection, or a thing that is a view of another.""" g.rect(x - sw / 2, y0, sw, y1 - y0, ink) for yy in (y0, y1 - sw): g.rect(x - sw / 2 if side > 0 else x + sw / 2 - serif - sw, yy, serif + sw, sw, ink) # ---- the state column --------------------------------------------------------------- def registers(g, y, regs, flags, marks): legend = [("stack", STACK, False), ("heap", HEAP, False), ("code", CODE, False), ("data", DATA, False), ("rwx", DATA, True), ("read-only", VELLUM, False)] y0 = panel(g, RX, y, CW, 17, "registers", note=legend) where = {} for i, (name, links, end) in enumerate(regs): yy = y0 + i * ROW if name == "rip": g.t(RX + 12, b(yy), name, S, current_row(g, RX + 2, yy, CW - 4, 54), BOLD) else: g.t(RX + 12, b(yy), name, S, DIM, MONO) where[name] = yy if links: chain(g, RX + 72, yy, links, end, marks.get(name), room=RX + CW - 12) else: if marks.get(name, {}).get(0) == "strike": s_ = ("0x%x" % end[1]) if end[1] >= 10 else str(end[1]) g.t(RX + 72, b(yy), s_, S, struck(g, RX + 67, yy, len(s_) * A + 10), BOLD) continue integer(g, RX + 72, yy, end[1]) if marks.get(name, {}).get(0) == "tick": held(g, RX + 72, yy, len(str(end[1])) * A) # the flags, in rip's row: where the machine is, and the condition it is in x = RX + CW - 12 - len(flags) * 42 + 10 for name, on, changed in flags: if changed: held(g, x + 4, yy, 2 * A) if on: g.rect(x, yy + 2, 2 * A + 8, 20, RAISED) g.t(x + 4, b(yy), name, S, BRIGHT, BOLD) else: g.t(x + 4, b(yy), name.lower(), S, mix(DIM, band(), 0.8), MONO) x += 42 return where def stack(g, y, rows, frames, note=None, rsp=None, roles=None): """rows: (slot, pins, links, end[, marks]). frames: (name, first row, last row), newest first: the backtrace, drawn on the words that are each frame; a first row under 0 runs above the window. The window is the newest frame's. A frame's name is never cut for a chain: the chains on the rows it sits on end 12 before it. rsp: the slots' offsets from it are drawn (pwndbg's column). roles: {row: (what the slot is, ink)}: a local's name, `saved rbp`, `return`, ranged right where the chain's room ends; the chain ends 12 before it. Returns each row's y.""" y0 = panel(g, RX, y, CW, len(rows), "stack", note=(note or "%s words from rsp" % {6: "six", 8: "eight"}[len(rows)]) + " · the frames they belong to") lead = shared([r[0] for r in rows]) room = {} # a row's chain ends here, where a frame's name begins spans = [] for i, (name, first, last) in enumerate(frames): if first >= len(rows): break open_top, open_ = first < 0, last >= len(rows) first, last = max(first, 0), min(last, len(rows) - 1) x, ya, yb = RX + CW - 14, y0 + first * ROW + (0 if open_top else 3), y0 + (last + 1) * ROW - (0 if open_ else 3) ny = (ya + yb) / 2 + 6 # the name's baseline, and the rows its letters cover nx = x - 14 - tw(name, 18, "sansm") for r in range(len(rows)): if y0 + r * ROW < ny + 4 and y0 + (r + 1) * ROW > ny - 14: room[r] = min(room.get(r, RX + CW - 136), nx - 12) spans.append((i, name, x, ya, yb, ny, open_top, open_)) ys = [] roles = roles or {} first = RX + (184 if rsp is not None else 122) for i, (slot, pins, links, end, *marks) in enumerate(rows): yy = y0 + i * ROW ys.append(yy) if pins: pin(g, RX + 10, yy, pins, STACK) if rsp is not None: # the offset from rsp, pwndbg's way: +18 off = slot - rsp g.t(RX + 172, b(yy), ("+%x" % off) if off >= 0 else ("-%x" % -off), S, FAINT, MONO, "end") end_x = room.get(i, RX + CW - 136) if i in roles: text, ink = roles[i] g.t(end_x, b(yy), text, S, ink, MONO, "end") end_x -= len(text) * A + 12 chain(g, first, yy, [(slot, STACK)] + links, end, marks[0] if marks else None, room=end_x, lead=lead) for i, name, x, ya, yb, ny, open_top, open_ in spans: ink = GOLD if i == 0 else RULE g.rect(x - 1, ya, 2, yb - ya, ink) if not open_top: g.rect(x - 7, ya, 8, 2, ink) if not open_: g.rect(x - 7, yb - 2, 8, 2, ink) g.t(x - 14, ny, name, 18, BRIGHT if i == 0 else DIM, "sansm", "end") return ys # ---- the program column ------------------------------------------------------------- C_WORDS = {"struct", "long", "static", "return", "while", "for", "int", "char", "sizeof", "if", "else", "void", "NULL", "__attribute__", "noinline", "const", "unsigned", "do", "elif", "defined"} def c_line(g, x, y, text, limit): """One line of C in the four inks. Cut, with a faint mark, where the panel ends.""" cut = len(text) > limit text = text[:limit - 1] if cut else text if text.lstrip().startswith("//"): g.t(x, b(y), text, S, COMMENT, ITAL) return for m in re.finditer(r'/\*.*?(\*/|$)|"[^"]*"?|#\w+|<[\w.]+>|\w+|\s+|.', text): s = m.group() if not s.strip(): continue if s.startswith("/*"): # a comment, to the line's end or its close g.t(x + m.start() * A, b(y), s, S, COMMENT, ITAL) continue ink, face = VELLUM, MONO if s in C_WORDS or s.startswith("#"): ink, face = KW, BOLD elif s[0] == '"' or s[0].isdigit() or (s[0] == "<" and len(s) > 2): ink = LIT g.t(x + m.start() * A, b(y), s, S, ink, face) if cut: g.t(x + (limit - 1) * A, b(y), "…", S, FAINT, MONO) def wide(total): """How much wider than three characters the program's largest line number is: the same in every window.""" return max(len(str(total)) - 3, 0) * A def source(g, y, rows, lines, first, cur, trail, name, total): """Returns the y of the current line's row. Numbers as wide as the file's last: the text moves by the extra.""" w = wide(total) y0 = panel(g, LX, y, CW, rows, name, note=f"lines {first} to {min(first + rows - 1, total)} of {total}") for i in range(rows): n = first + i yy = y0 + i * ROW if n == cur: g.t(LX + 46 + w, b(yy), str(n), S, current_row(g, LX + 2, yy, CW - 4, 50 + w), BOLD, "end") else: if n in trail: g.rect(LX + 2, yy + 1, 4, ROW - 2, TRAIL[min(trail.index(n), 2)]) g.t(LX + 46 + w, b(yy), str(n), S, FAINT, MONO, "end") c_line(g, LX + 64 + w, yy, lines[n - 1], (CW - 64 - w - 12) // A) return y0 + (cur - first) * ROW DX_ADDR, DX_LINE, DX_MN, DX_OPS, DX_NOTE = 40, 134, 180, 264, 564 def disasm(g, y, rows, func, cur_line, jump=None, w=0): """rows: (address, line, mnemonic, operands, state, note), in address order: the pc's row and as many above as below. state: cur | trail0..2 (it ran just now) | out (past the function's end) | None. note, the row's annotation: ("chain", links, end, marks) | ("set", register, links, end) | ("text", s). jump: (from, to): a jump that was taken, drawn in the lane. w: how much wider than three characters the program's line numbers are; every column right of the line's moves by it. Returns each address's row y.""" y0 = panel(g, LX, y, CW, len(rows), "disassembly", note=func) lead = shared([r[0] for r in rows if r[4] != "out"]) where, last_line = {}, None for i, (a, line, mn, ops, st, note) in enumerate(rows): yy = y0 + i * ROW where[a] = yy dim = st == "out" if dim or st == "other_first": # a function ends: a rule, and the next one's name g.rect(LX + 2, yy, CW - 4, 2, RULE) if st == "cur": g.path(f"M{LX + 20},{yy + 12} l-10,-6 v12 Z", fill=current_row(g, LX + 2, yy, CW - 4, 24)) elif st and st.startswith("trail"): g.rect(LX + 2, yy + 1, 4, ROW - 2, TRAIL[int(st[-1])]) addr(g, LX + DX_ADDR, yy, a, mix(CODE, PAGE, 0.6) if dim else CODE, lead=0 if dim else lead) if line is not None and line != last_line and not dim: # the line this run was compiled from on = line == cur_line g.t(LX + DX_LINE + 3 * A + w, b(yy), str(line), S, GOLD if on else FAINT, BOLD if on else MONO, "end") last_line = line g.t(LX + DX_MN + w, b(yy), mn, S, FAINT if dim else KW, MONO if dim else BOLD) x = LX + DX_OPS + w for part, ink in ops: if isinstance(part, int): x = addr(g, x, yy, part, ink) else: g.t(x, b(yy), part, S, FAINT if dim else ink, MONO) x += len(part) * A if not note: continue x = max(LX + DX_NOTE + w, x + A) # operands are never cut where the row has room if note[0] == "text": g.t(x, b(yy), note[1], S, note[2] if len(note) > 2 else DIM, MONO) elif note[0] == "set": # what an instruction that ran left in a register: a register row, small g.t(x, b(yy), note[1], S, DIM, MONO) chain(g, x + (len(note[1]) + 1) * A, yy, note[2], note[3], room=LX + CW - 12) else: where["note"] = (yy, chain(g, x, yy, note[1], note[2], note[3], room=LX + CW - 12)) if jump: # how control came here: up the lane, into the row it landed on ya, yb = where[jump[0]] + 12, where[jump[1]] + 12 gen.arrow(g, [(LX + 38, ya), (LX + 31, ya), (LX + 31, yb), (LX + 39, yb)], TRAIL[0], 2, r=4, hl=7, hw=8) return where def thread(g, ys, spans): """The gold thread: the source's current line and the instructions it was compiled to are one mark. A bracket on the line, a bracket on each run of its instructions, and a line in the margin between.""" x = LX - 10 bracket(g, x, ys + 2, ys + ROW - 2, GOLD, 3, 7) for ya, yb in spans: bracket(g, x, ya + 2, yb - 2, GOLD, 3, 7) g.rect(x - 1.5, ys + 2, 3, spans[-1][1] - 2 - ys - 2, GOLD) # ---- the lens: a list, and beside it the bytes it is drawn from ------------------------- def fields(g, y, h, about, base, length, flist, mem, region, region_of, marks=(), title="its bytes", x=None, framed=(), bare=False, rows_shown=None): """`hexdump` by `fields`: the region a scene names, read by the fields it gives it, in the band's view. flist: (at, len, reads, big, mark) with reads in number | pointer | text | bytes. mem: {address: byte} of what the stop shown saw (or the kernel took); a byte not in it is unread. marks: the field marks framed as read. Rows that hold no field are one `more` row and their count. The bytes begin 12 after the widest address. reads `malloc`: the allocator's size word, loose, read as a note. framed: (at, len) drawn with `attention`'s bright frame (a loupe's target). bare: no tag (a loupe draws its own). rows_shown: the rows to show, when the window is not every row that holds a field. Returns {row address: y}.""" X = RX if x is None else x if not bare: tag(g, X, y, CW, h, title) g.t(X + 28 + tw(title, 20, "sansm") + 12, y + 18, about, 18, FAINT, "sans") total = (length + 15) // 16 holds = lambda r: any(base + at < base + 16 * (r + 1) and base + at + n > base + 16 * r for at, n, *_ in flist) shown = rows_shown if rows_shown is not None else [r for r in range(total) if holds(r)] ys = {} digits = max(len("%x" % (base + 16 * r)) for r in shown) shift = max(18 + digits * A + 12 - 132, 0) bx = lambda i: X + 132 + shift + i * 30 + (12 if i >= 8 else 0) lead = shared([base + 16 * r for r in shown]) if len(shown) > 1 else 0 yy, last = y + TAG + PAD, None for r in shown: if last is not None and r > last + 1: # the rows left out: one row, and how many more(g, X + 18 - 6, yy) g.t(X + 18 + 30 + 36, b(yy), "%d rows" % (r - last - 1), S, FAINT, MONO) yy += ROW last = r a0 = base + 16 * r ys[a0] = yy bracket(g, X + 7, yy + 3, yy + ROW - 3, mix(region, PAGE, 0.6)) addr(g, X + 18, yy, a0, region, lead=lead) runs, i = [], 0 while i < 16 and a0 + i < base + length: f = next((f for f in flist if base + f[0] <= a0 + i < base + f[0] + f[1]), None) if f: n = min(base + f[0] + f[1] - (a0 + i), 16 - i) else: n = min([base + o[0] - a0 for o in flist if a0 + i < base + o[0] < a0 + 16] + [16, base + length - a0]) - i runs.append((i, n, f)) i += n x = X + 640 + shift # the reading: a list, a character apart for i0, n, f in runs: vals = [mem.get(a0 + k) for k in range(i0, i0 + n)] reads = f[2] if f else "loose" x0, x1 = bx(i0) - 4, bx(i0 + n - 1) + 28 if f and reads != "malloc": g.rect(x0, yy + 1, x1 - x0, ROW - 2, RAISED) if f[4] is not None and f[4] in marks: g.frame(x0 - 3, yy - 1, x1 - x0 + 6, ROW + 2, READ, 2) known = None not in vals word = 0 if known: order = vals[::-1] if not (f and f[3]) else vals for v in order: word = word << 8 | v for fa, fl in framed: # the target: framed bright, as attention if base + fa < a0 + i0 + n and base + fa + fl > a0 + i0: g.frame(x0 - 3, yy - 1, x1 - x0 + 6, ROW + 2, BRIGHT, 2) ink = {"number": VELLUM, "bytes": VELLUM, "text": LIT, "loose": DIM, "malloc": DIM, "pointer": (region_of(word) or VELLUM) if known else VELLUM}[reads] nz = [k for k, v in enumerate(vals) if v] for k, v in enumerate(vals): xx = bx(i0 + k) if v is None: # not read at this stop: two dots, on the field's paper g.rect(xx + 5, yy + 11, 4, 4, FAINT) g.rect(xx + 15, yy + 11, 4, 4, FAINT) continue padded = reads in ("number", "pointer") and nz and (k < nz[0] if f[3] else k > nz[-1]) g.t(xx, b(yy), "%02x" % v, S, mix(ink, PAGE, 0.45) if padded else ink, MONO) if not known or reads in ("bytes", "loose"): continue if reads == "malloc": # the allocator's own: the size word of the chunk after it note = "malloc's: a chunk of %d" % (word & ~7) if word < 0x10000 else "malloc's: the top chunk" g.t(x, b(yy) - 1, note, 18, FAINT, "sans") x += tw(note, 18, "sans") + A continue if reads == "pointer": if word == 0: s_, sink = "NULL", DIM else: x = addr(g, link_arrow(g, x, yy), yy, word, region_of(word) or VELLUM) + A continue elif reads == "number": s_, sink = str(word), VELLUM else: s_, sink = '"' + bytes(vals).split(b"\0")[0].decode("latin1") + '"', LIT if x + len(s_) * A > X + CW - 12: s_ = s_[:max(int((X + CW - 12 - x) // A) - 1, 0)] + "…" g.t(x, b(yy), s_, S, sink, MONO) x += (len(s_) + 1) * A yy += ROW if shown and shown[-1] < total - 1: # the rows after the last field: one row, and how many more(g, X + 18 - 6, yy) g.t(X + 18 + 30 + 36, b(yy), "%d rows" % (total - 1 - shown[-1]), S, FAINT, MONO) return ys def kernel(g, y, h, calls, name, nr, rows, given): """`syscalls` in the band: the kernel's side, on vellum. calls: (name, result), newest first (the first is the call in hand, gold: where execution is); rows: (register, argument, value, note); given: the bytes it took.""" tag(g, LX, y, CW, h, "kernel", note="the other side of a system call") g.rect(LX + 2, y + TAG, CW - 4, h - TAG - 2, gen.KERNEL) g.t(LX + 12, y + TAG + 20, "calls so far", 18, gen.KERNEL_DIM, "sans") for i, (c, ret) in enumerate(calls[:(h - TAG - 40) // 28]): yy = y + TAG + 28 + i * 28 if i == 0: g.rect(LX + 12, yy, 196, 24, GOLD) g.frame(LX + 12, yy, 196, 24, PAGE, 2) g.t(LX + 20, b(yy), c, S, PAGE, MONO) g.t(LX + 200, b(yy), str(ret), S, PAGE, MONO, "end") x = LX + 236 g.t(x, y + TAG + 46, name, 35, PAGE, "monob") g.t(x + len(name) * 21 + 16, y + TAG + 44, "system call %d" % nr, 18, gen.KERNEL_DIM, "sans") for i, (reg, arg, val, note) in enumerate(rows): yy = y + TAG + 60 + i * 28 g.rect(x, yy, 300, 2, gen.KERNEL_RULE) g.t(x, b(yy + 2), reg, S, gen.KERNEL_DIM, MONO) g.t(x + 52, b(yy + 2), arg, 20, PAGE, "sansm") g.t(x + 130, b(yy + 2), val, S, PAGE, MONO) if note: g.t(x + 130 + (len(val) + 1) * A, b(yy + 2), note, S, PAGE, MONO) x = LX + 564 g.t(x, y + TAG + 20, "the bytes it was given", 18, gen.KERNEL_DIM, "sans") for i, v in enumerate(given): xx, yy = x + (i % 10) * 28, y + TAG + 28 + (i // 10) * 30 g.rect(xx, yy, 26, 26, gen.KERNEL_HELD) g.frame(xx, yy, 26, 26, PAGE, 2) g.t(xx + 1, b(yy + 1), "%02x" % v, S, PAGE, MONO) def dump_row(g, y, a, runs, lead, mark=None, node=False): """A hexdump row: sixteen bytes and what they read as. runs: (first byte, bytes, kind, value) with kind in value | next | malloc | unread. mark: {"read": run index, "tick": run index}.""" mark = mark or {} bx = lambda i: RX + 132 + i * 30 + (12 if i >= 8 else 0) addr(g, RX + 18, y, a, HEAP if node else mix(HEAP, PAGE, 0.6), lead=lead) for k, (i0, n, kind, v) in enumerate(runs): x0, x1 = bx(i0) - 4, bx(i0 + n - 1) + 28 if kind in ("value", "next"): g.rect(x0, y + 1, x1 - x0, ROW - 2, RAISED) if mark.get("read") == k: g.frame(x0 - 3, y - 1, x1 - x0 + 6, ROW + 2, READ, 2) if mark.get("tick") == k: held(g, x0 + 4, y, x1 - x0 - 8) ink = {"value": VELLUM, "next": HEAP, "malloc": DIM, "unread": FAINT}[kind] top = max((j for j in range(n) if (v or 0) >> (8 * j) & 0xff), default=0) for j in range(n): x = bx(i0 + j) if kind == "unread": # never read: two dots a byte g.rect(x + 5, y + 11, 4, 4, FAINT) g.rect(x + 15, y + 11, 4, 4, FAINT) continue # little-endian: the bytes above the highest one set are padding, and faint g.t(x, b(y), "%02x" % (v >> (8 * j) & 0xff), S, ink if j <= top else mix(ink, PAGE, 0.45), MONO) # what the row reads as x = RX + 640 if not node: g.t(x, b(y) - 1, "malloc's: a chunk of 32", 18, FAINT, "sans") return value, nxt = runs[0][3], runs[1][3] g.t(x + 3 * A, b(y), str(value), S, VELLUM, MONO, "end") if nxt: addr(g, link_arrow(g, x + 3 * A + 8, y), y, nxt, HEAP) else: g.t(x + 3 * A + 8 + 30, b(y), "NULL", S, DIM, MONO) def lens(g, y, h, hv, nodes, pins, marks, first, nrows, link_from=None, subject=False, dw=None, k=1, view_rows=None): """The band: the list drawn, over the program column, and the heap bytes it is drawn from, over the state column; two panels, h and hv high, the gutter between them the ties'. nodes: (address, value, next address or 0), in the list's order. pins: {address: [registers]}. marks: {"read": address of a word, "tick": [addresses of words]}. link_from: the y of the register row the step's link comes from, and the register. As the subject the drawing is a size up; the dump stays on the context's grid and shows more rows. On the 4K stage the drawing is dw wide and drawn k times the size (2), and the view is drawn by `fields`, whose rows (view_rows: {row address: y}) the projection starts from.""" dw = dw or CW tag(g, LX, y, dw, h, "the list", focus=True) last = first + (nrows - 1) * 16 rows = view_rows or {} if view_rows is None: tag(g, RX, y, CW, hv, "its bytes", note=[("value", VELLUM, False), ("next", HEAP, False), ("malloc's", DIM, False), ("never read", FAINT, False)]) g.t(RX + 28 + tw("its bytes", 20, "sansm") + 12, y + 18, "the heap, %x to %x" % (first, last + 15), 18, FAINT, "sans") # the dump y0 = y + TAG + PAD by_addr = {a: (v, nx) for a, v, nx in nodes} lead = shared([first, last]) for i in range(nrows if view_rows is None else 0): a, yy = first + i * 16, y0 + i * ROW rows[a] = yy if a in by_addr: v, nx = by_addr[a] m = {} if marks.get("read") == a + 8: m["read"] = 1 if a + 8 in marks.get("tick", ()): m["tick"] = 1 dump_row(g, yy, a, [(0, 8, "value", v), (8, 8, "next", nx)], lead, m, node=True) if marks.get("read") != a + 8: bracket(g, RX + 7, yy + 3, yy + ROW - 3, mix(HEAP, PAGE, 0.6)) else: dump_row(g, yy, a, [(0, 8, "unread", None), (8, 8, "malloc", 0x21)], lead) # the drawing, centred between its lanes NW, NH, GAP, VS, LS = [v * k for v in ((124, 72, 22, 45, 25) if subject else (116, 44, 28, 25, 20))] VW = NW - 48 * k # the value's half; the pointer's is 48 tie_w = (3, 2) if k == 1 else (4, 3) # a link, a projection: on the 4K stage, 2 and 1.5 pixels at 1080p x0 = LX + (dw - len(nodes) * NW - (len(nodes) - 1) * GAP) / 2 lane_top, lane_bot = y + TAG + 4, y + h - 8 block = LS * 1.2 + 4 + NH + LS + 10 + 8 # address, node, the pins' stub and names ly = y + TAG + (16 * k if not subject else round((h - TAG - block) / 2)) # the row of addresses over the nodes ny = ly + LS * 1.2 + 4 xs = {a: x0 + i * (NW + GAP) for i, (a, v, nx) in enumerate(nodes)} for a, v, nx in nodes: x = xs[a] g.t(x + NW / 2, ly + LS * 0.96, "%x" % a, LS, HEAP, MONO, "middle") g.rect(x, ny, VW - 2, NH, RAISED) g.t(x + VW / 2 - 1, ny + NH / 2 + 0.36 * VS, str(v), VS, VELLUM, MONO if VS < 30 else "mono", "middle") g.rect(x + VW, ny, NW - VW, NH, WELL) if marks.get("read") == a + 8: g.frame(x + VW - 2 * k, ny - 2 * k, NW - VW + 4 * k, NH + 4 * k, READ, 2 * k) if a + 8 in marks.get("tick", ()): held_cell(g, x + VW, ny, NW - VW, NH, k) cx, cy = x + VW + (NW - VW) / 2, ny + NH / 2 if nx: g.rect(cx - 5 * k, cy - 5 * k, 10 * k, 10 * k, HEAP) gen.arrow(g, [(cx + 8 * k, cy), (xs[nx] - 3 * k, cy)], HEAP, 3 * k, hl=12 * k, hw=10 * k) else: g.path(f"M{x + VW + 10 * k},{ny + NH - 8 * k} L{x + NW - 10 * k},{ny + 8 * k}", DIM, 2 * k) names = pins.get(a) if names: via = None if link_from and link_from[1] in names: # the step's link ends in this pin via = [(RX + 2, link_from[0] + 12), (LANE_LINK, link_from[0] + 12), (LANE_LINK, lane_bot), (x + NW / 2, lane_bot)] pin_up(g, x + NW / 2, ny + NH, names, HEAP, LS, via, sw=tie_w[0]) # the projection: the bytes a step read, and the part of the drawing that is those bytes if marks.get("read"): a = marks["read"] & ~15 yy, x = rows[a], xs[a] bracket(g, RX + 7, yy + 2, yy + ROW - 2, READ, 3, 6) g.path(f"M{RX + 6},{yy + 12} H{LANE_VIEW + 6} Q{LANE_VIEW},{yy + 12} {LANE_VIEW},{yy + 6} V{lane_top + 6} " f"Q{LANE_VIEW},{lane_top} {LANE_VIEW - 6},{lane_top} H{x + NW / 2 + 6} " f"Q{x + NW / 2},{lane_top} {x + NW / 2},{lane_top + 6} V{ly - 4}", READ, tie_w[1]) g.rect(x, ly - 5, NW, 3, READ) g.rect(x, ly - 5, 3, 8, READ) g.rect(x + NW - 3, ly - 5, 3, 8, READ) return xs, rows # ---- the data: moments 71 and 72 of the recording --------------------------------------- SRC = open(__file__.replace("context.py", "list.c")).read().split("\n") S_, H_, C_, D_ = STACK, HEAP, CODE, DATA RBP = [(0x7ffe970f17b0, S_), (0x7ffe970f17d0, S_), (0x7ffe970f1880, S_), (0x7ffe970f18e0, S_)] ARGV = [(0x7ffe970f1908, S_), (0x7ffe970f2fce, S_)] def regs_at(rdi): return [ ("rax", [(0x28b41090, H_)], ("int", 4)), ("rbx", [], ("int", 0)), ("rcx", [(0x28b410b0, H_)], ("int", 1)), ("rdx", [], ("int", 0)), ("rsi", [(0x28b410c0, H_)], ("int", 0)), ("rdi", [(rdi[0], H_)], ("int", rdi[1])), ("rbp", RBP, ("int", 0)), ("rsp", RBP, ("int", 0)), ("r8", [(0x7f2ba3019ac0, D_)], ("int", 0)), ("r9", [], ("int", 0x20)), ("r10", [], ("int", 0x10)), ("r11", [(0x7f2ba3019ac8, D_), (0x28b410c0, H_)], ("int", 0)), ("r12", ARGV, ("str", "zig-out/targets/list")), ("r13", [], ("int", 1)), ("r14", [(0x7f2ba32ac000, D_), (0x7f2ba32ad3c0, D_)], ("int", 0)), ("r15", [(0x10029c0, VELLUM)], ("int", 1)), ("rip", [(0x1001926, C_, "reverse+22")], None), ] FLAGS = [("CF", 0, 0), ("PF", 1, 0), ("AF", 0, 0), ("ZF", 0, 1), ("SF", 0, 0), ("IF", 1, 0), ("DF", 0, 0), ("OF", 0, 0)] STACK_ROWS = [ (0x7ffe970f17b0, ["rsp", "rbp"], RBP[1:], ("int", 0)), (0x7ffe970f17b8, [], [(0x10018b0, C_, "main+80")], None), (0x7ffe970f17c0, [], [(0x7f2ba3020de8, D_), (0x7ffe970f1918, S_), (0x7ffe970f2fe3, S_)], ("str", "SHELL=/usr/bin/bash")), (0x7ffe970f17c8, [], [], ("int", 0)), (0x7ffe970f17d0, [], RBP[2:], ("int", 0)), (0x7ffe970f17d8, [], [(0x7f2ba2e27781, C_, "libc+27781")], None), (0x7ffe970f17e0, [], [(0x7f2ba328fc60, C_, "ld.so+22c60")], None), (0x7ffe970f17e8, [], ARGV, ("str", "zig-out/targets/list")), ] FRAMES = [("reverse", 0, 1), ("main", 2, 5), ("libc+27781", 6, 8)] NODES = [(0x28b410b0, 1, 0), (0x28b41090, 4, 0x28b41070), (0x28b41070, 9, 0x28b41050), (0x28b41050, 16, 0x28b41030), (0x28b41030, 25, 0x28b41010), (0x28b41010, 36, 0)] P = VELLUM RAX = ("set", "rax", [(0x28b41090, H_)], ("int", 4)) RCX = ("set", "rcx", [(0x28b410b0, H_)], ("int", 1)) DIS = [ # address, line, mnemonic, operands, state, annotation (0x1001910, 20, "test", [("rdi, rdi", P)], None, None), (0x1001913, 20, "je", [(0x1001935, C_)], None, None), (0x1001915, 20, "push", [("rbp", P)], None, None), (0x1001916, 20, "mov", [("rbp, rsp", P)], None, None), (0x1001919, 20, "xor", [("eax, eax", P)], None, None), (0x100191b, 20, "nop", [("dword ptr [rax + rax]", P)], None, None), (0x1001920, 20, "mov", [("rcx, rax", P)], "trail1", RCX), (0x1001923, 20, "mov", [("rax, rdi", P)], "trail0", RAX), (0x1001926, 21, "mov", [("rdi, qword ptr [rdi + 8]", P)], "cur", None), # its note is each frame's (0x100192a, 22, "mov", [("qword ptr [rax + 8], rcx", P)], None, None), (0x100192e, 20, "test", [("rdi, rdi", P)], None, None), (0x1001931, 20, "jne", [(0x1001920, C_)], "trail2", ("text", "taken")), (0x1001933, 20, "pop", [("rbp", P)], None, None), (0x1001934, 26, "ret", [], None, None), (0x1001935, 26, "xor", [("eax, eax", P)], None, None), (0x1001937, 26, "ret", [], None, None), (0x1001938, None, "endbr64", [], "out", ("text", "_init", FAINT)), ] # The splits with a lens: the drawing's and its view's heights, then source lines, instructions and stack slots. BESIDE = dict(band=152, view=152, src=8, dis=17, words=8, dump=5) SUBJECT = dict(band=296, view=200, src=10, dis=9, words=6, dump=7) def clock(g, moment, total): """The scene's clock: how far through the recording, on the rule over the caption. Still through a step.""" g.rect(LX, 899, W - 2 * LX, 2, RULE) g.rect(LX, 898, (W - 2 * LX) * moment / total, 4, GOLD) g.t(W - LX, 934, "moment %d of %d" % (moment, total), S, FAINT, MONO, "end") def frame(name, step, subject=False): """step: mid-step, the load done. subject: the lens is what the scene is about, and the band is taller.""" g = Svg() sp = SUBJECT if subject else BESIDE rdi = (0x28b41070, 9) if step else (0x28b41090, 4) # what the last three steps changed, and (mid-step) what this one has reg_marks = {"rax": {0: "tick"}, "rcx": {0: "tick"}, "rdi": {0: "strike" if step else "tick"}} lens_marks = {"tick": [0x28b410b8]} # names keep their side: rax stays left of its stub when rdi goes, and rdi takes the free side where it lands pins = {0x28b410b0: ["rcx"], 0x28b41090: ["rax"] + ([] if step else ["rdi"]), 0x28b41070: ["rdi"] if step else []} if step: lens_marks["read"] = 0x28b41098 k = [r[0] for r in DIS].index(0x1001926) half = sp["dis"] // 2 # the pc's row, and as many above as below dis = list(DIS[k - half:k + half + 1]) dump_first = 0x28b41050 if subject else 0x28b41070 y = TOP + sp["band"] + 12 ys = source(g, y, sp["src"], SRC, 18 if subject else 19, 21, [20, 22], "list.c", len(SRC) - 1) yd = y + ph(sp["src"]) + 12 i = [r[0] for r in dis].index(0x1001926) dis[i] = dis[i][:5] + (("chain", [(0x28b41098, H_), (0x28b41070, H_)], ("int", 9), {0: "read"} if step else None),) at = disasm(g, yd, dis, "reverse", 21, jump=(0x1001931, 0x1001920)) thread(g, ys, [(at[0x1001926], at[0x1001926] + ROW)]) yr = TOP + sp["view"] + 12 where = registers(g, yr, regs_at(rdi), FLAGS, reg_marks) stack(g, yr + ph(17) + 12, STACK_ROWS[:sp["words"]], FRAMES) lens(g, TOP, sp["band"], sp["view"], NODES, pins, lens_marks, dump_first, sp["dump"], link_from=(where["rdi"], "rdi") if step else None, subject=subject) clock(g, 71, 95) # mid-step the clock has not moved: it moves when the mark has landed if step: gen.caption(g, [[("The load read the word at ",), ("28b41098", "mono"), (": the address of the next node.",)], [("rdi", "mono"), (" holds it now, and points at the node whose value is 9.",)]]) else: gen.caption(g, [[("Stopped in ",), ("reverse", "mono"), (", about to load ",), ("head->next", "mono"), (".",)], [("rdi", "mono"), (" points at a node; the word after its value is the next node.",)]]) g.save(name) # ---- the calls lens: a tree of every call, and the backtrace it is a view of ------------- def fib_calls(n): """Every call of fib(n), in the order they are made: (argument, parent index, level, result).""" out = [] def call(k, parent, level): i = len(out) out.append([k, parent, level, None]) out[i][3] = k if k < 2 else call(k - 1, i, level + 1) + call(k - 2, i, level + 1) return out[i][3] call(n, None, 0) return out def tree_x(calls): """In leaf slots: leaves in call order, a parent over the middle of its children.""" kids = {i: [j for j, c in enumerate(calls) if c[1] == i] for i in range(len(calls))} xs, leaf = {}, [0] def place(i): if not kids[i]: xs[i] = leaf[0] leaf[0] += 1 else: for j in kids[i]: place(j) xs[i] = (xs[kids[i][0]] + xs[kids[i][-1]]) / 2 place(0) return xs, leaf[0] def calls(g, y, h, tree, made, caller, project_from=None): """The drawing: tree is fib_calls(); made: how many calls have been made (the last is running). project_from: the y of the stack row whose return address the newest node is drawn from, mid-step. Returns the newest node's centre.""" tag(g, LX, y, CW, h, "calls of fib", focus=True, note="each call a node · its result on its shoulder") D, LEVEL, BADGE = 48, 46, 30 xs, leaves = tree_x(tree) left, right = LX + 44, LX + CW - 12 - 48 # the last leaf's badge stays inside pitch = (right - left) / (leaves - 1) top = y + TAG + 48 at = lambda i: (left + xs[i] * pitch, top + tree[i][2] * LEVEL) newest = made - 1 waiting = set() p = tree[newest][1] while p is not None: waiting.add(p) p = tree[p][1] # the caller, at the drawing's left on the root's level, clear of the tree: waiting, with an edge into the root rx, ry = at(0) bx = LX + 20 g.path(f"M{bx + 64},{ry} H{rx - D / 2}", VELLUM, 3) g.rect(bx, ry - 14, 64, 28, PAGE) g.frame(bx, ry - 14, 64, 28, VELLUM, 3) g.t(bx + 32, b(ry - 12), caller, S, VELLUM, MONO, "middle") # edges under the nodes: the waiting path in primary for i in range(1, made): (px, py), (cx, cy) = at(tree[i][1]), at(i) live = i in waiting or i == newest g.line(px, py, cx, cy, VELLUM if live else RULE, 3) for i in range(made): cx, cy = at(i) k, _, _, result = tree[i] if i == newest: g.circle(cx, cy, D / 2, GOLD) g.t(cx, cy + 0.36 * 25, str(k), 25, INK, BOLD, "middle") elif i in waiting: g.circle(cx, cy, D / 2 - 1.5, PAGE, VELLUM, 3) g.t(cx, cy + 0.36 * 25, str(k), 25, VELLUM, MONO, "middle") else: g.circle(cx, cy, D / 2, RAISED) g.t(cx, cy + 0.36 * 25, str(k), 25, VELLUM, MONO, "middle") g.rect(cx + 12, cy - 42, BADGE, BADGE, PAGE) g.frame(cx + 12, cy - 42, BADGE, BADGE, FAINT, 2) g.t(cx + 12 + BADGE / 2, cy - 42 + BADGE / 2 + 0.36 * 25, str(result), 25, VELLUM, MONO, "middle") cx, cy = at(newest) if project_from is not None: # the frame's return address is the node: a projection, from below lane_bot = y + h - 8 bracket_y = cy + D / 2 + 5 gen.arrow(g, [(RX + 3, project_from + 12), (LANE_LINK, project_from + 12), (LANE_LINK, lane_bot), (cx, lane_bot), (cx, bracket_y + 3)], VERM, 2, r=6, head=False) g.rect(cx - D / 2, bracket_y, D, 3, VERM) g.rect(cx - D / 2, bracket_y - 5, 3, 8, VERM) g.rect(cx + D / 2 - 3, bracket_y - 5, 3, 8, VERM) bracket(g, RX + 4, project_from + 2, project_from + ROW - 2, VERM, 3, 5) return cx, cy def backtrace(g, y, h, frames, x=RX, note="the calls waiting · newest on top", focus=False): """The call chain as rows, newest on top: the view of the calls, or a lens's drawing (x = LX). frames: (name, args, file, line), file None where the recording does not know it. More frames than rows: the oldest go, counted.""" rows = (h - TAG - 2 * PAD) // ROW if len(frames) > rows: note += " · %d more" % (len(frames) - rows) y0 = panel(g, x, y, CW, rows, "backtrace", focus=focus, note=note) for i, (name, args, file, line) in enumerate(frames[:rows]): yy = y0 + i * ROW if i == 0: g.t(x + 12, b(yy), "#0", S, current_row(g, x + 2, yy, CW - 4, 40), BOLD) else: g.t(x + 12, b(yy), "#%d" % i, S, FAINT, MONO) g.t(x + 60, b(yy), name, S, VELLUM, MONO) if args: g.t(x + 384, b(yy), args, S, VELLUM, MONO) if file: g.t(x + CW - 12, b(yy), "%s:%d" % (file, line), S, DIM, MONO, "end") # ---- the data: moments 752 and 753 of the fib scene (anim/zig-out/recordings/steps.ztrace) ----- FIB_SRC = open(__file__.replace("context.py", "fib.c")).read().split("\n") FIB_RBP = [(0x7fffffffeda0, S_), (0x7fffffffedd0, S_), (0x7fffffffedf0, S_), (0x7fffffffee20, S_)] FIB_ARGV = [(0x7fffffffee38, S_), (0x7fffffffefe8, S_)] FIB_REGS = [ ("rax", [], ("int", 2)), ("rbx", FIB_ARGV, ("str", "./steps")), ("rcx", [], ("int", 1)), ("rdx", [(0x7fffffffee48, S_)], ("int", 0)), ("rsi", FIB_ARGV, ("str", "./steps")), ("rdi", [], ("int", 2)), ("rbp", FIB_RBP, ("int", 0)), ("rsp", [(0x7fffffffed78, S_), (0x10133ab, C_, "fib+59")], None), ("r8", [], ("int", 0)), ("r9", [], ("int", 0x800000)), ("r10", [], ("int", 0x800000)), ("r11", [], ("int", 0x346)), ("r12", [(0x7fffffffee48, S_)], ("int", 0)), ("r13", [], ("int", 0)), ("r14", [(0x10133d0, C_, "main+0")], None), ("r15", [], ("int", 1)), ("rip", [(0x10133a6, C_, "fib+54")], None), ] FIB_FLAGS = [("CF", 0, 0), ("PF", 0, 0), ("AF", 0, 0), ("ZF", 0, 0), ("SF", 0, 0), ("IF", 1, 0), ("DF", 0, 0), ("OF", 0, 0)] FIB_STACK = [ # the window from rsp: the new frame's return address, then fib(4)'s words down to its saved rbp (0x7fffffffed78, ["rsp"], [(0x10133ab, C_, "fib+59")], None, {1: "strike"}), (0x7fffffffed80, [], [], ("int", 0)), (0x7fffffffed88, [], [], ("int", 2), {"end": "tick"}), (0x7fffffffed90, [], [], ("int", 4)), (0x7fffffffed98, [], [(0x7ffff7ffd000, C_, "vdso+0")], None), (0x7fffffffeda0, ["rbp"], FIB_RBP[1:], ("int", 0)), ] FIB_FRAMES = [("fib(2)", 0, 0), ("fib(4)", 1, 9)] FIB_DIS = [ # fib(4) at its second call: line 6, one run (0x1013395, 6, "call", [(0x1013370, C_)], None, ("text", "fib", VELLUM)), (0x101339a, 6, "mov", [("qword ptr [rbp - 0x18], rax", P)], "trail2", ("chain", [(0x7fffffffed88, S_)], ("int", 2), None)), (0x101339e, 6, "mov", [("rdi, qword ptr [rbp - 0x10]", P)], "trail1", ("chain", [(0x7fffffffed90, S_)], ("int", 4), None)), (0x10133a2, 6, "sub", [("rdi, 2", P)], "trail0", ("set", "rdi", [], ("int", 2))), (0x10133a6, 6, "call", [(0x1013370, C_)], "cur", ("text", "fib", BRIGHT)), (0x10133ab, 6, "mov", [("rcx, rax", P)], None, ("set", "rdi", [], ("int", 2))), # the call's argument hangs here (0x10133ae, 6, "mov", [("rax, qword ptr [rbp - 0x18]", P)], None, None), (0x10133b2, 6, "add", [("rax, rcx", P)], None, None), (0x10133b5, 6, "mov", [("qword ptr [rbp - 8], rax", P)], None, None), ] FIB_BACKTRACE = [("fib+0", "n=2", "fib.c", 3), ("fib+59", "n=4", "fib.c", 6), ("fib+42", "n=5", "fib.c", 6), ("main+25", "", "fib.c", 10), ("libc_start_main_stage2+45", "", "__libc_start_main.c", 95), ("_start_c+0", "", "crt1.c", 15)] def frame_calls(name): """fib(4) has called fib(2), mid-step: rsp and the return address struck, and the new node drawn from it.""" g = Svg() sp = SUBJECT y = TOP + sp["band"] + 12 ys = source(g, y, sp["src"], FIB_SRC, 3, 6, [7, 5, 4], "fib.c", len(FIB_SRC) - 1) at = disasm(g, y + ph(sp["src"]) + 12, FIB_DIS, "fib", 6) thread(g, ys, [(at[0x1013395], at[0x10133b5] + ROW)]) yr = TOP + sp["view"] + 12 registers(g, yr, FIB_REGS, FIB_FLAGS, {"rsp": {0: "strike"}, "rdi": {0: "tick"}}) rows = stack(g, yr + ph(17) + 12, FIB_STACK, FIB_FRAMES) backtrace(g, TOP, sp["view"], FIB_BACKTRACE) calls(g, TOP, sp["band"], fib_calls(5), 8, "main", project_from=rows[0]) clock(g, 752, 1999) gen.caption(g, [[("The call pushed its return address, ",), ("fib+59", "mono"), (", on the stack.",)], [("That word is the new frame, and the frame is the node ",), ("fib(2)", "mono"), (".",)]]) g.save(name) # ---- the data: the sqlite scene (anim/scenes/sqlite.zig), its stops 120 and 169 --------------------- SQ = "/home/goblin/05-genizah/sqlite/sqlite-amalgamation-3500400/sqlite3.c" SQ_LINES = {n: l for n, l in enumerate(open(SQ, errors="replace").read().split("\n"), 1) if 42280 <= n <= 42300 or 80885 <= n <= 80905} SQ_TOTAL = 262899 class Lines(dict): """The source's lines a mock shows, by number (sqlite3.c is 262 899 of them).""" def __getitem__(self, i): return SQ_LINES.get(i + 1, "") def sq_region(v): """Where a value of the sqlite recording points, by its mappings: the ink of its digits.""" if 0x7ffffffde000 <= v < 0x7ffffffff000: return S_ if 0x517000 <= v < 0x55b000: return H_ if 0x510000 <= v < 0x517000: return D_ if 0x402000 <= v < 0x4ed000 or 0x7ffff7c24000 <= v < 0x7ffff7d9f000: return C_ return VELLUM SQ_FLAGS_120 = [("CF", 0, 0), ("PF", 0, 1), ("AF", 0, 0), ("ZF", 0, 1), ("SF", 0, 0), ("IF", 1, 0), ("DF", 0, 0), ("OF", 0, 0)] SQ_FLAGS_169 = [("CF", 1, 1), ("PF", 1, 1), ("AF", 0, 0), ("ZF", 0, 0), ("SF", 0, 0), ("IF", 1, 0), ("DF", 0, 0), ("OF", 0, 0)] E980 = [(0x7fffffffe980, S_), (0x7fffffffeb90, S_), (0x7fffffffec60, S_), (0x7fffffffece0, S_), (0x7fffffffed00, S_)] E7E0 = [(0x7fffffffe7e0, S_), (0x7fffffffe820, S_), (0x7fffffffe860, S_), (0x7fffffffe8d0, S_), (0x7fffffffe940, S_)] SQ_REGS_120 = [ ("rax", [(0x5226d0, H_)], ("int", 0)), ("rbx", [], ("int", 1)), ("rcx", [], ("int", 0)), ("rdx", [], ("int", 8)), ("rsi", [(0x7fffffffea60, S_)], ("int", 0)), ("rdi", [(0x521978, H_)], ("int", 0x101)), ("rbp", E980, None), ("rsp", E980, None), ("r8", [], ("int", 0x38)), ("r9", [], ("int", 0)), ("r10", [], ("int", 7)), ("r11", [], ("int", 0xffffffff)), ("r12", [], ("int", 0)), ("r13", [(0x5222d0, H_)], ("int", 0x39fb80)), ("r14", [(0x5218f8, H_)], ("int", 0x40100010000)), ("r15", [], ("int", 0)), ("rip", [(0x448d84, C_, "sqlite3BtreeInsert+4")], None), ] PAGE_W = 0xe60f030000000d SQ_REGS_169 = [ ("rax", [], ("int", 0x1000)), ("rbx", [], ("int", 3)), ("rcx", [(0x7ffff7cf1a7d, C_, "__pwrite64+173")], None), ("rdx", [], ("int", 0x1000)), ("rsi", [(0x538b28, H_)], ("int", PAGE_W)), ("rdi", [], ("int", 3)), ("rbp", E7E0, None), ("rsp", [(0x7fffffffe7a0, S_)], ("int", 0)), ("r8", [], ("int", 0)), ("r9", [], ("int", 0)), ("r10", [], ("int", 0x1000)), ("r11", [], ("int", 0x246)), ("r12", [], ("int", 0x1000)), ("r13", [(0x538b28, H_)], ("int", PAGE_W)), ("r14", [], ("int", 0x1000)), ("r15", [(0x538b28, H_)], ("int", PAGE_W)), ("rip", [(0x422051, C_, "unixWrite+65")], None), ] EA18 = [(0x7fffffffea18, S_), (0x517378, H_), (0x513010, D_)] SQ_STACK_120 = [ # from rsp: sqlite3BtreeInsert's saved rbp and return address, then its caller's words (0x7fffffffe980, ["rbp", "rsp"], E980[1:], None), (0x7fffffffe988, [], [(0x43e029, C_, "sqlite3VdbeExec+18905")], None), (0x7fffffffe990, [], [(0x7ffff7c0ed60, VELLUM)], ("int", 0xd001200000f05)), (0x7fffffffe998, [], EA18, ("int", 0x7800000003)), (0x7fffffffe9a0, [], [(0x521ed0, H_)], ("int", 0)), (0x7fffffffe9a8, [], EA18, ("int", 0x7800000003)), ] SQ_STACK_169 = [ # rsp+20 to rsp+48: the words unixWrite's prologue pushed, its saved rbp, its way back (0x7fffffffe7c0, [], [], ("int", 0), {"end": "tick"}), (0x7fffffffe7c8, [], [(0x538b28, H_)], ("int", PAGE_W), {1: "tick"}), (0x7fffffffe7d0, [], [(0x517e38, H_), (0x513010, D_)], ("int", 0x7800000003), {1: "tick"}), (0x7fffffffe7d8, [], [], ("int", 2), {"end": "tick"}), (0x7fffffffe7e0, ["rbp"], E7E0[1:], None), (0x7fffffffe7e8, [], [(0x42fa75, C_, "pager_write_pagelist+245")], None), ] SQ_DIS_120 = [(a, 80895, mn, [(ops, P)], "cur" if a == 0x448d84 else None, None) for a, mn, ops in [ (0x448d80, "push", "rbp"), (0x448d81, "mov", "rbp, rsp"), (0x448d84, "push", "r15"), (0x448d86, "push", "r14"), (0x448d88, "push", "r13"), (0x448d8a, "push", "r12"), (0x448d8c, "push", "rbx"), (0x448d8d, "sub", "rsp, 0xa8"), (0x448d94, "mov", "r14d, ecx")]] SQ_DIS_169 = [(a, 42290, mn, ops, "cur" if a == 0x422051 else None, None) for a, mn, ops in [ (0x422042, "mov", [("rsi, r15", P)]), (0x422045, "mov", [("rdx, r12", P)]), (0x422048, "mov", [("rcx, r14", P)]), (0x42204b, "call", [("qword ptr [rip + 0xf1567]", P)]), (0x422051, "mov", [("r13, rax", P)]), (0x422054, "test", [("r13d, r13d", P)]), (0x422057, "jns", [(0x422070, C_)]), (0x422059, "call", [(0x4021c0, C_)]), (0x42205e, "mov", [("ecx, dword ptr [rax]", P)])]] SQ_BT_120 = [("sqlite3BtreeInsert+4", "", "sqlite3.c", 80895), ("sqlite3VdbeExec+18905", "", None, 0), ("sqlite3_step+910", "", None, 0), ("sqlite3_exec+394", "", None, 0), ("main+56", "", None, 0), ("libc.so.6+27781", "", None, 0), ("__libc_start_main+137", "", None, 0), ("_start+37", "", None, 0)] # BtreePayload (the source's lines 16740 to 16748), as the scene gives it: (at, len, reads, big, mark) PAYLOAD = [(0, 8, "pointer", False, None), (8, 8, "number", False, 0), (16, 8, "pointer", False, None), (24, 8, "pointer", False, None), (32, 2, "number", False, None), (36, 4, "number", False, 1), (40, 4, "number", False, None)] ROW_BYTES = bytes.fromhex("0000000000000000 0100000000000000 884d520000000000 0000000000000000" "0000000007000000 0000000001000000".replace(" ", "")) PAGE0 = bytes.fromhex("0d000000030fe6000ff70fef0fe60000") PAGE_END = bytes.fromhex("0000000000000703021767616d6d61060202156265746107010217616c706861") def leaf(page): """A table's leaf page, read by SQLite's file format (the scene's `leaf`): the header, the cell pointers, each cell's length, rowid, record header and text. Every number big-endian, every varint here a byte.""" out = [(0, 1, "number", False, 0), (1, 2, "bytes", True, 0), (3, 2, "number", True, 0), (5, 2, "bytes", True, 0), (7, 1, "bytes", False, 0)] cells = page[3] << 8 | page[4] out += [(8 + 2 * k, 2, "number", True, 1) for k in range(cells)] for k in range(cells): at = page[8 + 2 * k] << 8 | page[9 + 2 * k] out += [(at, 1, "bytes", False, 2 + k), (at + 1, 1, "number", False, 2 + k), (at + 2, 2, "bytes", False, 2 + k), (at + 4, page[at] - 2, "text", False, 2 + k)] return out def frame_sqlite(name, late): """The sqlite scene at rest. Early (stop 120): the backtrace is the band's drawing, and the row the B-tree is handed, a struct on the stack, its view. Late (stop 169): pwrite64 has come back; the kernel's side is the drawing, and the page it took the view, read by SQLite's file format.""" g = Svg() sp = SUBJECT y = TOP + sp["band"] + 12 yr = TOP + sp["view"] + 12 lines = Lines() w = wide(SQ_TOTAL) if not late: source(g, y, sp["src"], lines, 80890, 80895, [], "sqlite3.c", SQ_TOTAL) disasm(g, y + ph(sp["src"]) + 12, SQ_DIS_120, "sqlite3BtreeInsert", 80895, w=w) ys = y + TAG + PAD + 5 * ROW changed = {r: {0: "tick"} for r, _, _ in SQ_REGS_120 if r not in ("r12", "rip")} registers(g, yr, SQ_REGS_120, SQ_FLAGS_120, changed) stack(g, yr + ph(17) + 12, SQ_STACK_120, [("sqlite3BtreeInsert", 0, 1), ("sqlite3VdbeExec", 2, 9)]) backtrace(g, TOP, sp["band"], SQ_BT_120, x=LX, note="newest on top", focus=True) base = 0x7fffffffea60 fields(g, TOP, sp["view"], "pX, the row: a BtreePayload, at rsi", base, 48, PAYLOAD, {base + i: v for i, v in enumerate(ROW_BYTES)}, STACK, sq_region, marks=(0, 1)) clock(g, 9, 58) gen.caption(g, [[("sqlite3VdbeExec", "mono"), (", the bytecode's loop, calls the B-tree: ",), ("rdi", "mono"), (" is",)], [("the table's cursor, ",), ("rsi", "mono"), (" the row: rowid 1, a record of 7 bytes.",)]]) else: source(g, y, sp["src"], lines, 42286, 42290, [], "sqlite3.c", SQ_TOTAL) disasm(g, y + ph(sp["src"]) + 12, SQ_DIS_169, "unixWrite", 42290, w=w) ys = y + TAG + PAD + 4 * ROW changed = {r: {0: "tick"} for r, _, _ in SQ_REGS_169 if r not in ("r9", "rip")} registers(g, yr, SQ_REGS_169, SQ_FLAGS_169, changed) stack(g, yr + ph(17) + 12, SQ_STACK_169, [("unixWrite", -1, 5)], note="rsp+20 to rsp+48") page = bytes(4096 - len(PAGE_END) - len(PAGE0)) # the middle of the page is not drawn: `more` page = PAGE0 + page + PAGE_END kernel(g, TOP, sp["band"], [("pwrite64", 4096), ("pwrite64", 4096), ("fsync", 0), ("pwrite64", 12), ("close", 0), ("fsync", 0), ("openat", 5), ("fsync", 0)], "pwrite64", 18, [("rdi", "fd", "3", '"t.db"'), ("rsi", "buf", "538b28", None), ("rdx", "count", "4096", None), ("r10", "offset", "4096", None), ("rax", "returns", "4096", None)], PAGE0 + bytes(4)) base = 0x538b28 took = {base + i: v for i, v in enumerate(PAGE0)} took.update({base + 0xfe0 + i: v for i, v in enumerate(PAGE_END)}) fields(g, TOP, sp["view"], "pBuf: page 2 of t.db, at rsi", base, 4096, leaf(page), took, HEAP, sq_region, marks=(0, 1)) clock(g, 58, 58) gen.caption(g, [[("Page 2 as the kernel took it: ",), ("0d", "mono"), (", a table's leaf; 3 cells;",)], [("their offsets, ",), ("0ff7 0fef 0fe6", "mono"), (", each a row at the page's end.",)]]) thread(g, ys, [(y + ph(sp["src"]) + 12 + TAG + PAD, y + ph(sp["src"]) + 12 + TAG + PAD + 9 * ROW)]) g.save(name) if __name__ == "__main__": assert ph(8) + 12 + ph(17) == ph(17) + 12 + ph(8) == BOTTOM - TOP - 152 - 12 # lens beside assert ph(10) + 12 + ph(9) == BOTTOM - TOP - 296 - 12 # lens as subject: the drawing assert ph(17) + 12 + ph(6) == BOTTOM - TOP - 200 - 12 and ph(7) == 200 # its view, and the stack under it assert ph(5) == 152 assert shared([0x1001910, 0x1001937]) == 5 and shared([0x28b41070]) == 6 frame("09-context", False) frame("10-context-step", True) frame("11-context-lens", True, subject=True) frame_calls("12-calls-subject") frame_sqlite("13-sqlite-row", False) frame_sqlite("14-sqlite-page", True)