komaru 0.1.0__tar.gz

komaru-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.egg-info/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+dist/
+index.json

komaru-0.1.0/NOTES.md

@@ -0,0 +1,138 @@
+# NOTES — assumptions about CPython internals
+
+Every assumption komaru relies on, with the CPython source that justifies it.
+Verified empirically (clang 21.1.8, `--with-tail-call-interp`, `OPT="-Og -g"`)
+against:
+
+| target | commit | handlers | helpers |
+|---|---|---|---|
+| 3.14.7 (branch `3.14`) | e7a45f431bf | 231 | `error`, `exception_unwind`, `start_frame` |
+| 3.16.0a0 (`main`) | ea85e8faecc | 239 | + `pop_1_error`, `pop_2_error`, `exit_unwind`, `exit_unwind_notrace`, `UNKNOWN_OPCODE` |
+
+The helper-symbol set differs between versions; nothing in komaru hardcodes
+it — helpers are whatever `_TAIL_CALL_*` symbols do not match an opname.
+The opcode↔handler bijection (below) holds exactly on both versions.
+
+## Reference builds
+
+```
+mkdir -p build/tailcall-static && cd build/tailcall-static
+CC=clang ../../configure --with-tail-call-interp OPT="-Og -g" && make -j
+
+mkdir -p build/tailcall-shared && cd build/tailcall-shared
+CC=clang ../../configure --with-tail-call-interp --enable-shared OPT="-Og -g" && make -j
+
+# 3.14 (branch worktree):
+git worktree add build/v3.14-src origin/3.14
+mkdir -p build/tailcall-3.14 && cd build/tailcall-3.14
+CC=clang ../v3.14-src/configure --with-tail-call-interp OPT="-Og -g" && make -j
+```
+
+## Symbol scheme
+
+- **One function per opcode, named `_TAIL_CALL_<OPNAME>`.** The tail-call
+  interpreter generates a `static` function per opcode:
+  `Python/opcode_targets.h:525` (declarations, under `_Py_TAIL_CALL_INTERP`),
+  bodies in `Python/generated_tail_call_handlers.c.h`. Verified: 239 symbols
+  in the static build's `python` binary.
+- **Symbols are `static` ⇒ LOCAL, `.symtab` only.** Zero appear in
+  `.dynsym`. A stripped binary is therefore unusable; the extractor fails
+  loudly (`objfile.py`, `StrippedBinaryError`).
+- **Which object:** default build → the `python` executable;
+  `--enable-shared` → `libpython3.X.so.1.0` (the `python` stub has none).
+- **No `.cold` / `.part.N` / `.constprop` fragments at `-Og`**, and every
+  symbol has a nonzero `st_size`, so byte ranges come straight from the
+  symbol table. **Revisit at `-O2`/LTO** — hot/cold splitting would break
+  the one-symbol-per-opcode assumption.
+- **Specialized opcodes have their own handlers** (e.g.
+  `_TAIL_CALL_BINARY_OP_ADD_INT` distinct from `_TAIL_CALL_BINARY_OP`),
+  because the cases generator emits one function per uop-instruction
+  (`Tools/cases_generator/tier1_tail_call_generator.py`).
+
+## Opcode ↔ handler accounting (verified bijection)
+
+- The target's `opcode.opmap` names with value **> 255 are
+  pseudo-instructions** (`Include/opcode_ids.h`, `_PyOpcode_ID` pseudo range;
+  emitted only inside the compiler) and can never appear in a code object —
+  a one-byte opcode field cannot encode them. Exactly those 11 names have no
+  handler symbol; every encodable opcode (242 − 11 = 231) has exactly one.
+- **8 extra symbols are not opcodes**: `_TAIL_CALL_UNKNOWN_OPCODE` plus the
+  lowercase helpers `start_frame`, `error`, `pop_1_error`, `pop_2_error`,
+  `exception_unwind`, `exit_unwind`, `exit_unwind_notrace`
+  (`Python/opcode_targets.h:525-531`). They are kept in the index (they are
+  common jump targets) but are distinguishable by case / UNKNOWN_OPCODE name.
+
+## Dispatch tail
+
+- `DISPATCH()` expands to NEXTOPARG-style decode plus
+  `Py_MUSTTAIL return table[opcode](...)` — `Python/ceval_macros.h:106-110`.
+  At `-Og` on x86-64 this codegens as a trailing contiguous sequence ending
+  in an indirect `jmp` (verified for `LOAD_FAST`:
+  `movzx ecx, [r15+2]; add r15,2; movzx esi,ch; movzx edx,cl;
+  mov rcx,[rdi+rdx*8]; jmp rcx`).
+- **Tagging heuristic** (`handlers.py`, `dispatch_flags`): for each indirect
+  jump, walk backwards collecting the register-dependency slice (stop at
+  control flow or a memory store, budget 16 instructions), then mark the
+  contiguous range up to the jump. This is a heuristic over codegen, not
+  ground truth; it is exact at `-Og` for all 226 handlers that dispatch.
+- **Direct tail calls are *not* tagged as dispatch.** `DISPATCH_GOTO`-style
+  same-target tail calls, deopt jumps from specialized handlers back to the
+  generic handler, and error-path jumps to `_TAIL_CALL_error`
+  (`Python/ceval_macros.h:114-124`) are semantically part of the opcode;
+  hiding them would misrepresent the handler.
+- 13 handlers legitimately have no dispatch tail: `INTERPRETER_EXIT`,
+  `CACHE`, `RESERVED`, `UNKNOWN_OPCODE`, `RAISE_VARARGS`, `RERAISE`,
+  `ENTER_EXECUTOR`, `TRACE_RECORD`, and the five error/unwind helpers.
+
+## Call-target resolution
+
+- Direct `call`/`jmp` immediates resolve against `.symtab` function
+  addresses. In the static build every direct call resolves this way.
+- In `--enable-shared` builds, cross-object calls go through the PLT; stubs
+  are resolved to `name@plt` by decoding the stub's RIP-relative `jmp` and
+  matching the GOT slot against `.rela.plt` / `.rela.dyn` relocations.
+  `.plt.got` stubs are 8 bytes and can sit at the very end of their section,
+  so the stub read backs off (16 → 8 → 6 bytes) instead of reading across
+  the section boundary.
+- Indirect calls (`call rax`, `call [r14+0x48]` — type slots, function
+  pointers) are left with `target: null`. They are not statically
+  resolvable, and komaru never guesses.
+- Intra-function branch targets (`jne 0x...` within a handler) are likewise
+  `null`; the address itself is shown.
+
+## Target-interpreter metadata
+
+- Opcode names/numbers come from shelling out to the *target* interpreter
+  (`target.py`), never the host's `opcode` module — numbering changes every
+  release. The index records the target's full `version_info`, and
+  `Index.check_interpreter()` refuses a mismatched consumer.
+- Build-tree interpreters from `--enable-shared` builds cannot locate their
+  own `libpython` without `LD_LIBRARY_PATH`; `interrogate()` prepends the
+  binary's directory for the probe subprocess only.
+- `platform.python_build()[0]` carries the git ref/commit
+  (e.g. `heads/main-dirty:ea85e8faecc`); `sysconfig` `CONFIG_ARGS` and
+  `HOST_GNU_TYPE` supply build flags and target triple.
+
+## Warmup / adaptive view
+
+- `--warmup N` compiles the script once and ``exec``s the same code object N
+  times, so tier-1 specialisation accumulates in the code objects being
+  displayed. Execution counts are observed via `sys.monitoring` PY_START
+  (`Python/instrumentation.c`) — never inferred from dis output.
+- Instrumentation swaps in `INSTRUMENTED_*` opcodes and de-instruments
+  *lazily* on next execution. After the N monitored runs, one extra
+  unmonitored settling run lets executed code de-instrument; otherwise
+  komaru's own measurement would appear in the adaptive view. A code path
+  taken during monitored runs but not during the settling run can still show
+  a leftover `INSTRUMENTED_*` opcode — that is genuinely what is in the code
+  object, and it is shown as-is.
+- `sys.monitoring` PY_START instrumentation does not inhibit specialisation
+  of other instruction families (verified empirically: `BINARY_OP_ADD_INT`
+  appears while monitored).
+
+## Architecture support
+
+- x86-64 is implemented and tested. The aarch64 code paths (capstone arch
+  selection, w→x register canonicalisation) are wired but **untested** — no
+  aarch64 machine was available. ELF only; `ObjectFile` is a protocol so
+  Mach-O can be added later.

