예제 #1
0
파일: cpu_bpf.py 프로젝트: zytMatrix/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.eBPF.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().items()))

#import specifications:
from amoco.arch.core import instruction, disassembler
instruction_BPF = type('instruction_BPF',(instruction,),{})
instruction_BPF.set_uarch(uarch)

# we use the same formatter has eBPF...
from amoco.arch.eBPF.formats import eBPF_full
instruction_BPF.set_formatter(eBPF_full)

#define disassembler with spec_bpf module:
from amoco.arch.eBPF import spec_bpf

disassemble = disassembler([spec_bpf],iclass=instruction_BPF)

def PC():
    return pc

def get_data_endian():
    return 1
예제 #2
0
파일: cpu_x86.py 프로젝트: zytMatrix/amoco 
# -*- coding: utf-8 -*-
from amoco.arch.x86.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().items()))

from amoco.arch.core import instruction, disassembler

instruction_x86 = type('instruction_x86',(instruction,),{})
instruction_x86.set_uarch(uarch)

from amoco.arch.x86.formats import *

from amoco.arch.x86 import spec_ia32
disassemble = disassembler([spec_ia32],iclass=instruction_x86)
disassemble.maxlen = 15

def PC():
    return eip

def get_data_endian():
    return 1 # LE

def configure(**kargs):
    from amoco.config import conf
    # asm format:
    f = kargs.get('format',conf.Arch.format_x86)
    if f in ('AT&T','at&t','ATT','att'):
        instruction_x86.set_formatter(IA32_ATT)
    elif f in ('Intel','INTEL','intel'):
        instruction_x86.set_formatter(IA32_Intel)
예제 #3
0
파일: cpu.py 프로젝트: zytMatrix/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.eBPF.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().items()))

#import specifications:
from amoco.arch.core import instruction, disassembler
instruction_eBPF = type('instruction_eBPF', (instruction, ), {})
instruction_eBPF.set_uarch(uarch)

from amoco.arch.eBPF.formats import eBPF_full
instruction_eBPF.set_formatter(eBPF_full)

#define disassembler:
from amoco.arch.eBPF import spec

disassemble = disassembler([spec], iclass=instruction_eBPF)


def PC():
    return pc


def get_data_endian():
    return 1
예제 #4
0
# Copyright (C) 2006-2014 Axel Tillequin ([email protected])
# published under GPLv2 license

from amoco.arch.arm.v7.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().items()))

from amoco.arch.core import instruction, disassembler

instruction_armv7 = type('instruction_armv7',(instruction,),{})
instruction_armv7.set_uarch(uarch)

# define disassembler:
from amoco.arch.arm.v7 import spec_armv7
from amoco.arch.arm.v7 import spec_thumb

from amoco.arch.arm.v7.formats import ARM_V7_full
instruction_armv7.set_formatter(ARM_V7_full)


mode   = (lambda : internals['isetstate'])
endian = (lambda : 1 if internals['ibigend']==0 else -1)

disassemble = disassembler([spec_armv7,spec_thumb],instruction_armv7,mode,endian)

def PC():
    return pc_

def get_data_endian():
    return 1 if internals['endianstate']==0 else -1
예제 #5
0
# -*- coding: utf-8 -*-

from amoco.arch.x86.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.x86.formats import *

instruction.set_formatter(IA32_Intel)

from amoco.arch.x86 import spec_ia32

disassemble = disassembler([spec_ia32])
disassemble.maxlen = 15

def PC():
    return eip

def configure(**kargs):
    from amoco.config import get_module_conf
    conf = get_module_conf('x86')
    conf.update(kargs)
    if conf['highlight']:
        instruction.set_formatter(IA32_Intel_highlighted)

configure()
예제 #6
0
파일: cpu_sh4.py 프로젝트: xorpse/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.superh.sh4.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_sh4 = type("instruction_sh4", (instruction, ), {})
instruction_sh4.set_uarch(uarch)

from amoco.arch.superh.sh4.formats import SH4_full
from amoco.arch.superh.sh4.formats import SH4_synthetic

instruction_sh4.set_formatter(SH4_synthetic)

# define disassembler:
from amoco.arch.superh.sh4 import spec_sh4

disassemble = disassembler([spec_sh4],
                           endian=lambda: -1,
                           iclass=instruction_sh4)


def PC():
    return PC
예제 #7
0
파일: cpu_z80.py 프로젝트: x86Labs/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.z80.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.z80.formats import Mostek_full
instruction.set_formatter(Mostek_full)

#define disassembler:
from amoco.arch.z80 import spec_mostek

disassemble = disassembler([spec_mostek])


def PC():
    return pc
예제 #8
0
# -*- coding: utf-8 -*-

