from rpython.jit.backend.zarch.instructions import (all_mnemonic_codes,)
from rpython.rtyper.lltypesystem.rbuilder import always_inline
from rpython.rlib.unroll import unrolling_iterable
from rpython.jit.backend.zarch import locations as loc

def dummy_argument(arg):
    """ NOT_RPYTHON """
    if arg in ('r', 'r/m', 'm', 'f', '-', 'eo', 'v'):
        return 0
    if arg.startswith('i') or arg.startswith('u'):
        return 0
    if arg.startswith('h'):
        return 0
    return loc.addr(0)

class builder(object):
    """ NOT_RPYTHON """
    @staticmethod
    def arguments(args_str):
        """ NOT_RPYTHON """
        """
        Available names:
        -      - unused
        f      - floating point register
        r      - register
        v      - vector register (128 bit)
        m      - mask
        eo     - even odd pair (= the even register)
        r/m    - register or mask
        iX     - immediate X bits (signed)
        uX     - immediate X bits (unsigend)
        bd     - base displacement (unsigned 12 bit)
        bdl    - base displacement long (20 bit)
        bid    - index base displacement (unsigned 12 bit)
        bidl   - index base displacement (20 bit)
        l4bd   - length base displacement (4 bit)
        l8bd   - length base displacement (8 bit)
        h32    - halfwords 32 bit (e.g. LARL, or other relative instr.)

        note that a suffix 'l' means long, and a prefix length
        """
        class Counter(object):
            def __init__(self):
                self.counter = 0
            def writechar(self, char):
                self.counter += 1
            def write_i16(self, _):
                self.counter += 2
            def write_i32(self, _):
                self.counter += 4
        def impl(func):
            func._arguments_ = args_str.split(',')
            if args_str == '':
                func._arguments_ = []
            args = [dummy_argument(a) for a in func._arguments_]
            c = Counter()
            # invoke it once and get the amount of bytes
            func(c, *args)
            func._byte_count = c.counter
            return func
        return impl

BIT_MASK_4 =  0xF
BIT_MASK_12 = 0xFFF
BIT_MASK_16 = 0xFFFF
BIT_MASK_20 = 0xFFFFF
BIT_MASK_32 = 0xFFFFFFFF

@always_inline
def encode_base_displace(mc, base_displace):
    """
        +---------------------------------+
        | ... | base | length[0:11] | ... |
        +---------------------------------+
    """
    displace = base_displace.displace
    base = base_displace.base & 0xf
    byte = (displace >> 8 & 0xf) | base << 4
    mc.writechar(chr(byte))
    mc.writechar(chr(displace & 0xff))

@always_inline
def encode_base_displace_long(mc, basedisp):
    """
        +-------------------------------------------------+
        | ... | base | length[0:11] | length[12:20] | ... |
        +-------------------------------------------------+
    """
    displace = basedisp.displace & BIT_MASK_20
    base = basedisp.base & 0xf
    byte = (displace >> 8) & 0xf | base << 4
    mc.writechar(chr(byte))
    mc.writechar(chr(displace & 0xff))
    byte = displace >> 12 & 0xff
    mc.writechar(chr(byte))

@always_inline
def encode_index_base_displace(mc, reg, idxbasedisp):
    """
        +----------------------------------------------------+
        | opcode | reg & index | base & displace[0:11] | ... |
        +----------------------------------------------------+
    """
    index = idxbasedisp.index
    byte = (reg & 0x0f) << 4 | index & 0xf
    mc.writechar(chr(byte))
    displace = idxbasedisp.displace & BIT_MASK_12
    base = idxbasedisp.base & 0xf
    byte = displace >> 8 & 0xf | base << 4
    mc.writechar(chr(byte))
    mc.writechar(chr(displace & 0xff))

def build_e(mnemonic, (opcode1,opcode2)):
    @builder.arguments('')
    def encode_e(self):
        self.writechar(opcode1)
        self.writechar(opcode2)
    return encode_e