komaru-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: komaru
+Version: 0.1.0
+Summary: TUI mapping CPython bytecode to the interpreter's native opcode handlers (tail-call builds)
+Author-email: Kirill Podoprigora <kirill.bast@gmail.com>
+License-Expression: MIT
+Keywords: assembly,bytecode,cpython,disassembly,interpreter,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.11
+Requires-Dist: capstone>=5.0
+Requires-Dist: pyelftools>=0.31
+Requires-Dist: rich>=13.0
+Requires-Dist: textual>=0.80
+Description-Content-Type: text/markdown
+
+# komaru
+
+A terminal UI that shows, for a Python function or module, three synchronised
+views: the source, the `dis` bytecode, and **the actual machine code the
+CPython interpreter executes for each opcode** — extracted from a real
+`--with-tail-call-interp` build, never synthesised.
+
+Not a compiler, not a JIT: an inspection tool. Tail-call interpreter builds
+(CPython 3.14+, clang ≥ 19 / GCC ≥ 15) emit one function per opcode
+(`_TAIL_CALL_<OPNAME>`), giving a mechanical opcode → machine-code mapping.
+
+## Quickstart
+
+```sh
+# 1. Build CPython with the tail-call interpreter (readable codegen at -Og):
+cd cpython && mkdir build && cd build
+CC=clang ../configure --with-tail-call-interp OPT="-Og -g" && make -j
+
+# 2. Just run it:
+komaru                # opens the TUI; first run asks for the CPython binary,
+                     # extracts the handlers and caches the index
+komaru script.py      # open a file directly (bare path implies `run`)
+komaru module.pyc
+```
+
+On first run komaru asks for the path to the tail-call `python` (or
+`libpython*.so` plus an interpreter) and caches the extracted index in
+`~/.cache/komaru/`, keyed by binary path — a rebuilt CPython is detected
+and re-extracted automatically. Inside the TUI, `f` opens files, `w` sets
+warmup, `o` picks nested code objects, `b` switches builds.
+
+Index discovery order: `--index` → `KOMARU_INDEX` → `./index.json` → cache.
+
+Everything is still scriptable with explicit flags:
+
+```sh
+komaru extract build/python -o index.json
+komaru run script.py --target-func myfunc --warmup 3 --index index.json
+komaru run --code 'a + b' --index index.json
+komaru run --target-func json:dumps --index index.json
+komaru open module.pyc --index index.json
+```
+
+For `--enable-shared` builds, extract from the library and point `--python`
+at the build-tree interpreter:
+
+```sh
+komaru extract build/libpython3.16.so.1.0 --python build/python -o index.json
+```
+
+## Adaptive (specialising) mode
+
+Warmup (`w` in the TUI, or `--warmup N`) executes the script/module body N
+times (plus one unmonitored settling run) so the interpreter specialises;
+the script itself is responsible for calling the functions you care about.
+Press `a` in the TUI to
+flip between `BINARY_OP` and e.g. `BINARY_OP_ADD_INT` — specialised opcodes
+have completely different handlers and the native-size column shows it.
+Execution counts are measured with `sys.monitoring`, so the UI tells you
+when a code object never actually ran.
+
+## Keys
+
+`Tab` cycle panes · `↑/↓` select instruction · `f` open file · `w` warmup ·
+`a` adaptive · `t` hide dispatch tail · `o` pick nested code object ·
+`b` switch CPython build · `/` search · `e` export markdown · `?` help ·
+`q` quit
+
+## Correctness
+
+- Every native instruction shown comes from capstone over bytes read out of
+  the binary; missing data is reported as unavailable, never guessed.
+- The index records the target interpreter's version; `komaru run` refuses a
+  mismatched index (opcode numbering changes every release).
+- Opcode names come from the target interpreter, never the host's `opcode`
+  module; nothing is hardcoded.
+
+See `NOTES.md` for every assumption about CPython internals and where in the
+CPython source it is justified.
+
+## Requirements & scope (v1)
+
+- Target: CPython ≥ 3.14 built with `--with-tail-call-interp` (verified
+  against 3.14 and main); each index is pinned to the exact version it was
+  extracted from. Linux, ELF, x86-64 (aarch64 wired but untested). The
+  extractor and the TUI may run under different interpreters; only the
+  target interpreter must match the extracted binary.
+- The binary must not be stripped: handler symbols are `.symtab`-local.
+
+Future work (explicitly out of scope for v1): Tier 2 uop expansion, JIT
+stencil inspection, `perf` integration, Mach-O/macOS, Windows.
+
+## Development
+
+```sh
+uv sync
+uv run pytest          # integration tests auto-skip without ../build trees
+uv run ruff check . && uv run ruff format --check .
+uv run mypy src tests
+```

