miasm2.arch.sh4.arch module

Show source ≡

#-*- coding:utf-8 -*-

from pyparsing import *
from miasm2.core.cpu import *
from miasm2.expression.expression import *
from collections import defaultdict
import miasm2.arch.sh4.regs as regs_module
from miasm2.arch.sh4.regs import *


from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp

jra = ExprId('jra', 32)
jrb = ExprId('jrb', 32)
jrc = ExprId('jrc', 32)


# parser helper ###########
PLUS = Suppress("+")
MULT = Suppress("*")
MINUS = Suppress("-")
AND = Suppress("&")
LBRACK = Suppress("[")
RBRACK = Suppress("]")
DEREF = Suppress("@")
COMMA = Suppress(",")
LPARENT = Suppress("(")
RPARENT = Suppress(")")


def cb_deref_pcimm(tokens):
    return tokens[0] + tokens[1]


def cb_pcandimmimm(tokens):
    return (tokens[0] & tokens[1]) + tokens[2]



ref_pc = (LPARENT + reg_info_pc.parser + COMMA + base_expr + RPARENT).setParseAction(cb_deref_pcimm)
ref_pcandimm = (LPARENT + reg_info_pc.parser + AND + base_expr + COMMA + base_expr + RPARENT).setParseAction(cb_pcandimmimm)
pcdisp = (reg_info_pc.parser + AND + base_expr + PLUS + base_expr).setParseAction(cb_pcandimmimm)

PTR = Suppress('PTR')


def cb_deref_mem(tokens):
    assert len(tokens) == 1
    result = AstMem(tokens[0], 32)
    return result


def cb_predec(tokens):
    assert len(tokens) == 1
    result = AstMem(AstOp('predec', tokens[0]), 32)
    return result


def cb_postinc(tokens):
    assert len(tokens) == 1
    result = AstMem(AstOp('postinc', tokens[0]), 32)
    return result


def cb_regdisp(tokens):
    assert len(tokens) == 2
    result = AstMem(tokens[0] + tokens[1], 32)
    return result


def cb_regreg(tokens):
    assert len(tokens) == 2
    result = AstMem(tokens[0] + tokens[1], 32)
    return result


deref_pc = (DEREF + ref_pc).setParseAction(cb_deref_mem)
deref_pcimm = (DEREF + ref_pcandimm).setParseAction(cb_deref_mem)

dgpregs_base = (DEREF + gpregs.parser).setParseAction(cb_deref_mem)
dgpregs_predec = (DEREF + MINUS + gpregs.parser).setParseAction(cb_predec)
dgpregs_postinc = (DEREF + gpregs.parser + PLUS).setParseAction(cb_postinc)

dgpregs = dgpregs_base | dgpregs_predec | dgpregs_postinc

d_gpreg_gpreg = (DEREF + LPARENT + gpregs.parser + COMMA + gpregs.parser + RPARENT).setParseAction(cb_regdisp)
dgpregs_p = dgpregs_predec | dgpregs_postinc


dgpregs_ir = (DEREF + LPARENT + gpregs.parser + COMMA + base_expr + RPARENT).setParseAction(cb_regdisp)
dgpregs_ir |= d_gpreg_gpreg

dgbr_imm = (DEREF + LPARENT + reg_info_gbr.parser + COMMA + base_expr + RPARENT).setParseAction(cb_regdisp)

dgbr_reg = (DEREF + LPARENT + reg_info_gbr.parser + COMMA + gpregs.parser + RPARENT).setParseAction(cb_regreg)


class sh4_arg(m_arg):
    def asm_ast_to_expr(self, arg, loc_db):
        if isinstance(arg, AstId):
            if isinstance(arg.name, ExprId):
                return arg.name
            if arg.name in gpregs.str:
                return None
            loc_key = loc_db.get_or_create_name_location(arg.name)
            return ExprLoc(loc_key, 32)
        if isinstance(arg, AstOp):
            args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
            if None in args:
                return None
            return ExprOp(arg.op, *args)
        if isinstance(arg, AstInt):
            return ExprInt(arg.value, 32)
        if isinstance(arg, AstMem):
            ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
            if ptr is None:
                return None
            return ExprMem(ptr, arg.size)
        return None


_, bs_pr = gen_reg_bs('PR', reg_info_pr, (m_reg, sh4_arg,))
_, bs_r0 = gen_reg_bs('R0', reg_info_r0, (m_reg, sh4_arg,))
_, bs_sr = gen_reg_bs('SR', reg_info_sr, (m_reg, sh4_arg,))
_, bs_gbr = gen_reg_bs('GBR', reg_info_gbr, (m_reg, sh4_arg,))
_, bs_vbr = gen_reg_bs('VBR', reg_info_vbr, (m_reg, sh4_arg,))
_, bs_ssr = gen_reg_bs('SSR', reg_info_ssr, (m_reg, sh4_arg,))
_, bs_spc = gen_reg_bs('SPC', reg_info_spc, (m_reg, sh4_arg,))
_, bs_sgr = gen_reg_bs('SGR', reg_info_sgr, (m_reg, sh4_arg,))
_, bs_dbr = gen_reg_bs('dbr', reg_info_dbr, (m_reg, sh4_arg,))
_, bs_mach = gen_reg_bs('mach', reg_info_mach, (m_reg, sh4_arg,))
_, bs_macl = gen_reg_bs('macl', reg_info_macl, (m_reg, sh4_arg,))
_, bs_fpul = gen_reg_bs('fpul', reg_info_fpul, (m_reg, sh4_arg,))
_, bs_fr0 = gen_reg_bs('fr0', reg_info_fr0, (m_reg, sh4_arg,))

class sh4_reg(reg_noarg, sh4_arg):
    pass


class sh4_gpreg(sh4_reg):
    reg_info = gpregs
    parser = reg_info.parser


class sh4_dr(sh4_reg):
    reg_info = dregs
    parser = reg_info.parser


class sh4_bgpreg(sh4_reg):
    reg_info = bgpregs
    parser = reg_info.parser


class sh4_gpreg_noarg(reg_noarg, ):
    reg_info = gpregs
    parser = reg_info.parser


class sh4_freg(sh4_reg):
    reg_info = fregs
    parser = reg_info.parser


class sh4_dgpreg(sh4_arg):
    parser = dgpregs_base

    def fromstring(self, text, loc_db, parser_result=None):
        start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
        if start is None or self.expr == [None]:
            return start, stop
        self.expr = ExprMem(self.expr.arg, self.sz)
        return start, stop

    def decode(self, v):
        r = gpregs.expr[v]
        self.expr = ExprMem(r, self.sz)
        return True

    def encode(self):
        e = self.expr
        if not isinstance(e, ExprMem):
            return False
        if not isinstance(e.arg, ExprId):
            return False
        v = gpregs.expr.index(e.arg)
        self.value = v
        return True


class sh4_dgpregpinc(sh4_arg):
    parser = dgpregs_p

    def fromstring(self, text, loc_db, parser_result=None):
        start, stop = super(sh4_dgpregpinc, self).fromstring(text, loc_db, parser_result)
        if self.expr == [None]:
            return None, None
        if not isinstance(self.expr.arg, ExprOp):
            return None, None
        if self.expr.arg.op != self.op:
            return None, None
        return start, stop

    def decode(self, v):
        r = gpregs.expr[v]
        e = ExprOp(self.op, r)
        self.expr = ExprMem(e, self.sz)
        return True

    def encode(self):
        e = self.expr
        if not isinstance(e, ExprMem):
            return False
        e = e.arg
        res = match_expr(e, ExprOp(self.op, jra), [jra])
        if not res:
            return False
        r = res[jra]
        if not r in gpregs.expr:
            return False
        v = gpregs.expr.index(r)
        self.value = v
        return True


class sh4_dgpregpdec(sh4_arg):
    parser = dgpregs_postinc
    op = "preinc"


class sh4_dgpreg_imm(sh4_dgpreg):
    parser = dgpregs_ir

    def decode(self, v):
        p = self.parent
        r = gpregs.expr[v]
        s = self.sz
        d = ExprInt(p.disp.value * s / 8, 32)
        e = ExprMem(r + d, s)
        self.expr = e
        return True

    def encode(self):
        e = self.expr
        p = self.parent
        s = self.sz
        if not isinstance(e, ExprMem):
            return False
        if isinstance(e.arg, ExprId):
            v = gpregs.expr.index(e.arg)
            p.disp.value = 0
        elif isinstance(e.arg, ExprOp):
            res = match_expr(e, ExprMem(jra + jrb, self.sz), [jra, jrb])
            if not res:
                return False
            if not isinstance(res[jra], ExprId):
                return False
            if not isinstance(res[jrb], ExprInt):
                return False
            d = int(res[jrb])
            p.disp.value = d / (s / 8)
            if not res[jra] in gpregs.expr:
                return False
            v = gpregs.expr.index(res[jra])
        else:
            return False
        self.value = v
        return True


class sh4_imm(imm_noarg, sh4_arg):
    parser = base_expr
    pass


class sh4_simm(sh4_imm):
    parser = base_expr

    def decode(self, v):
        v = sign_ext(v, self.l, 32)
        v = self.decodeval(v)
        self.expr = ExprInt(v, 32)
        return True

    def encode(self):
        if not isinstance(self.expr, ExprInt):
            return False
        v = int(self.expr)
        if (1 << (self.l - 1)) & v:
            v = -((0xffffffff ^ v) + 1)
        v = self.encodeval(v)
        self.value = (v & 0xffffffff) & self.lmask
        return True