def build_i(mnemonic, (opcode,)):
    @builder.arguments('u8')
    def encode_i(self, imm):
        self.writechar(opcode)
        self.writechar(chr(imm))
    return encode_i

def build_rr(mnemonic, (opcode,), argtypes='r,r'):
    @builder.arguments(argtypes)
    def encode_rr(self, reg1, reg2):
        self.writechar(opcode)
        operands = ((reg1 & 0x0f) << 4) | (reg2 & 0xf)
        self.writechar(chr(operands))
    return encode_rr

def build_rre(mnemonic, (opcode1,opcode2), argtypes='r,r'):
    @builder.arguments(argtypes)
    def encode_rre(self, reg1, reg2):
        self.writechar(opcode1)
        self.writechar(opcode2)
        self.writechar('\x00')
        operands = ((reg1 & 0x0f) << 4) | (reg2 & 0xf)
        self.writechar(chr(operands))
    return encode_rre

def build_rx(mnemonic, (opcode,)):
    @builder.arguments('r/m,bid')
    def encode_rx(self, reg_or_mask, idxbasedisp):
        self.writechar(opcode)
        encode_index_base_displace(self, reg_or_mask, idxbasedisp)
    return encode_rx

def build_rxy(mnemonic, (opcode1,opcode2), arguments='r/m,bidl'):
    @builder.arguments(arguments)
    def encode_rxy(self, reg_or_mask, idxbasedisp):
        self.writechar(opcode1)
        index = idxbasedisp.index
        byte = (reg_or_mask & 0x0f) << 4 | index & 0xf
        self.writechar(chr(byte))
        encode_base_displace_long(self, idxbasedisp)
        self.writechar(opcode2)
    return encode_rxy

def build_ri(mnemonic, (opcode,halfopcode)):
    br = is_branch_relative(mnemonic)
    @builder.arguments('r/m,i16')
    def encode_ri(self, reg_or_mask, imm16):
        self.writechar(opcode)
        byte = (reg_or_mask & 0xf) << 4 | (ord(halfopcode) & 0xf)
        self.writechar(chr(byte))
        if br:
            imm16 = imm16 >> 1
        self.writechar(chr(imm16 >> 8 & 0xff))
        self.writechar(chr(imm16 & 0xff))
    return encode_ri

def build_ri_u(mnemonic, (opcode,halfopcode)):
    # unsigned version of ri
    func = build_ri(mnemonic, (opcode,halfopcode))
    func._arguments_[1] = 'u16'
    return func

def build_ril(mnemonic, (opcode,halfopcode), args='r/m,i32'):
    br = is_branch_relative(mnemonic)
    @builder.arguments(args)
    def encode_ri(self, reg_or_mask, imm32):
        self.writechar(opcode)
        byte = (reg_or_mask & 0xf) << 4 | (ord(halfopcode) & 0xf)
        self.writechar(chr(byte))
        if br:
            imm32 = imm32 >> 1
        # half word boundary, addressing bytes
        self.write_i32(imm32 & BIT_MASK_32)
    return encode_ri

def build_s(mnemonic, (opcode1,opcode2)):
    @builder.arguments('bd')
    def encode_s(self, base_displace):
        self.writechar(opcode1)
        self.writechar(opcode2)
        encode_base_displace(self, base_displace)
    return encode_s

def build_si(mnemonic, (opcode,)):
    @builder.arguments('bd,u8')
    def encode_si(self, base_displace, uimm8):
        self.writechar(opcode)
        self.writechar(chr(uimm8))
        encode_base_displace(self, base_displace)
    return encode_si

def build_siy(mnemonic, (opcode1,opcode2)):
    @builder.arguments('bd,u8')
    def encode_siy(self, base_displace, uimm8):
        self.writechar(opcode1)
        self.writechar(chr(uimm8))
        encode_base_displace(self, base_displace)
        displace = base_displace.displace
        self.writechar(chr(displace >> 12 & 0xff))
        self.writechar(opcode2)
    return encode_siy

