# -*- 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
# -*- 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)
# -*- 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
# 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
# -*- 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()
# -*- 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
# -*- 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
# -*- 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
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
# -*- 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
# -*- 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
# -*- 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
# -*- 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
# -*- 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
# -*- 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
# -*- 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
# -*- 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
# -*- 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
# 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)
# -*- 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
# -*- 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
# -*- 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
# -*- 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
# -*- 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
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:
# -*- 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
# -*- 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
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
# -*- 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
# -*- 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
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)
# -*- 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
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