mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-18 12:08:38 +00:00
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
113 lines
5.1 KiB
Python
113 lines
5.1 KiB
Python
"""Code patch table for the generator: guest instructions replaced in the lifted C, switchable at run time.
|
|
|
|
Lifted code cannot be byte-patched when the game runs, so a patch is applied when the C is generated. A patch file
|
|
(gen.py --patches) has two kinds of lines; `#` starts a comment, fields are separated by whitespace:
|
|
|
|
set <name> <env> <default> a patch set: a run-time switch <env>=0/1, <default> when it is unset
|
|
site <set> <module> <address> <original> <replacement> [<replacement> ...]
|
|
|
|
<address> is a module offset (hex), <original> the instruction word the module has there (checked; a mismatch stops
|
|
the generator), each <replacement> an instruction word (hex) or `@page:x<n>`, which is `adrp x<n>, <patch page>`
|
|
encoded for the site's address. The patch page is the first 4 KiB page after main's image (layout.py leaves the rest
|
|
of the 2 MiB-aligned module slot free); the runtime commits it and owns its contents.
|
|
|
|
The replacement words are lifted at the site's address in place of the original instruction, and the generated C reads
|
|
`if (rt_patch_on[<set>]) { replacement } else { original }`: one byte load and a branch per executed site. Replacement
|
|
words must not branch except a final `bl` (lifted with the site's return address); the original must not be a branch
|
|
other than `bl`. So the function's control flow, labels and jump tables are the original's. The generator writes
|
|
patches.h (set names, switches, the page address) next to layout.h for the runtime.
|
|
"""
|
|
from pathlib import Path
|
|
|
|
PAGE = 0x1000
|
|
|
|
|
|
class PatchError(ValueError):
|
|
pass
|
|
|
|
|
|
def adrp(pc, target, rd):
|
|
imm = (target >> 12) - (pc >> 12)
|
|
if not -(1 << 20) <= imm < (1 << 20):
|
|
raise PatchError(f'{pc:#x}: patch page {target:#x} out of ADRP range')
|
|
imm &= 0x1FFFFF
|
|
return 0x90000000 | (imm & 3) << 29 | (imm >> 2) << 5 | rd
|
|
|
|
|
|
class Table:
|
|
"""sets: [(name, env, default)]; sites: {module: {offset: (set index, [word | ('page', reg)], original)}}; page."""
|
|
|
|
def __init__(self, sets=(), sites=None, page=0):
|
|
self.sets = list(sets)
|
|
self.sites = sites or {}
|
|
self.page = page
|
|
|
|
def for_module(self, name, base):
|
|
"""{absolute address: (set index, [words])} with @page resolved."""
|
|
out = {}
|
|
for off, (k, repl, _) in self.sites.get(name, {}).items():
|
|
a = base + off
|
|
out[a] = (k, [adrp(a, self.page, w[1]) if isinstance(w, tuple) else w for w in repl])
|
|
return out
|
|
|
|
|
|
def load(path, mods):
|
|
"""Table from a patch file; mods is layout() output [(name, base, size)]."""
|
|
sets, index, sites = [], {}, {}
|
|
bases = {n: (b, s) for n, b, s in mods}
|
|
for no, raw in enumerate(Path(path).read_text().splitlines(), 1):
|
|
f = raw.split('#', 1)[0].split()
|
|
if not f:
|
|
continue
|
|
where = f'{path}:{no}'
|
|
if f[0] == 'set' and len(f) == 4:
|
|
if f[1] in index:
|
|
raise PatchError(f'{where}: set {f[1]} defined twice')
|
|
index[f[1]] = len(sets)
|
|
sets.append((f[1], f[2], int(f[3])))
|
|
elif f[0] == 'site' and len(f) >= 6:
|
|
if f[1] not in index:
|
|
raise PatchError(f'{where}: unknown set {f[1]}')
|
|
if f[2] not in bases:
|
|
raise PatchError(f'{where}: module {f[2]} not in the layout')
|
|
off, orig = int(f[3], 16), int(f[4], 16)
|
|
repl = []
|
|
for w in f[5:]:
|
|
if w.startswith('@page:x'):
|
|
repl.append(('page', int(w[7:])))
|
|
else:
|
|
repl.append(int(w, 16))
|
|
mod = sites.setdefault(f[2], {})
|
|
if off in mod:
|
|
raise PatchError(f'{where}: {f[2]}+{off:#x} patched twice')
|
|
mod[off] = (index[f[1]], repl, orig)
|
|
else:
|
|
raise PatchError(f'{where}: cannot parse {raw!r}')
|
|
base, size = bases['main'][0], bases['main'][1]
|
|
page = (base + size + PAGE - 1) & ~(PAGE - 1)
|
|
nxt = min((b for _, b, _ in mods if b > base), default=None)
|
|
if nxt is not None and page + PAGE > nxt:
|
|
raise PatchError(f'no room for the patch page after main ({page:#x})')
|
|
return Table(sets, sites, page)
|
|
|
|
|
|
def check(table, mod, name):
|
|
"""Stops on a site whose original word differs from the module's."""
|
|
for off, (_, _, want) in table.sites.get(name, {}).items():
|
|
a = mod.base + off
|
|
if not mod.in_text(a):
|
|
raise PatchError(f'{name}+{off:#x}: patch site outside .text')
|
|
have = mod.word(a)
|
|
if have != want:
|
|
raise PatchError(f'{name}+{off:#x}: module has {have:08x}, the patch expects {want:08x}')
|
|
|
|
|
|
def header_text(table, marker):
|
|
lines = [f'// {marker}: code patch sets, generated by recomp/gen.py --patches. Do not edit or commit.',
|
|
'#pragma once', '', f'#define RT_PATCH_COUNT {len(table.sets)}',
|
|
f'#define RT_PATCH_PAGE {table.page:#x}ull',
|
|
'// X(index, name, env switch, default)',
|
|
'#define RT_PATCH_SETS(X) ' + ' '.join(f'X({i}, {n}, "{e}", {d})' for i, (n, e, d) in
|
|
enumerate(table.sets)), '']
|
|
return '\n'.join(lines)
|