def build_ssa(mnemonic, (opcode1,)):
    @builder.arguments('l8bd,bd')
    def encode_ssa(self, len_base_disp, base_displace):
        self.writechar(opcode1)
        self.writechar(chr(len_base_disp.length & 0xff))
        encode_base_displace(self, len_base_disp)
        encode_base_displace(self, base_displace)
    return encode_ssa

def build_ssb(mnemonic, (opcode1,)):
    @builder.arguments('l8bd,l8bd')
    def encode_ssb(self, len_base_disp1, len_base_disp2):
        self.writechar(opcode1)
        byte = (len_base_disp1.length & 0xf) << 4 | len_base_disp2.length & 0xf
        self.writechar(chr(byte))
        encode_base_displace(self, len_base_disp1)
        encode_base_displace(self, len_base_disp2)
    return encode_ssb

def build_ssc(mnemonic, (opcode1,)):
    @builder.arguments('l4bd,bd,u4')
    def encode_ssc(self, len_base_disp, base_disp, uimm4):
        self.writechar(opcode1)
        byte = (len_base_disp.length & 0xf) << 4 | uimm4 & 0xf
        self.writechar(chr(byte))
        encode_base_displace(self, len_base_disp)
        encode_base_displace(self, base_disp)
    return encode_ssc

def build_ssd(mnemonic, (opcode,)):
    @builder.arguments('bid,bd,r')
    def encode_ssd(self, index_base_disp, base_disp, reg):
        self.writechar(opcode)
        byte = (index_base_disp.index & 0xf) << 4 | reg & 0xf
        self.writechar(chr(byte))
        encode_base_displace(self, index_base_disp)
        encode_base_displace(self, base_disp)
    return encode_ssd

def build_sse(mnemonic, (opcode,)):
    @builder.arguments('r,r,bd,bd')
    def encode_sse(self, reg1, reg3, base_disp2, base_disp4):
        self.writechar(opcode)
        byte = (reg1 & BIT_MASK_4) << 4 | reg3 & BIT_MASK_4
        self.writechar(chr(byte))
        encode_base_displace(self, base_disp2)
        encode_base_displace(self, base_disp4)
    return encode_sse

def build_ssf(mnemonic, (opcode,)):
    @builder.arguments('bd,l8bd')
    def encode_ssf(self, base_disp, len_base_disp):
        self.writechar(opcode)
        self.writechar(chr(len_base_disp.length & 0xff))
        encode_base_displace(self, base_disp)
        encode_base_displace(self, len_base_disp)
    return encode_ssf

def build_rs(mnemonic, (opcode,), argtypes='r,r,bd'):
    @builder.arguments(argtypes)
    def encode_rs(self, reg1, reg3, base_displace):
        self.writechar(opcode)
        self.writechar(chr((reg1 & BIT_MASK_4) << 4 | reg3 & BIT_MASK_4))
        encode_base_displace(self, base_displace)
    return encode_rs

@always_inline
def _encode_rsy(self, opcode1, opcode2, reg1, reg3, base_displace):
    self.writechar(opcode1)
    self.writechar(chr((reg1 & BIT_MASK_4) << 4 | reg3 & BIT_MASK_4))
    encode_base_displace_long(self, base_displace)
    self.writechar(opcode2)

def build_rsy_a(mnemonic, (opcode1,opcode2)):
    @builder.arguments('r,r,bdl')
    def encode_rsy(self, reg1, reg3, base_displace):
        _encode_rsy(self, opcode1, opcode2, reg1, reg3, base_displace)
    return encode_rsy

def build_rsy_b(mnemonic, (opcode1,opcode2)):
    @builder.arguments('r,bdl,r')
    def encode_rsy(self, reg1, base_displace, reg3):
        _encode_rsy(self, opcode1, opcode2, reg1, reg3, base_displace)
    return encode_rsy