komaru-0.1.0/README.md

@@ -0,0 +1,100 @@
+# komaru
+
+A terminal UI that shows, for a Python function or module, three synchronised
+views: the source, the `dis` bytecode, and **the actual machine code the
+CPython interpreter executes for each opcode** — extracted from a real
+`--with-tail-call-interp` build, never synthesised.
+
+Not a compiler, not a JIT: an inspection tool. Tail-call interpreter builds
+(CPython 3.14+, clang ≥ 19 / GCC ≥ 15) emit one function per opcode
+(`_TAIL_CALL_<OPNAME>`), giving a mechanical opcode → machine-code mapping.
+
+## Quickstart
+
+```sh
+# 1. Build CPython with the tail-call interpreter (readable codegen at -Og):
+cd cpython && mkdir build && cd build
+CC=clang ../configure --with-tail-call-interp OPT="-Og -g" && make -j
+
+# 2. Just run it:
+komaru                # opens the TUI; first run asks for the CPython binary,
+                     # extracts the handlers and caches the index
+komaru script.py      # open a file directly (bare path implies `run`)
+komaru module.pyc
+```
+
+On first run komaru asks for the path to the tail-call `python` (or
+`libpython*.so` plus an interpreter) and caches the extracted index in
+`~/.cache/komaru/`, keyed by binary path — a rebuilt CPython is detected
+and re-extracted automatically. Inside the TUI, `f` opens files, `w` sets
+warmup, `o` picks nested code objects, `b` switches builds.
+
+Index discovery order: `--index` → `KOMARU_INDEX` → `./index.json` → cache.
+
+Everything is still scriptable with explicit flags:
+
+```sh
+komaru extract build/python -o index.json
+komaru run script.py --target-func myfunc --warmup 3 --index index.json
+komaru run --code 'a + b' --index index.json
+komaru run --target-func json:dumps --index index.json
+komaru open module.pyc --index index.json
+```
+
+For `--enable-shared` builds, extract from the library and point `--python`
+at the build-tree interpreter:
+
+```sh
+komaru extract build/libpython3.16.so.1.0 --python build/python -o index.json
+```
+
+## Adaptive (specialising) mode
+
+Warmup (`w` in the TUI, or `--warmup N`) executes the script/module body N
+times (plus one unmonitored settling run) so the interpreter specialises;
+the script itself is responsible for calling the functions you care about.
+Press `a` in the TUI to
+flip between `BINARY_OP` and e.g. `BINARY_OP_ADD_INT` — specialised opcodes
+have completely different handlers and the native-size column shows it.
+Execution counts are measured with `sys.monitoring`, so the UI tells you
+when a code object never actually ran.
+
+## Keys
+
+`Tab` cycle panes · `↑/↓` select instruction · `f` open file · `w` warmup ·
+`a` adaptive · `t` hide dispatch tail · `o` pick nested code object ·
+`b` switch CPython build · `/` search · `e` export markdown · `?` help ·
+`q` quit
+
+## Correctness
+
+- Every native instruction shown comes from capstone over bytes read out of
+  the binary; missing data is reported as unavailable, never guessed.
+- The index records the target interpreter's version; `komaru run` refuses a
+  mismatched index (opcode numbering changes every release).
+- Opcode names come from the target interpreter, never the host's `opcode`
+  module; nothing is hardcoded.
+
+See `NOTES.md` for every assumption about CPython internals and where in the
+CPython source it is justified.
+
+## Requirements & scope (v1)
+
+- Target: CPython ≥ 3.14 built with `--with-tail-call-interp` (verified
+  against 3.14 and main); each index is pinned to the exact version it was
+  extracted from. Linux, ELF, x86-64 (aarch64 wired but untested). The
+  extractor and the TUI may run under different interpreters; only the
+  target interpreter must match the extracted binary.
+- The binary must not be stripped: handler symbols are `.symtab`-local.
+
+Future work (explicitly out of scope for v1): Tier 2 uop expansion, JIT
+stencil inspection, `perf` integration, Mach-O/macOS, Windows.
+
+## Development
+
+```sh
+uv sync
+uv run pytest          # integration tests auto-skip without ../build trees
+uv run ruff check . && uv run ruff format --check .
+uv run mypy src tests
+```

