diff options
Diffstat (limited to 'design/mock/context.py')
| -rw-r--r-- | design/mock/context.py | 563 |
1 files changed, 341 insertions, 222 deletions
diff --git a/design/mock/context.py b/design/mock/context.py index 8a5d923..886372f 100644 --- a/design/mock/context.py +++ b/design/mock/context.py @@ -1,26 +1,33 @@ #!/usr/bin/env python3 -"""The default frame: the machine's whole context, pwndbg's way, and the scene's lens. +"""The frame: the machine's whole context, pwndbg's way, a lens over it, and the ties between them. python3 context.py # writes 09-context.svg, 10-context-step.svg, 11-context-lens.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 instructions at the pc, the -stack. The lens (the list, and the heap words that are its nodes) is what those chains -and the program say the heap holds; a recording made under ptrace has no allocations. +(`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. """ import re import gen -from gen import (PAGE, RAISED, RULE, VELLUM, BRIGHT, DIM, FAINT, INK, GOLD, VERM, READ, ALLOC, EMBER, TRAIL, - STACK, HEAP, CODE, DATA, KW, LIT, COMMENT, W, H, Svg, tw) +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 +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): @@ -28,9 +35,13 @@ def b(y): return y + ROW / 2 + 0.36 * S -def panel(g, x, y, w, rows, title, focus=False, note=None, h=None): - """A one-row tag and `rows` rows under it. Returns the y of the first row.""" - h = h or TAG + 12 + rows * ROW +def ph(rows): + """A panel's height.""" + return TAG + 2 * PAD + rows * ROW + + +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: @@ -40,52 +51,67 @@ def panel(g, x, y, w, rows, title, focus=False, note=None, h=None): 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: # runs, each in its own ink: the legend + 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 - return y + TAG + 6 -# ---- a value, by what it is --------------------------------------------------- -def groups(n): - """Hex at its natural length, in fours from the right.""" - d = "%x" % n - head = len(d) % 4 - return ([d[:head]] if head else []) + [d[i:i + 4] for i in range(head, len(d), 4)] +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): - gs = groups(n) - return sum(len(s) for s in gs) * A + (len(gs) - 1) * (A // 2) + return len("%x" % n) * A -def addr(g, x, y, n, ink, face=MONO, under=False): - for s in groups(n): - g.t(x, b(y), s, S, ink, face) - x += len(s) * A + A // 2 +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 - addr_w(n) - A // 2, y + ROW - 3, addr_w(n), 2, ink) - return x - A // 2 + g.rect(x, y + ROW - 3, len(d) * A, 2, ink) + return x + len(d) * A def link_arrow(g, x, y, ink=FAINT): - """A pointer to: 30 wide.""" + """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): - """Which holds: 30 wide, pointing back.""" + """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: @@ -100,17 +126,21 @@ def integer(g, x, y, v, ink=VELLUM): return x -def chain(g, x, y, links, end, marks=None, room=None): - """A telescope: links are (address, ink[, name]); end is ("int", v), ("str", s), ("more",) or None. - marks: {index: "strike" | "tick" | "read" | "land"} on a link, index len(links) being the end. +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) - w = addr_w(n) m = marks.get(i) if m == "strike": g.rect(x - 5, y + 1, w + 10, ROW - 2, VERM) @@ -120,53 +150,59 @@ def chain(g, x, y, links, end, marks=None, room=None): g.rect(x - 9, y + 3, 4, ROW - 6, VERM) if m == "read": g.frame(x - 6, y, w + 12, ROW, READ, 2) - if m == "land": - g.frame(x - 6, y, w + 12, ROW, BRIGHT, 2) - addr(g, x, y, n, ink) + addr(g, x, y, n, ink, lead=lead if i == 0 else 0) where.append((x, w)) x += w - if len(link) > 2: # code: its name is what a reader reads + if named: # code: its name is what a reader reads g.t(x + 10, b(y), link[2], S, VELLUM, MONO) - x += 10 + len(link[2]) * A + x += named if end is None: return where - if end[0] == "more": - x = link_arrow(g, x, y) - for d in range(3): - g.rect(x + 2 + d * 8, y + 14, 3, 3, FAINT) - return where x = value_arrow(g, x, y) if links else x - m = marks.get(len(links)) - if m == "tick": - g.rect(x - 3, y + 3, 4, ROW - 6, VERM) - x += 6 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: - s = s[:max(int((room - x) // A) - 2, 1)] + "…" - g.t(x, b(y), '"' + s, S, LIT, MONO) + 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 plaque(g, x, y, s, fill=RAISED, ink=VELLUM, stroke=None, pad=4): - """A register's name where it points: 20 tall in a 24 row.""" - w = len(s) * A + 2 * pad - g.rect(x, y + 2, w, ROW - 4, fill) - if stroke: - g.frame(x, y + 2, w, ROW - 4, stroke, 2) - g.t(x + pad, b(y) - 1, s, S, ink, MONO) - return w +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): + """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, 3, r=8, hl=10, hw=10) + face = BOLD + by = y + 8 + size * 0.86 + if names: + 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) -# ---- the context's five panels --------------------------------------------------- +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, 18, "registers", note=legend) + y0 = panel(g, RX, y, CW, 17, "registers", note=legend) where = {} for i, (name, links, end) in enumerate(regs): yy = y0 + i * ROW @@ -176,53 +212,53 @@ def registers(g, y, regs, flags, marks): g.t(RX + 12, b(yy), name, S, INK, BOLD) else: g.t(RX + 12, b(yy), name, S, DIM, MONO) - where[name] = (yy, chain(g, RX + 72, yy, links, end, marks.get(name), room=RX + CW - 12) if links else - [(RX + 72, integer(g, RX + 72, yy, end[1]) - RX - 72)]) - if not links and marks.get(name, {}).get(0) == "tick": - g.rect(RX + 63, yy + 3, 4, ROW - 6, VERM) - yy = y0 + 17 * ROW - g.t(RX + 12, b(yy), "flags", S, DIM, MONO) - g.t(RX + 84, b(yy), "0x%x" % flags[0], S, VELLUM, MONO) - x = RX + 84 + 6 * A + 12 - for name, on, changed in flags[1]: + where[name] = yy + if links: + chain(g, RX + 72, yy, links, end, marks.get(name), room=RX + CW - 12) + else: + integer(g, RX + 72, yy, end[1]) + if marks.get(name, {}).get(0) == "tick": + g.rect(RX + 63, yy + 3, 4, ROW - 6, VERM) + # 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: g.rect(x - 7, yy + 3, 4, ROW - 6, VERM) 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, FAINT, MONO) - x += 2 * A + 8 + 10 + g.t(x + 4, b(yy), name.lower(), S, mix(DIM, EMBER[GOLD], 0.8), MONO) + x += 42 return where -def stack(g, y, rows): - y0 = panel(g, RX, y, CW, len(rows), "stack", note="eight words from rsp · low addresses on top") - where = {} - for i, (slot, names, links, end, note) in enumerate(rows): +def stack(g, y, rows, frames): + """rows: (slot, pins, links, end). frames: (name, first row, last row), newest first: the backtrace, + drawn on the words that are each frame.""" + y0 = panel(g, RX, y, CW, len(rows), "stack", note="%s words from rsp · the frames they belong to" % + {4: "four", 8: "eight"}[len(rows)]) + lead = shared([r[0] for r in rows]) + for i, (slot, pins, links, end) in enumerate(rows): yy = y0 + i * ROW - x = RX + 10 - for n in names: - x += plaque(g, x, yy, n, stroke=STACK, pad=2) + 2 - where[slot] = yy - chain(g, RX + 104, yy, [(slot, STACK)] + links, end, room=RX + CW - 8) - if note: - g.t(RX + CW - 12, b(yy) - 1, note, 18, FAINT, "sans", "end") - return where - - -def backtrace(g, y, frames): - y0 = panel(g, RX, y, CW, len(frames), "backtrace", note="newest on top") - for i, (name, where_) in enumerate(frames): - yy = y0 + i * ROW - if i == 0: - g.rect(RX + 2, yy, CW - 4, ROW, EMBER[GOLD]) - g.rect(RX + 2, yy, 42, ROW, GOLD) - g.t(RX + 12, b(yy), "#%d" % i, S, INK if i == 0 else FAINT, BOLD if i == 0 else MONO) - g.t(RX + 60, b(yy), name, S, VELLUM, MONO) - g.t(RX + 60 + 18 * A, b(yy), where_, S, DIM, MONO) + if pins: + pin(g, RX + 10, yy, pins, STACK) + chain(g, RX + 122, yy, [(slot, STACK)] + links, end, room=RX + CW - 136, lead=lead) + for i, (name, first, last) in enumerate(frames): + if first >= len(rows): + break + ink = GOLD if i == 0 else RULE + open_ = last >= len(rows) + last = min(last, len(rows) - 1) + x, ya, yb = RX + CW - 14, y0 + first * ROW + 3, y0 + (last + 1) * ROW - (0 if open_ else 3) + g.rect(x - 1, ya, 2, yb - ya, ink) + g.rect(x - 7, ya, 8, 2, ink) + if not open_: + g.rect(x - 7, yb - 2, 8, 2, ink) + g.t(x - 14, (ya + yb) / 2 + 6, name, 18, BRIGHT if i == 0 else DIM, "sansm", "end") +# ---- the program column ------------------------------------------------------------- C_WORDS = {"struct", "long", "static", "return", "while", "for", "int", "char", "sizeof", "if", "else", "void", "NULL", "__attribute__", "noinline"} @@ -249,6 +285,7 @@ def c_line(g, x, y, text, limit): def source(g, y, rows, lines, first, cur, trail, name, total): + """Returns the y of the current line's row.""" y0 = panel(g, LX, y, CW, rows, name, note=f"lines {first} to {first + rows - 1} of {total}") for i in range(rows): n = first + i @@ -262,120 +299,195 @@ def source(g, y, rows, lines, first, cur, trail, name, total): g.rect(LX + 2, yy + 1, 4, ROW - 2, TRAIL[min(trail.index(n), 2)]) g.t(LX + 46, b(yy), str(n), S, FAINT, MONO, "end") c_line(g, LX + 64, yy, lines[n - 1], (CW - 64 - 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): - """rows: (address, offset, mnemonic, operands, state) with state in cur | trail0 | trail1 | None, - or ("note", parts) for the row under the pc that says what its operand is.""" + +def disasm(g, y, rows, func, cur_line, jump=None): + """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. + Returns each address's row y.""" y0 = panel(g, LX, y, CW, len(rows), "disassembly", note=func) - where = {} - for i, r in enumerate(rows): + 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 - if r[0] == "note": - g.rect(LX + 2, yy, CW - 4, ROW, EMBER[GOLD]) - g.t(LX + 198, b(yy), r[1], S, DIM, MONO) - x = LX + 198 + (len(r[1]) + 1) * A - where["note"] = (yy, chain(g, x, yy, r[2], r[3], r[4] if len(r) > 4 else None)) - continue - a, off, mn, ops, st = r + where[a] = yy + dim = st == "out" + if dim: # the function ends: a rule, and the next one's name + g.rect(LX + 2, yy, CW - 4, 2, RULE) if st == "cur": g.rect(LX + 2, yy, CW - 4, ROW, EMBER[GOLD]) - g.rect(LX + 2, yy, 26, ROW, GOLD) - g.path(f"M{LX + 21},{yy + 12} l-10,-6 v12 Z", fill=INK) - elif st: + g.rect(LX + 2, yy, 24, ROW, GOLD) + g.path(f"M{LX + 20},{yy + 12} l-10,-6 v12 Z", fill=INK) + elif st and st.startswith("trail"): g.rect(LX + 2, yy + 1, 4, ROW - 2, TRAIL[int(st[-1])]) - addr(g, LX + 36, yy, a, CODE) - g.t(LX + 138, b(yy), "+%d" % off, S, FAINT, MONO) - g.t(LX + 198, b(yy), mn, S, KW, BOLD) - x = LX + 198 + 6 * A + addr(g, LX + DX_ADDR, yy, a, mix(CODE, PAGE, 0.6) if dim else CODE, lead=0 if dim else lead) + if line != last_line and not dim: # the line this run of instructions was compiled from + on = line == cur_line + g.t(LX + DX_LINE + 3 * A, b(yy), str(line), S, GOLD if on else FAINT, BOLD if on else MONO, "end") + last_line = line + g.t(LX + DX_MN, b(yy), mn, S, FAINT if dim else KW, MONO if dim else BOLD) + x = LX + DX_OPS for part, ink in ops: if isinstance(part, int): - x = addr(g, x, yy, part, ink) + 0 + x = addr(g, x, yy, part, ink) else: - g.t(x, b(yy), part, S, ink, MONO) + g.t(x, b(yy), part, S, FAINT if dim else ink, MONO) x += len(part) * A - where[a] = yy + if not note: + continue + x = LX + DX_NOTE + 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 -# ---- the lens: a list, and the heap words that are its nodes ---------------------- -def lens(g, y, nodes, pointing, marks, h=312, subject=False): - """nodes: (address, value, next address or 0), in the list's first order. pointing: {address: [registers]}. - marks: {"read": address of a word, "tick": [...], "land": address of a node}. - As the subject it is one size up: mono 25 on rows of 30.""" - global S, A, ROW - keep = (S, A, ROW) - panel(g, LX, y, CW, 0, "the list", focus=True, note="each node, and under it the heap words that are that node", h=h) - if subject: - S, A, ROW = 25, 15, 30 - NW, NH, GAP = (124, 64, 22) if subject else (116, 44, 28) +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 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: + g.rect(x0 - 7, y + 3, 4, ROW - 6, VERM) + 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, nodes, pins, marks, first, nrows, link_from=None, subject=False): + """The band: the list drawn, and the heap bytes it is drawn from, in one panel across both columns. + 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.""" + tag(g, LX, y, W - 2 * LX, h, "the list", focus=True, + note=[("value", VELLUM, False), ("next", HEAP, False), ("malloc's", DIM, False), ("never read", FAINT, False)]) + last = first + (nrows - 1) * 16 + g.t(RX + 12, y + 18, "its bytes", 20, VELLUM, "sansm") + g.t(RX + 12 + 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]) + rows = {} + for i in range(nrows): + 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 + NW, NH, GAP, VS, LS = (124, 72, 22, 45, 25) if subject else (116, 44, 28, 25, 20) VW = NW - 48 # the value's half; the pointer's is 48 x0 = LX + (CW - len(nodes) * NW - (len(nodes) - 1) * GAP) / 2 - ny = y + TAG + (22 if subject else 14) + lane_top, lane_bot = y + TAG + 4, y + h - 8 + ly = y + TAG + (44 if subject else 16) # 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) - vs = 35 if subject else 25 - 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, "#101a48") + 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, ny - 2, NW - VW + 4, NH + 4, READ, 2) if a + 8 in marks.get("tick", ()): g.rect(x + VW, ny + NH - 4, NW - VW, 4, VERM) - if marks.get("land") == a: - g.frame(x - 4, ny - 4, NW + 8, NH + 8, BRIGHT, 2) cx, cy = x + VW + (NW - VW) / 2, ny + NH / 2 if nx: g.rect(cx - 5, cy - 5, 10, 10, HEAP) - tx = xs[nx] - if tx > x: - gen.arrow(g, [(cx + 8, cy), (tx - 3, cy)], HEAP, 3, hl=12, hw=10) - else: # a link turned round: under the row - gen.arrow(g, [(cx, cy + 8), (cx, ny + NH + 12), (tx + 34, ny + NH + 12), (tx + 34, ny + NH + 3)], HEAP, 3, r=8, hl=12, hw=10) + gen.arrow(g, [(cx + 8, cy), (xs[nx] - 3, cy)], HEAP, 3, hl=12, hw=10) else: g.path(f"M{x + VW + 10},{ny + NH - 8} L{x + NW - 10},{ny + 8}", DIM, 2) - addr(g, x + (NW - addr_w(a)) / 2, ny + NH + 2, a, HEAP) - px = x + 2 - for name in pointing.get(a, ()): - px += plaque(g, px, ny + NH + ROW + 2, name, stroke=HEAP) + 4 - # the words - wy = ny + NH + 2 * ROW + (46 if subject else 34) - c0, c1, c2 = (LX + 190, LX + 380, LX + 590) if subject else (LX + 150, LX + 300, LX + 470) - g.t(c0, wy - 6, "address", 18, FAINT, "sansm") - g.t(c1, wy - 6, "value", 18, FAINT, "sansm") - g.t(c2, wy - 6, "next", 18, FAINT, "sansm") - if not subject: - g.t(LX + CW - 12, wy - 6, "the heap, sixteen bytes a node", 18, FAINT, "sans", "end") - rows = {} - for i, (a, v, nx) in enumerate(sorted(nodes)): - yy = wy + i * ROW - rows[a] = yy - px = LX + 12 - for name in pointing.get(a, ()): - px += plaque(g, px, yy, name, stroke=HEAP) + 4 - if marks.get("land") == a: - g.frame(c0 - 6, yy, c2 - c0 + addr_w(a) + 12, ROW, BRIGHT, 2) - addr(g, c0, yy, a, HEAP) - integer(g, c1, yy, v) - if a + 8 in marks.get("tick", ()): - g.rect(c2 - 9, yy + 3, 4, ROW - 6, VERM) - if marks.get("read") == a + 8: - g.frame(c2 - 6, yy, addr_w(a) + 12, ROW, READ, 2) - if nx: - addr(g, c2, yy, nx, HEAP) - else: - g.t(c2, b(yy), "0", S, VELLUM, MONO) - g.t(c2 + 2 * A, b(yy), "NULL", S, FAINT, MONO) - land_x = c2 + addr_w(nodes[0][0]) + 10 - S, A, ROW = keep - return xs, rows, land_x + 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 + names = [link_from[1]] + [n for n in names if n != link_from[1]] + 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) + + # 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, 2) + 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 ----------------------------------- +# ---- 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): @@ -392,7 +504,7 @@ def regs_at(rdi): ("r9", [], ("int", 0x20)), ("r10", [], ("int", 0x10)), ("r11", [(0x7f2ba3019ac8, D_), (0x28b410c0, H_)], ("int", 0)), - ("r12", [(0x7ffe970f1908, S_), (0x7ffe970f2fce, S_)], ("str", "zig-out/targets/list")), + ("r12", ARGV, ("str", "zig-out/targets/list")), ("r13", [], ("int", 1)), ("r14", [(0x7f2ba32ac000, D_), (0x7f2ba32ad3c0, D_)], ("int", 0)), ("r15", [(0x10029c0, VELLUM)], ("int", 1)), @@ -400,81 +512,88 @@ def regs_at(rdi): ] +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, "return address"), - (0x7ffe970f17c0, [], [(0x7f2ba3020de8, D_), (0x7ffe970f1918, S_)], ("more",), ""), - (0x7ffe970f17c8, [], [], ("int", 0), ""), - (0x7ffe970f17d0, [], RBP[2:], ("int", 0), "main's saved rbp"), - (0x7ffe970f17d8, [], [(0x7f2ba2e27781, C_, "libc+27781")], None, "return address"), - (0x7ffe970f17e0, [], [(0x7f2ba328fc60, C_, "ld.so+22c60")], None, ""), - (0x7ffe970f17e8, [], [(0x7ffe970f1908, S_), (0x7ffe970f2fce, S_)], ("str", "zig-out/targets/list"), ""), + (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+22", "list.c:21"), ("main+80", "list.c:39"), ("libc+27781", "libc.so.6")] +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 -DIS = [ - (0x1001920, 16, "mov", [("rcx, rax", P)], "trail1"), - (0x1001923, 19, "mov", [("rax, rdi", P)], "trail0"), - (0x1001926, 22, "mov", [("rdi, qword ptr [rdi + 8]", P)], "cur"), - None, # the note, filled in by each frame - (0x100192a, 26, "mov", [("qword ptr [rax + 8], rcx", P)], None), - (0x100192e, 30, "test", [("rdi, rdi", P)], None), +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)), ] def frame(name, step, subject=False): - """subject: the lens is what the scene is about, and takes rows from the source and the disassembly.""" + """step: mid-step, the load done. subject: the lens is what the scene is about, and the band is taller.""" g = Svg() 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"}} + reg_marks = {"rax": {0: "tick"}, "rcx": {0: "tick"}, "rdi": {0: "strike" if step else "tick"}} lens_marks = {"tick": [0x28b410b8]} - pointing = {0x28b410b0: ["rcx"], 0x28b41090: ["rax"] + ([] if step else ["rdi"]), 0x28b41070: ["rdi"] if step else []} - note_marks = None + pins = {0x28b410b0: ["rcx"], 0x28b41090: ["rax"] + ([] if step else ["rdi"]), 0x28b41070: ["rdi"] if step else []} if step: - reg_marks["rdi"] = {0: "strike"} - lens_marks.update(read=0x28b41098, land=0x28b41070) - note_marks = {0: "read"} - else: - reg_marks["rdi"] = {0: "tick"} - - lens_h, src_rows, src_first = (432, 8, 17) if subject else (312, 12, 15) - xs, rows, land_x = lens(g, TOP, NODES, pointing, lens_marks, lens_h, subject) - y = TOP + lens_h + 12 - source(g, y, src_rows, SRC, src_first, 21, [20, 22], "list.c", len(SRC) - 1) - y += TAG + 12 + src_rows * ROW + 12 - dis = list(DIS) - dis[3] = ("note", "rdi + 8 =", [(0x28b41098, H_), (0x28b41070, H_)], ("int", 9), note_marks) - disasm(g, y, dis[1:] if subject else dis, "reverse") + lens_marks["read"] = 0x28b41098 - where = registers(g, TOP, regs_at(rdi), (0x206, [("CF", 0, 0), ("PF", 1, 0), ("AF", 0, 0), ("ZF", 0, 1), ("SF", 0, 0), - ("IF", 1, 0), ("DF", 0, 0), ("OF", 0, 0)]), reg_marks) - stack(g, TOP + 468 + 12, STACK_ROWS) - backtrace(g, TOP + 468 + 12 + 228 + 12, FRAMES) + band, src_rows, src_first, dis, words, dump_first, dump_rows = ( + (248, 10, 18, DIS[3:14], 4, 0x28b41030, 9) if subject else (152, 8, 19, DIS, 8, 0x28b41070, 5)) + y = TOP + band + 12 + ys = source(g, y, src_rows, SRC, src_first, 21, [20, 22], "list.c", len(SRC) - 1) + yd = y + ph(src_rows) + 12 + dis = list(dis) + 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)]) - if step: - # the one link drawn: from the register just struck to the node it now holds, in heap's ink, for this step - yy, links = where["rdi"] - ty = rows[0x28b41070] + (15 if subject else 12) - gen.arrow(g, [(RX, yy + 12), (RX - 16, yy + 12), (RX - 16, ty), (land_x, ty)], HEAP, 3, r=8, hl=12, hw=10) + where = registers(g, y, regs_at(rdi), FLAGS, reg_marks) + stack(g, y + ph(17) + 12, STACK_ROWS[:words], FRAMES) + lens(g, TOP, band, NODES, pins, lens_marks, dump_first, dump_rows, + link_from=(where["rdi"], "rdi") if step else None, subject=subject) # the scene's clock: how far through the recording, on the rule over the caption g.rect(LX, 899, W - 2 * LX, 2, RULE) - at = 71.5 if step else 71 - g.rect(LX, 898, (W - 2 * LX) * at / 95, 4, GOLD) + g.rect(LX, 898, (W - 2 * LX) * (71.5 if step else 71) / 95, 4, GOLD) g.t(W - LX, 934, "moment %d of 95" % (72 if step else 71), S, FAINT, MONO, "end") if step: - gen.caption(g, [[("The load read the word at ",), ("28b4 1098", "mono"), (": the address of the next node.",)], - [("rdi", "mono"), (" holds it now, and follows it to the node whose value is 9.",)]]) + 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"), (" holds a node's address; the word after its value is the next node.",)]]) + [("rdi", "mono"), (" points at a node; the word after its value is the next node.",)]]) 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(11) == ph(17) + 12 + ph(4) == BOTTOM - TOP - 248 - 12 # lens as subject + 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) |