def build_rsi(mnemonic, (opcode,)):
    br = is_branch_relative(mnemonic)
    @builder.arguments('r,r,i16')
    def encode_ri(self, reg1, reg2, imm16):
        self.writechar(opcode)
        byte = (reg1 & BIT_MASK_4) << 4 | (reg2 & BIT_MASK_4)
        self.writechar(chr(byte))
        if br:
            imm16 = imm16 >> 1
        self.write_i16(imm16 & BIT_MASK_16)
    return encode_ri

def build_rie_d(mnemonic, (opcode1,opcode2)):
    @builder.arguments('r,r,i16')
    def encode_rie_d(self, reg1, reg2, imm16):
        self.writechar(opcode1)
        byte = (reg1 & BIT_MASK_4) << 4 | (reg2 & BIT_MASK_4)
        self.writechar(chr(byte))
        self.write_i16(imm16 & BIT_MASK_16)
        self.writechar(chr(0x0))
        self.writechar(opcode2)
    return encode_rie_d

def build_rie_e(mnemonic, (opcode1,opcode2)):
    br = is_branch_relative(mnemonic)
    @builder.arguments('r,r,i16')
    def encode_rie_e(self, reg1, reg2, imm16):
        self.writechar(opcode1)
        byte = (reg1 & BIT_MASK_4) << 4 | (reg2 & BIT_MASK_4)
        self.writechar(chr(byte))
        if br:
            imm16 = imm16 >> 1
        self.write_i16(imm16 & BIT_MASK_16)
        self.writechar(chr(0x0))
        self.writechar(opcode2)
    return encode_rie_e

def build_rie_f(mnemonic, (opcode1,opcode2)):
    @builder.arguments('r,r,u8,u8,u8')
    def encode_rie_f(self, reg1, reg2, i1, i2, i3):
        self.writechar(opcode1)
        byte = (reg1 & BIT_MASK_4) << 4 | (reg2 & BIT_MASK_4)
        self.writechar(chr(byte))
        self.writechar(chr(i1))
        self.writechar(chr(i2))
        self.writechar(chr(i3))
        self.writechar(opcode2)
    return encode_rie_f

def build_rie_a(mnemonic, (opcode1,opcode2)):
    br = is_branch_relative(mnemonic)
    @builder.arguments('r,i16,r/m')
    def encode_rie_a(self, reg1, imm16, mask):
        self.writechar(opcode1)
        byte = (reg1 & BIT_MASK_4) << 4 | (mask & BIT_MASK_4)
        self.writechar(chr(byte))
        if br:
            imm16 = imm16 >> 1
        self.write_i16(imm16 & BIT_MASK_16)
        self.writechar(chr(0x0))
        self.writechar(opcode2)
    return encode_rie_a

build_rie_g = build_rie_a

def build_rie_b(mnemonic, (opcode1,opcode2)):
    br = is_branch_relative(mnemonic)
    @builder.arguments('r,r,r/m,i16')
    def encode_rie_b(self, reg1, reg2, mask, imm16):
        self.writechar(opcode1)
        byte = (reg1 & BIT_MASK_4) << 4 | (reg2 & BIT_MASK_4)
        self.writechar(chr(byte))
        if br:
            imm16 = imm16 >> 1
        self.write_i16(imm16 & BIT_MASK_16)
        byte = (mask & BIT_MASK_4) << 4
        self.writechar(chr(byte))
        self.writechar(opcode2)
    return encode_rie_b

def build_rie_c(mnemonic, (opcode1,opcode2), argtypes='r,i8,r/m,i16'):
    br = is_branch_relative(mnemonic)
    @builder.arguments(argtypes)
    def encode_rie_c(self, reg1, imm8, mask, imm16):
        self.writechar(opcode1)
        byte = (reg1 & BIT_MASK_4) << 4 | (mask & BIT_MASK_4)
        self.writechar(chr(byte))
        if br:
            imm16 = imm16 >> 1
        self.write_i16(imm16 & BIT_MASK_16)
        self.writechar(chr(imm8 & 0xff))
        self.writechar(opcode2)
    return encode_rie_c

