"""vu_isa.py: decoding of PS2 VU micro-mode instructions (shared by vu_recomp.py).

A VU micro instruction is a 64-bit pair: the lower word (at the lower address)
holds the lower-unit op (load/store, integer, branch, DIV/EFU...), the upper
word the FMAC op plus the I/E/M/D/T bits. With the I bit set the lower word is
a float immediate for the I register (LOI).
"""

XYZW = "xyzw"


def dest(w):
    d = (w >> 21) & 15
    return [i for i in range(4) if d & (8 >> i)]


def dstr(w):
    return "".join(XYZW[i] for i in dest(w))


class Up:
    """decoded upper op: name, kind, fd/fs/ft, comps, bc ('x'..'w', 'q', 'i' or None), acc (writes ACC)"""
    def __init__(self, name, w, **kw):
        self.name, self.w = name, w
        self.comps = dest(w)
        self.ft, self.fs, self.fd = (w >> 16) & 31, (w >> 11) & 31, (w >> 6) & 31
        self.bc = None
        self.__dict__.update(kw)

    def text(self):
        return "%s.%s ft=%d fs=%d fd=%d%s" % (self.name, dstr(self.w), self.ft, self.fs, self.fd,
                                             (" bc=" + self.bc) if self.bc else "")


_ARITH1 = {0x00: "add", 0x04: "sub", 0x08: "madd", 0x0C: "msub", 0x10: "max", 0x14: "mini", 0x18: "mul"}
_S1 = {0x1C: ("mul", "q"), 0x1D: ("max", "i"), 0x1E: ("mul", "i"), 0x1F: ("mini", "i"),
       0x20: ("add", "q"), 0x21: ("madd", "q"), 0x22: ("add", "i"), 0x23: ("madd", "i"),
       0x24: ("sub", "q"), 0x25: ("msub", "q"), 0x26: ("sub", "i"), 0x27: ("msub", "i"),
       0x28: ("add", None), 0x29: ("madd", None), 0x2A: ("mul", None), 0x2B: ("max", None),
       0x2C: ("sub", None), 0x2D: ("msub", None), 0x2F: ("mini", None)}
_ARITH2 = {0x00: "add", 0x04: "sub", 0x08: "madd", 0x0C: "msub", 0x18: "mul"}
_S2 = {0x1C: ("mul", "q"), 0x20: ("add", "q"), 0x21: ("madd", "q"), 0x22: ("add", "i"), 0x23: ("madd", "i"),
       0x24: ("sub", "q"), 0x25: ("msub", "q"), 0x26: ("sub", "i"), 0x27: ("msub", "i"), 0x1E: ("mul", "i"),
       0x28: ("add", None), 0x29: ("madd", None), 0x2A: ("mul", None), 0x2C: ("sub", None), 0x2D: ("msub", None)}


def decode_upper(w):
    op = w & 0x3F
    if op < 0x3C:
        if op < 0x1C:
            base = op & 0x3C
            if base in _ARITH1:
                return Up(_ARITH1[base], w, kind="arith", bc=XYZW[op & 3], acc=False)
        if op in _S1:
            n, bc = _S1[op]
            return Up(n, w, kind="arith", bc=bc, acc=False)
        if op == 0x2E:
            return Up("opmsub", w, kind="opmsub", acc=False)
        return Up("?up%02X" % op, w, kind="bad")
    op2 = ((w >> 6) & 31) << 2 | (w & 3)
    if op2 < 0x1C and (op2 & 0x3C) in _ARITH2 and op2 not in range(0x10, 0x18):
        return Up(_ARITH2[op2 & 0x3C] + "a", w, kind="arith", bc=XYZW[op2 & 3], acc=True, base=_ARITH2[op2 & 0x3C])
    if op2 in _S2:
        n, bc = _S2[op2]
        return Up(n + "a", w, kind="arith", bc=bc, acc=True, base=n)
    if 0x10 <= op2 <= 0x13:
        return Up("itof%d" % (0, 4, 12, 15)[op2 & 3], w, kind="itof", shift=(0, 4, 12, 15)[op2 & 3])
    if 0x14 <= op2 <= 0x17:
        return Up("ftoi%d" % (0, 4, 12, 15)[op2 & 3], w, kind="ftoi", shift=(0, 4, 12, 15)[op2 & 3])
    if op2 == 0x1D: return Up("abs", w, kind="abs")
    if op2 == 0x1F: return Up("clipw", w, kind="clip")
    if op2 == 0x2E: return Up("opmula", w, kind="opmula")
    if op2 == 0x2F: return Up("nop", w, kind="nop")
    return Up("?up2_%02X" % op2, w, kind="bad")