class sh4_dpc16imm(sh4_dgpreg):
    parser = deref_pc

    def decode(self, v):
        self.expr = ExprMem(PC + ExprInt(v * 2 + 4, 32), 16)
        return True

    def calcdisp(self, v):
        v = (int(v) - 4) / 2
        if not 0 < v <= 0xff:
            return None
        return v

    def encode(self):
        res = match_expr(self.expr, ExprMem(PC + jra, 16), [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        v = self.calcdisp(res[jra])
        if v is None:
            return False
        self.value = v
        return True


class sh4_dgbrimm8(sh4_dgpreg):
    parser = dgbr_imm

    def decode(self, v):
        s = self.sz
        self.expr = ExprMem(GBR + ExprInt(v * s / 8, 32), s)
        return True

    def encode(self):
        e = self.expr
        s = self.sz
        if e == ExprMem(GBR, 32):
            self.value = 0
            return True
        res = match_expr(self.expr, ExprMem(GBR + jra, s), [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        self.value = int(res[jra]) / (s / 8)
        return True


class sh4_dpc32imm(sh4_dpc16imm):
    parser = deref_pcimm

    def decode(self, v):
        self.expr = ExprMem(
            (PC & ExprInt(0xfffffffc, 32)) + ExprInt(v * 4 + 4, 32), 32)
        return True

    def calcdisp(self, v):
        v = (int(v) - 4) / 4
        if not 0 < v <= 0xff:
            return None
        return v

    def encode(self):
        res = match_expr(
            self.expr, ExprMem((PC & ExprInt(0xFFFFFFFC, 32)) + jra, 32), [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        v = self.calcdisp(res[jra])
        if v is None:
            return False
        self.value = v
        return True


class sh4_pc32imm(sh4_arg):
    parser = pcdisp

    def decode(self, v):
        self.expr = (PC & ExprInt(0xfffffffc, 32)) + ExprInt(v * 4 + 4, 32)
        return True

    def encode(self):
        res = match_expr(self.expr, (PC & ExprInt(0xfffffffc, 32)) + jra, [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        v = (int(res[jra]) - 4) / 4
        if v is None:
            return False
        self.value = v
        return True

class additional_info:

    def __init__(self):
        self.except_on_instr = False


class instruction_sh4(instruction):
    __slots__ = []
    delayslot = 0

    def __init__(self, *args, **kargs):
        super(instruction_sh4, self).__init__(*args, **kargs)

    def dstflow(self):
        return self.name.startswith('J')

    @staticmethod
    def arg2str(expr, index=None, loc_db=None):
        if isinstance(expr, ExprId) or isinstance(expr, ExprInt):
            return str(expr)
        elif expr.is_loc():
            if loc_db is not None:
                return loc_db.pretty_str(expr.loc_key)
            else:
                return str(expr)
        assert(isinstance(expr, ExprMem))
        expr = expr.arg

        if isinstance(expr, ExprOp):
            if expr.op == "predec":
                s = '-%s' % expr.args[0]
            elif expr.op == "postinc":
                s = '%s+' % expr.args[0]
            else:
                s = ','.join([str(x).replace('(', '').replace(')', '')
                              for x in expr.args])
                s = "(%s)"%s
            s = "@%s" % s
        elif isinstance(expr, ExprId):
            s = "@%s" % expr
        else:
            raise NotImplementedError('zarb arg2str')
        return s


    """
    def dstflow2label(self, loc_db):
        e = self.args[0]
        if not isinstance(e, ExprInt):
            return
        if self.name == 'BLX':
            ad = e.arg+8+self.offset
        else:
            ad = e.arg+8+self.offset
        l = loc_db.get_or_create_offset_location(ad)
        s = ExprId(l, e.size)
        self.args[0] = s
    """

    def breakflow(self):
        if self.name.startswith('J'):
            return True
        return False

    def is_subcall(self):
        return self.name == 'JSR'

    def getdstflow(self, loc_db):
        return [self.args[0]]

    def splitflow(self):
        return self.name == 'JSR'

    def get_symbol_size(self, symbol, loc_db):
        return 32

    def fixDstOffset(self):
        e = self.args[0]
        if self.offset is None:
            raise ValueError('symbol not resolved %s' % l)
        if not isinstance(e, ExprInt):
            log.debug('dyn dst %r', e)
            return
        off = e.arg - (self.offset + 4 + self.l)
        print hex(off)
        if int(off % 4):
            raise ValueError('strange offset! %r' % off)
        self.args[0] = ExprInt(off, 32)
        print 'final', self.args[0]

    def get_args_expr(self):
        args = [a for a in self.args]
        return args


class mn_sh4(cls_mn):
    bintree = {}
    regs = regs_module
    num = 0
    all_mn = []
    all_mn_mode = defaultdict(list)
    all_mn_name = defaultdict(list)
    all_mn_inst = defaultdict(list)
    pc = PC
    # delayslot:
    # http://resource.renesas.com/lib/eng/e_learnig/sh4/13/index.html
    delayslot = 0  # unit is instruction instruction
    instruction = instruction_sh4

    def additional_info(self):
        info = additional_info()
        return info

    @classmethod
    def getbits(cls, bs, attrib, start, n):
        if not n:
            return 0
        o = 0
        if n > bs.getlen() * 8:
            raise ValueError('not enought bits %r %r' % (n, len(bs.bin) * 8))
        while n:
            i = start / 8
            c = cls.getbytes(bs, i)
            if not c:
                raise IOError
            c = ord(c)
            r = 8 - start % 8
            c &= (1 << r) - 1
            l = min(r, n)
            c >>= (r - l)
            o <<= l
            o |= c
            n -= l
            start += l
        return o

    @classmethod
    def getbytes(cls, bs, offset, l=1):
        out = ""
        for _ in xrange(l):
            n_offset = (offset & ~1) + 1 - offset % 2
            out += bs.getbytes(n_offset, 1)
            offset += 1
        return out

    @classmethod
    def check_mnemo(cls, fields):
        l = sum([x.l for x in fields])
        assert l == 16, "len %r" % l

    @classmethod
    def getmn(cls, name):
        return name.upper().replace('_', '.')

    @classmethod
    def gen_modes(cls, subcls, name, bases, dct, fields):
        dct['mode'] = None
        return [(subcls, name, bases, dct, fields)]

    def value(self, mode):
        v = super(mn_sh4, self).value(mode)
        return [x[::-1] for x in v]


class bs_dr0gbr(sh4_dgpreg):
    parser = dgbr_reg

    def decode(self, v):
        self.expr = ExprMem(GBR + R0, 8)
        return True

    def encode(self):
        return self.expr == ExprMem(GBR + R0, 8)


class bs_dr0gp(sh4_dgpreg):
    parser = d_gpreg_gpreg

    def decode(self, v):
        self.expr = ExprMem(gpregs.expr[v] + R0, self.sz)
        return True

    def encode(self):
        res = match_expr(self.expr, ExprMem(R0 + jra, self.sz), [jra])
        if not res:
            return False
        r = res[jra]
        if not r in gpregs.expr:
            return False
        self.value = gpregs.expr.index(r)
        return True


class bs_dgpreg(sh4_dgpreg):
    parser = dgpregs_base


rn = bs(l=4, cls=(sh4_gpreg,), fname="rn")
rm = bs(l=4, cls=(sh4_gpreg,), fname="rm")


d08_rn = bs(l=4, cls=(sh4_dgpreg,), fname="rn", sz = 8)
d16_rn = bs(l=4, cls=(sh4_dgpreg,), fname="rn", sz = 16)
d32_rn = bs(l=4, cls=(sh4_dgpreg,), fname="rn", sz = 32)
d08_rm = bs(l=4, cls=(sh4_dgpreg,), fname="rm", sz = 8)
d16_rm = bs(l=4, cls=(sh4_dgpreg,), fname="rm", sz = 16)
d32_rm = bs(l=4, cls=(sh4_dgpreg,), fname="rm", sz = 32)


brm = bs(l=3, cls=(sh4_bgpreg,), fname="brm")
brn = bs(l=3, cls=(sh4_bgpreg,), fname="brn")

d08rnimm = bs(l=4, fname="rn", cls=(sh4_dgpreg_imm,), sz = 8)
d16rnimm = bs(l=4, fname="rn", cls=(sh4_dgpreg_imm,), sz = 16)
d32rnimm = bs(l=4, fname="rn", cls=(sh4_dgpreg_imm,), sz = 32)

d08rmimm = bs(l=4, fname="rm", cls=(sh4_dgpreg_imm,), sz = 8)
d16rmimm = bs(l=4, fname="rm", cls=(sh4_dgpreg_imm,), sz = 16)
d32rmimm = bs(l=4, fname="rm", cls=(sh4_dgpreg_imm,), sz = 32)

btype = bs(l=4, fname="btype", order=-1)

s08imm = bs(l=8, cls=(sh4_simm,), fname="imm")
s12imm = bs(l=12, cls=(sh4_simm,), fname="imm")
dpc16imm = bs(l=8, cls=(sh4_dpc16imm,), fname="pcimm", sz=16)
dpc32imm = bs(l=8, cls=(sh4_dpc32imm,), fname="pcimm", sz=32)
dimm4 = bs(l=4, fname='disp', order=-1)
d08gbrimm8 = bs(l=8, cls=(sh4_dgbrimm8,), fname='disp', sz=8)
d16gbrimm8 = bs(l=8, cls=(sh4_dgbrimm8,), fname='disp', sz=16)
d32gbrimm8 = bs(l=8, cls=(sh4_dgbrimm8,), fname='disp', sz=32)

pc32imm = bs(l=8, cls=(sh4_pc32imm,), fname="pcimm")

d08rnpinc = bs(l=4, cls=(sh4_dgpregpinc,), op='postinc', sz=8, fname="rn")
d08rmpinc = bs(l=4, cls=(sh4_dgpregpinc,), op='postinc', sz=8, fname="rm")

d16rnpinc = bs(l=4, cls=(sh4_dgpregpinc,), op='postinc', sz=16, fname="rn")
d16rmpinc = bs(l=4, cls=(sh4_dgpregpinc,), op='postinc', sz=16, fname="rm")

d32rnpinc = bs(l=4, cls=(sh4_dgpregpinc,), op='postinc', sz=32, fname="rn")
d32rmpinc = bs(l=4, cls=(sh4_dgpregpinc,), op='postinc', sz=32, fname="rm")

d08rnpdec = bs(l=4, cls=(sh4_dgpregpinc,), op='predec', sz=8, fname="rn")
d08rmpdec = bs(l=4, cls=(sh4_dgpregpinc,), op='predec', sz=8, fname="rm")

d16rnpdec = bs(l=4, cls=(sh4_dgpregpinc,), op='predec', sz=16, fname="rn")
d16rmpdec = bs(l=4, cls=(sh4_dgpregpinc,), op='predec', sz=16, fname="rm")

d32rnpdec = bs(l=4, cls=(sh4_dgpregpinc,), op='predec', sz=32, fname="rn")
d32rmpdec = bs(l=4, cls=(sh4_dgpregpinc,), op='predec', sz=32, fname="rm")


u08imm = bs(l=8, cls=(sh4_imm,), fname="imm")
dr0gbr = bs(l=0, cls=(bs_dr0gbr,), sz=8)

d08gpreg = bs(l=4, cls=(bs_dgpreg,), sz=8)
d32gpreg = bs(l=4, cls=(bs_dgpreg,), sz=32)

frn = bs(l=4, cls=(sh4_freg,), fname="frn")
frm = bs(l=4, cls=(sh4_freg,), fname="frm")

bd08r0gp = bs(l=4, cls=(bs_dr0gp,), sz=8)
bd16r0gp = bs(l=4, cls=(bs_dr0gp,), sz=16)
bd32r0gp = bs(l=4, cls=(bs_dr0gp,), sz=32)

drn = bs(l=3, cls=(sh4_dr,), fname="drn")
drm = bs(l=3, cls=(sh4_dr,), fname="drm")


def addop(name, fields, args=None, alias=False):
    dct = {"fields": fields}
    dct["alias"] = alias
    if args is not None:
        dct['args'] = args
    type(name, (mn_sh4,), dct)

addop("mov", [bs('1110'), rn, s08imm], [s08imm, rn])
addop("mov_w", [bs('1001'), rn, dpc16imm], [dpc16imm, rn])
addop("mov_l", [bs('1101'), rn, dpc32imm], [dpc32imm, rn])
addop("mov", [bs('0110', fname="opc"), rn, rm, bs('0011')], [rm, rn])
addop("mov_b", [bs('0010', fname="opc"), d08_rn, rm, bs('0000')], [rm, d08_rn])
addop("mov_w", [bs('0010', fname="opc"), d16_rn, rm, bs('0001')], [rm, d16_rn])
addop("mov_l", [bs('0010', fname="opc"), d32_rn, rm, bs('0010')], [rm, d32_rn])
addop("mov_b", [bs('0110', fname="opc"), rn, d08_rm, bs('0000')], [d08_rm, rn])
addop("mov_w", [bs('0110', fname="opc"), rn, d16_rm, bs('0001')], [d16_rm, rn])
addop("mov_l", [bs('0110', fname="opc"), rn, d32_rm, bs('0010')], [d32_rm, rn])
addop("mov_b",
      [bs('0010', fname="opc"), d08rnpdec, rm, bs('0100')], [rm, d08rnpdec])
addop("mov_w",
      [bs('0010', fname="opc"), d16rnpdec, rm, bs('0101')], [rm, d16rnpdec])
addop("mov_l",
      [bs('0010', fname="opc"), d32rnpdec, rm, bs('0110')], [rm, d32rnpdec])
addop("mov_b",
      [bs('0110', fname="opc"), rn, d08rmpinc, bs('0100')], [rm, d08rnpinc])
addop("mov_w",
      [bs('0110', fname="opc"), rn, d16rmpinc, bs('0101')], [d16rmpinc, rn])
addop("mov_l",
      [bs('0110', fname="opc"), rn, d32rmpinc, bs('0110')], [d32rmpinc, rn])
addop("mov_b", [bs('10000000', fname='opc'), bs_r0, d08rnimm, dimm4])
addop("mov_w", [bs('10000001', fname='opc'), bs_r0, d16rnimm, dimm4])
addop("mov_l", [bs('0001', fname='opc'), d32rnimm, rm, dimm4], [rm, d32rnimm])
addop("mov_b", [bs('10000100', fname='opc'), d08rmimm, dimm4, bs_r0])
addop("mov_w", [bs('10000101', fname='opc'), d16rmimm, dimm4, bs_r0])
addop("mov_l", [bs('0101', fname='opc'), rn, d32rmimm, dimm4], [d32rmimm, rn])
addop("mov_b",
      [bs('0000', fname='opc'), bd08r0gp, rm, bs('0100')], [rm, bd08r0gp])
addop("mov_w",
      [bs('0000', fname='opc'), bd16r0gp, rm, bs('0101')], [rm, bd16r0gp])
addop("mov_l",
      [bs('0000', fname='opc'), bd32r0gp, rm, bs('0110')], [rm, bd32r0gp])
addop("mov_b",
      [bs('0000', fname='opc'), rn, bd08r0gp, bs('1100')], [bd08r0gp, rn])
addop("mov_w",
      [bs('0000', fname='opc'), rn, bd16r0gp, bs('1101')], [bd16r0gp, rn])
addop("mov_l",
      [bs('0000', fname='opc'), rn, bd32r0gp, bs('1110')], [bd32r0gp, rn])

addop("mov_b", [bs('11000000'), bs_r0, d08gbrimm8])
addop("mov_w", [bs('11000001'), bs_r0, d16gbrimm8])
addop("mov_l", [bs('11000010'), bs_r0, d32gbrimm8])

addop("mov_b", [bs('11000100'), d08gbrimm8, bs_r0])
addop("mov_w", [bs('11000101'), d16gbrimm8, bs_r0])
addop("mov_l", [bs('11000110'), d32gbrimm8, bs_r0])

addop("mov", [bs('11000111'), pc32imm, bs_r0])

addop("swapb", [bs('0110'), rn, rm, bs('1000')], [rm, rn])
addop("swapw", [bs('0110'), rn, rm, bs('1001')], [rm, rn])
addop("xtrct", [bs('0010'), rn, rm, bs('1101')], [rm, rn])


addop("add", [bs('0011'), rn, rm, bs('1100')], [rm, rn])
addop("add", [bs('0111'), rn, s08imm], [s08imm, rn])
addop("addc", [bs('0011'), rn, rm, bs('1110')], [rm, rn])
addop("addv", [bs('0011'), rn, rm, bs('1111')], [rm, rn])


addop("cmpeq", [bs('10001000'), s08imm, bs_r0])


addop("cmpeq", [bs('0011'), rn, rm, bs('0000')], [rm, rn])
addop("cmphs", [bs('0011'), rn, rm, bs('0010')], [rm, rn])
addop("cmpge", [bs('0011'), rn, rm, bs('0011')], [rm, rn])
addop("cmphi", [bs('0011'), rn, rm, bs('0110')], [rm, rn])
addop("cmpgt", [bs('0011'), rn, rm, bs('0111')], [rm, rn])


addop("cmppz", [bs('0100'), rn, bs('00010001')])
addop("cmppl", [bs('0100'), rn, bs('00010101')])
addop("cmpstr", [bs('0010'), rn, rm, bs('1100')], [rm, rn])


addop("div1", [bs('0011'), rn, rm, bs('0100')], [rm, rn])

addop("div0s", [bs('0010'), rn, rm, bs('0111')], [rm, rn])
addop("div0u", [bs('0000000000011001')])

addop("dmuls", [bs('0011'), rn, rm, bs('1101')], [rm, rn])
addop("dmulu", [bs('0011'), rn, rm, bs('0101')], [rm, rn])

addop("dt", [bs('0100'), rn, bs('00010000')])


addop("extsb", [bs('0110'), rn, rm, bs('1110')], [rm, rn])
addop("extsw", [bs('0110'), rn, rm, bs('1111')], [rm, rn])
addop("extub", [bs('0110'), rn, rm, bs('1100')], [rm, rn])
addop("extuw", [bs('0110'), rn, rm, bs('1101')], [rm, rn])

addop("mac_l", [bs('0000', fname='opc'), d32rnpinc,
      d32rmpinc, bs('1111')], [d32rmpinc, d32rnpinc])
addop("mac_w", [bs('0100', fname='opc'), d16rnpinc,
      d16rmpinc, bs('1111')], [d16rmpinc, d16rnpinc])

addop("mull", [bs('0000'), rn, rm, bs('0111')], [rm, rn])
addop("mulsw", [bs('0010'), rn, rm, bs('1111')], [rm, rn])
addop("muluw", [bs('0010'), rn, rm, bs('1110')], [rm, rn])

addop("neg", [bs('0110'), rn, rm, bs('1011')], [rm, rn])
addop("negc", [bs('0110'), rn, rm, bs('1010')], [rm, rn])

addop("sub", [bs('0011'), rn, rm, bs('1000')], [rm, rn])
addop("subc", [bs('0011'), rn, rm, bs('1010')], [rm, rn])
addop("subv", [bs('0011'), rn, rm, bs('1011')], [rm, rn])

addop("and", [bs('0010'), rn, rm, bs('1001')], [rm, rn])
addop("and", [bs('11001001'), u08imm, bs_r0])
addop("and_b", [bs('11001101'), u08imm, dr0gbr])

addop("not", [bs('0110'), rn, rm, bs('0111')], [rm, rn])

addop("or", [bs('0010'), rn, rm, bs('1011')], [rm, rn])

addop("or", [bs('11001011'), u08imm, bs_r0])
addop("or_b", [bs('11001111'), u08imm, dr0gbr])

addop("tas_b", [bs('0100'), d08gpreg, bs('00011011')])
addop("tst", [bs('0010'), rn, rm, bs('1000')], [rm, rn])
addop("tst", [bs('11001000'), u08imm, bs_r0])
addop("tst_b", [bs('11001100'), u08imm, dr0gbr])


addop("xor", [bs('0010'), rn, rm, bs('1010')], [rm, rn])
addop("xor", [bs('11001010'), u08imm, bs_r0])
addop("xor_b", [bs('11001110'), u08imm, dr0gbr])

addop("rotl", [bs('0100'), rn, bs('00000100')])
addop("rotr", [bs('0100'), rn, bs('00000101')])
addop("rotcl", [bs('0100'), rn, bs('00100100')])
addop("rotcr", [bs('0100'), rn, bs('00100101')])

addop("shad", [bs('0100'), rn, rm, bs('1100')], [rm, rn])
addop("shal", [bs('0100'), rn, bs('00100000')])
addop("shar", [bs('0100'), rn, bs('00100001')])
addop("shld", [bs('0100'), rn, rm, bs('1101')], [rm, rn])

addop("shll", [bs('0100'), rn, bs('00000000')])
addop("shlr", [bs('0100'), rn, bs('00000001')])
addop("shll2", [bs('0100'), rn, bs('00001000')])
addop("shlr2", [bs('0100'), rn, bs('00001001')])
addop("shll8", [bs('0100'), rn, bs('00011000')])
addop("shlr8", [bs('0100'), rn, bs('00011001')])
addop("shll16", [bs('0100'), rn, bs('00101000')])
addop("shlr16", [bs('0100'), rn, bs('00101001')])


addop("bf", [bs('10001011'), s08imm])
"""
    def splitflow(self):
        return True
    def breakflow(self):
        return True
    def dstflow(self):
        return True
    def dstflow2label(self, loc_db):
        e = self.args[0].expr
        ad = e.arg*2+4+self.offset
        l = loc_db.get_or_create_offset_location(ad)
        s = ExprId(l, e.size)
        self.args[0].expr = s
"""

addop("bfs", [bs('10001111'), s08imm])
"""
    delayslot = 1
"""
addop("bt", [bs('10001001'), s08imm])

addop("bts", [bs('10001101'), s08imm])

addop("bra", [bs('1010'), s12imm])
"""
    delayslot = 1
    def breakflow(self):
        return True
    def dstflow(self):
        return True
    def dstflow2label(self, loc_db):
        e = self.args[0].expr
        ad = e.arg*2+4+self.offset
        l = loc_db.get_or_create_offset_location(ad)
        s = ExprId(l, e.size)
        self.args[0].expr = s
"""

addop("braf", [bs('0000'), rn, bs('00100011')])
"""
    delayslot = 1
    def breakflow(self):
        return True
    def dstflow(self):
        return True
"""
addop("bsr", [bs('1011'), s12imm])

addop("bsrf", [bs('0000'), rn, bs('00000011')])
"""
    delayslot = 1
    def breakflow(self):
        return True
    def is_subcall(self):
        return True
    def splitflow(self):
        return True
"""

addop("jmp_l", [bs('0100'), d32gpreg, bs('00101011')])
"""
    delayslot = 1
    def breakflow(self):
        return True
"""

addop("jsr_l", [bs('0100'), d32gpreg, bs('00001011')])
"""
    delayslot = 1
    def breakflow(self):
        return True
    def is_subcall(self):
        return True
    def splitflow(self):
        return True
"""

addop("rts", [bs('0000000000001011')])
"""
    delayslot = 1
    def breakflow(self):
        return True
"""
addop("clrmac", [bs('0000000000101000')])
addop("clrs", [bs('0000000001001000')])
addop("clrt", [bs('0000000000001000')])


addop("ldc", [bs('0100'), rm, bs_sr, bs('00001110')])
addop("ldc", [bs('0100'), rm, bs_gbr, bs('00011110')])
addop("ldc", [bs('0100'), rm, bs_vbr, bs('00101110')])
addop("ldc", [bs('0100'), rm, bs_ssr, bs('00111110')])
addop("ldc", [bs('0100'), rm, bs_spc, bs('01001110')])
addop("ldc", [bs('0100'), rm, bs_dbr, bs('11111010')])
addop("ldc", [bs('0100'), rm, bs('1'), brn, bs('1110')], [rm, brn])
addop("ldc_l", [bs('0100'), d32rmpinc, bs_sr,  bs('00000111')])
addop("ldc_l", [bs('0100'), d32rmpinc, bs_gbr, bs('00010111')])
addop("ldc_l", [bs('0100'), d32rmpinc, bs_vbr, bs('00100111')])
addop("ldc_l", [bs('0100'), d32rmpinc, bs_ssr, bs('00110111')])
addop("ldc_l", [bs('0100'), d32rmpinc, bs_spc, bs('01000111')])
addop("ldc_l", [bs('0100'), d32rmpinc, bs_dbr, bs('11110110')])
addop("ldc_l", [bs('0100'), d32rmpinc, bs('1'), brn, bs('0111')])
addop("lds", [bs('0100'), rm, bs_mach, bs('00001010')])
addop("lds", [bs('0100'), rm, bs_macl, bs('00011010')])
addop("lds", [bs('0100'), rm, bs_pr, bs('00101010')])
addop("lds_l", [bs('0100'), d32rmpinc, bs_mach, bs('00000110')])
addop("lds_l", [bs('0100'), d32rmpinc, bs_macl, bs('00010110')])
addop("lds_l", [bs('0100'), d32rmpinc, bs_pr, bs('00100110')])
addop("ldtlb", [bs('0000000000111000')])

addop("movca_l", [bs('0000'), bs_r0, d32gpreg, bs('11000011')])
addop("nop", [bs('0000000000001001')])
addop("ocbi_l", [bs('0000'), d32gpreg, bs('10010011')])
addop("ocbp_l", [bs('0000'), d32gpreg, bs('10100011')])
addop("ocbwb_l", [bs('0000'), d32gpreg, bs('10110011')])
addop("pref_l", [bs('0000'), d32gpreg, bs('10000011')])


addop("rte", [bs('0000000000101011')])
addop("sets", [bs('0000000001011000')])
addop("sett", [bs('0000000000011000')])
addop("sleep", [bs('0000000000011011')])
addop("stc", [bs('0000'), bs_sr,  rn, bs('00000010')])
addop("stc", [bs('0000'), bs_gbr, rn, bs('00010010')])
addop("stc", [bs('0000'), bs_vbr, rn, bs('00100010')])
addop("stc", [bs('0000'), bs_ssr, rn, bs('00110010')])
addop("stc", [bs('0000'), bs_spc, rn, bs('01000010')])
addop("stc", [bs('0000'), bs_sgr, rn, bs('00111010')])
addop("stc", [bs('0000'), bs_dbr, rn, bs('11111010')])
addop("stc", [bs('0000'), rn, bs('1'), brm, bs('0010')], [brm, rn])

addop("stc_l", [bs('0100'), bs_sr, d32rmpdec,  bs('00000011')])
addop("stc_l", [bs('0100'), bs_gbr, d32rmpdec, bs('00010011')])
addop("stc_l", [bs('0100'), bs_vbr, d32rmpdec, bs('00100011')])
addop("stc_l", [bs('0100'), bs_ssr, d32rmpdec, bs('00110011')])
addop("stc_l", [bs('0100'), bs_spc, d32rmpdec, bs('01000011')])
addop("stc_l", [bs('0100'), bs_sgr, d32rmpdec, bs('00110010')])
addop("stc_l", [bs('0100'), bs_dbr, d32rmpdec, bs('11110010')])
addop("stc_l",
      [bs('0100'), d32rnpdec, bs('1'), brm, bs('0011')], [brm, d32rnpdec])

# float
addop("sts", [bs('0000'), bs_mach, rm, bs('00001010')])
addop("sts", [bs('0000'), bs_macl, rm, bs('00011010')])
addop("sts", [bs('0000'), bs_pr, rm, bs('00101010')])
addop("sts_l", [bs('0100'), bs_mach, d32rmpdec, bs('00000010')])
addop("sts_l", [bs('0100'), bs_macl, d32rmpdec, bs('00010010')])
addop("sts_l",
      [bs('0100'), d32rnpdec, bs_pr, bs('00100010')], [bs_pr, d32rnpdec])
addop("trapa", [bs('11000011'), u08imm])

addop("fldi0", [bs('1111'), frn, bs('10001101')])
addop("fldi1", [bs('1111'), frn, bs('10011101')])
addop("fmov", [bs('1111'), frn, frm, bs('1100')], [frm, frn])
addop("fmov_s", [bs('1111'), frn, d32gpreg, bs('1000')], [d32gpreg, frn])
addop("fmov_s", [bs('1111'), frn, bd32r0gp, bs('0110')], [bd32r0gp, frn])
addop("fmov_s", [bs('1111'), frn, d32rmpinc, bs('1001')], [d32rmpinc, frn])
addop("fmov_s", [bs('1111'), d32gpreg, frm, bs('1010')], [frm, d32gpreg])
addop("fmov_s", [bs('1111'), d32rnpdec, frm, bs('1011')], [frm, d32rnpdec])
addop("fmov_s", [bs('1111'), bd32r0gp, frm, bs('0111')], [frm, bd32r0gp])

addop("flds", [bs('1111'), frm, bs_fpul, bs('00011101')])
addop("fsts", [bs('1111'), bs_fpul, frm, bs('00001101')])
addop("fabs", [bs('1111'), frn, bs('01011101')])
addop("fadd", [bs('1111'), frn, frm, bs('0000')], [frm, frn])
addop("fcmpeq", [bs('1111'), frn, frm, bs('0100')], [frm, frn])
addop("fcmpgt", [bs('1111'), frn, frm, bs('0101')], [frm, frn])
addop("fdiv", [bs('1111'), frn, frm, bs('0011')], [frm, frn])

addop("float", [bs('1111'), bs_fpul, frn, bs('00101101')])
addop("fmac", [bs('1111'), bs_fr0, frn, frm, bs('1110')], [bs_fr0, frm, frn])
addop("fmul", [bs('1111'), frn, frm, bs('0010')], [frm, frn])
addop("fneg", [bs('1111'), frn, bs('01001101')])
addop("fsqrt", [bs('1111'), frn, bs('01101101')])
addop("fsub", [bs('1111'), frn, frm, bs('0001')], [frm, frn])
addop("ftrc", [bs('1111'), frm, bs_fpul, bs('00111101')])

Module variables

var AND

var COMMA

var DEREF

var EXPRAFF

var EXPRCOMPOSE

var EXPRCOND

var EXPRID

var EXPRINT

var EXPRLOC

var EXPRMEM

var EXPROP

var EXPRSLICE

var EXPR_ORDER_DICT

var LBRACK

var LPARENT

var MINUS

var MULT

var PLUS

var PRIORITY_MAX

var PTR

var RBRACK

var RPARENT

var TOK_EQUAL

var TOK_INF

var TOK_INF_EQUAL

var TOK_INF_EQUAL_SIGNED

var TOK_INF_EQUAL_UNSIGNED

var TOK_INF_SIGNED

var TOK_INF_UNSIGNED

var TOK_POS

var TOK_POS_STRICT

var all_regs_ids

var all_regs_ids_byname

var all_regs_ids_init

var all_regs_ids_no_alias

var alphanums

var alphas

var alphas8bit

var bd08r0gp

var bd16r0gp

var bd32r0gp

var bgpregs_expr

var bgpregs_str

var brm

var brn

var btype

var d08_rm

var d08_rn

var d08gbrimm8

var d08gpreg

var d08rmimm

var d08rmpdec

var d08rmpinc

var d08rnimm

var d08rnpdec

var d08rnpinc

var d16_rm

var d16_rn

var d16gbrimm8

var d16rmimm

var d16rmpdec

var d16rmpinc

var d16rnimm

var d16rnpdec

var d16rnpinc

var d32_rm

var d32_rn

var d32gbrimm8

var d32gpreg

var d32rmimm

var d32rmpdec

var d32rmpinc

var d32rnimm

var d32rnpdec

var d32rnpinc

var d_gpreg_gpreg

var default_prio

var deref_pc

var deref_pcimm

var dgbr_imm

var dgbr_reg

var dgpregs

var dgpregs_base

var dgpregs_ir

var dgpregs_p

var dgpregs_postinc

var dgpregs_predec

var dimm4

var dpc16imm

var dpc32imm

var dr0gbr

var dregs_expr

var dregs_str

var drm

var drn

var fregs_expr

var fregs_str

var frm

var frn

var gpregs_expr

var gpregs_str

var hexnums

var i

var jra

var jrb

var jrc

var mod_size2uint

var nums

var pc32imm

var pcdisp

var printables

var priorities

var priorities_list

var punc8bit

var ref_pc

var ref_pcandimm

var reg_cf

var reg_nf

var reg_of

var reg_zf

var regs_flt_expr

var regs_init

var rm

var rn

var s08imm

var s12imm

var size_to_IEEE754_info

var total_scans

var u08imm

Functions

def addop(

name, fields, args=None, alias=False)

Show source ≡

def addop(name, fields, args=None, alias=False):
    dct = {"fields": fields}
    dct["alias"] = alias
    if args is not None:
        dct['args'] = args
    type(name, (mn_sh4,), dct)

def cb_deref_mem(

tokens)

Show source ≡

def cb_deref_mem(tokens):
    assert len(tokens) == 1
    result = AstMem(tokens[0], 32)
    return result

def cb_deref_pcimm(

tokens)

Show source ≡

def cb_deref_pcimm(tokens):
    return tokens[0] + tokens[1]

def cb_pcandimmimm(

tokens)

Show source ≡

def cb_pcandimmimm(tokens):
    return (tokens[0] & tokens[1]) + tokens[2]

def cb_postinc(

tokens)

Show source ≡

def cb_postinc(tokens):
    assert len(tokens) == 1
    result = AstMem(AstOp('postinc', tokens[0]), 32)
    return result

def cb_predec(

tokens)

Show source ≡

def cb_predec(tokens):
    assert len(tokens) == 1
    result = AstMem(AstOp('predec', tokens[0]), 32)
    return result

def cb_regdisp(

tokens)

Show source ≡

def cb_regdisp(tokens):
    assert len(tokens) == 2
    result = AstMem(tokens[0] + tokens[1], 32)
    return result

def cb_regreg(

tokens)

Show source ≡

def cb_regreg(tokens):
    assert len(tokens) == 2
    result = AstMem(tokens[0] + tokens[1], 32)
    return result

Classes

class additional_info

Show source ≡

class additional_info:

    def __init__(self):
        self.except_on_instr = False

Ancestors (in MRO)

additional_info

Instance variables

var except_on_instr

Methods

def __init__(

self)

Show source ≡

def __init__(self):
    self.except_on_instr = False

class bs_dgpreg

Show source ≡

class bs_dgpreg(sh4_dgpreg):
    parser = dgpregs_base

Ancestors (in MRO)

bs_dgpreg
sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_dgpreg.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_dgpreg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Inheritance: sh4_dgpreg.decode

Show source ≡

def decode(self, v):
    r = gpregs.expr[v]
    self.expr = ExprMem(r, self.sz)
    return True

def encode(

self)

Inheritance: sh4_dgpreg.encode

Show source ≡

def encode(self):
    e = self.expr
    if not isinstance(e, ExprMem):
        return False
    if not isinstance(e.arg, ExprId):
        return False
    v = gpregs.expr.index(e.arg)
    self.value = v
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_dgpreg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class bs_dr0gbr

Show source ≡

class bs_dr0gbr(sh4_dgpreg):
    parser = dgbr_reg

    def decode(self, v):
        self.expr = ExprMem(GBR + R0, 8)
        return True

    def encode(self):
        return self.expr == ExprMem(GBR + R0, 8)

Ancestors (in MRO)

bs_dr0gbr
sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_dgpreg.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_dgpreg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Inheritance: sh4_dgpreg.decode

Show source ≡

def decode(self, v):
    self.expr = ExprMem(GBR + R0, 8)
    return True

def encode(

self)

Inheritance: sh4_dgpreg.encode

Show source ≡

def encode(self):
    return self.expr == ExprMem(GBR + R0, 8)

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_dgpreg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class bs_dr0gp

Show source ≡

class bs_dr0gp(sh4_dgpreg):
    parser = d_gpreg_gpreg

    def decode(self, v):
        self.expr = ExprMem(gpregs.expr[v] + R0, self.sz)
        return True

    def encode(self):
        res = match_expr(self.expr, ExprMem(R0 + jra, self.sz), [jra])
        if not res:
            return False
        r = res[jra]
        if not r in gpregs.expr:
            return False
        self.value = gpregs.expr.index(r)
        return True

Ancestors (in MRO)

bs_dr0gp
sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_dgpreg.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_dgpreg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Inheritance: sh4_dgpreg.decode

Show source ≡

def decode(self, v):
    self.expr = ExprMem(gpregs.expr[v] + R0, self.sz)
    return True

def encode(

self)

Inheritance: sh4_dgpreg.encode

Show source ≡

def encode(self):
    res = match_expr(self.expr, ExprMem(R0 + jra, self.sz), [jra])
    if not res:
        return False
    r = res[jra]
    if not r in gpregs.expr:
        return False
    self.value = gpregs.expr.index(r)
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_dgpreg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class instruction_sh4

Show source ≡

class instruction_sh4(instruction):
    __slots__ = []
    delayslot = 0

    def __init__(self, *args, **kargs):
        super(instruction_sh4, self).__init__(*args, **kargs)

    def dstflow(self):
        return self.name.startswith('J')

    @staticmethod
    def arg2str(expr, index=None, loc_db=None):
        if isinstance(expr, ExprId) or isinstance(expr, ExprInt):
            return str(expr)
        elif expr.is_loc():
            if loc_db is not None:
                return loc_db.pretty_str(expr.loc_key)
            else:
                return str(expr)
        assert(isinstance(expr, ExprMem))
        expr = expr.arg

        if isinstance(expr, ExprOp):
            if expr.op == "predec":
                s = '-%s' % expr.args[0]
            elif expr.op == "postinc":
                s = '%s+' % expr.args[0]
            else:
                s = ','.join([str(x).replace('(', '').replace(')', '')
                              for x in expr.args])
                s = "(%s)"%s
            s = "@%s" % s
        elif isinstance(expr, ExprId):
            s = "@%s" % expr
        else:
            raise NotImplementedError('zarb arg2str')
        return s


    """
    def dstflow2label(self, loc_db):
        e = self.args[0]
        if not isinstance(e, ExprInt):
            return
        if self.name == 'BLX':
            ad = e.arg+8+self.offset
        else:
            ad = e.arg+8+self.offset
        l = loc_db.get_or_create_offset_location(ad)
        s = ExprId(l, e.size)
        self.args[0] = s
    """

    def breakflow(self):
        if self.name.startswith('J'):
            return True
        return False

    def is_subcall(self):
        return self.name == 'JSR'

    def getdstflow(self, loc_db):
        return [self.args[0]]

    def splitflow(self):
        return self.name == 'JSR'

    def get_symbol_size(self, symbol, loc_db):
        return 32

    def fixDstOffset(self):
        e = self.args[0]
        if self.offset is None:
            raise ValueError('symbol not resolved %s' % l)
        if not isinstance(e, ExprInt):
            log.debug('dyn dst %r', e)
            return
        off = e.arg - (self.offset + 4 + self.l)
        print hex(off)
        if int(off % 4):
            raise ValueError('strange offset! %r' % off)
        self.args[0] = ExprInt(off, 32)
        print 'final', self.args[0]

    def get_args_expr(self):
        args = [a for a in self.args]
        return args

Ancestors (in MRO)

instruction_sh4
miasm2.core.cpu.instruction
__builtin__.object

Class variables

var additional_info

var args

var b

var data

var delayslot

var l

var mode

var name

var offset

Static methods

def arg2str(

expr, index=None, loc_db=None)

Show source ≡

@staticmethod
def arg2str(expr, index=None, loc_db=None):
    if isinstance(expr, ExprId) or isinstance(expr, ExprInt):
        return str(expr)
    elif expr.is_loc():
        if loc_db is not None:
            return loc_db.pretty_str(expr.loc_key)
        else:
            return str(expr)
    assert(isinstance(expr, ExprMem))
    expr = expr.arg
    if isinstance(expr, ExprOp):
        if expr.op == "predec":
            s = '-%s' % expr.args[0]
        elif expr.op == "postinc":
            s = '%s+' % expr.args[0]
        else:
            s = ','.join([str(x).replace('(', '').replace(')', '')
                          for x in expr.args])
            s = "(%s)"%s
        s = "@%s" % s
    elif isinstance(expr, ExprId):
        s = "@%s" % expr
    else:
        raise NotImplementedError('zarb arg2str')
    return s

Methods

def __init__(

self, *args, **kargs)

Show source ≡

def __init__(self, *args, **kargs):
    super(instruction_sh4, self).__init__(*args, **kargs)

def breakflow(

self)

Show source ≡

def breakflow(self):
    if self.name.startswith('J'):
        return True
    return False

def dstflow(

self)

Show source ≡

def dstflow(self):
    return self.name.startswith('J')

def fixDstOffset(

self)

Show source ≡

def fixDstOffset(self):
    e = self.args[0]
    if self.offset is None:
        raise ValueError('symbol not resolved %s' % l)
    if not isinstance(e, ExprInt):
        log.debug('dyn dst %r', e)
        return
    off = e.arg - (self.offset + 4 + self.l)
    print hex(off)
    if int(off % 4):
        raise ValueError('strange offset! %r' % off)
    self.args[0] = ExprInt(off, 32)
    print 'final', self.args[0]

def gen_args(

self, args)

Show source ≡

def gen_args(self, args):
    out = ', '.join([str(x) for x in args])
    return out

def get_args_expr(

self)

Show source ≡

def get_args_expr(self):
    args = [a for a in self.args]
    return args

def get_asm_next_offset(

self, expr)

Show source ≡

def get_asm_next_offset(self, expr):
    return m2_expr.ExprInt(self.offset+self.l, expr.size)

def get_asm_offset(

self, expr)

Show source ≡

def get_asm_offset(self, expr):
    return m2_expr.ExprInt(self.offset, expr.size)

def get_info(

self, c)

Show source ≡

def get_info(self, c):
    return

def get_symbol_size(

self, symbol, loc_db)

Show source ≡

def get_symbol_size(self, symbol, loc_db):
    return 32

def getdstflow(

self, loc_db)

Show source ≡

def getdstflow(self, loc_db):
    return [self.args[0]]

def is_subcall(

self)

Show source ≡

def is_subcall(self):
    return self.name == 'JSR'

def resolve_args_with_symbols(

self, symbols=None)

Show source ≡

def resolve_args_with_symbols(self, symbols=None):
    if symbols is None:
        symbols = {}
    args_out = []
    for expr in self.args:
        # try to resolve symbols using symbols (0 for default value)
        loc_keys = m2_expr.get_expr_locs(expr)
        fixed_expr = {}
        for exprloc in loc_keys:
            loc_key = exprloc.loc_key
            names = symbols.get_location_names(loc_key)
            # special symbols
            if '$' in names:
                fixed_expr[exprloc] = self.get_asm_offset(exprloc)
                continue
            if '_' in names:
                fixed_expr[exprloc] = self.get_asm_next_offset(exprloc)
                continue
            if not names:
                raise ValueError('Unresolved symbol: %r' % exprloc)
            offset = symbols.get_location_offset(loc_key)
            if offset is None:
                raise ValueError(
                    'The offset of loc_key "%s" cannot be determined' % names
                )
            else:
                # Fix symbol with its offset
                size = exprloc.size
                if size is None:
                    default_size = self.get_symbol_size(exprloc, symbols)
                    size = default_size
                value = m2_expr.ExprInt(offset, size)
            fixed_expr[exprloc] = value
        expr = expr.replace_expr(fixed_expr)
        expr = expr_simp(expr)
        args_out.append(expr)
    return args_out

def splitflow(

self)

Show source ≡

def splitflow(self):
    return self.name == 'JSR'

def to_string(

self, loc_db=None)

Show source ≡

def to_string(self, loc_db=None):
    o = "%-10s " % self.name
    args = []
    for i, arg in enumerate(self.args):
        if not isinstance(arg, m2_expr.Expr):
            raise ValueError('zarb arg type')
        x = self.arg2str(arg, i, loc_db)
        args.append(x)
    o += self.gen_args(args)
    return o

class mn_sh4

Show source ≡

class mn_sh4(cls_mn):
    bintree = {}
    regs = regs_module
    num = 0
    all_mn = []
    all_mn_mode = defaultdict(list)
    all_mn_name = defaultdict(list)
    all_mn_inst = defaultdict(list)
    pc = PC
    # delayslot:
    # http://resource.renesas.com/lib/eng/e_learnig/sh4/13/index.html
    delayslot = 0  # unit is instruction instruction
    instruction = instruction_sh4

    def additional_info(self):
        info = additional_info()
        return info

    @classmethod
    def getbits(cls, bs, attrib, start, n):
        if not n:
            return 0
        o = 0
        if n > bs.getlen() * 8:
            raise ValueError('not enought bits %r %r' % (n, len(bs.bin) * 8))
        while n:
            i = start / 8
            c = cls.getbytes(bs, i)
            if not c:
                raise IOError
            c = ord(c)
            r = 8 - start % 8
            c &= (1 << r) - 1
            l = min(r, n)
            c >>= (r - l)
            o <<= l
            o |= c
            n -= l
            start += l
        return o

    @classmethod
    def getbytes(cls, bs, offset, l=1):
        out = ""
        for _ in xrange(l):
            n_offset = (offset & ~1) + 1 - offset % 2
            out += bs.getbytes(n_offset, 1)
            offset += 1
        return out

    @classmethod
    def check_mnemo(cls, fields):
        l = sum([x.l for x in fields])
        assert l == 16, "len %r" % l

    @classmethod
    def getmn(cls, name):
        return name.upper().replace('_', '.')

    @classmethod
    def gen_modes(cls, subcls, name, bases, dct, fields):
        dct['mode'] = None
        return [(subcls, name, bases, dct, fields)]

    def value(self, mode):
        v = super(mn_sh4, self).value(mode)
        return [x[::-1] for x in v]

Ancestors (in MRO)

mn_sh4
miasm2.core.cpu.cls_mn
__builtin__.object

Class variables

var alignment

var all_mn

var all_mn_inst

var all_mn_mode

var all_mn_name

var args_symb

var bintree

var delayslot

var instruction

var num

var pc

var regs

Methods

def add_pre_dis_info(

self, prefix=None)

Show source ≡

def add_pre_dis_info(self, prefix=None):
    return True

def additional_info(

self)

Show source ≡

def additional_info(self):
    info = additional_info()
    return info

def args2str(

self)

Show source ≡

def args2str(self):
    args = []
    for arg in self.args:
        # XXX todo test
        if not (isinstance(arg, m2_expr.Expr) or
                isinstance(arg.expr, m2_expr.Expr)):
            raise ValueError('zarb arg type')
        x = str(arg)
        args.append(x)
    return args

def asm(

cls, instr, symbols=None)

Re asm instruction by searching mnemo using name and args. We then can modify args and get the hex of a modified instruction

Show source ≡

@classmethod
def asm(cls, instr, symbols=None):
    """
    Re asm instruction by searching mnemo using name and args. We then
    can modify args and get the hex of a modified instruction
    """
    clist = cls.all_mn_name[instr.name]
    clist = [x for x in clist]
    vals = []
    candidates = []
    args = instr.resolve_args_with_symbols(symbols)
    for cc in clist:
        for c in cls.get_cls_instance(
            cc, instr.mode, instr.additional_info):
            cannot_parse = False
            if len(c.args) != len(instr.args):
                continue
            # only fix args expr
            for i in xrange(len(c.args)):
                c.args[i].expr = args[i]
            v = c.value(instr.mode)
            if not v:
                log.debug("cannot encode %r", c)
                cannot_parse = True
            if cannot_parse:
                continue
            vals += v
            candidates.append((c, v))
    if len(vals) == 0:
        raise ValueError('cannot asm %r %r' %
                         (instr.name, [str(x) for x in instr.args]))
    if len(vals) != 1:
        log.debug('asm multiple args ret default')
    vals = cls.filter_asm_candidates(instr, candidates)
    return vals

def check_mnemo(

cls, fields)

Show source ≡

@classmethod
def check_mnemo(cls, fields):
    l = sum([x.l for x in fields])
    assert l == 16, "len %r" % l

def decoded2bytes(

self, result)

Show source ≡

def decoded2bytes(self, result):
    if not result:
        return []
    out = []
    for decoded in result:
        decoded.sort()
        o = self.encodefields(decoded)
        if o is None:
            continue
        out.append(o)
    out = list(set(out))
    return out

def dis(

cls, bs_o, mode_o=None, offset=0)

Show source ≡

@classmethod
def dis(cls, bs_o, mode_o = None, offset=0):
    if not isinstance(bs_o, bin_stream):
        bs_o = bin_stream_str(bs_o)
    bs_o.enter_atomic_mode()
    offset_o = offset
    try:
        pre_dis_info, bs, mode, offset, prefix_len = cls.pre_dis(
            bs_o, mode_o, offset)
    except:
        bs_o.leave_atomic_mode()
        raise
    candidates = cls.guess_mnemo(bs, mode, pre_dis_info, offset)
    if not candidates:
        bs_o.leave_atomic_mode()
        raise Disasm_Exception('cannot disasm (guess) at %X' % offset)
    out = []
    out_c = []
    if hasattr(bs, 'getlen'):
        bs_l = bs.getlen()
    else:
        bs_l = len(bs)
    alias = False
    for c in candidates:
        log.debug("*" * 40, mode, c.mode)
        log.debug(c.fields)
        c = cls.all_mn_inst[c][0]
        c.reset_class()
        c.mode = mode
        if not c.add_pre_dis_info(pre_dis_info):
            continue
        todo = {}
        getok = True
        fname_values = dict(pre_dis_info)
        offset_b = offset * 8
        total_l = 0
        for i, f in enumerate(c.fields_order):
            if f.flen is not None:
                l = f.flen(mode, fname_values)
            else:
                l = f.l
            if l is not None:
                total_l += l
                f.l = l
                f.is_present = True
                log.debug("FIELD %s %s %s %s", f.__class__, f.fname,
                          offset_b, l)
                if bs_l * 8 - offset_b < l:
                    getok = False
                    break
                try:
                    bv = cls.getbits(bs, mode, offset_b, l)
                except:
                    bs_o.leave_atomic_mode()
                    raise
                offset_b += l
                if not f.fname in fname_values:
                    fname_values[f.fname] = bv
                todo[i] = bv
            else:
                f.is_present = False
                todo[i] = None
        if not getok:
            continue
        c.l = prefix_len + total_l / 8
        for i in c.to_decode:
            f = c.fields_order[i]
            if f.is_present:
                ret = f.decode(todo[i])
                if not ret:
                    log.debug("cannot decode %r", f)
                    break
        if not ret:
            continue
        for a in c.args:
            a.expr = expr_simp(a.expr)
        c.b = cls.getbytes(bs, offset_o, c.l)
        c.offset = offset_o
        c = c.post_dis()
        if c is None:
            continue
        c_args = [a.expr for a in c.args]
        instr = cls.instruction(c.name, mode, c_args,
                                additional_info=c.additional_info())
        instr.l = prefix_len + total_l / 8
        instr.b = cls.getbytes(bs, offset_o, instr.l)
        instr.offset = offset_o
        instr.get_info(c)
        if c.alias:
            alias = True
        out.append(instr)
        out_c.append(c)
    bs_o.leave_atomic_mode()
    if not out:
        raise Disasm_Exception('cannot disasm at %X' % offset_o)
    if len(out) != 1:
        if not alias:
            log.warning('dis multiple args ret default')
        for i, o in enumerate(out_c):
            if o.alias:
                return out[i]
        raise NotImplementedError('Multiple disas: \n' +
                                  "\n".join([str(x) for x in out]))
    return out[0]

def dup_info(

self, infos)

Show source ≡

def dup_info(self, infos):
    return

def encodefields(

self, decoded)

Show source ≡

def encodefields(self, decoded):
    bits = bitobj()
    for _, f in decoded:
        setattr(self, f.fname, f)
        if f.value is None:
            continue
        bits.putbits(f.value, f.l)
    return bits.tostring()

def filter_asm_candidates(

cls, instr, candidates)

Show source ≡

@classmethod
def filter_asm_candidates(cls, instr, candidates):
    o = []
    for _, v in candidates:
        o += v
    o.sort(key=len)
    return o

def fromstring(

cls, text, loc_db, mode=None)

Show source ≡

@classmethod
def fromstring(cls, text, loc_db, mode = None):
    global total_scans
    name = re.search('(\S+)', text).groups()
    if not name:
        raise ValueError('cannot find name', text)
    name = name[0]
    if not name in cls.all_mn_name:
        raise ValueError('unknown name', name)
    clist = [x for x in cls.all_mn_name[name]]
    out = []
    out_args = []
    parsers = defaultdict(dict)
    for cc in clist:
        for c in cls.get_cls_instance(cc, mode):
            args_expr = []
            args_str = text[len(name):].strip(' ')
            start = 0
            cannot_parse = False
            len_o = len(args_str)
            for i, f in enumerate(c.args):
                start_i = len_o - len(args_str)
                if type(f.parser) == tuple:
                    parser = f.parser
                else:
                    parser = (f.parser,)
                for p in parser:
                    if p in parsers[(i, start_i)]:
                        continue
                    try:
                        total_scans += 1
                        v, start, stop = p.scanString(args_str).next()
                    except StopIteration:
                        v, start, stop = [None], None, None
                    if start != 0:
                        v, start, stop = [None], None, None
                    if v != [None]:
                        v = f.asm_ast_to_expr(v[0], loc_db)
                    if v is None:
                        v, start, stop = [None], None, None
                    parsers[(i, start_i)][p] = v, start, stop
                start, stop = f.fromstring(args_str, loc_db, parsers[(i, start_i)])
                if start != 0:
                    log.debug("cannot fromstring %r", args_str)
                    cannot_parse = True
                    break
                if f.expr is None:
                    raise NotImplementedError('not fully functional')
                f.expr = expr_simp(f.expr)
                args_expr.append(f.expr)
                args_str = args_str[stop:].strip(' ')
                if args_str.startswith(','):
                    args_str = args_str[1:]
                args_str = args_str.strip(' ')
            if args_str:
                cannot_parse = True
            if cannot_parse:
                continue
            out.append(c)
            out_args.append(args_expr)
            break
    if len(out) == 0:
        raise ValueError('cannot fromstring %r' % text)
    if len(out) != 1:
        log.debug('fromstring multiple args ret default')
    c = out[0]
    c_args = out_args[0]
    instr = cls.instruction(c.name, mode, c_args,
                            additional_info=c.additional_info())
    return instr

def gen_args(

self, args)

Show source ≡

def gen_args(self, args):
    out = ', '.join([str(x) for x in args])
    return out

def gen_modes(

cls, subcls, name, bases, dct, fields)

Show source ≡

@classmethod
def gen_modes(cls, subcls, name, bases, dct, fields):
    dct['mode'] = None
    return [(subcls, name, bases, dct, fields)]

def get_cls_instance(

cls, cc, mode, infos=None)

Show source ≡

@classmethod
def get_cls_instance(cls, cc, mode, infos=None):
    c = cls.all_mn_inst[cc][0]
    c.reset_class()
    c.add_pre_dis_info()
    c.dup_info(infos)
    c.mode = mode
    yield c

def getbits(

cls, bs, attrib, start, n)

Show source ≡

@classmethod
def getbits(cls, bs, attrib, start, n):
    if not n:
        return 0
    o = 0
    if n > bs.getlen() * 8:
        raise ValueError('not enought bits %r %r' % (n, len(bs.bin) * 8))
    while n:
        i = start / 8
        c = cls.getbytes(bs, i)
        if not c:
            raise IOError
        c = ord(c)
        r = 8 - start % 8
        c &= (1 << r) - 1
        l = min(r, n)
        c >>= (r - l)
        o <<= l
        o |= c
        n -= l
        start += l
    return o

def getbytes(

cls, bs, offset, l=1)

Show source ≡

@classmethod
def getbytes(cls, bs, offset, l=1):
    out = ""
    for _ in xrange(l):
        n_offset = (offset & ~1) + 1 - offset % 2
        out += bs.getbytes(n_offset, 1)
        offset += 1
    return out

def getdstflow(

self, loc_db)

Show source ≡

def getdstflow(self, loc_db):
    return [self.args[0].expr]

def getmn(

cls, name)

Show source ≡

@classmethod
def getmn(cls, name):
    return name.upper().replace('_', '.')

def guess_mnemo(

cls, bs, attrib, pre_dis_info, offset)

Show source ≡

@classmethod
def guess_mnemo(cls, bs, attrib, pre_dis_info, offset):
    candidates = []
    candidates = set()
    fname_values = pre_dis_info
    todo = [(dict(fname_values), branch, offset * 8)
            for branch in cls.bintree.items()]
    for fname_values, branch, offset_b in todo:
        (l, fmask, fbits, fname, flen), vals = branch
        if flen is not None:
            l = flen(attrib, fname_values)
        if l is not None:
            try:
                v = cls.getbits(bs, attrib, offset_b, l)
            except IOError:
                # Raised if offset is out of bound
                continue
            offset_b += l
            if v & fmask != fbits:
                continue
            if fname is not None and not fname in fname_values:
                fname_values[fname] = v
        for nb, v in vals.items():
            if 'mn' in nb:
                candidates.update(v)
            else:
                todo.append((dict(fname_values), (nb, v), offset_b))
    return [c for c in candidates]

def init_class(

self)

Show source ≡

def init_class(self):
    args = []
    fields_order = []
    to_decode = []
    off = 0
    for i, fc in enumerate(self.fields):
        f = fc.gen(self)
        f.offset = off
        off += f.l
        fields_order.append(f)
        to_decode.append((i, f))
        if isinstance(f, m_arg):
            args.append(f)
        if f.fname:
            setattr(self, f.fname, f)
    if hasattr(self, 'args_permut'):
        args = [args[self.args_permut[i]]
                for i in xrange(len(self.args_permut))]
    to_decode.sort(key=lambda x: (x[1].order, x[0]))
    to_decode = [fields_order.index(f[1]) for f in to_decode]
    self.args = args
    self.fields_order = fields_order
    self.to_decode = to_decode

def mod_fields(

cls, fields)

Show source ≡

@classmethod
def mod_fields(cls, fields):
    return fields

def parse_prefix(

self, v)

Show source ≡

def parse_prefix(self, v):
    return 0

def post_dis(

self)

Show source ≡

def post_dis(self):
    return self

def pre_dis(

cls, v_o, attrib, offset)

Show source ≡

@classmethod
def pre_dis(cls, v_o, attrib, offset):
    return {}, v_o, attrib, offset, 0

def reset_class(

self)

Show source ≡

def reset_class(self):
    for f in self.fields_order:
        if f.strbits and isbin(f.strbits):
            f.value = int(f.strbits, 2)
        elif 'default_val' in f.kargs:
            f.value = int(f.kargs['default_val'], 2)
        else:
            f.value = None
        if f.fname:
            setattr(self, f.fname, f)

def set_dst_symbol(

self, loc_db)

Show source ≡

def set_dst_symbol(self, loc_db):
    dst = self.getdstflow(loc_db)
    args = []
    for d in dst:
        if isinstance(d, m2_expr.ExprInt):
            l = loc_db.get_or_create_offset_location(int(d))
            a = m2_expr.ExprId(l.name, d.size)
        else:
            a = d
        args.append(a)
    self.args_symb = args

def value(

self, mode)

Show source ≡

def value(self, mode):
    v = super(mn_sh4, self).value(mode)
    return [x[::-1] for x in v]

class sh4_arg

Show source ≡

class sh4_arg(m_arg):
    def asm_ast_to_expr(self, arg, loc_db):
        if isinstance(arg, AstId):
            if isinstance(arg.name, ExprId):
                return arg.name
            if arg.name in gpregs.str:
                return None
            loc_key = loc_db.get_or_create_name_location(arg.name)
            return ExprLoc(loc_key, 32)
        if isinstance(arg, AstOp):
            args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
            if None in args:
                return None
            return ExprOp(arg.op, *args)
        if isinstance(arg, AstInt):
            return ExprInt(arg.value, 32)
        if isinstance(arg, AstMem):
            ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
            if ptr is None:
                return None
            return ExprMem(ptr, arg.size)
        return None

Ancestors (in MRO)

sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def fromstring(

self, text, loc_db, parser_result=None)

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.asm_ast_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_bgpreg

Show source ≡

class sh4_bgpreg(sh4_reg):
    reg_info = bgpregs
    parser = reg_info.parser

Ancestors (in MRO)

sh4_bgpreg
sh4_reg
miasm2.core.cpu.reg_noarg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_reg.parser

var reg_info

Inheritance: sh4_reg.reg_info

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_reg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def check_fbits(

self, v)

Inheritance: sh4_reg.check_fbits

Show source ≡

def check_fbits(self, v):
    return v & self.fmask == self.fbits

def decode(

self, v)

Inheritance: sh4_reg.decode

Show source ≡

def decode(self, v):
    v = v & self.lmask
    if v >= len(self.reg_info.expr):
        return False
    self.expr = self.reg_info.expr[v]
    return True

def encode(

self)

Inheritance: sh4_reg.encode

Show source ≡

def encode(self):
    if not self.expr in self.reg_info.expr:
        log.debug("cannot encode reg %r", self.expr)
        return False
    self.value = self.reg_info.expr.index(self.expr)
    if self.value > self.lmask:
        log.debug("cannot encode field value %x %x",
                  self.value, self.lmask)
        return False
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_reg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.parses_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_dgbrimm8

Show source ≡

class sh4_dgbrimm8(sh4_dgpreg):
    parser = dgbr_imm

    def decode(self, v):
        s = self.sz
        self.expr = ExprMem(GBR + ExprInt(v * s / 8, 32), s)
        return True

    def encode(self):
        e = self.expr
        s = self.sz
        if e == ExprMem(GBR, 32):
            self.value = 0
            return True
        res = match_expr(self.expr, ExprMem(GBR + jra, s), [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        self.value = int(res[jra]) / (s / 8)
        return True

Ancestors (in MRO)

sh4_dgbrimm8
sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_dgpreg.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_dgpreg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Inheritance: sh4_dgpreg.decode

Show source ≡

def decode(self, v):
    s = self.sz
    self.expr = ExprMem(GBR + ExprInt(v * s / 8, 32), s)
    return True

def encode(

self)

Inheritance: sh4_dgpreg.encode

Show source ≡

def encode(self):
    e = self.expr
    s = self.sz
    if e == ExprMem(GBR, 32):
        self.value = 0
        return True
    res = match_expr(self.expr, ExprMem(GBR + jra, s), [jra])
    if not res:
        return False
    if not isinstance(res[jra], ExprInt):
        return False
    self.value = int(res[jra]) / (s / 8)
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_dgpreg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class sh4_dgpreg

Show source ≡

class sh4_dgpreg(sh4_arg):
    parser = dgpregs_base

    def fromstring(self, text, loc_db, parser_result=None):
        start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
        if start is None or self.expr == [None]:
            return start, stop
        self.expr = ExprMem(self.expr.arg, self.sz)
        return start, stop

    def decode(self, v):
        r = gpregs.expr[v]
        self.expr = ExprMem(r, self.sz)
        return True

    def encode(self):
        e = self.expr
        if not isinstance(e, ExprMem):
            return False
        if not isinstance(e.arg, ExprId):
            return False
        v = gpregs.expr.index(e.arg)
        self.value = v
        return True

Ancestors (in MRO)

sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_arg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Show source ≡

def decode(self, v):
    r = gpregs.expr[v]
    self.expr = ExprMem(r, self.sz)
    return True

def encode(

self)

Show source ≡

def encode(self):
    e = self.expr
    if not isinstance(e, ExprMem):
        return False
    if not isinstance(e.arg, ExprId):
        return False
    v = gpregs.expr.index(e.arg)
    self.value = v
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_arg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class sh4_dgpreg_imm

Show source ≡

class sh4_dgpreg_imm(sh4_dgpreg):
    parser = dgpregs_ir

    def decode(self, v):
        p = self.parent
        r = gpregs.expr[v]
        s = self.sz
        d = ExprInt(p.disp.value * s / 8, 32)
        e = ExprMem(r + d, s)
        self.expr = e
        return True

    def encode(self):
        e = self.expr
        p = self.parent
        s = self.sz
        if not isinstance(e, ExprMem):
            return False
        if isinstance(e.arg, ExprId):
            v = gpregs.expr.index(e.arg)
            p.disp.value = 0
        elif isinstance(e.arg, ExprOp):
            res = match_expr(e, ExprMem(jra + jrb, self.sz), [jra, jrb])
            if not res:
                return False
            if not isinstance(res[jra], ExprId):
                return False
            if not isinstance(res[jrb], ExprInt):
                return False
            d = int(res[jrb])
            p.disp.value = d / (s / 8)
            if not res[jra] in gpregs.expr:
                return False
            v = gpregs.expr.index(res[jra])
        else:
            return False
        self.value = v
        return True

Ancestors (in MRO)

sh4_dgpreg_imm
sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_dgpreg.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_dgpreg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Inheritance: sh4_dgpreg.decode

Show source ≡

def decode(self, v):
    p = self.parent
    r = gpregs.expr[v]
    s = self.sz
    d = ExprInt(p.disp.value * s / 8, 32)
    e = ExprMem(r + d, s)
    self.expr = e
    return True

def encode(

self)

Inheritance: sh4_dgpreg.encode

Show source ≡

def encode(self):
    e = self.expr
    p = self.parent
    s = self.sz
    if not isinstance(e, ExprMem):
        return False
    if isinstance(e.arg, ExprId):
        v = gpregs.expr.index(e.arg)
        p.disp.value = 0
    elif isinstance(e.arg, ExprOp):
        res = match_expr(e, ExprMem(jra + jrb, self.sz), [jra, jrb])
        if not res:
            return False
        if not isinstance(res[jra], ExprId):
            return False
        if not isinstance(res[jrb], ExprInt):
            return False
        d = int(res[jrb])
        p.disp.value = d / (s / 8)
        if not res[jra] in gpregs.expr:
            return False
        v = gpregs.expr.index(res[jra])
    else:
        return False
    self.value = v
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_dgpreg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class sh4_dgpregpdec

Show source ≡

class sh4_dgpregpdec(sh4_arg):
    parser = dgpregs_postinc
    op = "preinc"

Ancestors (in MRO)

sh4_dgpregpdec
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var op

var parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_arg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_arg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.asm_ast_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_dgpregpinc

Show source ≡

class sh4_dgpregpinc(sh4_arg):
    parser = dgpregs_p

    def fromstring(self, text, loc_db, parser_result=None):
        start, stop = super(sh4_dgpregpinc, self).fromstring(text, loc_db, parser_result)
        if self.expr == [None]:
            return None, None
        if not isinstance(self.expr.arg, ExprOp):
            return None, None
        if self.expr.arg.op != self.op:
            return None, None
        return start, stop

    def decode(self, v):
        r = gpregs.expr[v]
        e = ExprOp(self.op, r)
        self.expr = ExprMem(e, self.sz)
        return True

    def encode(self):
        e = self.expr
        if not isinstance(e, ExprMem):
            return False
        e = e.arg
        res = match_expr(e, ExprOp(self.op, jra), [jra])
        if not res:
            return False
        r = res[jra]
        if not r in gpregs.expr:
            return False
        v = gpregs.expr.index(r)
        self.value = v
        return True

Ancestors (in MRO)

sh4_dgpregpinc
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_arg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Show source ≡

def decode(self, v):
    r = gpregs.expr[v]
    e = ExprOp(self.op, r)
    self.expr = ExprMem(e, self.sz)
    return True

def encode(

self)

Show source ≡

def encode(self):
    e = self.expr
    if not isinstance(e, ExprMem):
        return False
    e = e.arg
    res = match_expr(e, ExprOp(self.op, jra), [jra])
    if not res:
        return False
    r = res[jra]
    if not r in gpregs.expr:
        return False
    v = gpregs.expr.index(r)
    self.value = v
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_arg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpregpinc, self).fromstring(text, loc_db, parser_result)
    if self.expr == [None]:
        return None, None
    if not isinstance(self.expr.arg, ExprOp):
        return None, None
    if self.expr.arg.op != self.op:
        return None, None
    return start, stop

class sh4_dpc16imm

Show source ≡

class sh4_dpc16imm(sh4_dgpreg):
    parser = deref_pc

    def decode(self, v):
        self.expr = ExprMem(PC + ExprInt(v * 2 + 4, 32), 16)
        return True

    def calcdisp(self, v):
        v = (int(v) - 4) / 2
        if not 0 < v <= 0xff:
            return None
        return v

    def encode(self):
        res = match_expr(self.expr, ExprMem(PC + jra, 16), [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        v = self.calcdisp(res[jra])
        if v is None:
            return False
        self.value = v
        return True

Ancestors (in MRO)

sh4_dpc16imm
sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_dgpreg.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_dgpreg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def calcdisp(

self, v)

Show source ≡

def calcdisp(self, v):
    v = (int(v) - 4) / 2
    if not 0 < v <= 0xff:
        return None
    return v

def decode(

self, v)

Inheritance: sh4_dgpreg.decode

Show source ≡

def decode(self, v):
    self.expr = ExprMem(PC + ExprInt(v * 2 + 4, 32), 16)
    return True

def encode(

self)

Inheritance: sh4_dgpreg.encode

Show source ≡

def encode(self):
    res = match_expr(self.expr, ExprMem(PC + jra, 16), [jra])
    if not res:
        return False
    if not isinstance(res[jra], ExprInt):
        return False
    v = self.calcdisp(res[jra])
    if v is None:
        return False
    self.value = v
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_dgpreg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class sh4_dpc32imm

Show source ≡

class sh4_dpc32imm(sh4_dpc16imm):
    parser = deref_pcimm

    def decode(self, v):
        self.expr = ExprMem(
            (PC & ExprInt(0xfffffffc, 32)) + ExprInt(v * 4 + 4, 32), 32)
        return True

    def calcdisp(self, v):
        v = (int(v) - 4) / 4
        if not 0 < v <= 0xff:
            return None
        return v

    def encode(self):
        res = match_expr(
            self.expr, ExprMem((PC & ExprInt(0xFFFFFFFC, 32)) + jra, 32), [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        v = self.calcdisp(res[jra])
        if v is None:
            return False
        self.value = v
        return True

Ancestors (in MRO)

sh4_dpc32imm
sh4_dpc16imm
sh4_dgpreg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_dpc16imm.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_dpc16imm.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def calcdisp(

self, v)

Inheritance: sh4_dpc16imm.calcdisp

Show source ≡

def calcdisp(self, v):
    v = (int(v) - 4) / 4
    if not 0 < v <= 0xff:
        return None
    return v

def decode(

self, v)

Inheritance: sh4_dpc16imm.decode

Show source ≡

def decode(self, v):
    self.expr = ExprMem(
        (PC & ExprInt(0xfffffffc, 32)) + ExprInt(v * 4 + 4, 32), 32)
    return True

def encode(

self)

Inheritance: sh4_dpc16imm.encode

Show source ≡

def encode(self):
    res = match_expr(
        self.expr, ExprMem((PC & ExprInt(0xFFFFFFFC, 32)) + jra, 32), [jra])
    if not res:
        return False
    if not isinstance(res[jra], ExprInt):
        return False
    v = self.calcdisp(res[jra])
    if v is None:
        return False
    self.value = v
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_dpc16imm.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result)
    if start is None or self.expr == [None]:
        return start, stop
    self.expr = ExprMem(self.expr.arg, self.sz)
    return start, stop

class sh4_dr

Show source ≡

class sh4_dr(sh4_reg):
    reg_info = dregs
    parser = reg_info.parser

Ancestors (in MRO)

sh4_dr
sh4_reg
miasm2.core.cpu.reg_noarg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_reg.parser

var reg_info

Inheritance: sh4_reg.reg_info

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_reg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def check_fbits(

self, v)

Inheritance: sh4_reg.check_fbits

Show source ≡

def check_fbits(self, v):
    return v & self.fmask == self.fbits

def decode(

self, v)

Inheritance: sh4_reg.decode

Show source ≡

def decode(self, v):
    v = v & self.lmask
    if v >= len(self.reg_info.expr):
        return False
    self.expr = self.reg_info.expr[v]
    return True

def encode(

self)

Inheritance: sh4_reg.encode

Show source ≡

def encode(self):
    if not self.expr in self.reg_info.expr:
        log.debug("cannot encode reg %r", self.expr)
        return False
    self.value = self.reg_info.expr.index(self.expr)
    if self.value > self.lmask:
        log.debug("cannot encode field value %x %x",
                  self.value, self.lmask)
        return False
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_reg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.parses_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_freg

Show source ≡

class sh4_freg(sh4_reg):
    reg_info = fregs
    parser = reg_info.parser

Ancestors (in MRO)

sh4_freg
sh4_reg
miasm2.core.cpu.reg_noarg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_reg.parser

var reg_info

Inheritance: sh4_reg.reg_info

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_reg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def check_fbits(

self, v)

Inheritance: sh4_reg.check_fbits

Show source ≡

def check_fbits(self, v):
    return v & self.fmask == self.fbits

def decode(

self, v)

Inheritance: sh4_reg.decode

Show source ≡

def decode(self, v):
    v = v & self.lmask
    if v >= len(self.reg_info.expr):
        return False
    self.expr = self.reg_info.expr[v]
    return True

def encode(

self)

Inheritance: sh4_reg.encode

Show source ≡

def encode(self):
    if not self.expr in self.reg_info.expr:
        log.debug("cannot encode reg %r", self.expr)
        return False
    self.value = self.reg_info.expr.index(self.expr)
    if self.value > self.lmask:
        log.debug("cannot encode field value %x %x",
                  self.value, self.lmask)
        return False
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_reg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.parses_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_gpreg

Show source ≡

class sh4_gpreg(sh4_reg):
    reg_info = gpregs
    parser = reg_info.parser

Ancestors (in MRO)

sh4_gpreg
sh4_reg
miasm2.core.cpu.reg_noarg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Inheritance: sh4_reg.parser

var reg_info

Inheritance: sh4_reg.reg_info

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_reg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def check_fbits(

self, v)

Inheritance: sh4_reg.check_fbits

Show source ≡

def check_fbits(self, v):
    return v & self.fmask == self.fbits

def decode(

self, v)

Inheritance: sh4_reg.decode

Show source ≡

def decode(self, v):
    v = v & self.lmask
    if v >= len(self.reg_info.expr):
        return False
    self.expr = self.reg_info.expr[v]
    return True

def encode(

self)

Inheritance: sh4_reg.encode

Show source ≡

def encode(self):
    if not self.expr in self.reg_info.expr:
        log.debug("cannot encode reg %r", self.expr)
        return False
    self.value = self.reg_info.expr.index(self.expr)
    if self.value > self.lmask:
        log.debug("cannot encode field value %x %x",
                  self.value, self.lmask)
        return False
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_reg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.parses_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_gpreg_noarg

Show source ≡

class sh4_gpreg_noarg(reg_noarg, ):
    reg_info = gpregs
    parser = reg_info.parser

Ancestors (in MRO)

sh4_gpreg_noarg
miasm2.core.cpu.reg_noarg
__builtin__.object

Class variables

var parser

var reg_info

Methods

def check_fbits(

self, v)

Show source ≡

def check_fbits(self, v):
    return v & self.fmask == self.fbits

def decode(

self, v)

Show source ≡

def decode(self, v):
    v = v & self.lmask
    if v >= len(self.reg_info.expr):
        return False
    self.expr = self.reg_info.expr[v]
    return True

def encode(

self)

Show source ≡

def encode(self):
    if not self.expr in self.reg_info.expr:
        log.debug("cannot encode reg %r", self.expr)
        return False
    self.value = self.reg_info.expr.index(self.expr)
    if self.value > self.lmask:
        log.debug("cannot encode field value %x %x",
                  self.value, self.lmask)
        return False
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.parses_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_imm

Show source ≡

class sh4_imm(imm_noarg, sh4_arg):
    parser = base_expr
    pass

Ancestors (in MRO)

sh4_imm
miasm2.core.cpu.imm_noarg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var intmask

var intsize

var parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_arg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Show source ≡

def decode(self, v):
    v = v & self.lmask
    v = self.decodeval(v)
    e = self.int2expr(v)
    if not e:
        return False
    self.expr = e
    return True

def decodeval(

self, v)

Show source ≡

def decodeval(self, v):
    return v

def encode(

self)

Show source ≡

def encode(self):
    v = self.expr2int(self.expr)
    if v is None:
        return False
    v = self.encodeval(v)
    if v is False:
        return False
    if v > self.lmask:
        return False
    self.value = v
    return True

def encodeval(

self, v)

Show source ≡

def encodeval(self, v):
    if v > self.lmask:
        return False
    return v

def expr2int(

self, e)

Show source ≡

def expr2int(self, e):
    if not isinstance(e, m2_expr.ExprInt):
        return None
    v = int(e)
    if v & ~self.intmask != 0:
        return None
    return v

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_arg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
    else:
        try:
            e, start, stop = self.parser.scanString(text).next()
        except StopIteration:
            return None, None
    if e == [None]:
        return None, None
    assert(isinstance(e, m2_expr.Expr))
    if isinstance(e, tuple):
        self.expr = self.int2expr(e[1])
    elif isinstance(e, m2_expr.Expr):
        self.expr = e
    else:
        raise TypeError('zarb expr')
    if self.expr is None:
        log.debug('cannot fromstring int %r', text)
        return None, None
    return start, stop

def int2expr(

self, v)

Show source ≡

def int2expr(self, v):
    if (v & ~self.intmask) != 0:
        return None
    return m2_expr.ExprInt(v, self.intsize)

class sh4_pc32imm

Show source ≡

class sh4_pc32imm(sh4_arg):
    parser = pcdisp

    def decode(self, v):
        self.expr = (PC & ExprInt(0xfffffffc, 32)) + ExprInt(v * 4 + 4, 32)
        return True

    def encode(self):
        res = match_expr(self.expr, (PC & ExprInt(0xfffffffc, 32)) + jra, [jra])
        if not res:
            return False
        if not isinstance(res[jra], ExprInt):
            return False
        v = (int(res[jra]) - 4) / 4
        if v is None:
            return False
        self.value = v
        return True

Ancestors (in MRO)

sh4_pc32imm
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_arg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Show source ≡

def decode(self, v):
    self.expr = (PC & ExprInt(0xfffffffc, 32)) + ExprInt(v * 4 + 4, 32)
    return True

def encode(

self)

Show source ≡

def encode(self):
    res = match_expr(self.expr, (PC & ExprInt(0xfffffffc, 32)) + jra, [jra])
    if not res:
        return False
    if not isinstance(res[jra], ExprInt):
        return False
    v = (int(res[jra]) - 4) / 4
    if v is None:
        return False
    self.value = v
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_arg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.asm_ast_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_reg

Show source ≡

class sh4_reg(reg_noarg, sh4_arg):
    pass

Ancestors (in MRO)

sh4_reg
miasm2.core.cpu.reg_noarg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var parser

var reg_info

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_arg.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def check_fbits(

self, v)

Show source ≡

def check_fbits(self, v):
    return v & self.fmask == self.fbits

def decode(

self, v)

Show source ≡

def decode(self, v):
    v = v & self.lmask
    if v >= len(self.reg_info.expr):
        return False
    self.expr = self.reg_info.expr[v]
    return True

def encode(

self)

Show source ≡

def encode(self):
    if not self.expr in self.reg_info.expr:
        log.debug("cannot encode reg %r", self.expr)
        return False
    self.value = self.reg_info.expr.index(self.expr)
    if self.value > self.lmask:
        log.debug("cannot encode field value %x %x",
                  self.value, self.lmask)
        return False
    return True

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_arg.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
        self.expr = e
        return start, stop
    try:
        v, start, stop = self.parser.scanString(text).next()
    except StopIteration:
        return None, None
    arg = v[0]
    expr = self.parses_to_expr(arg, loc_db)
    self.expr = expr
    return start, stop

class sh4_simm

Show source ≡

class sh4_simm(sh4_imm):
    parser = base_expr

    def decode(self, v):
        v = sign_ext(v, self.l, 32)
        v = self.decodeval(v)
        self.expr = ExprInt(v, 32)
        return True

    def encode(self):
        if not isinstance(self.expr, ExprInt):
            return False
        v = int(self.expr)
        if (1 << (self.l - 1)) & v:
            v = -((0xffffffff ^ v) + 1)
        v = self.encodeval(v)
        self.value = (v & 0xffffffff) & self.lmask
        return True

Ancestors (in MRO)

sh4_simm
sh4_imm
miasm2.core.cpu.imm_noarg
sh4_arg
miasm2.core.cpu.m_arg
__builtin__.object

Class variables

var intmask

Inheritance: sh4_imm.intmask

var intsize

Inheritance: sh4_imm.intsize

var parser

Inheritance: sh4_imm.parser

Methods

def asm_ast_to_expr(

self, arg, loc_db)

Inheritance: sh4_imm.asm_ast_to_expr

Show source ≡

def asm_ast_to_expr(self, arg, loc_db):
    if isinstance(arg, AstId):
        if isinstance(arg.name, ExprId):
            return arg.name
        if arg.name in gpregs.str:
            return None
        loc_key = loc_db.get_or_create_name_location(arg.name)
        return ExprLoc(loc_key, 32)
    if isinstance(arg, AstOp):
        args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args]
        if None in args:
            return None
        return ExprOp(arg.op, *args)
    if isinstance(arg, AstInt):
        return ExprInt(arg.value, 32)
    if isinstance(arg, AstMem):
        ptr = self.asm_ast_to_expr(arg.ptr, loc_db)
        if ptr is None:
            return None
        return ExprMem(ptr, arg.size)
    return None

def decode(

self, v)

Inheritance: sh4_imm.decode

Show source ≡

def decode(self, v):
    v = sign_ext(v, self.l, 32)
    v = self.decodeval(v)
    self.expr = ExprInt(v, 32)
    return True

def decodeval(

self, v)

Inheritance: sh4_imm.decodeval

Show source ≡

def decodeval(self, v):
    return v

def encode(

self)

Inheritance: sh4_imm.encode

Show source ≡

def encode(self):
    if not isinstance(self.expr, ExprInt):
        return False
    v = int(self.expr)
    if (1 << (self.l - 1)) & v:
        v = -((0xffffffff ^ v) + 1)
    v = self.encodeval(v)
    self.value = (v & 0xffffffff) & self.lmask
    return True

def encodeval(

self, v)

Inheritance: sh4_imm.encodeval

Show source ≡

def encodeval(self, v):
    if v > self.lmask:
        return False
    return v

def expr2int(

self, e)

Inheritance: sh4_imm.expr2int

Show source ≡

def expr2int(self, e):
    if not isinstance(e, m2_expr.ExprInt):
        return None
    v = int(e)
    if v & ~self.intmask != 0:
        return None
    return v

def fromstring(

self, text, loc_db, parser_result=None)

Inheritance: sh4_imm.fromstring

Show source ≡

def fromstring(self, text, loc_db, parser_result=None):
    if parser_result:
        e, start, stop = parser_result[self.parser]
    else:
        try:
            e, start, stop = self.parser.scanString(text).next()
        except StopIteration:
            return None, None
    if e == [None]:
        return None, None
    assert(isinstance(e, m2_expr.Expr))
    if isinstance(e, tuple):
        self.expr = self.int2expr(e[1])
    elif isinstance(e, m2_expr.Expr):
        self.expr = e
    else:
        raise TypeError('zarb expr')
    if self.expr is None:
        log.debug('cannot fromstring int %r', text)
        return None, None
    return start, stop

def int2expr(

self, v)

Inheritance: sh4_imm.int2expr

Show source ≡

def int2expr(self, v):
    if (v & ~self.intmask) != 0:
        return None
    return m2_expr.ExprInt(v, self.intsize)

Index

Module variables

Functions

Classes

Module variables

Functions

Classes

Ancestors (in MRO)

Instance variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Static methods

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods

Ancestors (in MRO)

Class variables

Methods