@always_inline
def _encode_rrf(self, opcode1, opcode2, r1, r2, rm3, rm4):
    self.writechar(opcode1)
    self.writechar(opcode2)
    byte = (rm3 & BIT_MASK_4) << 4 | (rm4 & BIT_MASK_4)
    self.writechar(chr(byte))
    byte = (r1 & BIT_MASK_4) << 4 | (r2 & BIT_MASK_4)
    self.writechar(chr(byte))

def build_rrf_a(mnemonic, (opcode1,opcode2), argtypes='r,r,r'):
    @builder.arguments(argtypes)
    def encode_rrf_a(self, r1, r2, r3):
        _encode_rrf(self, opcode1, opcode2, r1, r2, r3, 0)
    return encode_rrf_a

def build_rrf_c(mnemonic, (opcode1,opcode2), argtypes='r,r,r/m,-'):
    @builder.arguments(argtypes)
    def encode_rrf_b(self, r1, r2, rm3, rm4):
        _encode_rrf(self, opcode1, opcode2, r1, r2, rm3, rm4)
    return encode_rrf_b

def build_rrf_e(mnemonic, (opcode1,opcode2), argtypes):
    @builder.arguments(argtypes)
    def encode_rrf_e(self, r1, rm3, r2, rm4):
        _encode_rrf(self, opcode1, opcode2, r1, r2, rm3, rm4)
    return encode_rrf_e
build_rrf_b = build_rrf_e

def build_rxe(mnemonic, (opcode1,opcode2), argtypes):
    @builder.arguments(argtypes)
    def encode_rxe(self, reg, idxbasedisp, mask):
        self.writechar(opcode1)
        encode_index_base_displace(self, reg, idxbasedisp)
        self.writechar(chr((mask & 0xf) << 4))
        self.writechar(opcode2)
    return encode_rxe

def build_rxf(mnemonic, (opcode1,opcode2)):
    @builder.arguments('r,bidl,r/m')
    def encode_rxe(self, reg1, idxbasedisp, reg3):
        self.writechar(opcode1)
        index = idxbasedisp.index
        byte = (reg3 & 0x0f) << 4 | index & 0xf
        self.writechar(chr(byte))
        encode_base_displace_long(self, reg, idxbasedisp)
        self.writechar(chr((reg1 & 0xf) << 4))
        self.writechar(opcode2)
    return encode_rxe

def build_ris(mnemonic, (opcode1,opcode2), argtypes='r,i8,r/m,bd'):
    @builder.arguments(argtypes)
    def encode_rie_c(self, reg1, imm8, mask, basedisp):
        self.writechar(opcode1)
        byte = (reg1 & BIT_MASK_4) << 4 | (mask & BIT_MASK_4)
        self.writechar(chr(byte))
        #
        encode_base_displace(self, basedisp)
        self.writechar(chr(imm8 & 0xff))
        self.writechar(opcode2)
    return encode_rie_c

