#!/usr/bin/env python3 """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 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, 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 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": g.rect(x - 5, y + 1, w + 10, ROW - 2, VERM) addr(g, x, y, n, INK, BOLD) else: if m == "tick": g.rect(x - 9, y + 3, 4, ROW - 6, VERM) 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 x = value_arrow(g, x, y) if links else x 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): """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) 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.rect(RX + 2, yy, CW - 4, ROW, EMBER[GOLD]) g.rect(RX + 2, yy, 54, ROW, GOLD) g.t(RX + 12, b(yy), name, S, INK, 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: 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, mix(DIM, EMBER[GOLD], 0.8), MONO) x += 42 return where 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 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"} 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 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 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 yy = y0 + i * ROW if n == cur: g.rect(LX + 2, yy, CW - 4, ROW, EMBER[GOLD]) g.rect(LX + 2, yy, 50, ROW, GOLD) g.t(LX + 46, b(yy), str(n), S, INK, 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, 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, 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) 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: # 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, 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 + 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) else: g.t(x, b(yy), part, S, FAINT if dim else ink, MONO) x += len(part) * A 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 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 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) 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) cx, cy = x + VW + (NW - VW) / 2, ny + NH / 2 if nx: g.rect(cx - 5, cy - 5, 10, 10, HEAP) 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) 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 --------------------------------------- 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)), ] 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() 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]} pins = {0x28b410b0: ["rcx"], 0x28b41090: ["rax"] + ([] if step else ["rdi"]), 0x28b41070: ["rdi"] if step else []} if step: lens_marks["read"] = 0x28b41098 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)]) 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) 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 ",), ("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) 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)