class Lo:
    def __init__(self, name, w, **kw):
        self.name, self.w = name, w
        self.comps = dest(w)
        self.it, self.is_, self.id_ = (w >> 16) & 31, (w >> 11) & 31, (w >> 6) & 31
        self.ft, self.fs, self.fd = self.it, self.is_, self.id_
        self.fsf, self.ftf = (w >> 21) & 3, (w >> 23) & 3
        self.__dict__.update(kw)

    def text(self):
        return "%s.%s it=%d is=%d id=%d %s" % (self.name, dstr(self.w), self.it, self.is_, self.id_,
                                              " ".join("%s=%s" % (k, getattr(self, k)) for k in ("imm",) if hasattr(self, k)))


def s11(w):
    v = w & 0x7FF
    return v - 0x800 if v & 0x400 else v


_LOWER_S2 = {0x30: "move", 0x31: "mr32", 0x34: "lqi", 0x35: "sqi", 0x36: "lqd", 0x37: "sqd", 0x38: "div",
             0x39: "sqrt", 0x3A: "rsqrt", 0x3B: "waitq", 0x3C: "mtir", 0x3D: "mfir", 0x3E: "ilwr", 0x3F: "iswr",
             0x40: "rnext", 0x41: "rget", 0x42: "rinit", 0x43: "rxor", 0x64: "mfp", 0x68: "xtop", 0x69: "xitop",
             0x6C: "xgkick", 0x70: "esadd", 0x71: "ersadd", 0x72: "eleng", 0x73: "erleng", 0x74: "eatanxy",
             0x75: "eatanxz", 0x76: "esum", 0x78: "esqrt", 0x79: "ersqrt", 0x7A: "ercpr", 0x7B: "waitp",
             0x7C: "esin", 0x7D: "eatan", 0x7E: "eexp"}
_LOWER = {0x00: "lq", 0x01: "sq", 0x04: "ilw", 0x05: "isw", 0x08: "iaddiu", 0x09: "isubiu", 0x10: "fceq",
          0x11: "fcset", 0x12: "fcand", 0x13: "fcor", 0x14: "fseq", 0x15: "fsset", 0x16: "fsand", 0x17: "fsor",
          0x18: "fmeq", 0x1A: "fmand", 0x1B: "fmor", 0x1C: "fcget", 0x20: "b", 0x21: "bal", 0x24: "jr",
          0x25: "jalr", 0x28: "ibeq", 0x29: "ibne", 0x2C: "ibltz", 0x2D: "ibgtz", 0x2E: "iblez", 0x2F: "ibgez"}
BRANCHES = {"b", "bal", "jr", "jalr", "ibeq", "ibne", "ibltz", "ibgtz", "iblez", "ibgez"}


def decode_lower(w):
    op = w >> 25
    if op == 0x40:
        f = w & 0x3F
        if f < 0x3C:
            n = {0x30: "iadd", 0x31: "isub", 0x32: "iaddi", 0x34: "iand", 0x35: "ior"}.get(f)
            if n is None:
                return Lo("?lo40_%02X" % f, w)
            l = Lo(n, w)
            if n == "iaddi":
                imm = (w >> 6) & 31
                l.imm = imm - 32 if imm & 16 else imm
            return l
        op2 = ((w >> 6) & 31) << 2 | (w & 3)
        n = _LOWER_S2.get(op2)
        if n is None:
            return Lo("?lo2_%02X" % op2, w)
        return Lo(n, w)
    n = _LOWER.get(op)
    if n is None:
        return Lo("?lo%02X" % op, w)
    l = Lo(n, w)
    if n in ("lq", "sq", "ilw", "isw", "b", "bal", "ibeq", "ibne", "ibltz", "ibgtz", "iblez", "ibgez"):
        l.imm = s11(w)
    elif n in ("iaddiu", "isubiu"):
        l.imm = ((w >> 10) & 0x7800) | (w & 0x7FF)
    elif n in ("fceq", "fcset", "fcand", "fcor"):
        l.imm = w & 0xFFFFFF
    elif n in ("fseq", "fsset", "fsand", "fsor"):
        l.imm = ((w >> 10) & 0x800) | (w & 0x7FF)
    return l


def decode_pair(lo, hi):
    """returns (upper, lower or None, flags dict, i_imm or None)"""
    up = decode_upper(hi)
    fl = {"I": (hi >> 31) & 1, "E": (hi >> 30) & 1, "M": (hi >> 29) & 1, "D": (hi >> 28) & 1, "T": (hi >> 27) & 1}
    if fl["I"]:
        return up, None, fl, lo
    return up, decode_lower(lo), fl, None