580 lines
27 KiB
Python
580 lines
27 KiB
Python
#!/usr/bin/env python3
|
|
"""vu_recomp.py GEN_DIR DECOMP_REPO [--dis OUT_DIR]
|
|
|
|
Ahead-of-time translator for the game's VU microprograms (VU0 and VU1 micro
|
|
mode). The microcode lives in the executable's .vutext section, listed by its
|
|
.DVP.ovlytab overlay table: one entry per MPG upload (VU address, size, load
|
|
address). Uploads of one program image share a group id in the overlay's
|
|
name (".DVP.overlay..<vu address>.<group>.<line>.<n>").
|
|
|
|
Each image is translated to one C function over an RcVu0 (host/include/vu.h):
|
|
a switch on the start address, then one labelled piece of C per instruction
|
|
pair. The function is compiled with the rest of the host program; nothing is
|
|
decoded at run time. Images that fit VU0's 4 KB micro memory are translated
|
|
for both VUs, the rest for VU1 only. The bytes of every upload are kept too,
|
|
so the runtime (host/src/gfx/vu.c) can tell which image is in micro memory
|
|
after the game's MPG uploads.
|
|
|
|
Semantics kept:
|
|
- upper and lower ops of a pair both read the registers as they were before
|
|
the pair; the upper op's result wins when both write the same register;
|
|
with the I bit the lower word is LOI's immediate (the pair's own upper
|
|
op still reads the old I: the game's sine code depends on it).
|
|
- branches and E (end) have one delay slot pair.
|
|
- FMAC results that overflow are +-MAX, as on the VU (which has no inf
|
|
or NaN): x86 would give inf, and then NaN (inf * 0, inf - inf), where
|
|
the VU keeps finite numbers (vu_fc).
|
|
- MAC/status/clip flags reach FSAND/FMAND/FCAND... 4 cycles after the op
|
|
issues, Q 7 cycles after DIV/SQRT and 13 after RSQRT: the code counts
|
|
cycles, including the stalls on VF registers that are still being written
|
|
(4-cycle latency, per component), which are worked out here.
|
|
|
|
Writes GEN_DIR/vu_prog_<n>.c (one per image and VU) and GEN_DIR/vu_table.c.
|
|
"""
|
|
import os, re, struct, sys
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
from vu_isa import decode_pair, BRANCHES, XYZW
|
|
|
|
GEN, REPO = sys.argv[1], sys.argv[2]
|
|
DIS = sys.argv[sys.argv.index("--dis") + 1] if "--dis" in sys.argv else None
|
|
EXE = os.environ.get("UYA_EXE") or os.path.join(REPO, "baserom", "SCES_509.16") # build.py: the copy read from the disc image
|
|
img = open(EXE, "rb").read()
|
|
|
|
# ---- the executable's sections ------------------------------------------------
|
|
e_shoff, = struct.unpack_from("<I", img, 0x20)
|
|
shentsize, shnum, shstrndx = struct.unpack_from("<HHH", img, 0x2E)
|
|
secs = [struct.unpack_from("<10I", img, e_shoff + i * shentsize) for i in range(shnum)]
|
|
strtab_off = secs[shstrndx][4]
|
|
|
|
|
|
def secname(s):
|
|
o = strtab_off + s[0]
|
|
return img[o:img.index(b"\0", o)].decode()
|
|
|
|
|
|
bysec = {secname(s): s for s in secs}
|
|
vutext = bysec[".vutext"]
|
|
VT_ADDR, VT_OFF, VT_SIZE = vutext[3], vutext[4], vutext[5]
|
|
tab = bysec[".DVP.ovlytab"]
|
|
ostr = bysec[".DVP.ovlystrtab"]
|
|
tabd = img[tab[4]:tab[4] + tab[5]]
|
|
strd = img[ostr[4]:ostr[4] + ostr[5]]
|
|
|
|
groups = {}
|
|
order = []
|
|
for k in range(0, len(tabd) // 12 * 12, 12):
|
|
no, lma, vma = struct.unpack_from("<3I", tabd, k)
|
|
name = strd[no:strd.index(b"\0", no)].decode()
|
|
size = bysec[name][5]
|
|
parts = name.split(".") # ['', 'DVP', 'overlay', '', '0x0', group, line, n]
|
|
g = parts[5]
|
|
o = VT_OFF + (lma - VT_ADDR)
|
|
data = img[o:o + size]
|
|
if g not in groups:
|
|
groups[g] = []
|
|
order.append(g)
|
|
groups[g].append((vma, data))
|
|
|
|
|
|
# ---- register use (for stalls) ------------------------------------------------
|
|
def up_rw(u):
|
|
"""VF (reg, comp) read and written by an upper op"""
|
|
r, w = [], []
|
|
k = u.kind
|
|
if k in ("nop", "bad"):
|
|
return r, w
|
|
if k == "arith":
|
|
for c in u.comps:
|
|
r.append((u.fs, c))
|
|
if u.bc in ("x", "y", "z", "w"):
|
|
r.append((u.ft, XYZW.index(u.bc)))
|
|
elif u.bc is None:
|
|
r.append((u.ft, c))
|
|
if not u.acc:
|
|
w.append((u.fd, c))
|
|
elif k in ("opmula", "opmsub"):
|
|
for c in (0, 1, 2):
|
|
r += [(u.fs, c), (u.ft, c)]
|
|
if k == "opmsub":
|
|
w += [(u.fd, c) for c in u.comps if c < 3]
|
|
elif k in ("itof", "ftoi", "abs"):
|
|
r += [(u.fs, c) for c in u.comps]
|
|
w += [(u.ft, c) for c in u.comps]
|
|
elif k == "clip":
|
|
r += [(u.fs, 0), (u.fs, 1), (u.fs, 2), (u.ft, 3)]
|
|
return r, w
|
|
|
|
|
|
def lo_rw(l):
|
|
r, w = [], []
|
|
if l is None:
|
|
return r, w
|
|
n = l.name
|
|
if n in ("lq", "lqi", "lqd"):
|
|
w += [(l.ft, c) for c in l.comps]
|
|
elif n in ("sq", "sqi", "sqd"):
|
|
r += [(l.fs, c) for c in l.comps]
|
|
elif n == "move":
|
|
r += [(l.fs, c) for c in l.comps]
|
|
w += [(l.ft, c) for c in l.comps]
|
|
elif n == "mr32":
|
|
r += [(l.fs, (c + 1) & 3) for c in l.comps]
|
|
w += [(l.ft, c) for c in l.comps]
|
|
elif n == "mtir":
|
|
r.append((l.fs, l.fsf))
|
|
elif n == "mfir":
|
|
w += [(l.ft, c) for c in l.comps]
|
|
elif n == "div":
|
|
r += [(l.fs, l.fsf), (l.ft, l.ftf)]
|
|
elif n == "sqrt":
|
|
r.append((l.ft, l.ftf))
|
|
elif n == "rsqrt":
|
|
r += [(l.fs, l.fsf), (l.ft, l.ftf)]
|
|
return [x for x in r if x[0]], [x for x in w if x[0]]
|
|
|
|
|
|
FLAG_UPPER = {"add", "sub", "mul", "madd", "msub", "adda", "suba", "mula", "madda", "msuba"}
|
|
|
|
|
|
class Image:
|
|
def __init__(self, gid, blocks, vu):
|
|
self.gid, self.blocks, self.vu = gid, sorted(blocks), vu
|
|
self.mem = {}
|
|
for vma, data in self.blocks:
|
|
for k in range(0, len(data), 8):
|
|
self.mem[vma + k] = struct.unpack_from("<II", data, k)
|
|
self.warn = []
|
|
|
|
|
|
def dis_image(im, out):
|
|
with open(out, "w") as f:
|
|
for pc in sorted(im.mem):
|
|
lo, hi = im.mem[pc]
|
|
u, l, fl, imm = decode_pair(lo, hi)
|
|
fs = "".join(x for x in "IEMDT" if fl[x])
|
|
ls = "loi %08X" % imm if imm is not None else l.text()
|
|
f.write("%04X %-3s %-45s | %s\n" % (pc, fs, u.text(), ls))
|
|
|
|
|
|
# ---- translation ----------------------------------------------------------------
|
|
def gen_image(im):
|
|
vu = im.vu
|
|
MEM = "VU%d_MEM" % vu
|
|
PCMASK = 0x3FF8 if vu == 1 else 0xFF8
|
|
pcs = sorted(im.mem)
|
|
dec = {}
|
|
for pc in pcs:
|
|
lo, hi = im.mem[pc]
|
|
dec[pc] = decode_pair(lo, hi)
|
|
|
|
reads_sm = any(d[1] is not None and d[1].name in ("fsand", "fsor", "fseq", "fmand", "fmor", "fmeq") for d in dec.values())
|
|
# ---- static cycles: stalls on VF registers still being written ----
|
|
stall, qstall = {}, {}
|
|
ready, t, qready = {}, 0, None
|
|
prev_end = True
|
|
for pc in pcs:
|
|
u, l, fl, imm = dec[pc]
|
|
if prev_end or (pc - 8) not in dec:
|
|
ready, t, qready = {}, 0, None
|
|
ti = t + 1
|
|
r1, w1 = up_rw(u)
|
|
r2, w2 = lo_rw(l)
|
|
need = max([ready.get(x, 0) for x in r1 + r2] + [0])
|
|
s = max(0, need - ti)
|
|
ti += s
|
|
qs = 0
|
|
if l is not None and l.name in ("waitq", "div", "sqrt", "rsqrt") and qready is not None and qready > ti:
|
|
qs = qready - ti
|
|
ti += qs
|
|
if l is not None and l.name in ("div", "sqrt", "rsqrt"):
|
|
qready = ti + (13 if l.name == "rsqrt" else 7)
|
|
stall[pc] = s + qs
|
|
for x in w1 + w2:
|
|
ready[x] = ti + 4
|
|
t = ti
|
|
# a new straight-line run starts after an unconditional jump's or E's delay slot
|
|
prev_end = False
|
|
p = pc - 8
|
|
if p in dec:
|
|
pu, pl, pf, pimm = dec[p]
|
|
if pf["E"] or (pl is not None and pl.name in ("b", "jr")):
|
|
prev_end = True
|
|
|
|
used_q = False
|
|
|
|
# ---- branch VI delay: a conditional branch (or JR/JALR) whose VI register
|
|
# was written by the instruction right before it reads the value the
|
|
# register had before that write (before the earliest of a run of such
|
|
# writes, up to 4 back), unless the branch stalls or the write reads flags
|
|
# (FCAND and friends). This is the hardware's integer pipeline; PCSX2's
|
|
# microVU models it the same way (analyzeBranchVI). ----
|
|
FLAGREAD = {"fcand", "fcor", "fceq", "fcget", "fsand", "fsor", "fseq", "fmand", "fmor", "fmeq"}
|
|
def vi_written(lw):
|
|
if lw is None: return 0
|
|
n = lw.name
|
|
if n in ("iadd", "isub", "iand", "ior"): return lw.id_ & 15
|
|
if n in ("iaddi", "iaddiu", "isubiu", "ilw", "ilwr", "mtir", "xtop", "xitop", "bal", "jalr"): return lw.it & 15
|
|
if n in ("lqi", "lqd"): return lw.is_ & 15
|
|
if n in ("sqi", "sqd"): return lw.it & 15
|
|
return 0
|
|
targets = set()
|
|
for pc_ in pcs:
|
|
l_ = dec[pc_][1]
|
|
if l_ is not None and l_.name in ("b", "bal", "ibeq", "ibne", "ibltz", "ibgtz", "iblez", "ibgez"):
|
|
targets.add((pc_ + 8 + l_.imm * 8) & PCMASK)
|
|
vib_save, vib_use = {}, {}
|
|
for pc_ in pcs:
|
|
l_ = dec[pc_][1]
|
|
if l_ is None or l_.name not in ("ibeq", "ibne", "ibltz", "ibgtz", "iblez", "ibgez", "jr", "jalr"): continue
|
|
if stall[pc_] or pc_ in targets: continue
|
|
regs = [l_.is_ & 15] + ([l_.it & 15] if l_.name in ("ibeq", "ibne") else [])
|
|
for x in regs:
|
|
if not x: continue
|
|
p_ = pc_ - 8
|
|
if p_ not in dec or dec[p_][1] is None or dec[p_][1].name in FLAGREAD or vi_written(dec[p_][1]) != x: continue
|
|
j_ = p_
|
|
for k_ in range(3):
|
|
q_ = j_ - 8
|
|
if j_ in targets or q_ not in dec or stall[j_]: break
|
|
lq_ = dec[q_][1]
|
|
if lq_ is None or lq_.name in FLAGREAD or vi_written(lq_) != x: break
|
|
j_ = q_
|
|
vib_save[j_] = x
|
|
vib_use[pc_] = x
|
|
break
|
|
|
|
def VI(r):
|
|
r &= 15
|
|
return "0u" if r == 0 else "v->vi[%d]" % r
|
|
|
|
def setvi(r, e):
|
|
r &= 15
|
|
return "" if r == 0 else "v->vi[%d] = (%s) & 0xFFFF;" % (r, e)
|
|
|
|
def U32(r):
|
|
return "((u32 *)v->vf[%d])" % r
|
|
|
|
def upper(pc, u):
|
|
"""(compute, commit) code for the upper op"""
|
|
nonlocal used_q
|
|
k = u.kind
|
|
if k == "nop":
|
|
return "", ""
|
|
if k == "bad":
|
|
im.warn.append("%04X upper %s" % (pc, u.name))
|
|
return 'vu_bad(%d, 0x%04X, "%s");' % (vu, pc, u.name), ""
|
|
comp, commit = [], []
|
|
F = lambda r, c: "v->vf[%d][%d]" % (r, c)
|
|
if k == "arith":
|
|
base = u.base if u.acc else u.name
|
|
if u.bc == "q":
|
|
used_q = True
|
|
comp.append("f32 qv = vu_q(v, cyc);")
|
|
|
|
def B(c):
|
|
if u.bc in ("x", "y", "z", "w"): return F(u.ft, XYZW.index(u.bc))
|
|
if u.bc == "q": return "qv"
|
|
if u.bc == "i": return "v->i"
|
|
return F(u.ft, c)
|
|
for c in u.comps:
|
|
a, b = F(u.fs, c), B(c)
|
|
e = {"add": "%s + %s" % (a, b), "sub": "%s - %s" % (a, b), "mul": "%s * %s" % (a, b),
|
|
"madd": "v->acc[%d] + vu_fc(%s * %s)" % (c, a, b), "msub": "v->acc[%d] - vu_fc(%s * %s)" % (c, a, b),
|
|
"max": "fmaxf(%s, %s)" % (a, b), "mini": "fminf(%s, %s)" % (a, b)}[base]
|
|
comp.append("f32 u%d = %s;" % (c, e))
|
|
for c in u.comps:
|
|
if u.acc: commit.append("v->acc[%d] = vu_fc(u%d);" % (c, c))
|
|
elif u.fd: commit.append("v->vf[%d][%d] = vu_fc(u%d);" % (u.fd, c, c))
|
|
if reads_sm and base in ("add", "sub", "mul", "madd", "msub"):
|
|
commit.append("vu_fl_push(v, cyc, %s);" % (" | ".join("vu_macbits(u%d, %d)" % (c, c) for c in u.comps) or "0"))
|
|
elif k in ("opmula", "opmsub"):
|
|
ex = {0: (1, 2), 1: (2, 0), 2: (0, 1)}
|
|
cs = [c for c in u.comps if c < 3]
|
|
for c in cs:
|
|
a, b = ex[c]
|
|
p = "%s * %s" % (F(u.fs, a), F(u.ft, b))
|
|
comp.append("f32 u%d = %s;" % (c, p if k == "opmula" else "v->acc[%d] - vu_fc(%s)" % (c, p)))
|
|
for c in cs:
|
|
if k == "opmula": commit.append("v->acc[%d] = vu_fc(u%d);" % (c, c))
|
|
elif u.fd: commit.append("v->vf[%d][%d] = vu_fc(u%d);" % (u.fd, c, c))
|
|
if reads_sm:
|
|
commit.append("vu_fl_push(v, cyc, %s);" % (" | ".join("vu_macbits(u%d, %d)" % (c, c) for c in cs) or "0"))
|
|
elif k == "itof":
|
|
for c in u.comps:
|
|
comp.append("u32 n%d = vu_itof(%s[%d], %.9ef);" % (c, U32(u.fs), c, 1.0 / (1 << u.shift)))
|
|
if u.ft:
|
|
commit += ["%s[%d] = n%d;" % (U32(u.ft), c, c) for c in u.comps]
|
|
elif k == "ftoi":
|
|
for c in u.comps:
|
|
comp.append("s32 n%d = vu_ftoi(%s, %.1ff);" % (c, F(u.fs, c), float(1 << u.shift)))
|
|
if u.ft:
|
|
commit += ["%s[%d] = (u32)n%d;" % (U32(u.ft), c, c) for c in u.comps]
|
|
elif k == "abs":
|
|
for c in u.comps:
|
|
comp.append("u32 n%d = %s[%d] & 0x7FFFFFFFu;" % (c, U32(u.fs), c))
|
|
if u.ft:
|
|
commit += ["%s[%d] = n%d;" % (U32(u.ft), c, c) for c in u.comps]
|
|
elif k == "clip":
|
|
comp.append("f32 cw = v->vf[%d][3];" % u.ft)
|
|
comp.append("f32 cs[3] = { v->vf[%d][0], v->vf[%d][1], v->vf[%d][2] };" % (u.fs, u.fs, u.fs))
|
|
commit.append("vu_clipw(v, cyc, cs, cw);")
|
|
return " ".join(comp), " ".join(commit)
|
|
|
|
def lower(pc, l):
|
|
"""(pre, code, kind, target) ; kind in None, 'b' (static target), 'j' (npc)"""
|
|
nonlocal used_q
|
|
n = l.name
|
|
c0 = l.comps[0] if l.comps else 0
|
|
if n.startswith("?"):
|
|
im.warn.append("%04X lower %s" % (pc, n))
|
|
return "", 'vu_bad(%d, 0x%04X, "%s");' % (vu, pc, n), None, None
|
|
if n == "move":
|
|
if not l.comps or not l.ft: return "", "", None, None
|
|
return "", " ".join("%s[%d] = %s[%d];" % (U32(l.ft), c, U32(l.fs), c) for c in l.comps), None, None
|
|
if n == "mr32":
|
|
if not l.ft: return "", "", None, None
|
|
s = "{ u32 m0 = %s[1], m1 = %s[2], m2 = %s[3], m3 = %s[0]; " % (U32(l.fs), U32(l.fs), U32(l.fs), U32(l.fs))
|
|
return "", s + " ".join("%s[%d] = m%d;" % (U32(l.ft), c, c) for c in l.comps) + " }", None, None
|
|
if n in ("lq", "lqi", "lqd"):
|
|
reg = l.is_
|
|
pre = setvi(reg, VI(reg) + " - 1") + " " if n == "lqd" else ""
|
|
post = " " + setvi(reg, VI(reg) + " + 1") if n == "lqi" else ""
|
|
addr = VI(reg) + (" + %d" % l.imm if n == "lq" else "")
|
|
body = " ".join("%s[%d] = m[%d];" % (U32(l.ft), c, c) for c in l.comps) if l.ft else ""
|
|
return "", "%s{ const u32 *m = %s(%s); %s }%s" % (pre, MEM, addr, body, post), None, None
|
|
if n in ("sq", "sqi", "sqd"):
|
|
reg = l.it
|
|
pre = setvi(reg, VI(reg) + " - 1") + " " if n == "sqd" else ""
|
|
post = " " + setvi(reg, VI(reg) + " + 1") if n == "sqi" else ""
|
|
addr = VI(reg) + (" + %d" % l.imm if n == "sq" else "")
|
|
body = " ".join("m[%d] = %s[%d];" % (c, U32(l.fs), c) for c in l.comps)
|
|
return "", "%s{ u32 *m = %s(%s); %s }%s" % (pre, MEM, addr, body, post), None, None
|
|
if n in ("ilw", "ilwr"):
|
|
addr = VI(l.is_) + (" + %d" % l.imm if n == "ilw" else "")
|
|
return "", setvi(l.it, "%s(%s)[%d]" % (MEM, addr, c0)), None, None
|
|
if n in ("isw", "iswr"):
|
|
addr = VI(l.is_) + (" + %d" % l.imm if n == "isw" else "")
|
|
return "", "{ u32 *m = %s(%s); %s }" % (MEM, addr, " ".join("m[%d] = %s;" % (c, VI(l.it)) for c in l.comps)), None, None
|
|
if n in ("iadd", "isub", "iand", "ior"):
|
|
op = {"iadd": "+", "isub": "-", "iand": "&", "ior": "|"}[n]
|
|
return "", setvi(l.id_, "%s %s %s" % (VI(l.is_), op, VI(l.it))), None, None
|
|
if n == "iaddi":
|
|
return "", setvi(l.it, "%s + (%d)" % (VI(l.is_), l.imm)), None, None
|
|
if n == "iaddiu":
|
|
return "", setvi(l.it, "%s + %d" % (VI(l.is_), l.imm)), None, None
|
|
if n == "isubiu":
|
|
return "", setvi(l.it, "%s - %d" % (VI(l.is_), l.imm)), None, None
|
|
if n == "mtir":
|
|
return "", setvi(l.it, "%s[%d]" % (U32(l.fs), l.fsf)), None, None
|
|
if n == "mfir":
|
|
if not l.ft: return "", "", None, None
|
|
return "", " ".join("%s[%d] = (u32)(s32)(s16)%s;" % (U32(l.ft), c, VI(l.is_)) for c in l.comps), None, None
|
|
F = lambda r, c: "v->vf[%d][%d]" % (r, c)
|
|
if n == "div":
|
|
used_q = True
|
|
return "cyc = vu_qwait(v, cyc);", "vu_qset(v, cyc, 7, vu_div(%s, %s));" % (F(l.fs, l.fsf), F(l.ft, l.ftf)), None, None
|
|
if n == "sqrt":
|
|
used_q = True
|
|
return "cyc = vu_qwait(v, cyc);", "vu_qset(v, cyc, 7, vu_sqrt(%s));" % F(l.ft, l.ftf), None, None
|
|
if n == "rsqrt":
|
|
used_q = True
|
|
return "cyc = vu_qwait(v, cyc);", "vu_qset(v, cyc, 13, vu_rsqrt(%s, %s));" % (F(l.fs, l.fsf), F(l.ft, l.ftf)), None, None
|
|
if n == "waitq":
|
|
return "cyc = vu_qwait(v, cyc);", "", None, None
|
|
if n == "fcand": return "", setvi(1, "(vu_clip(v, cyc) & 0x%X) != 0" % l.imm), None, None
|
|
if n == "fcor": return "", setvi(1, "((vu_clip(v, cyc) | 0x%X) & 0xFFFFFF) == 0xFFFFFF" % l.imm), None, None
|
|
if n == "fceq": return "", setvi(1, "(vu_clip(v, cyc) & 0xFFFFFF) == 0x%X" % l.imm), None, None
|
|
if n == "fcset": return "", "vu_fcset(v, cyc, 0x%X);" % l.imm, None, None
|
|
if n == "fcget": return "", setvi(l.it, "vu_clip(v, cyc) & 0xFFF"), None, None
|
|
if n == "fsand": return "", setvi(l.it, "vu_status(v, cyc) & 0x%X" % l.imm), None, None
|
|
if n == "fsor": return "", setvi(l.it, "vu_status(v, cyc) | 0x%X" % l.imm), None, None
|
|
if n == "fseq": return "", setvi(l.it, "(vu_status(v, cyc) & 0xFFF) == 0x%X" % l.imm), None, None
|
|
if n == "fsset": return "", "vu_fsset(v, cyc, 0x%X);" % l.imm, None, None
|
|
if n == "fmand": return "", setvi(l.it, "%s & vu_mac(v, cyc)" % VI(l.is_)), None, None
|
|
if n == "fmor": return "", setvi(l.it, "%s | vu_mac(v, cyc)" % VI(l.is_)), None, None
|
|
if n == "fmeq": return "", setvi(l.it, "(%s & 0xFFFF) == vu_mac(v, cyc)" % VI(l.is_)), None, None
|
|
if n == "xgkick":
|
|
if vu != 1:
|
|
im.warn.append("%04X xgkick on VU0" % pc)
|
|
return "", 'vu_bad(0, 0x%04X, "xgkick");' % pc, None, None
|
|
return "", "vu_xgkick(%s);" % VI(l.is_), None, None
|
|
if n == "xtop": return "", setvi(l.it, "vu_vif_top(%d)" % vu), None, None
|
|
if n == "xitop": return "", setvi(l.it, "vu_vif_itop(%d)" % vu), None, None
|
|
if n in BRANCHES:
|
|
link = (pc + 16) // 8
|
|
if n == "b":
|
|
return "", "", "b", (pc + 8 + l.imm * 8) & PCMASK
|
|
if n == "bal":
|
|
return "", setvi(l.it, "%d" % link), "b", (pc + 8 + l.imm * 8) & PCMASK
|
|
JV = "vib" if vib_use.get(pc) == (l.is_ & 15) else VI(l.is_)
|
|
if n == "jr":
|
|
return "", "npc = (%s << 3) & 0x%X;" % (JV, PCMASK), "j", None
|
|
if n == "jalr":
|
|
return "", "npc = (%s << 3) & 0x%X; %s" % (JV, PCMASK, setvi(l.it, "%d" % link)), "j", None
|
|
BV = (lambda r: "vib" if vib_use.get(pc) == (r & 15) else VI(r))
|
|
cond = {"ibeq": "%s == %s" % (BV(l.it), BV(l.is_)), "ibne": "%s != %s" % (BV(l.it), BV(l.is_)),
|
|
"ibltz": "(s16)%s < 0" % BV(l.is_), "ibgtz": "(s16)%s > 0" % BV(l.is_),
|
|
"iblez": "(s16)%s <= 0" % BV(l.is_), "ibgez": "(s16)%s >= 0" % BV(l.is_)}[n]
|
|
return "", "bt = %s;" % cond, "c", (pc + 8 + l.imm * 8) & PCMASK
|
|
im.warn.append("%04X lower %s not translated" % (pc, n))
|
|
return "", 'vu_bad(%d, 0x%04X, "%s");' % (vu, pc, n), None, None
|
|
|
|
def pair(pc):
|
|
"""C for one pair; returns (code, flow kind, target)"""
|
|
u, l, fl, imm = dec[pc]
|
|
out = ["VU_TRACE(0x%04X); cyc += %d;" % (pc, 1 + stall[pc])]
|
|
if pc in vib_save: out.append("vib = %s;" % VI(vib_save[pc]))
|
|
uc, ucommit = upper(pc, u)
|
|
pre = code = ""
|
|
kind = tgt = None
|
|
if l is not None:
|
|
pre, code, kind, tgt = lower(pc, l)
|
|
if pre: out.append(pre)
|
|
if imm is not None: # LOI: the pair's upper op still reads the old I
|
|
code = "v->i = vu_f(0x%08Xu);" % imm
|
|
if uc or ucommit:
|
|
out.append("{ %s %s %s }" % (uc, code, ucommit))
|
|
elif code:
|
|
out.append(code)
|
|
return " ".join(x for x in out if x), kind, tgt, fl["E"]
|
|
|
|
body = []
|
|
lab = lambda pc: "L_%04X" % pc
|
|
import re as _re
|
|
def idle(pc): # a pair that does nothing but count its cycle
|
|
c_, k_, t_, e_ = pair(pc)
|
|
return k_ is None and not e_ and not _re.sub(r"VU_TRACE\(0x[0-9A-F]+\);|cyc \+= \d+;|\s", "", c_)
|
|
for pc in pcs:
|
|
code, kind, tgt, ebit = pair(pc)
|
|
body.append("%s: %s" % (lab(pc), code))
|
|
nxt = pc + 8
|
|
if kind is None and not ebit:
|
|
if nxt not in dec:
|
|
body.append(" vu_bad(%d, 0x%04X, \"ran off the end\"); goto done;" % (vu, nxt))
|
|
continue
|
|
# a branch or the end: its delay slot pair runs here as well
|
|
if nxt in dec:
|
|
dcode, dkind, dtgt, debit = pair(nxt)
|
|
if dkind is not None:
|
|
im.warn.append("%04X branch in a delay slot (ignored)" % nxt)
|
|
if debit and not ebit:
|
|
im.warn.append("%04X E bit in a branch delay slot" % nxt)
|
|
body.append(" /* delay slot */ " + dcode)
|
|
else:
|
|
im.warn.append("%04X delay slot outside the image" % pc)
|
|
if ebit:
|
|
if kind is not None:
|
|
im.warn.append("%04X branch with the E bit" % pc)
|
|
body.append(" v->tpc = 0x%04X; goto done;" % ((pc + 16) & PCMASK))
|
|
continue
|
|
if kind == "b" and tgt == pc - 16 and tgt in dec and pair(tgt)[1] == "c" and idle(tgt + 8) and (nxt not in dec or idle(nxt)) \
|
|
and "vi[" in pair(tgt)[0] and not _re.search(r"vf\[|acc\[|VU\d_MEM", pair(tgt)[0]):
|
|
# a wait loop on a VI register the EE writes (ctc2): park here and
|
|
# let the EE resume the program (rc_vu0_resume) when it writes one
|
|
body.append(" v->tpc = 0x%04X; v->susp = 1; goto done; /* wait for the EE */" % tgt)
|
|
elif kind == "b":
|
|
body.append(" goto %s;" % lab(tgt) if tgt in dec else " pc = 0x%04X; goto dispatch;" % tgt)
|
|
elif kind == "c":
|
|
body.append(" if (bt) %s" % ("goto %s;" % lab(tgt) if tgt in dec else "{ pc = 0x%04X; goto dispatch; }" % tgt))
|
|
if nxt + 8 in dec:
|
|
body.append(" goto %s;" % lab(nxt + 8))
|
|
else:
|
|
body.append(" goto done;")
|
|
elif kind == "j":
|
|
body.append(" pc = npc; goto dispatch;")
|
|
|
|
name = "vup_%s_vu%d" % (im.gid, vu)
|
|
out = ["/* VU%d microprogram image %s, translated from the executable by tools/vu_recomp.py */" % (vu, im.gid),
|
|
'#include "vu.h"', "",
|
|
"void %s(RcVu0 *v, u32 pc)" % name, "{",
|
|
" u32 cyc = 0, npc = 0, vib = 0; int bt = 0; (void)npc; (void)bt; (void)vib;",
|
|
" v->st_int = v->status; v->cl_int = v->clip;",
|
|
"dispatch:",
|
|
" switch (pc & 0x%X) {" % PCMASK]
|
|
for pc in pcs:
|
|
out.append(" case 0x%04X: goto %s;" % (pc, lab(pc)))
|
|
out.append(' default: vu_bad(%d, pc, "start address"); goto done;' % vu)
|
|
out.append(" }")
|
|
out += body
|
|
out += ["done:", " vu_settle(v);", "}"]
|
|
return name, "\n".join(out) + "\n"
|
|
|
|
|
|
def extra_images():
|
|
"""Microcode the game uploads that is not in .vutext (none is known for
|
|
RAC1): the runtime reports such an upload and, with UYA_VUDUMP=dir, saves
|
|
it as vu<N>_<addr>_<hash>.bin. Files of that name in RAC1_VU_EXTRA (or
|
|
the vu_extra folder next to build.py) are translated as images of their
|
|
own, one upload each."""
|
|
d = os.environ.get("RAC1_VU_EXTRA") or os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "vu_extra")
|
|
out = []
|
|
if not os.path.isdir(d):
|
|
return out
|
|
for fn in sorted(os.listdir(d)):
|
|
m = re.fullmatch(r"vu([01])_([0-9A-Fa-f]{4})_([0-9A-Fa-f]{8})\.bin", fn)
|
|
if not m:
|
|
continue
|
|
data = open(os.path.join(d, fn), "rb").read()
|
|
data = data[:len(data) // 8 * 8]
|
|
out.append(Image("x%s_%s" % (m.group(2).upper(), m.group(3).upper()), [(int(m.group(2), 16), data)], int(m.group(1))))
|
|
return out
|
|
|
|
|
|
def main():
|
|
os.makedirs(GEN, exist_ok=True)
|
|
images = []
|
|
for g in order:
|
|
blocks = groups[g]
|
|
size = max(vma + len(d) for vma, d in blocks)
|
|
kicks = any(decode_pair(*struct.unpack_from("<II", d, k))[1] is not None and
|
|
decode_pair(*struct.unpack_from("<II", d, k))[1].name == "xgkick"
|
|
for vma, d in blocks for k in range(0, len(d), 8))
|
|
# XGKICK only exists on VU1; anything bigger than 4 KB is VU1 code too
|
|
for vu in ((0, 1) if size <= 0x1000 and not kicks else (1,)):
|
|
images.append(Image(g, blocks, vu))
|
|
images += extra_images()
|
|
if DIS:
|
|
os.makedirs(DIS, exist_ok=True)
|
|
for im in images:
|
|
if im.vu == 1 or len([i for i in images if i.gid == im.gid]) == 1:
|
|
dis_image(im, os.path.join(DIS, "%s.txt" % im.gid))
|
|
tbl = ['/* VU microprogram images (tools/vu_recomp.py) */', '#include "vu.h"', "",
|
|
"typedef struct { u32 vma, size; const u32 *words; } VuBlock;",
|
|
"typedef struct { const char *name; int vu; void (*fn)(RcVu0 *, u32); int nblk; const VuBlock *blk; } VuImage;", ""]
|
|
names = []
|
|
nwarn = 0
|
|
for im in images:
|
|
name, src = gen_image(im)
|
|
path = os.path.join(GEN, "%s.c" % name)
|
|
old = open(path).read() if os.path.exists(path) else None
|
|
if old != src:
|
|
open(path, "w").write(src)
|
|
tbl.append("void %s(RcVu0 *, u32);" % name)
|
|
for vma, d in im.blocks:
|
|
ws = struct.unpack("<%dI" % (len(d) // 4), d)
|
|
tbl.append("static const u32 %s_b%04X[%d] = {" % (name, vma, len(ws)))
|
|
for k in range(0, len(ws), 8):
|
|
tbl.append(" " + ", ".join("0x%08X" % x for x in ws[k:k + 8]) + ",")
|
|
tbl.append("};")
|
|
tbl.append("static const VuBlock %s_blk[] = { %s };" % (name, ", ".join(
|
|
"{ 0x%04X, 0x%X, %s_b%04X }" % (vma, len(d), name, vma) for vma, d in im.blocks)))
|
|
names.append((name, im))
|
|
for w in im.warn:
|
|
nwarn += 1
|
|
print("vu_recomp: image %s VU%d: %s" % (im.gid, im.vu, w))
|
|
tbl.append("const VuImage vu_images[] = {")
|
|
for name, im in names:
|
|
tbl.append(' { "%s", %d, %s, %d, %s_blk },' % (im.gid, im.vu, name, len(im.blocks), name))
|
|
tbl.append("};")
|
|
tbl.append("const int vu_image_count = %d;" % len(names))
|
|
src = "\n".join(tbl) + "\n"
|
|
path = os.path.join(GEN, "vu_table.c")
|
|
if not os.path.exists(path) or open(path).read() != src:
|
|
open(path, "w").write(src)
|
|
print("vu_recomp: %d microprogram images (%d pairs) translated, %d warnings" % (
|
|
len(names), sum(len(im.mem) for _, im in names), nwarn))
|
|
|
|
|
|
main()
|