from amoco.arch.mips.r3000.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_r3000 = type("instruction_r3000", (instruction, ), {})
instruction_r3000.set_uarch(uarch)

from amoco.arch.mips.r3000.formats import MIPS_full
from amoco.arch.mips.r3000.formats import MIPS_synthetic

instruction_r3000.set_formatter(MIPS_full)

# define disassembler:
from amoco.arch.mips.r3000 import spec

disassemble = disassembler([spec], iclass=instruction_r3000)


def PC():
    return pc


def get_data_endian():
    return 1  # LE
예제 #9
0
파일: cpu.py 프로젝트: sthagen/amoco 
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_wasm = type("instruction_wasm", (instruction, ), {})
instruction_wasm.set_uarch(uarch)

from amoco.arch.wasm.formats import DW_full

instruction_wasm.set_formatter(DW_full)

# define disassembler:
from amoco.arch.wasm import spec

disassemble = disassembler([spec], iclass=instruction_wasm)

# wasm instructions are fully determined with 1 byte only, but the operands
# are encoded in leb128 form for 32 or 33 bits integers. Wasm enforces a leb128
# encoding of ceil(N/7), leading to at most 5 bytes for one leb128 value.
# Since most instructions have not more than 3 operands we set the maxlen to 16.
# If an instruction needs more bytes in must rely on the xdata API (see arch.core.)
disassemble.maxlen = 16


def PC():
    return op_ptr


def get_data_endian():
    return 1
예제 #10
0
# -*- coding: utf-8 -*-

from amoco.arch.tricore.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_tricore = type("instruction_tricore", (instruction, ), {})
instruction_tricore.set_uarch(uarch)

from amoco.arch.tricore.formats import TriCore_full

instruction_tricore.set_formatter(TriCore_full)

# define disassembler:
from amoco.arch.tricore import spec

disassemble = disassembler([spec], iclass=instruction_tricore)


def PC():
    return pc


def get_data_endian():
    return 1  # LE
예제 #11
0
# -*- coding: utf-8 -*-

from amoco.arch.msp430.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.msp430.formats import MSP430_synthetic
instruction.set_formatter(MSP430_synthetic)

#define disassembler:
from amoco.arch.msp430 import spec_msp430

disassemble = disassembler([spec_msp430])
disassemble.maxlen = 6


def PC():
    return pc
예제 #12
0
파일: cpu.py 프로젝트: zachriggle/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.msp430.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.msp430.formats import MSP430_synthetic
instruction.set_formatter(MSP430_synthetic)

#define disassembler:
from amoco.arch.msp430 import spec_msp430

disassemble = disassembler([spec_msp430])
disassemble.maxlen = 6

def PC():
    return pc
예제 #13
0
# -*- coding: utf-8 -*-

# This code is part of Amoco
# Copyright (C) 2006-2014 Axel Tillequin ([email protected])
# published under GPLv2 license

from amoco.arch.arm.v8.asm64 import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

# define disassembler:
from amoco.arch.arm.v8 import spec_armv8
from amoco.arch.arm.v8.formats import ARM_V8_full

instruction.set_formatter(ARM_V8_full)

endian = (lambda : 1 if internals['endianstate']==0 else -1)

disassemble = disassembler([spec_armv8],endian=endian)

def PC():
    return pc
예제 #14
0
# -*- coding: utf-8 -*-

from amoco.arch.dwarf.asm import *
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().items()))

#import specifications:
from amoco.arch.core import instruction, disassembler
instruction_dwarf = type('instruction_dwarf', (instruction, ), {})
instruction_dwarf.set_uarch(uarch)

from amoco.arch.dwarf.formats import DW_full
instruction_dwarf.set_formatter(DW_full)

#define disassembler:
from amoco.arch.dwarf import spec

disassemble = disassembler([spec], iclass=instruction_dwarf)
disassemble.maxlen = 21


def PC():
    return op_ptr
예제 #15
0
# -*- coding: utf-8 -*-

from amoco.arch.pic.F46K22.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.pic.F46K22.formats import PIC_full
instruction.set_formatter(PIC_full)

#define disassembler:
from amoco.arch.pic.F46K22 import spec_pic18

disassemble = disassembler([spec_pic18])

def PC():
    return pc
예제 #16
0
파일: cpu_gb.py 프로젝트: zachriggle/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.z80.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.z80.formats import GB_full
instruction.set_formatter(GB_full)

#define disassembler:
from amoco.arch.z80 import spec_gb

disassemble = disassembler([spec_gb])

def PC():
    return pc
예제 #17
0
파일: cpu_gb.py 프로젝트: x86Labs/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.z80.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.z80.formats import GB_full
instruction.set_formatter(GB_full)