def build_vrx(mnemonic, (opcode1,opcode2), argtypes='v,bid,m'):
    @builder.arguments(argtypes)
    def encode_vrx(self, v1, bid, mask=0):
        self.writechar(opcode1)
        rbx = (v1 >= 16) << 3
        idx = bid.index
        byte = (v1 & BIT_MASK_4) << 4 | (idx & BIT_MASK_4)
        self.writechar(chr(byte))
        encode_base_displace(self, bid)
        self.writechar(chr((mask & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vrx

def build_vrr_a(mnemonic, (opcode1,opcode2), argtypes='v,v,m,m,m'):
    @builder.arguments(argtypes)
    def encode_vrr_a(self, v1, v2, mask3=0, mask4=0, mask5=0):
        self.writechar(opcode1)
        rbx =  (v1 >= 16) << 3
        rbx |= (v2 >= 16) << 2
        byte = (v1 & BIT_MASK_4) << 4 | (v2 & BIT_MASK_4)
        self.writechar(chr(byte))
        self.writechar(chr(0))
        self.writechar(chr((mask5 & BIT_MASK_4) << 4 | (mask4 & BIT_MASK_4)))
        self.writechar(chr((mask3 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vrr_a

def build_vrr_b(mnemonic, (opcode1,opcode2), argtypes='v,v,v,m,m'):
    @builder.arguments(argtypes)
    def encode_vrr_b(self, v1, v2, v3, mask4, mask5):
        self.writechar(opcode1)
        rbx =  (v1 >= 16) << 3
        rbx |= (v2 >= 16) << 2
        rbx |= (v3 >= 16) << 1
        byte = (v1 & BIT_MASK_4) << 4 | (v2 & BIT_MASK_4)
        self.writechar(chr(byte))
        self.writechar(chr((v3 & BIT_MASK_4) << 4))
        self.writechar(chr((mask5 & BIT_MASK_4) << 4))
        self.writechar(chr((mask4 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vrr_b

def build_vrr_c(mnemonic, (opcode1,opcode2), argtypes='v,v,v,m,m,m'):
    @builder.arguments(argtypes)
    def encode_vrr_c(self, v1, v2, v3, mask4=0, mask5=0, mask6=0):
        self.writechar(opcode1)
        rbx =  (v1 >= 16) << 3
        rbx |= (v2 >= 16) << 2
        rbx |= (v3 >= 16) << 1
        byte = (v1 & BIT_MASK_4) << 4 | (v2 & BIT_MASK_4)
        self.writechar(chr(byte))
        byte = (v3 & BIT_MASK_4) << 4
        self.writechar(chr(byte))
        self.writechar(chr((mask6 & BIT_MASK_4) << 4 | (mask5 & BIT_MASK_4)))
        self.writechar(chr((mask4 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vrr_c

def build_vrr_e(mnemonic, (opcode1,opcode2), argtypes='v,v,v,v,m,m'):
    @builder.arguments(argtypes)
    def encode_vrr_e(self, v1, v2, v3, v4, mask5=0, mask6=0):
        self.writechar(opcode1)
        rbx =  (v1 >= 16) << 3
        rbx |= (v2 >= 16) << 2
        rbx |= (v3 >= 16) << 1
        rbx |= (v4 >= 16)
        byte = (v1 & BIT_MASK_4) << 4 | (v2 & BIT_MASK_4)
        self.writechar(chr(byte))
        byte = (v3 & BIT_MASK_4) << 4 | (mask6 & BIT_MASK_4) << 4
        self.writechar(chr(byte))
        self.writechar(chr((mask5 & BIT_MASK_4)))
        self.writechar(chr((v4 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vrr_e

def build_vri_a(mnemonic, (opcode1,opcode2), argtypes='v,i16,m'):
    @builder.arguments(argtypes)
    def encode_vri_a(self, v1, i2, mask3):
        self.writechar(opcode1)
        rbx =  (v1 >= 16) << 3
        byte = (v1 & BIT_MASK_4) << 4
        self.writechar(chr(byte))
        self.write_i16(i2 & BIT_MASK_16)
        self.writechar(chr((mask3 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vri_a

def build_vri_c(mnemonic, (opcode1,opcode2), argtypes='v,v,i16,m'):
    @builder.arguments(argtypes)
    def encode_vri_c(self, v1, v3, i2, mask4):
        self.writechar(opcode1)
        rbx  = (v1 >= 16) << 3
        rbx |= (v3 >= 16) << 2
        byte = (v1 & BIT_MASK_4) << 4 | (v3 & BIT_MASK_4)
        self.writechar(chr(byte))
        self.write_i16(i2 & BIT_MASK_16)
        self.writechar(chr((mask4 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vri_c

def build_vrs_b(mnemonic, (opcode1,opcode2), argtypes='v,r,db,m'):
    @builder.arguments(argtypes)
    def encode_vrs_b(self, v1, r2, db3, m4):
        self.writechar(opcode1)
        rbx = (v1 >= 16) << 3
        byte = (v1 & BIT_MASK_4) << 4 | (r2 & BIT_MASK_4)
        self.writechar(chr(byte))
        encode_base_displace(self, db3)
        self.writechar(chr((m4 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vrs_b

def build_vrs_c(mnemonic, (opcode1,opcode2), argtypes='r,v,db,m'):
    @builder.arguments(argtypes)
    def encode_vrs_c(self, r1, v2, db3, m4):
        self.writechar(opcode1)
        rbx = (v2 >= 16) << 2
        byte = (r1 & BIT_MASK_4) << 4 | (v2 & BIT_MASK_4)
        self.writechar(chr(byte))
        encode_base_displace(self, db3)
        self.writechar(chr((m4 & BIT_MASK_4) << 4 | (rbx & BIT_MASK_4)))
        self.writechar(opcode2)
    return encode_vrs_c


def build_unpack_func(mnemonic, func):
    @always_inline
    def check_arg_type(arg, type):
        #iX     - immediate X bits (signed)
        if type.startswith('i'):
            value = arg.value
            if type == 'i8': assert -2**7 <= value <= 2**7-1
            if type == 'i12': assert -2**11 <= value <= 2**11-1
            if type == 'i16': assert -2**15 <= value <= 2**15-1
            if type == 'i20': assert -2**19 <= value <= 2**19-1
            if type == 'i32': assert -2**31 <= value <= 2**31-1
        #uX     - immediate X bits (unsigend)
        if type.startswith('u'):
            value = arg.value
            if type == 'u8': assert  0 <= value <= 2**8-1
            if type == 'u12': assert 0 <= value <= 2**12-1
            if type == 'u16': assert 0 <= value <= 2**16-1
            if type == 'u20': assert 0 <= value <= 2**20-1
            if type == 'u32': assert 0 <= value <= 2**32-1
        #bd     - base displacement (unsigned 12 bit)
        #bid    - index base displacement (unsigned 12 bit)
        if type == 'bd' or type == 'bid':
            value = arg.displace
            assert 0 <= value <= 2**12-1
        #bdl    - base displacement long (20 bit)
        #bidl   - index base displacement (20 bit)
        if type == 'bdl' or type == 'bidl':
            value = arg.displace
            assert -2**19 <= value <= 2**19-1
        #l4bd   - length base displacement (4 bit)
        if type == 'l4db':
            value = arg.displace
            assert 0 <= value <= 2**4-1
        #h32    - halfwords 32 bit (e.g. LARL, or other relative instr.)
        if type == 'h32':
            value = arg.value
            assert -2**31 <= value <= 2**31-1
    @always_inline
    def unpack_arg(arg, argtype):
        check_arg_type(arg, argtype)
        if argtype == '-':
            return 0
        elif argtype == 'r' or argtype == 'r/m' or \
             argtype == 'f' or argtype == 'eo' or \
             argtype == 'v' or argtype == 'm':
            return arg.value
        elif argtype.startswith('i') or argtype.startswith('u') or argtype.startswith('h'):
            return arg.value
        else:
            return arg
    unpack_arg._annspecialcase_ = 'specialize:arg(1)'
    argtypes = func._arguments_[:]
    at = argtypes[0] if len(argtypes) >= 1 else '-'
    bt = argtypes[1] if len(argtypes) >= 2 else '-'
    ct = argtypes[2] if len(argtypes) >= 3 else '-'
    dt = argtypes[3] if len(argtypes) >= 4 else '-'
    et = argtypes[4] if len(argtypes) >= 5 else '-'
    ft = argtypes[5] if len(argtypes) >= 6 else '-'
    def function0(self):
        return func(self)
    def function1(self, a):
        e = unpack_arg(a, at)
        return func(self, e)
    def function2(self, a, b):
        e = unpack_arg(a, at)
        f = unpack_arg(b, bt)
        return func(self, e, f)
    def function2_last_default(self, a):
        e = unpack_arg(a, at)
        return func(self, e, 0)
    def function3(self, a, b, c):
        e = unpack_arg(a, at)
        f = unpack_arg(b, bt)
        g = unpack_arg(c, ct)
        return func(self, e, f, g)
    def function3_last_default(self, a, b):
        e = unpack_arg(a, at)
        f = unpack_arg(b, bt)
        return func(self, e, f, 0)
    def function4(self, a, b, c, d):
        e = unpack_arg(a, at)
        f = unpack_arg(b, bt)
        g = unpack_arg(c, ct)
        h = unpack_arg(d, dt)
        return func(self, e, f, g, h)
    def function4_last_default(self, a, b, c):
        e = unpack_arg(a, at)
        f = unpack_arg(b, bt)
        g = unpack_arg(c, ct)
        return func(self, e, f, g, 0)
    def function5(self, a, b, c, d, e):
        f = unpack_arg(a, at)
        g = unpack_arg(b, bt)
        h = unpack_arg(c, ct)
        i = unpack_arg(d, dt)
        j = unpack_arg(e, et)
        return func(self, f, g, h, i, j)
    def function6(self, a, b, c, d, e, f):
        g = unpack_arg(a, at)
        h = unpack_arg(b, bt)
        i = unpack_arg(c, ct)
        j = unpack_arg(d, dt)
        k = unpack_arg(e, et)
        l = unpack_arg(f, ft)
        return func(self, g, h, i, j, k, l)
    if len(argtypes) == 0:
        function = function0
    elif len(argtypes) == 1:
        function = function1
    elif len(argtypes) == 2:
        function = function2
        if argtypes[1] == '-':
            # e.g. SPM/IPM
            function = function2_last_default
    elif len(argtypes) == 3:
        function = function3
        if argtypes[2] == '-':
            # e.g. FIEBR or CGEBR ignore the last element
            function = function3_last_default
    elif len(argtypes) == 4:
        function = function4
        if argtypes[3] == '-':
            # e.g. FIEBR or CGEBR ignore the last element
            function = function4_last_default
    elif len(argtypes) == 5:
        function = function5
    elif len(argtypes) == 6:
        function = function6
    else:
        assert 0, "implement function for argtypes %s" % (argtypes,)
    function.__name__ = mnemonic
    return function

def is_branch_relative(name):
    return name.startswith('BR') or name.endswith('J')

def get_arg_types_of(mnemonic):
    """ NOT_RPYTHON """
    params = all_mnemonic_codes[mnemonic.split("_")[0]]
    if len(params) == 2:
        argtypes = None
        (instrtype, args) = params
    else:
        (instrtype, args, argtypes) = params
    builder = globals()['build_' + instrtype]
    if argtypes:
        func = builder(mnemonic, args, argtypes)
    else:
        func = builder(mnemonic, args)
    return func._arguments_

def build_instr_codes(clazz):
    for mnemonic, params in all_mnemonic_codes.items():
        argtypes = None
        if len(params) == 2:
            (instrtype, args) = params
        else:
            (instrtype, args, argtypes) = params
        builder = globals()['build_' + instrtype]
        if argtypes:
            func = builder(mnemonic, args, argtypes)
        else:
            func = builder(mnemonic, args)
        name = mnemonic + "_" + instrtype
        setattr(clazz, name, func)
        setattr(clazz, mnemonic, build_unpack_func(mnemonic, func))
        setattr(clazz, mnemonic + '_byte_count', func._byte_count)
        del func._byte_count
        del func._arguments_