komaru-0.1.0/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "komaru"
+version = "0.1.0"
+description = "TUI mapping CPython bytecode to the interpreter's native opcode handlers (tail-call builds)"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Kirill Podoprigora", email = "kirill.bast@gmail.com" }]
+keywords = ["cpython", "bytecode", "disassembly", "assembly", "interpreter", "tui"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: Software Development :: Interpreters",
+]
+requires-python = ">=3.11"
+dependencies = [
+    "capstone>=5.0",
+    "pyelftools>=0.31",
+    "rich>=13.0",
+    "textual>=0.80",
+]
+
+[project.scripts]
+komaru = "komaru.cli:main"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.11",
+    "pytest>=8.0",
+    "ruff>=0.6",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/komaru"]
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "example.py",
+    "index.json",
+    "docs/",
+    ".gitignore",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "C4", "SIM", "RUF"]
+
+[tool.mypy]
+strict = true
+python_version = "3.11"
+
+[[tool.mypy.overrides]]
+module = ["capstone.*", "elftools.*"]
+ignore_missing_imports = true
+
+# The probe runs under the *target* interpreter (possibly a different
+# CPython version); checking it against the host's stdlib stubs is wrong
+# by construction. It is exercised for real by tests/test_probe.py.
+[[tool.mypy.overrides]]
+module = "komaru._probe_script"
+ignore_errors = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