#define disassembler:
from amoco.arch.z80 import spec_gb

disassemble = disassembler([spec_gb])


def PC():
    return pc
예제 #18
0
# -*- coding: utf-8 -*-

from amoco.arch.pic.F46K22.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().items()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction_f46k22 = type('instruction_f46k22', (instruction, ), {})
instruction_f46k22.set_uarch(uarch)

from amoco.arch.pic.F46K22.formats import PIC_full
instruction_f46k22.set_formatter(PIC_full)

#define disassembler:
from amoco.arch.pic.F46K22 import spec_pic18

disassemble = disassembler([spec_pic18], iclass=instruction_f46k22)


def PC():
    return pc


def get_data_endian():
    return 1
예제 #19
0
# This code is part of Amoco
# Copyright (C) 2006-2014 Axel Tillequin ([email protected])
# published under GPLv2 license

from amoco.arch.arm.v8.asm64 import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().iteritems()))

from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

# define disassembler:
from amoco.arch.arm.v8 import spec_armv8
from amoco.arch.arm.v8.formats import ARM_V8_full

instruction.set_formatter(ARM_V8_full)

endian = (lambda: 1 if internals['endianstate'] == 0 else -1)

disassemble = disassembler([spec_armv8], endian=endian)
예제 #20
0
파일: cpu.py 프로젝트: jiandandan/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.msp430.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().items()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction_msp430 = type('instruction_msp430', (instruction, ), {})
instruction_msp430.set_uarch(uarch)

from amoco.arch.msp430.formats import MSP430_full
from amoco.arch.msp430.formats import MSP430_synthetic
instruction_msp430.set_formatter(MSP430_synthetic)

#define disassembler:
from amoco.arch.msp430 import spec_msp430

disassemble = disassembler([spec_msp430], iclass=instruction_msp430)
disassemble.maxlen = 6


def PC():
    return pc
예제 #21
0
파일: cpu_v8.py 프로젝트: zachriggle/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.sparc.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.sparc.formats import SPARC_V8_full
from amoco.arch.sparc.formats import SPARC_V8_synthetic
instruction.set_formatter(SPARC_V8_synthetic)

#define disassembler:
from amoco.arch.sparc import spec_v8

disassemble = disassembler([spec_v8],endian=lambda:-1)

def PC():
    return pc
예제 #22
0
# -*- coding: utf-8 -*-

# This code is part of Amoco
# Copyright (C) 2006-2014 Axel Tillequin ([email protected])
# published under GPLv2 license

from amoco.arch.arm.v7.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

# define disassembler:
from amoco.arch.arm.v7 import spec_armv7
from amoco.arch.arm.v7 import spec_thumb

from amoco.arch.arm.v7.formats import ARM_V7_full
instruction.set_formatter(ARM_V7_full)


mode   = (lambda : internals['isetstate'])
endian = (lambda : 1 if internals['endianstate']==0 else -1)

disassemble = disassembler([spec_armv7,spec_thumb],mode,endian)

def PC():
    return pc
예제 #23
0
# -*- coding: utf-8 -*-

from amoco.arch.z80.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().items()))

#import specifications:
from amoco.arch.core import instruction, disassembler
instruction_gb = type('instruction_gb', (instruction, ), {})
instruction_gb.set_uarch(uarch)

from amoco.arch.z80.formats import GB_full
instruction_gb.set_formatter(GB_full)

#define disassembler:
from amoco.arch.z80 import spec_gb

disassemble = disassembler([spec_gb], iclass=instruction_gb)


def PC():
    return pc
예제 #24
0
# -*- coding: utf-8 -*-

from amoco.arch.riscv.rv32i.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_riscv = type("instruction_riscv", (instruction, ), {})
instruction_riscv.set_uarch(uarch)

from amoco.arch.riscv.rv32i.formats import RISCV_full
from amoco.arch.riscv.rv32i.formats import RISCV_synthetic

instruction_riscv.set_formatter(RISCV_full)

# define disassembler:
from amoco.arch.riscv.rv32i import spec_rv32i

disassemble = disassembler([spec_rv32i], iclass=instruction_riscv)


def PC():
    return pc


def get_data_endian():
    return 1  # LE
예제 #25
0
from amoco.arch.x64.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

from amoco.arch.core import instruction, disassembler

instruction_x64 = type("instruction_x64", (instruction,), {})
instruction_x64.set_uarch(uarch)
from amoco.arch.x64.formats import IA32e_Intel, IA32e_ATT

instruction_x64.set_formatter(IA32e_Intel)

from amoco.arch.x64 import spec_ia32e

disassemble = disassembler([spec_ia32e], iclass=instruction_x64)
disassemble.maxlen = 15


def PC():
    return rip


def get_data_endian():
    return 1


def configure(**kargs):
    from amoco.config import conf

    # asm format:
예제 #26
0
# -*- coding: utf-8 -*-

# This code is part of Amoco
# Copyright (C) 2006-2014 Axel Tillequin ([email protected])
# published under GPLv2 license

from amoco.arch.arm.v8.asm64 import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().items()))

from amoco.arch.core import instruction, disassembler
instruction_armv8 = type('instruction_armv8', (instruction, ), {})
instruction_armv8.set_uarch(uarch)

# define disassembler:
from amoco.arch.arm.v8 import spec_armv8
from amoco.arch.arm.v8.formats import ARM_V8_full

instruction_armv8.set_formatter(ARM_V8_full)

endian = (lambda: 1 if internals['ibigend'] == 0 else -1)

disassemble = disassembler([spec_armv8],
                           endian=endian,
                           iclass=instruction_armv8)


def PC():
    return pc
예제 #27
0
파일: cpu_x86.py 프로젝트: zachriggle/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.x86.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)
from amoco.arch.x86.formats import IA32_Intel
instruction.set_formatter(IA32_Intel)

from amoco.arch.x86 import spec_ia32

disassemble = disassembler([spec_ia32])
disassemble.maxlen = 15

def PC():
    return eip
예제 #28
0
from amoco.arch.sparc.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_sparc = type("instruction_sparc", (instruction, ), {})
instruction_sparc.set_uarch(uarch)

from amoco.arch.sparc.formats import SPARC_V8_full
from amoco.arch.sparc.formats import SPARC_V8_synthetic

instruction_sparc.set_formatter(SPARC_V8_full)

# define disassembler:
from amoco.arch.sparc import spec_v8

disassemble = disassembler([spec_v8],
                           endian=lambda: -1,
                           iclass=instruction_sparc)


def PC():
    return pc


def get_data_endian():
    return -1
예제 #29
0
파일: cpu_z80.py 프로젝트: xorpse/amoco 
# -*- coding: utf-8 -*-

from amoco.arch.z80.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_z80 = type("instruction_z80", (instruction, ), {})
instruction_z80.set_uarch(uarch)

from amoco.arch.z80.formats import Mostek_full

instruction_z80.set_formatter(Mostek_full)

# define disassembler:
from amoco.arch.z80 import spec_mostek

disassemble = disassembler([spec_mostek], iclass=instruction_z80)


def PC():
    return pc


def get_data_endian():
    return 1
예제 #30
0
# -*- coding: utf-8 -*-

from amoco.arch.v850.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().items()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction_v850 = type('instruction_v850', (instruction, ), {})
instruction_v850.set_uarch(uarch)

from amoco.arch.v850.formats import v850_full

instruction_v850.set_formatter(v850_full)

#define disassembler:
import amoco.arch.v850.spec_v850e2s as spec

disassemble = disassembler([spec], iclass=instruction_v850)


def PC():
    return pc


def get_data_endian():
    return 1
예제 #31
0
from amoco.arch.sparc.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv:kv[0].startswith('i_'),locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.sparc.formats import SPARC_V8_full
from amoco.arch.sparc.formats import SPARC_V8_synthetic
instruction.set_formatter(SPARC_V8_synthetic)

#define disassembler:
from amoco.arch.sparc import spec_v8

disassemble = disassembler([spec_v8],endian=lambda:-1)
예제 #32
0
# -*- coding: utf-8 -*-

from amoco.arch.pic.F46K22.asm import *
# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith('i_'), locals().iteritems()))

#import specifications:
from amoco.arch.core import instruction, disassembler

instruction.set_uarch(uarch)

from amoco.arch.pic.F46K22.formats import PIC_full
instruction.set_formatter(PIC_full)

#define disassembler:
from amoco.arch.pic.F46K22 import spec_pic18

disassemble = disassembler([spec_pic18])


def PC():
    return pc
예제 #33
0
파일: cpu_r3000.py 프로젝트: sthagen/amoco 
from amoco.arch.mips.r3000.asm import *

# expose "microarchitecture" (instructions semantics)
uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items()))

# import specifications:
from amoco.arch.core import instruction, disassembler

instruction_r3000 = type("instruction_r3000", (instruction, ), {})
instruction_r3000.set_uarch(uarch)

from amoco.arch.mips.r3000.formats import MIPS_full
from amoco.arch.mips.r3000.formats import MIPS_synthetic

instruction_r3000.set_formatter(MIPS_full)

# define disassembler:
from amoco.arch.mips.r3000 import spec

endian = lambda: -1

disassemble = disassembler([spec], iclass=instruction_r3000, endian=endian)


def PC():
    return pc


def get_data_endian():
    return -1  # BE