komaru-0.1.0/src/komaru/_probe_script.py

@@ -0,0 +1,176 @@
+import dis
+import importlib.util
+import json
+import marshal
+import sys
+import traceback
+
+_PYC_HEADER = 16  # PEP 552: magic + flags + two words
+
+
+def read(path, mode="r"):
+    with open(path, mode) as f:
+        return f.read()
+
+
+def fail(message):
+    print(json.dumps({"error": message}))
+    sys.exit(2)
+
+
+def serializeinstructions(code, adaptive):
+    out = []
+    for i in dis.get_instructions(code, adaptive=adaptive):
+        pos = i.positions
+        if pos is None or pos.lineno is None:
+            positions = None
+        else:
+            positions = [pos.lineno, pos.end_lineno, pos.col_offset, pos.end_col_offset]
+        out.append(
+            {
+                "offset": i.offset,
+                "opname": i.opname,
+                "arg": i.arg,
+                "argrepr": i.argrepr,
+                "line": i.line_number,
+                "positions": positions,
+                "jump_target": getattr(i, "jump_target", None),
+            }
+        )
+    return out
+
+
+def childcodes(code):
+    return [c for c in code.co_consts if isinstance(c, type(code))]
+
+
+def walk(code, counts, warmed):
+    return {
+        "name": code.co_name,
+        "qualname": code.co_qualname,
+        "filename": code.co_filename,
+        "firstlineno": code.co_firstlineno,
+        "instructions": serializeinstructions(code, adaptive=False),
+        "adaptive": serializeinstructions(code, adaptive=True) if warmed else None,
+        "exec_count": counts.get(code, 0),
+        "children": [walk(c, counts, warmed) for c in childcodes(code)],
+    }
+
+
+def findbyqualname(code, qualname):
+    if code.co_qualname == qualname:
+        return code
+    for child in childcodes(code):
+        found = findbyqualname(child, qualname)
+        if found is not None:
+            return found
+    return None
+
+
+def allqualnames(code):
+    result = [code.co_qualname]
+    for child in childcodes(code):
+        result.extend(allqualnames(child))
+    return result
+
+
+def load(request):
+    mode = request["mode"]
+    if mode == "script":
+        path = request["path"]
+        source = read(path)
+        return compile(source, path, "exec"), source
+    if mode == "code":
+        snippet = request["code"]
+        return compile(snippet, "<komaru>", "exec"), snippet
+    if mode == "module":
+        spec = importlib.util.find_spec(request["path"])
+        if spec is None or spec.origin is None or not spec.origin.endswith(".py"):
+            fail(f"cannot locate source for module {request['path']!r}")
+        source = read(spec.origin)
+        return compile(source, spec.origin, "exec"), source
+    if mode == "pyc":
+        data = read(request["path"], "rb")
+        magic = importlib.util.MAGIC_NUMBER
+        if data[:4] != magic:
+            fail(
+                f"{request['path']}: pyc magic {data[:4].hex()} does not match "
+                f"this interpreter's magic {magic.hex()} — compiled by a "
+                "different CPython version"
+            )
+        code = marshal.loads(data[_PYC_HEADER:])
+        try:
+            source = read(code.co_filename)
+        except OSError:
+            source = None
+        return code, source
+    fail(f"unknown mode {mode!r}")
+
+
+def runonce(code):
+    namespace = {"__name__": "__main__", "__file__": code.co_filename}
+    try:
+        exec(code, namespace)
+    except BaseException:
+        return "".join(traceback.format_exception_only(*sys.exc_info()[:2])).strip()
+    return None
+
+
+def warm(code, runs):
+    mon = sys.monitoring
+    tool = mon.PROFILER_ID
+    counts = {}
+
+    def onstart(started_code, _offset):
+        counts[started_code] = counts.get(started_code, 0) + 1
+
+    mon.use_tool_id(tool, "komaru")
+    mon.register_callback(tool, mon.events.PY_START, onstart)
+    mon.set_events(tool, mon.events.PY_START)
+    error = None
+    try:
+        for _ in range(runs):
+            error = runonce(code)
+            if error is not None:
+                break
+    finally:
+        mon.set_events(tool, 0)
+        mon.register_callback(tool, mon.events.PY_START, None)
+        mon.free_tool_id(tool)
+    if error is None:
+        error = runonce(code)
+    return counts, error
+
+
+def main():
+    request = json.load(sys.stdin)
+    code, source = load(request)
+    warmup = request.get("warmup") or 0
+    counts, warmup_error = ({}, None) if warmup == 0 else warm(code, warmup)
+
+    root = code
+    target = request.get("target_func")
+    if target:
+        found = findbyqualname(code, target)
+        if found is None:
+            fail(
+                f"no code object with qualname {target!r}; available: "
+                + ", ".join(sorted(allqualnames(code)))
+            )
+        root = found
+
+    print(
+        json.dumps(
+            {
+                "version_info": list(sys.version_info),
+                "source": source,
+                "root": walk(root, counts, warmed=warmup > 0),
+                "warmup_runs": warmup,
+                "warmup_error": warmup_error,
+            }
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()