ROSE  0.11.137.0
Namespaces | Classes | Typedefs | Enumerations | Functions
Rose::BinaryAnalysis Namespace Reference

Description

Binary analysis.

ROSE supports both source code analysis and binary analysis. This namespace contains most of the binary analysis features. The Binary analysis tutorial is a good place to get started, and most of its examples link to the API documentation. Follow those links to the enclosing class and/or namespace to obtain an overview of how those classes and namespaces work.

Namespaces

 CallingConvention
 Support for binary calling conventions.
 
 Commit
 Whether to commit memory allocations.
 
 Concolic
 Combined concrete and symbolic analysis.
 
 Debugger
 Name space for dynamic debuggers.
 
 Disassembler
 Instruction decoders.
 
 Dwarf
 Functions for DWARF debugging information.
 
 InstructionSemantics
 Binary instruction semantics.
 
 Partitioner2
 Binary function detection.
 
 PointerDetection
 Pointer detection analysis.
 
 ReturnValueUsed
 Contains functions that analyze whether a function returns a value which is used by the caller.
 
 StackDelta
 Stack delta analysis.
 
 Strings
 Suport for finding strings in memory.
 
 SymbolicExpression
 Namespace supplying types and functions for symbolic expressions.
 
 Unparser
 Generates pseudo-assembly listings.
 
 Variables
 Facilities for detecting variables in binaries.
 

Classes

class  AbstractLocation
 Abstract location. More...
 
class  AsmFunctionIndex
 Functions indexed by entry address. More...
 
class  AsmUnparser
 Unparses binary AST into text. More...
 
class  Assembler
 Virtual base class for instruction assemblers. More...
 
class  AssemblerX86
 This class contains methods for assembling x86 instructions (SgAsmX86Instruction). More...
 
class  AstHash
 A simple traversal that builds up a hash code for the AST. More...
 
class  BestMapAddress
 Finds best address for mapping code. More...
 
class  BinaryLoader
 Base class for loading a static or dynamic object. More...
 
class  BinaryLoaderElf
 Loader for ELF files. More...
 
class  BinaryLoaderElfObj
 A loader suitable for ELF object files. More...
 
class  BinaryLoaderPe
 Loader for Windows PE files. More...
 
class  BinaryToSource
 Convert binary to low-level C source code. More...
 
class  CodeInserter
 Insert new code in place of existing instructions. More...
 
class  CompareLeavesByName
 
class  CompareRawLeavesByName
 
class  ConcreteLocation
 Concrete location of data. More...
 
class  ControlFlow
 Binary control flow analysis. More...
 
class  DataFlow
 Various tools for data-flow analysis. More...
 
class  Demangler
 Demangle mangled names. More...
 
class  FeasiblePath
 Feasible path analysis. More...
 
class  FunctionCall
 Binary function call analysis. More...
 
class  FunctionSimilarity
 Analysis to test the similarity of two functions. More...
 
class  HotPatch
 Describes how to modify machine state after each instruction. More...
 
struct  InsnCFGVertexWriter
 A vertex property writer for instruction-based CFGs. More...
 
class  InstructionProvider
 Provides and caches instructions. More...
 
class  MagicNumber
 
class  Matrix
 Matrix values. More...
 
class  MemoryMap
 An efficient mapping from an address space to stored data. More...
 
class  NoOperation
 Analysis that looks for no-op equivalents. More...
 
class  Reachability
 Analysis that computes reachability of CFG vertices. More...
 
class  RegisterDescriptor
 Describes (part of) a physical CPU register. More...
 
class  RegisterDictionary
 Defines registers available for a particular architecture. More...
 
class  RegisterNames
 Convert a register descriptor to a name. More...
 
class  RegisterParts
 Holds a set of registers without regard for register boundaries. More...
 
class  SerialInput
 Input binary analysis state. More...
 
class  SerialIo
 Base class for binary state input and output. More...
 
class  SerialOutput
 Output binary analysis state. More...
 
class  SmtlibSolver
 Wrapper around solvers that speak SMT-LIB. More...
 
class  SmtSolver
 Interface to Satisfiability Modulo Theory (SMT) solvers. More...
 
class  SmtSolverValidator
 Validates SMT solver name from command-line. More...
 
class  SourceLocations
 Bidirectional mapping between addresses and source locations. More...
 
class  SRecord
 S-Record hexadecimal data formats. More...
 
class  SymbolicExpressionParser
 Parses symbolic expressions from text. More...
 
class  SystemCall
 Analyzes basic blocks to get system call names. More...
 
class  TaintedFlow
 Various tools for performing tainted flow analysis. More...
 
class  VxcoreParser
 Parser for Vxcore format files. More...
 
class  Z3Solver
 Interface to the Z3 SMT solver. More...
 

Typedefs

typedef Sawyer::Container::Set< rose_addr_t > AddressSet
 
using BinaryLoaderPtr = Sawyer::SharedPointer< BinaryLoader >
 Reference counting pointer. More...
 
using BinaryLoaderElfPtr = Sawyer::SharedPointer< BinaryLoaderElf >
 Reference counting pointer. More...
 
using BinaryLoaderElfObjPtr = Sawyer::SharedPointer< BinaryLoaderElfObj >
 Reference counting pointer. More...
 
using BinaryLoaderPePtr = Sawyer::SharedPointer< BinaryLoaderPe >
 Refernce counting pointer. More...
 
using MemoryMapPtr = Sawyer::SharedPointer< MemoryMap >
 Reference counting pointer. More...
 
using RegisterDescriptors = std::vector< RegisterDescriptor >
 List of register descriptors in dictionary. More...
 
using RegisterDictionaryPtr = Sawyer::SharedPointer< RegisterDictionary >
 Reference counting pointer. More...
 
using SerialInputPtr = Sawyer::SharedPointer< SerialInput >
 Reference counting pointer. More...
 
using SerialIoPtr = Sawyer::SharedPointer< SerialIo >
 Reference counting pointer. More...
 
using SerialOutputPtr = Sawyer::SharedPointer< SerialOutput >
 Reference counting pointer. More...
 
using SmtSolverPtr = std::shared_ptr< SmtSolver >
 Reference counting pointer. More...
 
using SymbolicExpresssionPtr = SymbolicExpression::Ptr
 
using SymbolicExpressionPtr = SymbolicExpression::Ptr
 

Enumerations

enum  CilFamily { Cil_family = 0xffffffff }
 Members of the Motorola Coldfire family of m68k processors. More...
 
enum  CilInstructionKind {
  Cil_unknown_instruction = 0x0000,
  Cil_nop =0xFF00,
  Cil_break,
  Cil_ldarg_0,
  Cil_ldarg_1,
  Cil_ldarg_2,
  Cil_ldarg_3,
  Cil_ldloc_0,
  Cil_ldloc_1,
  Cil_ldloc_2,
  Cil_ldloc_3,
  Cil_stloc_0,
  Cil_stloc_1,
  Cil_stloc_2,
  Cil_stloc_3,
  Cil_ldarg_s,
  Cil_ldarga_s,
  Cil_starg_s,
  Cil_ldloc_s,
  Cil_ldloca_s,
  Cil_stloc_s,
  Cil_ldnull,
  Cil_ldc_i4_m1,
  Cil_ldc_i4_0,
  Cil_ldc_i4_1,
  Cil_ldc_i4_2,
  Cil_ldc_i4_3,
  Cil_ldc_i4_4,
  Cil_ldc_i4_5,
  Cil_ldc_i4_6,
  Cil_ldc_i4_7,
  Cil_ldc_i4_8,
  Cil_ldc_i4_s,
  Cil_ldc_i4,
  Cil_ldc_i8,
  Cil_ldc_r4,
  Cil_ldc_r8,
  Cil_unused99,
  Cil_dup,
  Cil_pop,
  Cil_jmp,
  Cil_call,
  Cil_calli,
  Cil_ret,
  Cil_br_s,
  Cil_brfalse_s,
  Cil_brtrue_s,
  Cil_beq_s,
  Cil_bge_s,
  Cil_bgt_s,
  Cil_ble_s,
  Cil_blt_s,
  Cil_bne_un_s,
  Cil_bge_un_s,
  Cil_bgt_un_s,
  Cil_ble_un_s,
  Cil_blt_un_s,
  Cil_br,
  Cil_brfalse,
  Cil_brtrue,
  Cil_beq,
  Cil_bge,
  Cil_bgt,
  Cil_ble,
  Cil_blt,
  Cil_bne_un,
  Cil_bge_un,
  Cil_bgt_un,
  Cil_ble_un,
  Cil_blt_un,
  Cil_switch,
  Cil_ldind_i1,
  Cil_ldind_u1,
  Cil_ldind_i2,
  Cil_ldind_u2,
  Cil_ldind_i4,
  Cil_ldind_u4,
  Cil_ldind_i8,
  Cil_ldind_i,
  Cil_ldind_r4,
  Cil_ldind_r8,
  Cil_ldind_ref,
  Cil_stind_ref,
  Cil_stind_i1,
  Cil_stind_i2,
  Cil_stind_i4,
  Cil_stind_i8,
  Cil_stind_r4,
  Cil_stind_r8,
  Cil_add,
  Cil_sub,
  Cil_mul,
  Cil_div,
  Cil_div_un,
  Cil_rem,
  Cil_rem_un,
  Cil_and,
  Cil_or,
  Cil_xor,
  Cil_shl,
  Cil_shr,
  Cil_shr_un,
  Cil_neg,
  Cil_not,
  Cil_conv_i1,
  Cil_conv_i2,
  Cil_conv_i4,
  Cil_conv_i8,
  Cil_conv_r4,
  Cil_conv_r8,
  Cil_conv_u4,
  Cil_conv_u8,
  Cil_callvirt,
  Cil_cpobj,
  Cil_ldobj,
  Cil_ldstr,
  Cil_newobj,
  Cil_castclass,
  Cil_isinst,
  Cil_conv_r_un,
  Cil_unused58,
  Cil_unused1,
  Cil_unbox,
  Cil_throw,
  Cil_ldfld,
  Cil_ldflda,
  Cil_stfld,
  Cil_ldsfld,
  Cil_ldsflda,
  Cil_stsfld,
  Cil_stobj,
  Cil_conv_ovf_i1_un,
  Cil_conv_ovf_i2_un,
  Cil_conv_ovf_i4_un,
  Cil_conv_ovf_i8_un,
  Cil_conv_ovf_u1_un,
  Cil_conv_ovf_u2_un,
  Cil_conv_ovf_u4_un,
  Cil_conv_ovf_u8_un,
  Cil_conv_ovf_i_un,
  Cil_conv_ovf_u_un,
  Cil_box,
  Cil_newarr,
  Cil_ldlen,
  Cil_ldelema,
  Cil_ldelem_i1,
  Cil_ldelem_u1,
  Cil_ldelem_i2,
  Cil_ldelem_u2,
  Cil_ldelem_i4,
  Cil_ldelem_u4,
  Cil_ldelem_i8,
  Cil_ldelem_i,
  Cil_ldelem_r4,
  Cil_ldelem_r8,
  Cil_ldelem_ref,
  Cil_stelem_i,
  Cil_stelem_i1,
  Cil_stelem_i2,
  Cil_stelem_i4,
  Cil_stelem_i8,
  Cil_stelem_r4,
  Cil_stelem_r8,
  Cil_stelem_ref,
  Cil_ldelem,
  Cil_stelem,
  Cil_unbox_any,
  Cil_unused5,
  Cil_unused6,
  Cil_unused7,
  Cil_unused8,
  Cil_unused9,
  Cil_unused10,
  Cil_unused11,
  Cil_unused12,
  Cil_unused13,
  Cil_unused14,
  Cil_unused15,
  Cil_unused16,
  Cil_unused17,
  Cil_conv_ovf_i1,
  Cil_conv_ovf_u1,
  Cil_conv_ovf_i2,
  Cil_conv_ovf_u2,
  Cil_conv_ovf_i4,
  Cil_conv_ovf_u4,
  Cil_conv_ovf_i8,
  Cil_conv_ovf_u8,
  Cil_unused50,
  Cil_unused18,
  Cil_unused19,
  Cil_unused20,
  Cil_unused21,
  Cil_unused22,
  Cil_unused23,
  Cil_refanyval,
  Cil_ckfinite,
  Cil_unused24,
  Cil_unused25,
  Cil_mkrefany,
  Cil_unused59,
  Cil_unused60,
  Cil_unused61,
  Cil_unused62,
  Cil_unused63,
  Cil_unused64,
  Cil_unused65,
  Cil_unused66,
  Cil_unused67,
  Cil_ldtoken,
  Cil_conv_u2,
  Cil_conv_u1,
  Cil_conv_i,
  Cil_conv_ovf_i,
  Cil_conv_ovf_u,
  Cil_add_ovf,
  Cil_add_ovf_un,
  Cil_mul_ovf,
  Cil_mul_ovf_un,
  Cil_sub_ovf,
  Cil_sub_ovf_un,
  Cil_endfinally,
  Cil_leave,
  Cil_leave_s,
  Cil_stind_i,
  Cil_conv_u,
  Cil_unused26,
  Cil_unused27,
  Cil_unused28,
  Cil_unused29,
  Cil_unused30,
  Cil_unused31,
  Cil_unused32,
  Cil_unused33,
  Cil_unused34,
  Cil_unused35,
  Cil_unused36,
  Cil_unused37,
  Cil_unused38,
  Cil_unused39,
  Cil_unused40,
  Cil_unused41,
  Cil_unused42,
  Cil_unused43,
  Cil_unused44,
  Cil_unused45,
  Cil_unused46,
  Cil_unused47,
  Cil_unused48,
  Cil_prefix7,
  Cil_prefix6,
  Cil_prefix5,
  Cil_prefix4,
  Cil_prefix3,
  Cil_prefix2,
  Cil_prefix1,
  Cil_prefixref,
  Cil_arglist =0xFE00,
  Cil_ceq,
  Cil_cgt,
  Cil_cgt_un,
  Cil_clt,
  Cil_clt_un,
  Cil_ldftn,
  Cil_ldvirtftn,
  Cil_unused56,
  Cil_ldarg,
  Cil_ldarga,
  Cil_starg,
  Cil_ldloc,
  Cil_ldloca,
  Cil_stloc,
  Cil_localloc,
  Cil_unused57,
  Cil_endfilter,
  Cil_unaligned_,
  Cil_volatile_,
  Cil_tail_,
  Cil_initobj,
  Cil_constrained_,
  Cil_cpblk,
  Cil_initblk,
  Cil_no_,
  Cil_rethrow,
  Cil_unused,
  Cil_sizeof,
  Cil_refanytype,
  Cil_readonly_,
  Cil_unused53,
  Cil_unused54,
  Cil_unused55,
  Cil_unused70,
  Cil_mono_icall =0xF000,
  Cil_mono_objaddr,
  Cil_mono_ldptr,
  Cil_mono_vtaddr,
  Cil_mono_newobj,
  Cil_mono_retobj,
  Cil_mono_ldnativeobj,
  Cil_mono_cisinst,
  Cil_mono_ccastclass,
  Cil_mono_save_lmf,
  Cil_mono_restore_lmf,
  Cil_mono_classconst,
  Cil_mono_not_taken,
  Cil_mono_tls,
  Cil_mono_icall_addr,
  Cil_mono_dyn_call,
  Cil_mono_memory_barrier,
  Cil_unused71,
  Cil_unused72,
  Cil_mono_jit_icall_addr,
  Cil_mono_ldptr_int_req_flag,
  Cil_mono_ldptr_card_table,
  Cil_mono_ldptr_nursery_start,
  Cil_mono_ldptr_nursery_bits,
  Cil_mono_calli_extra_arg,
  Cil_mono_lddomain,
  Cil_mono_atomic_store_i4,
  Cil_mono_save_last_error,
  Cil_mono_get_rgctx_arg,
  Cil_mono_ldptr_prof_alloc_count,
  Cil_mono_ld_delegate_method_ptr,
  Cil_mono_rethrow,
  Cil_mono_get_sp,
  Cil_mono_methodconst,
  Cil_mono_pinvoke_addr_cache,
  Cil_last_instruction =0xF023
}
 CIL instruction types.
 
enum  JvmInstructionKind {
  JvmInstructionKind::nop = 0,
  JvmInstructionKind::aconst_null = 1,
  JvmInstructionKind::iconst_m1 = 2,
  JvmInstructionKind::iconst_0 = 3,
  JvmInstructionKind::iconst_1 = 4,
  JvmInstructionKind::iconst_2 = 5,
  JvmInstructionKind::iconst_3 = 6,
  JvmInstructionKind::iconst_4 = 7,
  JvmInstructionKind::iconst_5 = 8,
  JvmInstructionKind::lconst_0 = 9,
  JvmInstructionKind::lconst_1 = 10,
  JvmInstructionKind::fconst_0 = 11,
  JvmInstructionKind::fconst_1 = 12,
  JvmInstructionKind::fconst_2 = 13,
  JvmInstructionKind::dconst_0 = 14,
  JvmInstructionKind::dconst_1 = 15,
  JvmInstructionKind::bipush = 16,
  JvmInstructionKind::sipush = 17,
  JvmInstructionKind::ldc = 18,
  JvmInstructionKind::ldc_w = 19,
  JvmInstructionKind::ldc2_w = 20,
  JvmInstructionKind::iload = 21,
  JvmInstructionKind::lload = 22,
  JvmInstructionKind::fload = 23,
  JvmInstructionKind::dload = 24,
  JvmInstructionKind::aload = 25,
  JvmInstructionKind::iload_0 = 26,
  JvmInstructionKind::iload_1 = 27,
  JvmInstructionKind::iload_2 = 28,
  JvmInstructionKind::iload_3 = 29,
  JvmInstructionKind::lload_0 = 30,
  JvmInstructionKind::lload_1 = 31,
  JvmInstructionKind::lload_2 = 32,
  JvmInstructionKind::lload_3 = 33,
  JvmInstructionKind::fload_0 = 34,
  JvmInstructionKind::fload_1 = 35,
  JvmInstructionKind::fload_2 = 36,
  JvmInstructionKind::fload_3 = 37,
  JvmInstructionKind::dload_0 = 38,
  JvmInstructionKind::dload_1 = 39,
  JvmInstructionKind::dload_2 = 40,
  JvmInstructionKind::dload_3 = 41,
  JvmInstructionKind::aload_0 = 42,
  JvmInstructionKind::aload_1 = 43,
  JvmInstructionKind::aload_2 = 44,
  JvmInstructionKind::aload_3 = 45,
  JvmInstructionKind::iaload = 46,
  JvmInstructionKind::laload = 47,
  JvmInstructionKind::faload = 48,
  JvmInstructionKind::daload = 49,
  JvmInstructionKind::aaload = 50,
  JvmInstructionKind::baload = 51,
  JvmInstructionKind::caload = 52,
  JvmInstructionKind::saload = 53,
  JvmInstructionKind::istore = 54,
  JvmInstructionKind::lstore = 55,
  JvmInstructionKind::fstore = 56,
  JvmInstructionKind::dstore = 57,
  JvmInstructionKind::astore = 58,
  JvmInstructionKind::istore_0 = 59,
  JvmInstructionKind::istore_1 = 60,
  JvmInstructionKind::istore_2 = 61,
  JvmInstructionKind::istore_3 = 62,
  JvmInstructionKind::lstore_0 = 63,
  JvmInstructionKind::lstore_1 = 64,
  JvmInstructionKind::lstore_2 = 65,
  JvmInstructionKind::lstore_3 = 66,
  JvmInstructionKind::fstore_0 = 67,
  JvmInstructionKind::fstore_1 = 68,
  JvmInstructionKind::fstore_2 = 69,
  JvmInstructionKind::fstore_3 = 70,
  JvmInstructionKind::dstore_0 = 71,
  JvmInstructionKind::dstore_1 = 72,
  JvmInstructionKind::dstore_2 = 73,
  JvmInstructionKind::dstore_3 = 74,
  JvmInstructionKind::astore_0 = 75,
  JvmInstructionKind::astore_1 = 76,
  JvmInstructionKind::astore_2 = 77,
  JvmInstructionKind::astore_3 = 78,
  JvmInstructionKind::iastore = 79,
  JvmInstructionKind::lastore = 80,
  JvmInstructionKind::fastore = 81,
  JvmInstructionKind::dastore = 82,
  JvmInstructionKind::aastore = 83,
  JvmInstructionKind::bastore = 84,
  JvmInstructionKind::castore = 85,
  JvmInstructionKind::sastore = 86,
  JvmInstructionKind::pop = 87,
  JvmInstructionKind::pop2 = 88,
  JvmInstructionKind::dup = 89,
  JvmInstructionKind::dup_x1 = 90,
  JvmInstructionKind::dup_x2 = 91,
  JvmInstructionKind::dup2 = 92,
  JvmInstructionKind::dup2_x1 = 93,
  JvmInstructionKind::dup2_x2 = 94,
  JvmInstructionKind::swap = 95,
  JvmInstructionKind::iadd = 96,
  JvmInstructionKind::ladd = 97,
  JvmInstructionKind::fadd = 98,
  JvmInstructionKind::dadd = 99,
  JvmInstructionKind::isub = 100,
  JvmInstructionKind::lsub = 101,
  JvmInstructionKind::fsub = 102,
  JvmInstructionKind::dsub = 103,
  JvmInstructionKind::imul = 104,
  JvmInstructionKind::lmul = 105,
  JvmInstructionKind::fmul = 106,
  JvmInstructionKind::dmul = 107,
  JvmInstructionKind::idiv = 108,
  JvmInstructionKind::ldiv = 109,
  JvmInstructionKind::fdiv = 110,
  JvmInstructionKind::ddiv = 111,
  JvmInstructionKind::irem = 112,
  JvmInstructionKind::lrem = 113,
  JvmInstructionKind::frem = 114,
  JvmInstructionKind::drem = 115,
  JvmInstructionKind::ineg = 116,
  JvmInstructionKind::lneg = 117,
  JvmInstructionKind::fneg = 118,
  JvmInstructionKind::dneg = 119,
  JvmInstructionKind::ishl = 120,
  JvmInstructionKind::lshl = 121,
  JvmInstructionKind::ishr = 122,
  JvmInstructionKind::lshr = 123,
  JvmInstructionKind::iushr = 124,
  JvmInstructionKind::lushr = 125,
  JvmInstructionKind::iand = 126,
  JvmInstructionKind::land = 127,
  JvmInstructionKind::ior = 128,
  JvmInstructionKind::lor = 129,
  JvmInstructionKind::ixor = 130,
  JvmInstructionKind::lxor = 131,
  JvmInstructionKind::iinc = 132,
  JvmInstructionKind::i2l = 133,
  JvmInstructionKind::i2f = 134,
  JvmInstructionKind::i2d = 135,
  JvmInstructionKind::l2i = 136,
  JvmInstructionKind::l2f = 137,
  JvmInstructionKind::l2d = 138,
  JvmInstructionKind::f2i = 139,
  JvmInstructionKind::f2l = 140,
  JvmInstructionKind::f2d = 141,
  JvmInstructionKind::d2i = 142,
  JvmInstructionKind::d2l = 143,
  JvmInstructionKind::d2f = 144,
  JvmInstructionKind::i2b = 145,
  JvmInstructionKind::i2c = 146,
  JvmInstructionKind::i2s = 147,
  JvmInstructionKind::lcmp = 148,
  JvmInstructionKind::fcmpl = 149,
  JvmInstructionKind::fcmpg = 150,
  JvmInstructionKind::dcmpl = 151,
  JvmInstructionKind::dcmpg = 152,
  JvmInstructionKind::ifeq = 153,
  JvmInstructionKind::ifne = 154,
  JvmInstructionKind::iflt = 155,
  JvmInstructionKind::ifge = 156,
  JvmInstructionKind::ifgt = 157,
  JvmInstructionKind::ifle = 158,
  JvmInstructionKind::if_icmpeq = 159,
  JvmInstructionKind::if_icmpne = 160,
  JvmInstructionKind::if_icmplt = 161,
  JvmInstructionKind::if_icmpge = 162,
  JvmInstructionKind::if_icmpgt = 163,
  JvmInstructionKind::if_icmple = 164,
  JvmInstructionKind::if_acmpeq = 165,
  JvmInstructionKind::if_acmpne = 166,
  JvmInstructionKind::goto_ = 167,
  JvmInstructionKind::jsr = 168,
  JvmInstructionKind::ret = 169,
  JvmInstructionKind::tableswitch = 170,
  JvmInstructionKind::lookupswitch = 171,
  JvmInstructionKind::ireturn = 172,
  JvmInstructionKind::lreturn = 173,
  JvmInstructionKind::freturn = 174,
  JvmInstructionKind::dreturn = 175,
  JvmInstructionKind::areturn = 176,
  JvmInstructionKind::return_ = 177,
  JvmInstructionKind::getstatic = 178,
  JvmInstructionKind::putstatic = 179,
  JvmInstructionKind::getfield = 180,
  JvmInstructionKind::putfield = 181,
  JvmInstructionKind::invokevirtual = 182,
  JvmInstructionKind::invokespecial = 183,
  JvmInstructionKind::invokestatic = 184,
  JvmInstructionKind::invokeinterface = 185,
  JvmInstructionKind::invokedynamic = 186,
  JvmInstructionKind::new_ = 187,
  JvmInstructionKind::newarray = 188,
  JvmInstructionKind::anewarray = 189,
  JvmInstructionKind::arraylength = 190,
  JvmInstructionKind::athrow = 191,
  JvmInstructionKind::checkcast = 192,
  JvmInstructionKind::instanceof = 193,
  JvmInstructionKind::monitorenter = 194,
  JvmInstructionKind::monitorexit = 195,
  JvmInstructionKind::wide = 196,
  JvmInstructionKind::multianewarray = 197,
  JvmInstructionKind::ifnull = 198,
  JvmInstructionKind::ifnonnull = 199,
  JvmInstructionKind::goto_w = 200,
  JvmInstructionKind::jsr_w = 201,
  JvmInstructionKind::breakpoint = 202,
  JvmInstructionKind::impdep1 = 254,
  JvmInstructionKind::impdep2 = 255,
  JvmInstructionKind::unknown = 666
}
 The Java Virtual Machine (JVM) instruction set. More...
 
enum  M68kFamily {
  m68k_family = 0xffffffff,
  m68k_generation_1 = 0x000000ff,
  m68k_68000_only = 0x00000001,
  m68k_68ec000 = 0x00000002,
  m68k_68hc000 = 0x00000004,
  m68k_68000 = 0x00000007,
  m68k_68008 = 0x00000008,
  m68k_68010 = 0x00000010,
  m68k_68012 = 0x00000020,
  m68k_generation_2 = 0x0000ff00,
  m68k_68020_only = 0x00000100,
  m68k_68ec020 = 0x00000200,
  m68k_68020 = 0x00000300,
  m68k_68030_only = 0x00000400,
  m68k_68ec030 = 0x00001000,
  m68k_68030 = 0x00002000,
  m68k_generation_3 = 0x00ff0000,
  m68k_68040_only = 0x00010000,
  m68k_68ec040 = 0x00020000,
  m68k_68lc040 = 0x00040000,
  m68k_68040 = 0x00070000,
  m68k_freescale = 0xff000000,
  m68k_freescale_cpu32 = 0x01000000,
  m68k_freescale_isaa = 0x02000000,
  m68k_freescale_isab = 0x04000000,
  m68k_freescale_isac = 0x08000000,
  m68k_freescale_fpu = 0x10000000,
  m68k_freescale_mac = 0x20000000,
  m68k_freescale_emac = 0x40000000,
  m68k_freescale_emacb = 0x80000000
}
 Members of the Motorola Coldfire family of m68k processors. More...
 
enum  M68kRegisterClass {
  m68k_regclass_data,
  m68k_regclass_addr,
  m68k_regclass_fpr,
  m68k_regclass_spr,
  m68k_regclass_mac,
  m68k_regclass_sup
}
 M68k register classes. More...
 
enum  M68kSpecialPurposeRegister {
  m68k_spr_pc,
  m68k_spr_sr,
  m68k_spr_fpcr,
  m68k_spr_fpsr,
  m68k_spr_fpiar
}
 M68k special purpose registers. More...
 
enum  M68kMacRegister {
  m68k_mac_macsr,
  m68k_mac_acc0,
  m68k_mac_acc1,
  m68k_mac_acc2,
  m68k_mac_acc3,
  m68k_mac_ext01,
  m68k_mac_ext23,
  m68k_mac_ext0,
  m68k_mac_ext1,
  m68k_mac_ext2,
  m68k_mac_ext3,
  m68k_mac_mask
}
 M68k MAC registers. More...
 
enum  M68kEmacRegister {
  m68k_emac_macsr,
  m68k_emac_acc0,
  m68k_emac_acc1,
  m68k_emac_acc2,
  m68k_emac_acc3,
  m68k_emac_mask
}
 M68k EMAC registers. More...
 
enum  M68kSupervisorRegister {
  m68k_sup_vbr,
  m68k_sup_ssp,
  m68k_sup_sfc,
  m68k_sup_dfc,
  m68k_sup_cacr,
  m68k_sup_asid,
  m68k_sup_acr0,
  m68k_sup_acr1,
  m68k_sup_acr2,
  m68k_sup_acr3,
  m68k_sup_mmubar,
  m68k_sup_rombar0,
  m68k_sup_rombar1,
  m68k_sup_rambar0,
  m68k_sup_rambar1,
  m68k_sup_mbar,
  m68k_sup_mpcr,
  m68k_sup_edrambar,
  m68k_sup_secmbar,
  m68k_sup_0_pcr1,
  m68k_sup_0_pcr2,
  m68k_sup_0_pcr3,
  m68k_sup_1_pcr1,
  m68k_sup_1_pcr2,
  m68k_sup_1_pcr3
}
 M68k supervisor registers. More...
 
enum  M68kEffectiveAddressMode {
  m68k_eam_unknown = 0,
  m68k_eam_drd = 0x00000001,
  m68k_eam_ard = 0x00000002,
  m68k_eam_ari = 0x00000004,
  m68k_eam_inc = 0x00000008,
  m68k_eam_dec = 0x00000010,
  m68k_eam_dsp = 0x00000020,
  m68k_eam_idx8 = 0x00000040,
  m68k_eam_idxbd = 0x00000080,
  m68k_eam_mpost = 0x00000100,
  m68k_eam_mpre = 0x00000200,
  m68k_eam_pcdsp = 0x00000400,
  m68k_eam_pcidx8 = 0x00000800,
  m68k_eam_pcidxbd = 0x00001000,
  m68k_eam_pcmpost = 0x00002000,
  m68k_eam_pcmpre = 0x00004000,
  m68k_eam_absw = 0x00008000,
  m68k_eam_absl = 0x00010000,
  m68k_eam_imm = 0x00020000,
  m68k_eam_all = 0x0003ffff,
  m68k_eam_rd = 0x00000003,
  m68k_eam_ri = 0x0000003c,
  m68k_eam_idx = 0x000000c0,
  m68k_eam_mi = 0x00000300,
  m68k_eam_pci = 0x00000400,
  m68k_eam_pcidx = 0x00001800,
  m68k_eam_pcmi = 0x00006000,
  m68k_eam_abs = 0x00018000,
  m68k_eam_data = 0x0003fffd,
  m68k_eam_memory = 0x0003fffc,
  m68k_eam_control = 0x0001ffe4,
  m68k_eam_alter = 0x0001e3ff,
  m68k_eam_234 = 0x00007380,
  m68k_eam_direct = 0x00000003,
  m68k_eam_pc = 0x00007c00
}
 M68k effective addressing modes. More...
 
enum  M68kDataFormat {
  m68k_fmt_i32 = 0,
  m68k_fmt_f32 = 1,
  m68k_fmt_f96 = 2,
  m68k_fmt_p96 = 3,
  m68k_fmt_i16 = 4,
  m68k_fmt_f64 = 5,
  m68k_fmt_i8 = 6,
  m68k_fmt_unknown = 255
}
 M68k data formats for floating-point operations. More...
 
enum  M68kInstructionKind {
  m68k_unknown_instruction,
  m68k_abcd,
  m68k_add,
  m68k_adda,
  m68k_addi,
  m68k_addq,
  m68k_addx,
  m68k_and,
  m68k_andi,
  m68k_asl,
  m68k_asr,
  m68k_bcc,
  m68k_bcs,
  m68k_beq,
  m68k_bge,
  m68k_bgt,
  m68k_bhi,
  m68k_ble,
  m68k_bls,
  m68k_blt,
  m68k_bmi,
  m68k_bne,
  m68k_bpl,
  m68k_bvc,
  m68k_bvs,
  m68k_bchg,
  m68k_bclr,
  m68k_bfchg,
  m68k_bfclr,
  m68k_bfexts,
  m68k_bfextu,
  m68k_bfins,
  m68k_bfset,
  m68k_bftst,
  m68k_bkpt,
  m68k_bra,
  m68k_bset,
  m68k_bsr,
  m68k_btst,
  m68k_callm,
  m68k_cas,
  m68k_cas2,
  m68k_chk,
  m68k_chk2,
  m68k_clr,
  m68k_cmp,
  m68k_cmp2,
  m68k_cmpa,
  m68k_cmpi,
  m68k_cmpm,
  m68k_cpusha,
  m68k_cpushl,
  m68k_cpushp,
  m68k_dbt,
  m68k_dbf,
  m68k_dbhi,
  m68k_dbls,
  m68k_dbcc,
  m68k_dbcs,
  m68k_dbne,
  m68k_dbeq,
  m68k_dbvc,
  m68k_dbvs,
  m68k_dbpl,
  m68k_dbmi,
  m68k_dbge,
  m68k_dblt,
  m68k_dbgt,
  m68k_dble,
  m68k_divs,
  m68k_divsl,
  m68k_divu,
  m68k_divul,
  m68k_eor,
  m68k_eori,
  m68k_exg,
  m68k_ext,
  m68k_extb,
  m68k_fabs,
  m68k_fadd,
  m68k_fbeq,
  m68k_fbne,
  m68k_fbgt,
  m68k_fbngt,
  m68k_fbge,
  m68k_fbnge,
  m68k_fblt,
  m68k_fbnlt,
  m68k_fble,
  m68k_fbnle,
  m68k_fbgl,
  m68k_fbngl,
  m68k_fbgle,
  m68k_fbngle,
  m68k_fbogt,
  m68k_fbule,
  m68k_fboge,
  m68k_fbult,
  m68k_fbolt,
  m68k_fbuge,
  m68k_fbole,
  m68k_fbugt,
  m68k_fbogl,
  m68k_fbueq,
  m68k_fbor,
  m68k_fbun,
  m68k_fbf,
  m68k_fbt,
  m68k_fbsf,
  m68k_fbst,
  m68k_fbseq,
  m68k_fbsne,
  m68k_fcmp,
  m68k_fdabs,
  m68k_fdadd,
  m68k_fddiv,
  m68k_fdiv,
  m68k_fdmove,
  m68k_fdmul,
  m68k_fdneg,
  m68k_fdsqrt,
  m68k_fdsub,
  m68k_fint,
  m68k_fintrz,
  m68k_fmove,
  m68k_fmovem,
  m68k_fmul,
  m68k_fneg,
  m68k_fnop,
  m68k_fsabs,
  m68k_fsadd,
  m68k_fsdiv,
  m68k_fsmove,
  m68k_fsmul,
  m68k_fsneg,
  m68k_fsqrt,
  m68k_fssqrt,
  m68k_fssub,
  m68k_fsub,
  m68k_ftst,
  m68k_illegal,
  m68k_jmp,
  m68k_jsr,
  m68k_lea,
  m68k_link,
  m68k_lsl,
  m68k_lsr,
  m68k_mac,
  m68k_mov3q,
  m68k_movclr,
  m68k_move,
  m68k_move_acc,
  m68k_move_accext,
  m68k_move_ccr,
  m68k_move_macsr,
  m68k_move_mask,
  m68k_move_sr,
  m68k_move16,
  m68k_movea,
  m68k_movec,
  m68k_movem,
  m68k_movep,
  m68k_moveq,
  m68k_msac,
  m68k_muls,
  m68k_mulu,
  m68k_mvs,
  m68k_mvz,
  m68k_nbcd,
  m68k_neg,
  m68k_negx,
  m68k_nop,
  m68k_not,
  m68k_or,
  m68k_ori,
  m68k_pack,
  m68k_pea,
  m68k_rol,
  m68k_ror,
  m68k_roxl,
  m68k_roxr,
  m68k_rtd,
  m68k_rtm,
  m68k_rtr,
  m68k_rts,
  m68k_sbcd,
  m68k_st,
  m68k_sf,
  m68k_shi,
  m68k_sls,
  m68k_scc,
  m68k_scs,
  m68k_sne,
  m68k_seq,
  m68k_svc,
  m68k_svs,
  m68k_spl,
  m68k_smi,
  m68k_sge,
  m68k_slt,
  m68k_sgt,
  m68k_sle,
  m68k_sub,
  m68k_suba,
  m68k_subi,
  m68k_subq,
  m68k_subx,
  m68k_swap,
  m68k_tas,
  m68k_trap,
  m68k_trapt,
  m68k_trapf,
  m68k_traphi,
  m68k_trapls,
  m68k_trapcc,
  m68k_trapcs,
  m68k_trapne,
  m68k_trapeq,
  m68k_trapvc,
  m68k_trapvs,
  m68k_trappl,
  m68k_trapmi,
  m68k_trapge,
  m68k_traplt,
  m68k_trapgt,
  m68k_traple,
  m68k_trapv,
  m68k_tst,
  m68k_unlk,
  m68k_unpk,
  m68k_last_instruction
}
 M68k instruction types. More...
 
enum  MipsRegisterClass {
  mips_regclass_gpr,
  mips_regclass_spr,
  mips_regclass_fpr,
  mips_regclass_fcsr,
  mips_regclass_cp0gpr,
  mips_regclass_cp2gpr,
  mips_regclass_cp2spr,
  mips_regclass_sgpr,
  mips_regclass_hw
}
 MIPS major register numbers. More...
 
enum  MipsFcsrMinors {
  mips_fcsr_all,
  mips_fcsr_fccr,
  mips_fcsr_fexr,
  mips_fcsr_fenr
}
 Portions of the FCSR register. More...
 
enum  MipsSpecialPurposeRegister {
  mips_spr_hi,
  mips_spr_lo,
  mips_spr_pc,
  mips_spr_fir,
  mips_spr_fcsr
}
 MIPS special purpose register minor numbers. More...
 
enum  MipsInstructionKind {
  mips_unknown_instruction,
  mips_abs_s,
  mips_abs_d,
  mips_abs_ps,
  mips_add,
  mips_add_s,
  mips_add_d,
  mips_add_ps,
  mips_addi,
  mips_addiu,
  mips_addu,
  mips_alnv_ps,
  mips_and,
  mips_andi,
  mips_bc1f,
  mips_bc1fl,
  mips_bc1t,
  mips_bc1tl,
  mips_bc2f,
  mips_bc2fl,
  mips_bc2t,
  mips_bc2tl,
  mips_beq,
  mips_beql,
  mips_bgez,
  mips_bgezal,
  mips_bgezall,
  mips_bgezl,
  mips_bgtz,
  mips_bgtzl,
  mips_blez,
  mips_blezl,
  mips_bltz,
  mips_bltzal,
  mips_bltzall,
  mips_bltzl,
  mips_bne,
  mips_bnel,
  mips_break,
  mips_c_f_s,
  mips_c_un_s,
  mips_c_eq_s,
  mips_c_ueq_s,
  mips_c_olt_s,
  mips_c_ult_s,
  mips_c_ole_s,
  mips_c_ule_s,
  mips_c_sf_s,
  mips_c_ngle_s,
  mips_c_seq_s,
  mips_c_ngl_s,
  mips_c_lt_s,
  mips_c_nge_s,
  mips_c_le_s,
  mips_c_ngt_s,
  mips_c_f_d,
  mips_c_un_d,
  mips_c_eq_d,
  mips_c_ueq_d,
  mips_c_olt_d,
  mips_c_ult_d,
  mips_c_ole_d,
  mips_c_ule_d,
  mips_c_sf_d,
  mips_c_ngle_d,
  mips_c_seq_d,
  mips_c_ngl_d,
  mips_c_lt_d,
  mips_c_nge_d,
  mips_c_le_d,
  mips_c_ngt_d,
  mips_c_f_ps,
  mips_c_un_ps,
  mips_c_eq_ps,
  mips_c_ueq_ps,
  mips_c_olt_ps,
  mips_c_ult_ps,
  mips_c_ole_ps,
  mips_c_ule_ps,
  mips_c_sf_ps,
  mips_c_ngle_ps,
  mips_c_seq_ps,
  mips_c_ngl_ps,
  mips_c_lt_ps,
  mips_c_nge_ps,
  mips_c_le_ps,
  mips_c_ngt_ps,
  mips_cache,
  mips_cachee,
  mips_ceil_l_s,
  mips_ceil_l_d,
  mips_ceil_w_s,
  mips_ceil_w_d,
  mips_cfc1,
  mips_cfc2,
  mips_clo,
  mips_clz,
  mips_cop2,
  mips_ctc1,
  mips_ctc2,
  mips_cvt_d_s,
  mips_cvt_d_w,
  mips_cvt_d_l,
  mips_cvt_l_s,
  mips_cvt_l_d,
  mips_cvt_ps_s,
  mips_cvt_s_d,
  mips_cvt_s_w,
  mips_cvt_s_l,
  mips_cvt_s_pl,
  mips_cvt_s_pu,
  mips_cvt_w_s,
  mips_cvt_w_d,
  mips_di,
  mips_div,
  mips_div_s,
  mips_div_d,
  mips_divu,
  mips_ehb,
  mips_ei,
  mips_eret,
  mips_ext,
  mips_floor_l_s,
  mips_floor_l_d,
  mips_floor_w_s,
  mips_floor_w_d,
  mips_ins,
  mips_j,
  mips_jal,
  mips_jalr,
  mips_jalr_hb,
  mips_jalx,
  mips_jr,
  mips_jr_hb,
  mips_lb,
  mips_lbe,
  mips_lbu,
  mips_lbue,
  mips_ldc1,
  mips_ldc2,
  mips_ldxc1,
  mips_lh,
  mips_lhe,
  mips_lhu,
  mips_lhue,
  mips_ll,
  mips_lle,
  mips_lui,
  mips_luxc1,
  mips_lw,
  mips_lwc1,
  mips_lwc2,
  mips_lwe,
  mips_lwl,
  mips_lwle,
  mips_lwr,
  mips_lwre,
  mips_lwxc1,
  mips_madd,
  mips_madd_s,
  mips_madd_d,
  mips_madd_ps,
  mips_maddu,
  mips_mfc0,
  mips_mfc1,
  mips_mfc2,
  mips_mfhc1,
  mips_mfhc2,
  mips_mfhi,
  mips_mflo,
  mips_mov_s,
  mips_mov_d,
  mips_mov_ps,
  mips_movf,
  mips_movf_s,
  mips_movf_d,
  mips_movf_ps,
  mips_movn,
  mips_movn_s,
  mips_movn_d,
  mips_movn_ps,
  mips_movt,
  mips_movt_s,
  mips_movt_d,
  mips_movt_ps,
  mips_movz,
  mips_movz_s,
  mips_movz_d,
  mips_movz_ps,
  mips_msub,
  mips_msub_s,
  mips_msub_d,
  mips_msub_ps,
  mips_msubu,
  mips_mtc0,
  mips_mtc1,
  mips_mtc2,
  mips_mthc1,
  mips_mthc2,
  mips_mthi,
  mips_mtlo,
  mips_mul,
  mips_mul_s,
  mips_mul_d,
  mips_mul_ps,
  mips_mult,
  mips_multu,
  mips_neg_s,
  mips_neg_d,
  mips_neg_ps,
  mips_nmadd_s,
  mips_nmadd_d,
  mips_nmadd_ps,
  mips_nmsub_s,
  mips_nmsub_d,
  mips_nmsub_ps,
  mips_nop,
  mips_nor,
  mips_or,
  mips_ori,
  mips_pause,
  mips_pll_ps,
  mips_plu_ps,
  mips_pref,
  mips_prefe,
  mips_prefx,
  mips_pul_ps,
  mips_puu_ps,
  mips_rdhwr,
  mips_rdpgpr,
  mips_recip_s,
  mips_recip_d,
  mips_rotr,
  mips_rotrv,
  mips_round_l_s,
  mips_round_l_d,
  mips_round_w_s,
  mips_round_w_d,
  mips_rsqrt_s,
  mips_rsqrt_d,
  mips_sb,
  mips_sbe,
  mips_sc,
  mips_sce,
  mips_sdc1,
  mips_sdc2,
  mips_sdxc1,
  mips_seb,
  mips_seh,
  mips_sh,
  mips_she,
  mips_sll,
  mips_sllv,
  mips_slt,
  mips_slti,
  mips_sltiu,
  mips_sltu,
  mips_sqrt_s,
  mips_sqrt_d,
  mips_sra,
  mips_srav,
  mips_srl,
  mips_srlv,
  mips_ssnop,
  mips_sub,
  mips_sub_s,
  mips_sub_d,
  mips_sub_ps,
  mips_subu,
  mips_suxc1,
  mips_sw,
  mips_swc1,
  mips_swc2,
  mips_swe,
  mips_swl,
  mips_swle,
  mips_swr,
  mips_swre,
  mips_swxc1,
  mips_sync,
  mips_synci,
  mips_syscall,
  mips_teq,
  mips_teqi,
  mips_tge,
  mips_tgei,
  mips_tgeiu,
  mips_tgeu,
  mips_tlbinv,
  mips_tlbinvf,
  mips_tlbp,
  mips_tlbr,
  mips_tlbwi,
  mips_tlbwr,
  mips_tlt,
  mips_tlti,
  mips_tltiu,
  mips_tltu,
  mips_tne,
  mips_tnei,
  mips_trunc_l_s,
  mips_trunc_l_d,
  mips_trunc_w_s,
  mips_trunc_w_d,
  mips_wait,
  mips_wrpgpr,
  mips_wsbh,
  mips_xor,
  mips_xori,
  mips_last_instruction
}
 Kinds of MIPS instructions. More...
 
enum  PowerpcWordSize {
  powerpc_32,
  powerpc_64
}
 PowerPC word size. More...
 
enum  PowerpcInstructionKind {
  powerpc_unknown_instruction = 0,
  powerpc_add,
  powerpc_add_record,
  powerpc_addo,
  powerpc_addo_record,
  powerpc_addc,
  powerpc_addc_record,
  powerpc_addco,
  powerpc_addco_record,
  powerpc_adde,
  powerpc_adde_record,
  powerpc_addeo,
  powerpc_addeo_record,
  powerpc_addi,
  powerpc_addic,
  powerpc_addic_record,
  powerpc_addis,
  powerpc_addme,
  powerpc_addme_record,
  powerpc_addmeo,
  powerpc_addmeo_record,
  powerpc_addze,
  powerpc_addze_record,
  powerpc_addzeo,
  powerpc_addzeo_record,
  powerpc_and,
  powerpc_and_record,
  powerpc_andc,
  powerpc_andc_record,
  powerpc_andi_record,
  powerpc_andis_record,
  powerpc_b,
  powerpc_ba,
  powerpc_bl,
  powerpc_bla,
  powerpc_bc,
  powerpc_bca,
  powerpc_bcl,
  powerpc_bcla,
  powerpc_bcctr,
  powerpc_bcctrl,
  powerpc_bclr,
  powerpc_bclrl,
  powerpc_cmp,
  powerpc_cmpi,
  powerpc_cmpl,
  powerpc_cmpli,
  powerpc_cntlzd,
  powerpc_cntlzd_record,
  powerpc_cntlzw,
  powerpc_cntlzw_record,
  powerpc_crand,
  powerpc_crandc,
  powerpc_creqv,
  powerpc_crnand,
  powerpc_crnor,
  powerpc_cror,
  powerpc_crorc,
  powerpc_crxor,
  powerpc_dcbf,
  powerpc_dcba,
  powerpc_dcbi,
  powerpc_dcbst,
  powerpc_dcbt,
  powerpc_dcbtst,
  powerpc_dcbz,
  powerpc_divd,
  powerpc_divd_record,
  powerpc_divdo,
  powerpc_divdo_record,
  powerpc_divdu,
  powerpc_divdu_record,
  powerpc_divduo,
  powerpc_divduo_record,
  powerpc_divw,
  powerpc_divw_record,
  powerpc_divwo,
  powerpc_divwo_record,
  powerpc_divwu,
  powerpc_divwu_record,
  powerpc_divwuo,
  powerpc_divwuo_record,
  powerpc_dst,
  powerpc_dstt,
  powerpc_dstst,
  powerpc_dststt,
  powerpc_dss,
  powerpc_dssall,
  powerpc_eciwx,
  powerpc_ecowx,
  powerpc_eieio,
  powerpc_eqv,
  powerpc_eqv_record,
  powerpc_extsb,
  powerpc_extsb_record,
  powerpc_extsh,
  powerpc_extsh_record,
  powerpc_extsw,
  powerpc_extsw_record,
  powerpc_fabs,
  powerpc_fabs_record,
  powerpc_fadd,
  powerpc_fadd_record,
  powerpc_fadds,
  powerpc_fadds_record,
  powerpc_fcfid,
  powerpc_fcfid_record,
  powerpc_fcmpo,
  powerpc_fcmpu,
  powerpc_fctid,
  powerpc_fctid_record,
  powerpc_fctidz,
  powerpc_fctidz_record,
  powerpc_fctiw,
  powerpc_fctiw_record,
  powerpc_fctiwz,
  powerpc_fctiwz_record,
  powerpc_fdiv,
  powerpc_fdiv_record,
  powerpc_fdivs,
  powerpc_fdivs_record,
  powerpc_fmadd,
  powerpc_fmadd_record,
  powerpc_fmadds,
  powerpc_fmadds_record,
  powerpc_fmr,
  powerpc_fmr_record,
  powerpc_fmsub,
  powerpc_fmsub_record,
  powerpc_fmsubs,
  powerpc_fmsubs_record,
  powerpc_fmul,
  powerpc_fmul_record,
  powerpc_fmuls,
  powerpc_fmuls_record,
  powerpc_fnabs,
  powerpc_fnabs_record,
  powerpc_fneg,
  powerpc_fneg_record,
  powerpc_fnmadd,
  powerpc_fnmadd_record,
  powerpc_fnmadds,
  powerpc_fnmadds_record,
  powerpc_fnmsub,
  powerpc_fnmsub_record,
  powerpc_fnmsubs,
  powerpc_fnmsubs_record,
  powerpc_fpmul,
  powerpc_fxmul,
  powerpc_fxpmul,
  powerpc_fxsmul,
  powerpc_fpadd,
  powerpc_fpsub,
  powerpc_fpre,
  powerpc_fprsqrte,
  powerpc_fpmr,
  powerpc_fpabs,
  powerpc_lfssx,
  powerpc_fpneg,
  powerpc_lfssux,
  powerpc_fprsp,
  powerpc_lfsdx,
  powerpc_fpnabs,
  powerpc_lfsdux,
  powerpc_lfxsx,
  powerpc_fsmr,
  powerpc_lfxsux,
  powerpc_lfxdx,
  powerpc_fsabs,
  powerpc_lfxdux,
  powerpc_lfpsx,
  powerpc_fsneg,
  powerpc_lfpsux,
  powerpc_lfpdx,
  powerpc_fsnabs,
  powerpc_lfpdux,
  powerpc_stfpiwx,
  powerpc_fxmr,
  powerpc_fpctiw,
  powerpc_stfssx,
  powerpc_stfssux,
  powerpc_fpctiwz,
  powerpc_stfsdx,
  powerpc_stfsdux,
  powerpc_stfxsx,
  powerpc_fsmtp,
  powerpc_stfxsux,
  powerpc_stfxdx,
  powerpc_stfxdux,
  powerpc_stfpsx,
  powerpc_fsmfp,
  powerpc_stfpsux,
  powerpc_stfpdx,
  powerpc_stfpdux,
  powerpc_fpsel,
  powerpc_fpmadd,
  powerpc_fpmsub,
  powerpc_fxmadd,
  powerpc_fxcpmadd,
  powerpc_fxcsmadd,
  powerpc_fpnmadd,
  powerpc_fxnmadd,
  powerpc_fxcpnmadd,
  powerpc_fxcsnmadd,
  powerpc_fxcpnpma,
  powerpc_fxmsub,
  powerpc_fxcsnpma,
  powerpc_fxcpmsub,
  powerpc_fxcpnsma,
  powerpc_fxcsmsub,
  powerpc_fxcsnsma,
  powerpc_fpnmsub,
  powerpc_fxcxma,
  powerpc_fxnmsub,
  powerpc_fxcxnpma,
  powerpc_fxcpnmsub,
  powerpc_fxcxnsma,
  powerpc_fxcsnmsub,
  powerpc_fxcxnms,
  powerpc_fre,
  powerpc_fre_record,
  powerpc_fres,
  powerpc_fres_record,
  powerpc_frsp,
  powerpc_frsp_record,
  powerpc_frsqrte,
  powerpc_frsqrte_record,
  powerpc_frsqrtes,
  powerpc_frsqrtes_record,
  powerpc_fsel,
  powerpc_fsel_record,
  powerpc_fsqrt,
  powerpc_fsqrt_record,
  powerpc_fsqrts,
  powerpc_fsqrts_record,
  powerpc_fsub,
  powerpc_fsub_record,
  powerpc_fsubs,
  powerpc_fsubs_record,
  powerpc_icbi,
  powerpc_isync,
  powerpc_lbz,
  powerpc_lbzu,
  powerpc_lbzux,
  powerpc_lbzx,
  powerpc_ld,
  powerpc_ldarx,
  powerpc_ldu,
  powerpc_ldux,
  powerpc_ldx,
  powerpc_lfd,
  powerpc_lfdu,
  powerpc_lfdux,
  powerpc_lfdx,
  powerpc_lfs,
  powerpc_lfsu,
  powerpc_lfsux,
  powerpc_lfsx,
  powerpc_lha,
  powerpc_lhau,
  powerpc_lhaux,
  powerpc_lhax,
  powerpc_lhbrx,
  powerpc_lhz,
  powerpc_lhzu,
  powerpc_lhzux,
  powerpc_lhzx,
  powerpc_lmw,
  powerpc_lswi,
  powerpc_lswx,
  powerpc_lwa,
  powerpc_lwarx,
  powerpc_lwaux,
  powerpc_lwax,
  powerpc_lwbrx,
  powerpc_lwz,
  powerpc_lwzu,
  powerpc_lwzux,
  powerpc_lwzx,
  powerpc_mcrf,
  powerpc_mcrfs,
  powerpc_mcrxr,
  powerpc_mfcr,
  powerpc_mffs,
  powerpc_mffs_record,
  powerpc_mfmsr,
  powerpc_mfspr,
  powerpc_mfsr,
  powerpc_mfsrin,
  powerpc_mftb,
  powerpc_mtcrf,
  powerpc_mtfsb0,
  powerpc_mtfsb0_record,
  powerpc_mtfsb1,
  powerpc_mtfsb1_record,
  powerpc_mtfsf,
  powerpc_mtfsf_record,
  powerpc_mtfsfi,
  powerpc_mtfsfi_record,
  powerpc_mtmsr,
  powerpc_mtmsrd,
  powerpc_mtspr,
  powerpc_mtsr,
  powerpc_mtsrd,
  powerpc_mtsrdin,
  powerpc_mtsrin,
  powerpc_mulhd,
  powerpc_mulhd_record,
  powerpc_mulhdu,
  powerpc_mulhdu_record,
  powerpc_mulhw,
  powerpc_mulhw_record,
  powerpc_mulhwu,
  powerpc_mulhwu_record,
  powerpc_mulld,
  powerpc_mulld_record,
  powerpc_mulldo,
  powerpc_mulldo_record,
  powerpc_mulli,
  powerpc_mullw,
  powerpc_mullw_record,
  powerpc_mullwo,
  powerpc_mullwo_record,
  powerpc_nand,
  powerpc_nand_record,
  powerpc_neg,
  powerpc_neg_record,
  powerpc_nego,
  powerpc_nego_record,
  powerpc_nor,
  powerpc_nor_record,
  powerpc_or,
  powerpc_or_record,
  powerpc_orc,
  powerpc_orc_record,
  powerpc_ori,
  powerpc_oris,
  powerpc_popcntb,
  powerpc_rfi,
  powerpc_rfid,
  powerpc_rldcl,
  powerpc_rldcl_record,
  powerpc_rldcr,
  powerpc_rldcr_record,
  powerpc_rldic,
  powerpc_rldic_record,
  powerpc_rldicl,
  powerpc_rldicl_record,
  powerpc_rldicr,
  powerpc_rldicr_record,
  powerpc_rldimi,
  powerpc_rldimi_record,
  powerpc_rlwimi,
  powerpc_rlwimi_record,
  powerpc_rlwinm,
  powerpc_rlwinm_record,
  powerpc_rlwnm,
  powerpc_rlwnm_record,
  powerpc_sc,
  powerpc_slbia,
  powerpc_slbie,
  powerpc_sld,
  powerpc_sld_record,
  powerpc_slw,
  powerpc_slw_record,
  powerpc_srad,
  powerpc_srad_record,
  powerpc_sradi,
  powerpc_sradi_record,
  powerpc_srd,
  powerpc_srd_record,
  powerpc_sraw,
  powerpc_sraw_record,
  powerpc_srawi,
  powerpc_srawi_record,
  powerpc_srw,
  powerpc_srw_record,
  powerpc_stb,
  powerpc_stbu,
  powerpc_stbux,
  powerpc_stbx,
  powerpc_std,
  powerpc_stdcx_record,
  powerpc_stdu,
  powerpc_stdux,
  powerpc_stdx,
  powerpc_stfd,
  powerpc_stfdu,
  powerpc_stfdux,
  powerpc_stfdx,
  powerpc_stfiwx,
  powerpc_stfs,
  powerpc_stfsu,
  powerpc_stfsux,
  powerpc_stfsx,
  powerpc_sth,
  powerpc_sthbrx,
  powerpc_sthu,
  powerpc_sthux,
  powerpc_sthx,
  powerpc_stmw,
  powerpc_stswi,
  powerpc_stswx,
  powerpc_stw,
  powerpc_stwbrx,
  powerpc_stwcx_record,
  powerpc_stwu,
  powerpc_stwux,
  powerpc_stwx,
  powerpc_subf,
  powerpc_subf_record,
  powerpc_subfo,
  powerpc_subfo_record,
  powerpc_subfc,
  powerpc_subfc_record,
  powerpc_subfco,
  powerpc_subfco_record,
  powerpc_subfe,
  powerpc_subfe_record,
  powerpc_subfeo,
  powerpc_subfeo_record,
  powerpc_subfic,
  powerpc_subfme,
  powerpc_subfme_record,
  powerpc_subfmeo,
  powerpc_subfmeo_record,
  powerpc_subfze,
  powerpc_subfze_record,
  powerpc_subfzeo,
  powerpc_subfzeo_record,
  powerpc_sync,
  powerpc_td,
  powerpc_tdi,
  powerpc_tlbia,
  powerpc_tlbie,
  powerpc_tlbsync,
  powerpc_tw,
  powerpc_twi,
  powerpc_xor,
  powerpc_xor_record,
  powerpc_xori,
  powerpc_xoris,
  powerpc_last_instruction
}
 PowerPC instruction types. More...
 
enum  PowerpcRegisterClass {
  powerpc_regclass_unknown,
  powerpc_regclass_gpr,
  powerpc_regclass_fpr,
  powerpc_regclass_cr,
  powerpc_regclass_fpscr,
  powerpc_regclass_spr,
  powerpc_regclass_tbr,
  powerpc_regclass_msr,
  powerpc_regclass_sr,
  powerpc_regclass_iar,
  powerpc_regclass_pvr,
  powerpc_last_register_class
}
 PowerPC register classes. More...
 
enum  PowerpcConditionRegisterAccessGranularity {
  powerpc_condreggranularity_whole,
  powerpc_condreggranularity_field,
  powerpc_condreggranularity_bit
}
 PowerPC condition register access granularity. More...
 
enum  PowerpcSpecialPurposeRegister {
  powerpc_spr_xer = 1,
  powerpc_spr_lr = 8,
  powerpc_spr_ctr = 9,
  powerpc_spr_dsisr = 18,
  powerpc_spr_dar = 19,
  powerpc_spr_dec = 22
}
 PowerPC special purpose registers. More...
 
enum  PowerpcTimeBaseRegister {
  powerpc_tbr_tbl = 268,
  powerpc_tbr_tbu = 269
}
 PowerPC time base registers. More...
 
enum  X86InstructionSize {
  x86_insnsize_none,
  x86_insnsize_16,
  x86_insnsize_32,
  x86_insnsize_64
}
 Intel x86 instruction size constants. More...
 
enum  X86RegisterClass {
  x86_regclass_gpr,
  x86_regclass_segment,
  x86_regclass_cr,
  x86_regclass_dr,
  x86_regclass_st,
  x86_regclass_xmm,
  x86_regclass_ip,
  x86_regclass_flags
}
 Intel x86 major register numbers. More...
 
enum  X86SegmentRegister {
  x86_segreg_es = 0,
  x86_segreg_cs = 1,
  x86_segreg_ss = 2,
  x86_segreg_ds = 3,
  x86_segreg_fs = 4,
  x86_segreg_gs = 5,
  x86_segreg_none = 16
}
 Intel x86 segment registers. More...
 
enum  X86GeneralPurposeRegister {
  x86_gpr_ax = 0,
  x86_gpr_cx = 1,
  x86_gpr_dx = 2,
  x86_gpr_bx = 3,
  x86_gpr_sp = 4,
  x86_gpr_bp = 5,
  x86_gpr_si = 6,
  x86_gpr_di = 7,
  x86_gpr_r8 = 8,
  x86_gpr_r9 = 9,
  x86_gpr_r10 = 10,
  x86_gpr_r11 = 11,
  x86_gpr_r12 = 12,
  x86_gpr_r13 = 13,
  x86_gpr_r14 = 14,
  x86_gpr_r15 = 15
}
 Intel x86 general purpose registers.
 
enum  X86StRegister {
  x86_st_0 = 0,
  x86_st_1 = 1,
  x86_st_2 = 2,
  x86_st_3 = 3,
  x86_st_4 = 4,
  x86_st_5 = 5,
  x86_st_6 = 6,
  x86_st_7 = 7,
  x86_st_nregs = 8
}
 Intel x86 ST-related registers. More...
 
enum  X86Flags {
  x86_flags_status = 0,
  x86_flags_fpstatus = 1,
  x86_flags_fptag = 2,
  x86_flags_fpctl = 3,
  x86_flags_mxcsr = 4
}
 Minor numbers for x86_regclass_flag. More...
 
enum  X86Flag {
  x86_flag_cf = 0,
  x86_flag_pf = 2,
  x86_flag_af = 4,
  x86_flag_zf = 6,
  x86_flag_sf = 7,
  x86_flag_tf = 8,
  x86_flag_if = 9,
  x86_flag_df = 10,
  x86_flag_of = 11,
  x86_flag_iopl = 12,
  x86_flag_nt = 14,
  x86_flag_rf = 16,
  x86_flag_vm = 17,
  x86_flag_ac = 18,
  x86_flag_vif = 19,
  x86_flag_vip = 20,
  x86_flag_id = 21
}
 Intel x86 status flags. More...
 
enum  X86BranchPrediction {
  x86_branch_prediction_none,
  x86_branch_prediction_taken,
  x86_branch_prediction_not_taken
}
 Intel x86 branch prediction types. More...
 
enum  X86RepeatPrefix {
  x86_repeat_none,
  x86_repeat_repne,
  x86_repeat_repe
}
 Intel x86 instruction repeat prefix. More...
 
enum  X86Exception {
  x86_exception_int,
  x86_exception_sysenter,
  x86_exception_syscall,
  x86_exception_de,
  x86_exception_db,
  x86_exception_bp,
  x86_exception_of,
  x86_exception_br,
  x86_exception_ud,
  x86_exception_nm,
  x86_exception_df,
  x86_exception_ts,
  x86_exception_np,
  x86_exception_ss,
  x86_exception_gp,
  x86_exception_pf,
  x86_exception_mf,
  x86_exception_ac,
  x86_exception_mc,
  x86_exception_xm
}
 Protected mode exceptions. More...
 
enum  X86InstructionKind {
  x86_unknown_instruction = 0x0000,
  x86_aaa = 0x0001,
  x86_aad = 0x0002,
  x86_aam = 0x0003,
  x86_aas = 0x0004,
  x86_adc = 0x0005,
  x86_add = 0x0006,
  x86_addpd = 0x0007,
  x86_addps = 0x0008,
  x86_addsd = 0x0009,
  x86_addss = 0x000a,
  x86_addsubpd = 0x000b,
  x86_addsubps = 0x000c,
  x86_and = 0x000d,
  x86_andnpd = 0x000e,
  x86_andnps = 0x000f,
  x86_andpd = 0x0010,
  x86_andps = 0x0011,
  x86_arpl = 0x0012,
  x86_blendpd = 0x0013,
  x86_blendps = 0x0014,
  x86_blendvpd = 0x0015,
  x86_blendvps = 0x0016,
  x86_bound = 0x0017,
  x86_bsf = 0x0018,
  x86_bsr = 0x0019,
  x86_bswap = 0x001a,
  x86_bt = 0x001b,
  x86_btc = 0x001c,
  x86_btr = 0x001d,
  x86_bts = 0x001e,
  x86_call = 0x001f,
  x86_cbw = 0x0020,
  x86_cdq = 0x0021,
  x86_cdqe = 0x0022,
  x86_clc = 0x0023,
  x86_cld = 0x0024,
  x86_clflush = 0x0025,
  x86_clgi = 0x0026,
  x86_cli = 0x0027,
  x86_clts = 0x0028,
  x86_cmc = 0x0029,
  x86_cmova = 0x002a,
  x86_cmovae = 0x002b,
  x86_cmovb = 0x002c,
  x86_cmovbe = 0x002d,
  x86_cmove = 0x002e,
  x86_cmovg = 0x002f,
  x86_cmovge = 0x0030,
  x86_cmovl = 0x0031,
  x86_cmovle = 0x0032,
  x86_cmovne = 0x0033,
  x86_cmovno = 0x0034,
  x86_cmovns = 0x0035,
  x86_cmovo = 0x0036,
  x86_cmovpe = 0x0037,
  x86_cmovpo = 0x0038,
  x86_cmovs = 0x0039,
  x86_cmp = 0x003a,
  x86_cmppd = 0x003b,
  x86_cmpps = 0x003c,
  x86_cmpsb = 0x003d,
  x86_cmpsd = 0x003e,
  x86_cmpsq = 0x003f,
  x86_cmpss = 0x0040,
  x86_cmpsw = 0x0041,
  x86_cmpxchg = 0x0042,
  x86_cmpxchg16b = 0x0043,
  x86_cmpxchg8b = 0x0044,
  x86_comisd = 0x0045,
  x86_comiss = 0x0046,
  x86_cpuid = 0x0047,
  x86_cqo = 0x0048,
  x86_crc32 = 0x0049,
  x86_cvtdq2pd = 0x004a,
  x86_cvtdq2ps = 0x004b,
  x86_cvtpd2dq = 0x004c,
  x86_cvtpd2pi = 0x004d,
  x86_cvtpd2ps = 0x004e,
  x86_cvtpi2pd = 0x004f,
  x86_cvtpi2ps = 0x0050,
  x86_cvtps2dq = 0x0051,
  x86_cvtps2pd = 0x0052,
  x86_cvtps2pi = 0x0053,
  x86_cvtsd2si = 0x0054,
  x86_cvtsd2ss = 0x0055,
  x86_cvtsi2sd = 0x0056,
  x86_cvtsi2ss = 0x0057,
  x86_cvtss2sd = 0x0058,
  x86_cvtss2si = 0x0059,
  x86_cvttpd2dq = 0x005a,
  x86_cvttpd2pi = 0x005b,
  x86_cvttps2dq = 0x005c,
  x86_cvttps2pi = 0x005d,
  x86_cvttsd2si = 0x005e,
  x86_cvttss2si = 0x005f,
  x86_cwd = 0x0060,
  x86_cwde = 0x0061,
  x86_daa = 0x0062,
  x86_das = 0x0063,
  x86_dec = 0x0064,
  x86_div = 0x0065,
  x86_divpd = 0x0066,
  x86_divps = 0x0067,
  x86_divsd = 0x0068,
  x86_divss = 0x0069,
  x86_dppd = 0x006a,
  x86_dpps = 0x006b,
  x86_emms = 0x006c,
  x86_enter = 0x006d,
  x86_extractps = 0x006e,
  x86_extrq = 0x006f,
  x86_f2xm1 = 0x0070,
  x86_fabs = 0x0071,
  x86_fadd = 0x0072,
  x86_faddp = 0x0073,
  x86_farcall = 0x0074,
  x86_farjmp = 0x0075,
  x86_fbld = 0x0076,
  x86_fbstp = 0x0077,
  x86_fchs = 0x0078,
  x86_fcmovb = 0x0079,
  x86_fcmovbe = 0x007a,
  x86_fcmove = 0x007b,
  x86_fcmovnb = 0x007c,
  x86_fcmovnbe = 0x007d,
  x86_fcmovne = 0x007e,
  x86_fcmovnu = 0x007f,
  x86_fcmovu = 0x0080,
  x86_fcom = 0x0081,
  x86_fcomi = 0x0082,
  x86_fcomip = 0x0083,
  x86_fcomp = 0x0084,
  x86_fcompp = 0x0085,
  x86_fcos = 0x0086,
  x86_fdecstp = 0x0087,
  x86_fdiv = 0x0088,
  x86_fdivp = 0x0089,
  x86_fdivr = 0x008a,
  x86_fdivrp = 0x008b,
  x86_femms = 0x008c,
  x86_ffree = 0x008d,
  x86_fiadd = 0x008e,
  x86_ficom = 0x008f,
  x86_ficomp = 0x0090,
  x86_fidiv = 0x0091,
  x86_fidivr = 0x0092,
  x86_fild = 0x0093,
  x86_fimul = 0x0094,
  x86_fincstp = 0x0095,
  x86_fist = 0x0096,
  x86_fistp = 0x0097,
  x86_fisttp = 0x0098,
  x86_fisub = 0x0099,
  x86_fisubr = 0x009a,
  x86_fld = 0x009b,
  x86_fld1 = 0x009c,
  x86_fldcw = 0x009d,
  x86_fldenv = 0x009e,
  x86_fldl2e = 0x009f,
  x86_fldl2t = 0x00a0,
  x86_fldlg2 = 0x00a1,
  x86_fldln2 = 0x00a2,
  x86_fldpi = 0x00a3,
  x86_fldz = 0x00a4,
  x86_fmul = 0x00a5,
  x86_fmulp = 0x00a6,
  x86_fnclex = 0x00a7,
  x86_fninit = 0x00a8,
  x86_fnop = 0x00a9,
  x86_fnsave = 0x00aa,
  x86_fnstcw = 0x00ab,
  x86_fnstenv = 0x00ac,
  x86_fnstsw = 0x00ad,
  x86_fpatan = 0x00ae,
  x86_fprem = 0x00af,
  x86_fprem1 = 0x00b0,
  x86_fptan = 0x00b1,
  x86_frndint = 0x00b2,
  x86_frstor = 0x00b3,
  x86_fscale = 0x00b4,
  x86_fsin = 0x00b5,
  x86_fsincos = 0x00b6,
  x86_fsqrt = 0x00b7,
  x86_fst = 0x00b8,
  x86_fstp = 0x00b9,
  x86_fsub = 0x00ba,
  x86_fsubp = 0x00bb,
  x86_fsubr = 0x00bc,
  x86_fsubrp = 0x00bd,
  x86_ftst = 0x00be,
  x86_fucom = 0x00bf,
  x86_fucomi = 0x00c0,
  x86_fucomip = 0x00c1,
  x86_fucomp = 0x00c2,
  x86_fucompp = 0x00c3,
  x86_fwait = 0x00c4,
  x86_fxam = 0x00c5,
  x86_fxch = 0x00c6,
  x86_fxrstor = 0x00c7,
  x86_fxsave = 0x00c8,
  x86_fxtract = 0x00c9,
  x86_fyl2x = 0x00ca,
  x86_fyl2xp1 = 0x00cb,
  x86_getsec = 0x00cc,
  x86_haddpd = 0x00cd,
  x86_haddps = 0x00ce,
  x86_hlt = 0x00cf,
  x86_hsubpd = 0x00d0,
  x86_hsubps = 0x00d1,
  x86_idiv = 0x00d2,
  x86_imul = 0x00d3,
  x86_in = 0x00d4,
  x86_inc = 0x00d5,
  x86_insb = 0x00d6,
  x86_insd = 0x00d7,
  x86_insertps = 0x00d8,
  x86_insertq = 0x00d9,
  x86_insw = 0x00da,
  x86_int = 0x00db,
  x86_int1 = 0x00dc,
  x86_int3 = 0x00dd,
  x86_into = 0x00de,
  x86_invd = 0x00df,
  x86_invept = 0x00e0,
  x86_invlpg = 0x00e1,
  x86_invlpga = 0x00e2,
  x86_invvpid = 0x00e3,
  x86_iret = 0x00e4,
  x86_ja = 0x00e5,
  x86_jae = 0x00e6,
  x86_jb = 0x00e7,
  x86_jbe = 0x00e8,
  x86_jcxz = 0x00e9,
  x86_je = 0x00ea,
  x86_jecxz = 0x00eb,
  x86_jg = 0x00ec,
  x86_jge = 0x00ed,
  x86_jl = 0x00ee,
  x86_jle = 0x00ef,
  x86_jmp = 0x00f0,
  x86_jmpe = 0x00f1,
  x86_jne = 0x00f2,
  x86_jno = 0x00f3,
  x86_jns = 0x00f4,
  x86_jo = 0x00f5,
  x86_jpe = 0x00f6,
  x86_jpo = 0x00f7,
  x86_jrcxz = 0x00f8,
  x86_js = 0x00f9,
  x86_lahf = 0x00fa,
  x86_lar = 0x00fb,
  x86_lddqu = 0x00fc,
  x86_ldmxcsr = 0x00fd,
  x86_lds = 0x00fe,
  x86_lea = 0x00ff,
  x86_leave = 0x0100,
  x86_les = 0x0101,
  x86_lfence = 0x0102,
  x86_lfs = 0x0103,
  x86_lgdt = 0x0104,
  x86_lgs = 0x0105,
  x86_lidt = 0x0106,
  x86_lldt = 0x0107,
  x86_lmsw = 0x0108,
  x86_lock = 0x0109,
  x86_lodsb = 0x010a,
  x86_lodsd = 0x010b,
  x86_lodsq = 0x010c,
  x86_lodsw = 0x010d,
  x86_loop = 0x010e,
  x86_loopnz = 0x010f,
  x86_loopz = 0x0110,
  x86_lsl = 0x0111,
  x86_lss = 0x0112,
  x86_ltr = 0x0113,
  x86_lzcnt = 0x0114,
  x86_maskmovq = 0x0115,
  x86_maxpd = 0x0116,
  x86_maxps = 0x0117,
  x86_maxsd = 0x0118,
  x86_maxss = 0x0119,
  x86_mfence = 0x011a,
  x86_minpd = 0x011b,
  x86_minps = 0x011c,
  x86_minsd = 0x011d,
  x86_minss = 0x011e,
  x86_monitor = 0x011f,
  x86_mov = 0x0120,
  x86_movapd = 0x0121,
  x86_movaps = 0x0122,
  x86_movbe = 0x0123,
  x86_movd = 0x0124,
  x86_movddup = 0x0125,
  x86_movdq2q = 0x0126,
  x86_movdqa = 0x0127,
  x86_movdqu = 0x0128,
  x86_movhlps = 0x0129,
  x86_movhpd = 0x012a,
  x86_movhps = 0x012b,
  x86_movlhps = 0x012c,
  x86_movlpd = 0x012d,
  x86_movlps = 0x012e,
  x86_movmskpd = 0x012f,
  x86_movmskps = 0x0130,
  x86_movntdq = 0x0131,
  x86_movntdqa = 0x0132,
  x86_movnti = 0x0133,
  x86_movntpd = 0x0134,
  x86_movntps = 0x0135,
  x86_movntq = 0x0136,
  x86_movntsd = 0x0137,
  x86_movntss = 0x0138,
  x86_movq = 0x0139,
  x86_movq2dq = 0x013a,
  x86_movsb = 0x013b,
  x86_movsd = 0x013c,
  x86_movsd_sse = 0x013d,
  x86_movshdup = 0x013e,
  x86_movsldup = 0x013f,
  x86_movsq = 0x0140,
  x86_movss = 0x0141,
  x86_movsw = 0x0142,
  x86_movsx = 0x0143,
  x86_movsxd = 0x0144,
  x86_movupd = 0x0145,
  x86_movups = 0x0146,
  x86_movzx = 0x0147,
  x86_mpsadbw = 0x0148,
  x86_mul = 0x0149,
  x86_mulpd = 0x014a,
  x86_mulps = 0x014b,
  x86_mulsd = 0x014c,
  x86_mulss = 0x014d,
  x86_mwait = 0x014e,
  x86_neg = 0x014f,
  x86_nop = 0x0150,
  x86_not = 0x0151,
  x86_or = 0x0152,
  x86_orpd = 0x0153,
  x86_orps = 0x0154,
  x86_out = 0x0155,
  x86_outs = 0x0156,
  x86_outsb = 0x0157,
  x86_outsd = 0x0158,
  x86_outsw = 0x0159,
  x86_pabsb = 0x015a,
  x86_pabsd = 0x015b,
  x86_pabsw = 0x015c,
  x86_packssdw = 0x015d,
  x86_packsswb = 0x015e,
  x86_packusdw = 0x015f,
  x86_packuswb = 0x0160,
  x86_paddb = 0x0161,
  x86_paddd = 0x0162,
  x86_paddq = 0x0163,
  x86_paddsb = 0x0164,
  x86_paddsw = 0x0165,
  x86_paddusb = 0x0166,
  x86_paddusw = 0x0167,
  x86_paddw = 0x0168,
  x86_palignr = 0x0169,
  x86_pand = 0x016a,
  x86_pandn = 0x016b,
  x86_pause = 0x016c,
  x86_pavgb = 0x016d,
  x86_pavgusb = 0x016e,
  x86_pavgw = 0x016f,
  x86_pblendvb = 0x0170,
  x86_pblendw = 0x0171,
  x86_pcmpeqb = 0x0172,
  x86_pcmpeqd = 0x0173,
  x86_pcmpeqq = 0x0174,
  x86_pcmpeqw = 0x0175,
  x86_pcmpestri = 0x0176,
  x86_pcmpestrm = 0x0177,
  x86_pcmpgtb = 0x0178,
  x86_pcmpgtd = 0x0179,
  x86_pcmpgtq = 0x017a,
  x86_pcmpgtw = 0x017b,
  x86_pcmpistri = 0x017c,
  x86_pcmpistrm = 0x017d,
  x86_pextrb = 0x017e,
  x86_pextrd = 0x017f,
  x86_pextrq = 0x0180,
  x86_pextrw = 0x0181,
  x86_pf2id = 0x0182,
  x86_pf2iw = 0x0183,
  x86_pfacc = 0x0184,
  x86_pfadd = 0x0185,
  x86_pfcmpeq = 0x0186,
  x86_pfcmpge = 0x0187,
  x86_pfcmpgt = 0x0188,
  x86_pfmax = 0x0189,
  x86_pfmin = 0x018a,
  x86_pfmul = 0x018b,
  x86_pfnacc = 0x018c,
  x86_pfpnacc = 0x018d,
  x86_pfrcp = 0x018e,
  x86_pfrcpit1 = 0x018f,
  x86_pfrcpit2 = 0x0190,
  x86_pfrsqit1 = 0x0191,
  x86_pfrsqrt = 0x0192,
  x86_pfsub = 0x0193,
  x86_pfsubr = 0x0194,
  x86_phaddd = 0x0195,
  x86_phaddsw = 0x0196,
  x86_phaddw = 0x0197,
  x86_phminposuw = 0x0198,
  x86_phsubd = 0x0199,
  x86_phsubsw = 0x019a,
  x86_phsubw = 0x019b,
  x86_pi2fd = 0x019c,
  x86_pi2fw = 0x019d,
  x86_pinsrb = 0x019e,
  x86_pinsrd = 0x019f,
  x86_pinsrq = 0x01a0,
  x86_pinsrw = 0x01a1,
  x86_pmaddubsw = 0x01a2,
  x86_pmaddwd = 0x01a3,
  x86_pmaxsb = 0x01a4,
  x86_pmaxsd = 0x01a5,
  x86_pmaxsw = 0x01a6,
  x86_pmaxub = 0x01a7,
  x86_pmaxud = 0x01a8,
  x86_pmaxuw = 0x01a9,
  x86_pminsb = 0x01aa,
  x86_pminsd = 0x01ab,
  x86_pminsw = 0x01ac,
  x86_pminub = 0x01ad,
  x86_pminud = 0x01ae,
  x86_pminuw = 0x01af,
  x86_pmovmskb = 0x01b0,
  x86_pmovsxbd = 0x01b1,
  x86_pmovsxbq = 0x01b2,
  x86_pmovsxbw = 0x01b3,
  x86_pmovsxdq = 0x01b4,
  x86_pmovsxwd = 0x01b5,
  x86_pmovsxwq = 0x01b6,
  x86_pmovzxbd = 0x01b7,
  x86_pmovzxbq = 0x01b8,
  x86_pmovzxbw = 0x01b9,
  x86_pmovzxdq = 0x01ba,
  x86_pmovzxwd = 0x01bb,
  x86_pmovzxwq = 0x01bc,
  x86_pmuldq = 0x01bd,
  x86_pmulhrsw = 0x01be,
  x86_pmulhrw = 0x01bf,
  x86_pmulhuw = 0x01c0,
  x86_pmulhw = 0x01c1,
  x86_pmulld = 0x01c2,
  x86_pmullw = 0x01c3,
  x86_pmuludq = 0x01c4,
  x86_pop = 0x01c5,
  x86_popa = 0x01c6,
  x86_popad = 0x01c7,
  x86_popcnt = 0x01c8,
  x86_popf = 0x01c9,
  x86_popfd = 0x01ca,
  x86_popfq = 0x01cb,
  x86_por = 0x01cc,
  x86_prefetch = 0x01cd,
  x86_prefetchnta = 0x01ce,
  x86_prefetcht0 = 0x01cf,
  x86_prefetcht1 = 0x01d0,
  x86_prefetcht2 = 0x01d1,
  x86_prefetchw = 0x01d2,
  x86_psadbw = 0x01d3,
  x86_pshufb = 0x01d4,
  x86_pshufd = 0x01d5,
  x86_pshufhw = 0x01d6,
  x86_pshuflw = 0x01d7,
  x86_pshufw = 0x01d8,
  x86_psignb = 0x01d9,
  x86_psignd = 0x01da,
  x86_psignw = 0x01db,
  x86_pslld = 0x01dc,
  x86_pslldq = 0x01dd,
  x86_psllq = 0x01de,
  x86_psllw = 0x01df,
  x86_psrad = 0x01e0,
  x86_psraq = 0x01e1,
  x86_psraw = 0x01e2,
  x86_psrld = 0x01e3,
  x86_psrldq = 0x01e4,
  x86_psrlq = 0x01e5,
  x86_psrlw = 0x01e6,
  x86_psubb = 0x01e7,
  x86_psubd = 0x01e8,
  x86_psubq = 0x01e9,
  x86_psubsb = 0x01ea,
  x86_psubsw = 0x01eb,
  x86_psubusb = 0x01ec,
  x86_psubusw = 0x01ed,
  x86_psubw = 0x01ee,
  x86_pswapd = 0x01ef,
  x86_ptest = 0x01f0,
  x86_punpckhbw = 0x01f1,
  x86_punpckhdq = 0x01f2,
  x86_punpckhqdq = 0x01f3,
  x86_punpckhwd = 0x01f4,
  x86_punpcklbw = 0x01f5,
  x86_punpckldq = 0x01f6,
  x86_punpcklqdq = 0x01f7,
  x86_punpcklwd = 0x01f8,
  x86_push = 0x01f9,
  x86_pusha = 0x01fa,
  x86_pushad = 0x01fb,
  x86_pushf = 0x01fc,
  x86_pushfd = 0x01fd,
  x86_pushfq = 0x01fe,
  x86_pxor = 0x01ff,
  x86_rcl = 0x0200,
  x86_rcpps = 0x0201,
  x86_rcpss = 0x0202,
  x86_rcr = 0x0203,
  x86_rdmsr = 0x0204,
  x86_rdpmc = 0x0205,
  x86_rdtsc = 0x0206,
  x86_rdtscp = 0x0207,
  x86_rep_insb = 0x0208,
  x86_rep_insd = 0x0209,
  x86_rep_insw = 0x020a,
  x86_rep_lodsb = 0x020b,
  x86_rep_lodsd = 0x020c,
  x86_rep_lodsq = 0x020d,
  x86_rep_lodsw = 0x020e,
  x86_rep_movsb = 0x020f,
  x86_rep_movsd = 0x0210,
  x86_rep_movsq = 0x0211,
  x86_rep_movsw = 0x0212,
  x86_rep_outsb = 0x0213,
  x86_rep_outsd = 0x0214,
  x86_rep_outsw = 0x0215,
  x86_rep_stosb = 0x0216,
  x86_rep_stosd = 0x0217,
  x86_rep_stosq = 0x0218,
  x86_rep_stosw = 0x0219,
  x86_repe_cmpsb = 0x021a,
  x86_repe_cmpsd = 0x021b,
  x86_repe_cmpsq = 0x021c,
  x86_repe_cmpsw = 0x021d,
  x86_repe_scasb = 0x021e,
  x86_repe_scasd = 0x021f,
  x86_repe_scasq = 0x0220,
  x86_repe_scasw = 0x0221,
  x86_repne_cmpsb = 0x0222,
  x86_repne_cmpsd = 0x0223,
  x86_repne_cmpsq = 0x0224,
  x86_repne_cmpsw = 0x0225,
  x86_repne_scasb = 0x0226,
  x86_repne_scasd = 0x0227,
  x86_repne_scasq = 0x0228,
  x86_repne_scasw = 0x0229,
  x86_ret = 0x022a,
  x86_retf = 0x022b,
  x86_rol = 0x022c,
  x86_ror = 0x022d,
  x86_roundpd = 0x022e,
  x86_roundps = 0x022f,
  x86_roundsd = 0x0230,
  x86_roundss = 0x0231,
  x86_rsm = 0x0232,
  x86_rsqrtps = 0x0233,
  x86_rsqrtss = 0x0234,
  x86_sahf = 0x0235,
  x86_salc = 0x0236,
  x86_sar = 0x0237,
  x86_sbb = 0x0238,
  x86_scasb = 0x0239,
  x86_scasd = 0x023a,
  x86_scasq = 0x023b,
  x86_scasw = 0x023c,
  x86_seta = 0x023d,
  x86_setae = 0x023e,
  x86_setb = 0x023f,
  x86_setbe = 0x0240,
  x86_sete = 0x0241,
  x86_setg = 0x0242,
  x86_setge = 0x0243,
  x86_setl = 0x0244,
  x86_setle = 0x0245,
  x86_setne = 0x0246,
  x86_setno = 0x0247,
  x86_setns = 0x0248,
  x86_seto = 0x0249,
  x86_setpe = 0x024a,
  x86_setpo = 0x024b,
  x86_sets = 0x024c,
  x86_sfence = 0x024d,
  x86_sgdt = 0x024e,
  x86_shl = 0x024f,
  x86_shld = 0x0250,
  x86_shr = 0x0251,
  x86_shrd = 0x0252,
  x86_shufpd = 0x0253,
  x86_shufps = 0x0254,
  x86_sidt = 0x0255,
  x86_skinit = 0x0256,
  x86_sldt = 0x0257,
  x86_smsw = 0x0258,
  x86_sqrtpd = 0x0259,
  x86_sqrtps = 0x025a,
  x86_sqrtsd = 0x025b,
  x86_sqrtss = 0x025c,
  x86_stc = 0x025d,
  x86_std = 0x025e,
  x86_stgi = 0x025f,
  x86_sti = 0x0260,
  x86_stmxcsr = 0x0261,
  x86_stos = 0x0262,
  x86_stosb = 0x0263,
  x86_stosd = 0x0264,
  x86_stosq = 0x0265,
  x86_stosw = 0x0266,
  x86_str = 0x0267,
  x86_sub = 0x0268,
  x86_subpd = 0x0269,
  x86_subps = 0x026a,
  x86_subsd = 0x026b,
  x86_subss = 0x026c,
  x86_swapgs = 0x026d,
  x86_syscall = 0x026e,
  x86_sysenter = 0x026f,
  x86_sysexit = 0x0270,
  x86_sysret = 0x0271,
  x86_test = 0x0272,
  x86_ucomisd = 0x0273,
  x86_ucomiss = 0x0274,
  x86_ud2 = 0x0275,
  x86_unpckhpd = 0x0276,
  x86_unpckhps = 0x0277,
  x86_unpcklpd = 0x0278,
  x86_unpcklps = 0x0279,
  x86_verr = 0x027a,
  x86_verw = 0x027b,
  x86_vmcall = 0x027c,
  x86_vmclear = 0x027d,
  x86_vmlaunch = 0x027e,
  x86_vmload = 0x027f,
  x86_vmmcall = 0x0280,
  x86_vmoff = 0x0281,
  x86_vmptrld = 0x0282,
  x86_vmptrst = 0x0283,
  x86_vmread = 0x0284,
  x86_vmresume = 0x0285,
  x86_vmrun = 0x0286,
  x86_vmsave = 0x0287,
  x86_vmwrite = 0x0288,
  x86_vmxoff = 0x0289,
  x86_vmxon = 0x028a,
  x86_wait = 0x028b,
  x86_wbinvd = 0x028c,
  x86_wrmsr = 0x028d,
  x86_xadd = 0x028e,
  x86_xchg = 0x028f,
  x86_xgetbv = 0x0290,
  x86_xlatb = 0x0291,
  x86_xor = 0x0292,
  x86_xorpd = 0x0293,
  x86_xorps = 0x0294,
  x86_xrstor = 0x0295,
  x86_xsave = 0x0296,
  x86_xsetbv = 0x0297,
  x86_last_instruction = 0x0298
}
 List of all x86 instructions known to the ROSE disassembler/assembler. More...
 

Functions

std::ostream & operator<< (std::ostream &, const BinaryLoaderElf::VersionedSymbol &)
 
template<class V , class E >
Sawyer::Container::Graph< V, E >::VertexValue get_ast_node (const Sawyer::Container::Graph< V, E > &cfg, size_t vertexId)
 Return the AST node associated with a vertex. More...
 
template<class V , class E , class AstNode >
void put_ast_node (Sawyer::Container::Graph< V, E > &cfg, size_t vertexId, AstNode *astNode)
 Set the AST node associated with a vertex. More...
 
template<class A , class B , class C , class D , class E , class F , class G >
boost::property_traits< typename boost::property_map< boost::adjacency_list< A, B, C, D, E, F, G >, boost::vertex_name_t >::type >::value_type get_ast_node (const boost::adjacency_list< A, B, C, D, E, F, G > &cfg, typename boost::graph_traits< boost::adjacency_list< A, B, C, D, E, F, G > >::vertex_descriptor vertex)
 
template<class A , class B , class C , class D , class E , class F , class G >
void put_ast_node (boost::adjacency_list< A, B, C, D, E, F, G > &cfg, typename boost::graph_traits< boost::adjacency_list< A, B, C, D, E, F, G > >::vertex_descriptor vertex, typename boost::property_traits< typename boost::property_map< boost::adjacency_list< A, B, C, D, E, F, G >, boost::vertex_name_t >::type >::value_type ast_node)
 
std::ostream & operator<< (std::ostream &, const FunctionSimilarity &)
 
template<typename T , typename U >
boost::enable_if_c< boost::is_integral< T >::value &&boost::is_integral< U >::value, T >::type alignUp (T address, U alignment)
 Align address downward to boundary. More...
 
template<typename T , typename U >
boost::enable_if_c< boost::is_integral< T >::value &&boost::is_integral< U >::value, T >::type alignDown (T address, U alignment)
 Align address upward to boundary. More...
 
std::ostream & operator<< (std::ostream &, const RegisterDictionary &)
 
bool listSmtSolverNames (std::ostream &)
 List known SMT solvers and their availability. More...
 
std::string validateSmtSolverName (const std::string &name)
 Validate SMT solver name. More...
 
std::string bestSmtSolverName ()
 SMT solver corresponding to "best". More...
 
void checkSmtCommandLineArg (const std::string &arg, const std::string &listSwitch, std::ostream &errorStream=std::cerr)
 Process SMT solver name from command-line. More...
 
std::string smtSolverDocumentationString (const std::string &dfltSolver)
 Documentation string for an SMT solver switch. More...
 
std::ostream & operator<< (std::ostream &, const SmtSolver::SExpr &)
 
std::ostream & operator<< (std::ostream &, const SourceLocations &)
 
std::ostream & operator<< (std::ostream &, const SymbolicExpressionParser::SyntaxError &)
 
std::ostream & operator<< (std::ostream &, const SymbolicExpressionParser::SubstitutionError &)
 
std::ostream & operator<< (std::ostream &out, const TaintedFlow::State &state)
 
bool x86InstructionIsConditionalFlagControlTransfer (SgAsmX86Instruction *inst)
 
bool x86InstructionIsConditionalFlagDataTransfer (SgAsmX86Instruction *inst)
 
bool x86InstructionIsConditionalControlTransfer (SgAsmX86Instruction *inst)
 
bool x86InstructionIsConditionalDataTransfer (SgAsmX86Instruction *inst)
 
bool x86InstructionIsPrivileged (SgAsmX86Instruction *)
 
bool x86InstructionIsFloatingPoint (SgAsmX86Instruction *)
 
bool x86InstructionIsConditionalFlagBitAndByte (SgAsmX86Instruction *inst)
 
bool x86InstructionIsControlTransfer (SgAsmX86Instruction *inst)
 
bool x86InstructionIsUnconditionalBranch (SgAsmX86Instruction *inst)
 
bool x86InstructionIsConditionalBranch (SgAsmX86Instruction *inst)
 
bool x86InstructionIsDataTransfer (SgAsmX86Instruction *inst)
 
const char * gprToString (X86GeneralPurposeRegister n)
 
const char * segregToString (X86SegmentRegister n)
 
const char * flagToString (X86Flag n)
 

Typedef Documentation

using Rose::BinaryAnalysis::BinaryLoaderPtr = typedef Sawyer::SharedPointer<BinaryLoader>

Reference counting pointer.

Definition at line 20 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::BinaryLoaderElfPtr = typedef Sawyer::SharedPointer<BinaryLoaderElf>

Reference counting pointer.

Definition at line 22 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::BinaryLoaderElfObjPtr = typedef Sawyer::SharedPointer<BinaryLoaderElfObj>

Reference counting pointer.

Definition at line 24 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::BinaryLoaderPePtr = typedef Sawyer::SharedPointer<BinaryLoaderPe>

Refernce counting pointer.

Definition at line 26 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::MemoryMapPtr = typedef Sawyer::SharedPointer<MemoryMap>

Reference counting pointer.

Definition at line 43 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::RegisterDescriptors = typedef std::vector<RegisterDescriptor>

List of register descriptors in dictionary.

Definition at line 46 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::RegisterDictionaryPtr = typedef Sawyer::SharedPointer<RegisterDictionary>

Reference counting pointer.

Definition at line 48 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::SerialInputPtr = typedef Sawyer::SharedPointer<SerialInput>

Reference counting pointer.

Definition at line 52 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::SerialIoPtr = typedef Sawyer::SharedPointer<SerialIo>

Reference counting pointer.

Definition at line 54 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::SerialOutputPtr = typedef Sawyer::SharedPointer<SerialOutput>

Reference counting pointer.

Definition at line 56 of file BinaryAnalysis/BasicTypes.h.

using Rose::BinaryAnalysis::SmtSolverPtr = typedef std::shared_ptr<SmtSolver>

Reference counting pointer.

Definition at line 59 of file BinaryAnalysis/BasicTypes.h.

Enumeration Type Documentation

enum Rose::BinaryAnalysis::CilFamily

Members of the Motorola Coldfire family of m68k processors.

These descriptions come from page 1-1 of the manual. In particular, when the manual mentions a processor (like "MC68020") it refers to both that particular processor and the embedded versions thereof ("MC68EC020"). We'll use the same approach here, and if we need to refer to only a paricular processor excluding embedded version, we append "_only" to the name.

Enumerator
Cil_family 

All CIL Instruction sets.

Definition at line 18 of file InstructionEnumsCil.h.

enum Rose::BinaryAnalysis::JvmInstructionKind
strong

The Java Virtual Machine (JVM) instruction set.

Chapter 6 [1] Format of JVM instruction opcode (kind) description

mnemonic = opcode (decimal) , opcode (hex) : # operands : [operands] : "Short description of the instruction"

nop = 0 , 0x00 : 0 : : "Do nothing" ... bipush = 16 , 0x10 : 1 : byte : "Push byte" ...JVM instruction types.

Enumerator
nop 

0x00:0:: "Do nothing"

aconst_null 

0x01: "Push null"

iconst_m1 

0x02: "Push int constant -1"

iconst_0 

0x03: "Push int constant 0"

iconst_1 

0x04: "Push int constant 1"

iconst_2 

0x05: "Push int constant 2"

iconst_3 

0x06: "Push int constant 3"

iconst_4 

0x07: "Push int constant 4"

iconst_5 

0x08: "Push int constant 5"

lconst_0 

0x09: "Push long constant 0"

lconst_1 

0x0a: "Push long constant 1"

fconst_0 

0x0b: "Push float 0.0"

fconst_1 

0x0c: "Push float 1.0"

fconst_2 

0x0d: "Push float 2.0"

dconst_0 

0x0e: "Push double 0.0"

dconst_1 

0x0f: "Push double 1.0"

bipush 

0x10 1: byte: "Push byte"

sipush 

0x11 2: byte1, byte2: "Push short"

ldc 

0x12 1: index: "Push item from run-time constant pool"

ldc_w 

0x13 2: indexbyte1, indexbyte2: "Push item from run-time constant pool (wide index)"

ldc2_w 

0x14 2: indexbyte1, indexbyte2: "Push long or double from run-time constant pool (wide index)"

iload 

0x15 1: index: "Load int from local variable"

lload 

0x16 1: index: "Load long from local variable"

fload 

0x17 1: index: "Load float from local variable"

dload 

0x18 1: index: "Load double from local variable"

aload 

0x19 1: index: "Load reference from local variable"

iload_0 

0x1a: "Load int from local variable 0"

iload_1 

0x1b: "Load int from local variable 1"

iload_2 

0x1c: "Load int from local variable 2"

iload_3 

0x1d: "Load int from local variable 3"

lload_0 

0x1e: "Load long from local variable 0"

lload_1 

0x1f: "Load long from local variable 1"

lload_2 

0x20: "Load long from local variable 2"

lload_3 

0x21: "Load long from local variable 3"

fload_0 

0x22: "Load float from local variable 0"

fload_1 

0x23: "Load float from local variable 1"

fload_2 

0x24: "Load float from local variable 2"

fload_3 

0x25: "Load float from local variable 3"

dload_0 

0x26: "Load double from local variable 0"

dload_1 

0x27: "Load double from local variable 1"

dload_2 

0x28: "Load double from local variable 2"

dload_3 

0x29: "Load double from local variable 3"

aload_0 

0x2a: "Load reference from local variable 0"

aload_1 

0x2b: "Load reference from local variable 1"

aload_2 

0x2c: "Load reference from local variable 2"

aload_3 

0x2d: "Load reference from local variable 3"

iaload 

0x2e: "Load int from array"

laload 

0x2f: "Load long from array"

faload 

0x30: "Load float from array"

daload 

0x31: "Load double from array"

aaload 

0x32: "Load reference from array"

baload 

0x33: "Load byte or boolean from array"

caload 

0x34: "Load char from array"

saload 

0x35: "Load short from array"

istore 

0x36 1: index "Store int into local variable at index"

lstore 

0x37 1: index

fstore 

0x38 1: index

dstore 

0x39 1: index

astore 

0x3a 1: index

istore_0 

0x3b: "Store int into local variable 0"

istore_1 

0x3c: "Store int into local variable 1"

istore_2 

0x3d: "Store int into local variable 2"

istore_3 

0x3e: "Store int into local variable 3"

lstore_0 

0x3f: "Store long into local variable 0"

lstore_1 

0x40: "Store long into local variable 1"

lstore_2 

0x41: "Store long into local variable 2"

lstore_3 

0x42: "Store long into local variable 3"

fstore_0 

0x43: "Store float into local variable 0"

fstore_1 

0x44: "Store float into local variable 1"

fstore_2 

0x45: "Store float into local variable 2"

fstore_3 

0x46: "Store float into local variable 3"

dstore_0 

0x47: "Store double into local variable 0"

dstore_1 

0x48: "Store double into local variable 1"

dstore_2 

0x49: "Store double into local variable 2"

dstore_3 

0x4a: "Store double into local variable 3"

astore_0 

0x4b: "Store reference into local variable 0"

astore_1 

0x4c: "Store reference into local variable 1"

astore_2 

0x4d: "Store reference into local variable 2"

astore_3 

0x4e: "Store reference into local variable 3"

iastore 

0x4f: "Store into int array"

lastore 

0x50: "Store into long array"

fastore 

0x51: "Store into float array"

dastore 

0x52: "Store into double array"

aastore 

0x53: "Store into reference array"

bastore 

0x54: "Store into byte or boolean array"

castore 

0x55: "Store into char array"

sastore 

0x56: "Store into short array"

pop 

0x57: "Pop the top operand stack value"

pop2 

0x58: "Pop the top one or two operand stack values"

dup 

0x59: "Duplicate the top operand stack value"

dup_x1 

0x5a: "Duplicate the top operand stack value and insert two values down"

dup_x2 

0x5b: "Duplicate the top operand stack value and insert two or three values down"

dup2 

0x5c: "Duplicate the top one or two operand stack values"

dup2_x1 

0x5d: "Duplicate the top one or two operand stack values and insert two or three values down"

dup2_x2 

0x5e: "Duplicate the top one or two operand stack values and insert two, three, or four values down"

swap 

0x5f: "Swap the top two operand stack values"

iadd 

0x60: "Add int"

ladd 

0x61: "Add long"

fadd 

0x62: "Add float"

dadd 

0x63: "Add double"

isub 

0x64: "Subtract int"

lsub 

0x65: "Subtract long"

fsub 

0x66: "Subtract float"

dsub 

0x67: "Subtract double"

imul 

0x68: "Multiply int"

lmul 

0x69: "Multiply long"

fmul 

0x6a: "Multiply float"

dmul 

0x6b: "Multiply double"

idiv 

0x6c: "Divide int"

ldiv 

0x6d: "Divide long"

fdiv 

0x6e: "Divide float"

ddiv 

0x6f: "Divide double"

irem 

0x70: "Remainder int"

lrem 

0x71: "Remainder long"

frem 

0x72: "Remainder float"

drem 

0x73: "Remainder double"

ineg 

0x74: "Negate int"

lneg 

0x75: "Negate long"

fneg 

0x76: "Negate float"

dneg 

0x77: "Negate double"

ishl 

0x78: "Shift left int"

lshl 

0x79: "Shift left long"

ishr 

0x7a: "Shift right int"

lshr 

0x7b: "Shift right long"

iushr 

0x7c: "Logical shift right int"

lushr 

0x7d: "Logical shift right long"

iand 

0x7e: "Boolean AND int"

land 

0x7f: "Boolean AND long"

ior 

0x80: "Boolean OR int"

lor 

0x81: "Boolean OR long"

ixor 

0x82: "Boolean XOR int"

lxor 

0x83: "Boolean XOR long"

iinc 

0x84:2: index, const: "Increment local variable"

i2l 

0x85: "Convert int to long"

i2f 

0x86: "Convert int to float"

i2d 

0x87: "Convert int to double"

l2i 

0x88: "Convert long to int"

l2f 

0x89: "Convert long to float"

l2d 

0x8a: "Convert long to double"

f2i 

0x8b: "Convert float to int"

f2l 

0x8c: "Convert float to long"

f2d 

0x8d: "Convert float to double"

d2i 

0x8e: "Convert double to int"

d2l 

0x8f: "Convert double to long"

d2f 

0x90: "Convert double to float"

i2b 

0x91: "Convert int to byte"

i2c 

0x92: "Convert int to char"

i2s 

0x93: "Convert int to short"

lcmp 

0x94: "Compare long"

fcmpl 

0x95: "Compare float"

fcmpg 

0x96: "Compare float"

dcmpl 

0x97: "Compare double"

dcmpg 

0x98: "Compare double"

ifeq 

0x99 2: branchbyte1, branchbyte2: "Branch if int comparison .eq. with zero succeeds"

ifne 

0x9a 2: branchbyte1, branchbyte2

iflt 

0x9b 2: branchbyte1, branchbyte2

ifge 

0x9c 2: branchbyte1, branchbyte2

ifgt 

0x9d 2: branchbyte1, branchbyte2

ifle 

0x9e 2: branchbyte1, branchbyte2

if_icmpeq 

0x9f 2: branchbyte1, branchbyte2

if_icmpne 

0xa0 2: branchbyte1, branchbyte2

if_icmplt 

0xa1 2: branchbyte1, branchbyte2

if_icmpge 

0xa2 2: branchbyte1, branchbyte2

if_icmpgt 

0xa3 2: branchbyte1, branchbyte2

if_icmple 

0xa4 2: branchbyte1, branchbyte2: "Branch if int comparison .le. succeeds"

if_acmpeq 

0xa5 2: branchbyte1, branchbyte2

if_acmpne 

0xa6 2: branchbyte1, branchbyte2

goto_ 

0xa7 2: branchbyte1, branchbyte2

jsr 

0xa8 2: branchbyte1, branchbyte2

ret 

0xa9 1: index

tableswitch 

0xaa 16+: [0-3 bytes padding],defaultbyte1,defaultbyte2,defaultbyte3,defaultbyte4,lowbye1,lowbyte2,lowbyte3,lowbyte4,highbyte1,highbyte2,highbyte3,highbyte4,jump offsets...

lookupswitch 

0xab 8+: <0-3 bytes padding>,defaultbyte1,defaultbyte2,defaultbyte3,defaultbyte4,npairs,npairs2,npairs3,npairs4,match-offset pairs...

ireturn 

0xac: "Return int from method"

lreturn 

0xad: "Return long from method"

freturn 

0xae: "Return float from method"

dreturn 

0xaf: "Return double from method"

areturn 

0xb0: "Return reference from method"

return_ 

0xb1: "Return void from method"

getstatic 

0xb2 2: indexbyte1, indexbyte2: "Get static field in class"

putstatic 

0xb3 2: indexbyte1, indexbyte2: "Set static field in class"

getfield 

0xb4 2: indexbyte1, indexbyte2: "Fetch field from object"

putfield 

0xb5 2: indexbyte1, indexbyte2: "Set field in object"

invokevirtual 

0xb6 2: indexbyte1, indexbyte2

invokespecial 

0xb7 2: indexbyte1, indexbyte2: "Invoke instance method; direct invocation of instance initialization methods and methods of the current class and its supertypes"

invokestatic 

0xb8 2: indexbyte1, indexbyte2

invokeinterface 

0xb9 4: indexbyte1, indexbyte2, count, 0

invokedynamic 

0xba 4: indexbyte1, indexbyte2, 0, 0

new_ 

0xbb 2: indexbyte1, indexbyte2

newarray 

0xbc 1: atype: "Create new array"

anewarray 

0xbd 2: indexbyte1, indexbyte2: "Create new array of reference"

arraylength 

0xbe: "Get length of array"

athrow 

0xbf: "Throw exception or error"

checkcast 

0xc0 2: indexbyte1, indexbyte2: "Check whether object is of given type"

instanceof 

0xc1 2: indexbyte1, indexbyte2: "Determine if object is of given type"

monitorenter 

0xc2: "Enter monitor for object"

monitorexit 

0xc3: "Exit monitor for object"

wide 

0xc4 3/5: opcode,indexbyte1,indexbyte2 or iinc,indexbyte1,indexbyte2,countbyte1,countbye2

multianewarray 

0xc5 3: indexbyte1, indexbyte2, dimensions

ifnull 

0xc6 2: branchbyte1, branchbyte2: "Branch if reference is null"

ifnonnull 

0xc7 2: branchbyte1, branchbyte2

goto_w 

0xc8 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4

jsr_w 

0xc9 4: branchbyte1, branchbyte2, branchbyte3, branchbyte4

breakpoint 

0xca

impdep1 

0xfe

impdep2 

0xff

unknown 

unknown/illegal opcode

Definition at line 29 of file InstructionEnumsJvm.h.

enum Rose::BinaryAnalysis::M68kFamily

Members of the Motorola Coldfire family of m68k processors.

These descriptions come from page 1-1 of the manual. In particular, when the manual mentions a processor (like "MC68020") it refers to both that particular processor and the embedded versions thereof ("MC68EC020"). We'll use the same approach here, and if we need to refer to only a paricular processor excluding embedded version, we append "_only" to the name.

Enumerator
m68k_family 

All M68k CPUs.

m68k_generation_1 

M68k first generation.

m68k_68000_only 

MC68000 16-/32-bit microprocessor.

m68k_68ec000 

MC68EC000 16-/32-bit embedded controller.

m68k_68hc000 

MC68HC000 low-power CMOS version of MC68000.

m68k_68000 

MC68000 and embedded versions thereof.

m68k_68008 

MC68008 16-bit microprocessor with 8-bit external data bus.

m68k_68010 

MC68010 16-/32-bit virtual memory microprocessor.

m68k_68012 

MC68012 84-pin PGA version of MC68010 supporting 2GB RAM.

m68k_generation_2 

M68k second generation.

m68k_68020_only 

MC68020 32-bit virtual memory microprocessor.

m68k_68ec020 

MC68EC020 32-bit embedded controller.

m68k_68020 

MC68020 and embedded versions thereof.

m68k_68030_only 

MC68030 second-generation 32-bit enhanced microprocessor.

m68k_68ec030 

MC68EC030 32-bit embedded controller.

m68k_68030 

MC68030 and embedded versions thereof.

m68k_generation_3 

M68k third generation.

m68k_68040_only 

MC68040 third-generation 32-bit microprocessor.

m68k_68ec040 

MC68EC040 32-bit embedded controller w/out FPU or MMU.

m68k_68lc040 

MC68LC040 32-bit embedded controller w/out FPU.

m68k_68040 

MC68040 and embedded versions thereof.

m68k_freescale 

Freescale CPUs based on Motorola 683xx.

m68k_freescale_cpu32 

Freescale CPU32 (similar to MC68020 w/out bitfield insns.

m68k_freescale_isaa 

Freescale ISA_A, the original ColdFire ISA (subset of M68000)

m68k_freescale_isab 

Freescale ISA_B, improved data movement instructions, etc.

m68k_freescale_isac 

Freescale ISA_C, improved bit manipulation instructions.

m68k_freescale_fpu 

Freescale FPU, original ColdFire floating point ISA.

m68k_freescale_mac 

Freescale MAC, original ColdFire multiply-accumulate ISA.

m68k_freescale_emac 

Freescale EMAC, enhanced multiply-accumulate ISA.

m68k_freescale_emacb 

Freescale EMAC_B, dual accumulation instructions.

Definition at line 18 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kRegisterClass

M68k register classes.

Enumerator
m68k_regclass_data 

Data registers.

m68k_regclass_addr 

Address registers.

m68k_regclass_fpr 

Floating point registers.

m68k_regclass_spr 

Special purpose registers.

m68k_regclass_mac 

Multiply-accumulate registers (includes EMAC registers).

m68k_regclass_sup 

Supervisor registers.

Definition at line 56 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kSpecialPurposeRegister

M68k special purpose registers.

Enumerator
m68k_spr_pc 

Program counter.

m68k_spr_sr 

Status register, including condition codes.

m68k_spr_fpcr 

Floating-point control register.

m68k_spr_fpsr 

Floating-point status register.

m68k_spr_fpiar 

Floating-point instruction address register.

Definition at line 66 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kMacRegister

M68k MAC registers.

Enumerator
m68k_mac_macsr 

MAC status register.

m68k_mac_acc0 

MAC 32-bit accumulator #0.

m68k_mac_acc1 

MAC 32-bit accumulator #1.

m68k_mac_acc2 

MAC 32-bit accumulator #2.

m68k_mac_acc3 

MAC 32-bit accumulator #3.

m68k_mac_ext01 

Extensions for ACC0 and ACC1.

m68k_mac_ext23 

Extensions for ACC2 and ACC3.

m68k_mac_ext0 

Extension for ACC0.

m68k_mac_ext1 

Extension for ACC1.

m68k_mac_ext2 

Extension for ACC2.

m68k_mac_ext3 

Extension for ACC3.

m68k_mac_mask 

MAC mask register.

Definition at line 75 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kEmacRegister

M68k EMAC registers.

Enumerator
m68k_emac_macsr 

EMAC status register.

m68k_emac_acc0 

EMAC accumulator 0.

m68k_emac_acc1 

EMAC accumulator 1.

m68k_emac_acc2 

EMAC accumulator 2.

m68k_emac_acc3 

EMAC accumulator 3.

m68k_emac_mask 

EMAC mask register.

Definition at line 91 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kSupervisorRegister

M68k supervisor registers.

Enumerator
m68k_sup_vbr 

Interrupt vector base address.

m68k_sup_ssp 

Supervisor stack pointer.

m68k_sup_sfc 

Alternate function.

m68k_sup_dfc 

Code registers.

m68k_sup_cacr 

Cache control register.

m68k_sup_asid 

Address space ID register.

m68k_sup_acr0 

Access control register 0 (data).

m68k_sup_acr1 

Access control register 1 (data).

m68k_sup_acr2 

Access control register 2 (instruction).

m68k_sup_acr3 

Access control register 3 (instruction).

m68k_sup_mmubar 

MMU base address register.

m68k_sup_rombar0 

ROM base address register 0.

m68k_sup_rombar1 

ROM base address register 1.

m68k_sup_rambar0 

RAM base address register 0.

m68k_sup_rambar1 

RAM base address register 1.

m68k_sup_mbar 

Module base address register.

m68k_sup_mpcr 

Multiprocessor control register.

m68k_sup_edrambar 

Embedded DRAM base address register.

m68k_sup_secmbar 

Secondary module base address register.

m68k_sup_0_pcr1 

RAM 0 permutation control register 1.

m68k_sup_0_pcr2 

RAM 0 permutation control register 2.

m68k_sup_0_pcr3 

RAM 0 permutation control register 3.

m68k_sup_1_pcr1 

RAM 1 permutation control register 1.

m68k_sup_1_pcr2 

RAM 1 permutation control register 2.

m68k_sup_1_pcr3 

RAM 1 permutation control register 3.

Definition at line 101 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kEffectiveAddressMode

M68k effective addressing modes.

Mode Reg.
Addressing Modes Syntax Field Field Data Mem Ctl Alter 234 Symbol
------------------------------- --------------- ----- ----- ---- --- --- ----- --- -----------------
Register direct m68k_eam_rd
Data Dn 000 reg# X - - X - m68k_eam_drd
Address An 001 reg# - - - X - m68k_eam_ard
Register indirect m68k_eam_ri
Address (An) 010 reg# X X X X - m68k_eam_ari
Address with postincrement (An)+ 011 reg# X X - X - m68k_eam_inc
Address with predecrement -(An) 100 reg# X X - X - m68k_eam_dec
Address with displacement (d16,An) 101 reg# X X X X - m68k_eam_dsp
Address register indirect with index m68k_eam_idx
8-bit displacement (d8,An,Xn) 110 reg# X X X X - m68k_eam_idx8
Base Displacement (bd,An,Xn) 110 reg# X X X X X m68k_eam_idxbd
Memory indirect m68k_eam_mi
Postindexed ([bd,An],Xn,od) 110 reg# X X X X X m68k_eam_mpost
Preindexed ([bd,An,Xn],od) 110 reg# X X X X X m68k_eam_mpre
Program counter indirect m68k_eam_pci
With displacement (d16,PC) 111 010 X X X - - m68k_eam_pcdsp
Program counter indirect with index m68k_eam_pcidx
8-Bit Displacement (d8,PC,Xn) 111 011 X X X - - m68k_eam_pcidx8
Base Displacement (bd,PC,Xn) 111 011 X X X - X m68k_eam_pcidxbd
Program counter memory indirect m68k_eam_pcmi
Postindexed ([bd,PC],Xn,od) 111 011 X X X X(+) X m68k_eam_pcmpost
Preindexed ([bd,PC,Xn],od) 111 011 X X X X(+) X m68k_eam_pcmpre
Absolute data addressing m68k_eam_abs
Short (xxx).W 111 000 X X X X(+) - m68k_eam_absw
Long (xxx).L 111 001(*) X X X X(+) - m68k_eam_absl
Immediate #<xxx> 111 100 X X - - - m68k_eam_imm
Unused
NA NA 111 101 - - - - -
NA NA 111 110 - - - - -
NA NA 111 111 - - - - -

Note *: the "reg field" for absolute data addressing long is indicated as "000" in the documentation but I believe it should be "001". [Robb P. Matzke 2013-10-07]

Note +: the absolute data addressing modes are marked as non-alterable in this table in the m68k documentation, but the documentation for instructions that say an operand "uses the alterable addressing modes shown in the following table" shows the absolute addressing modes as being valid for the instruction. Therefore, I'm including the absolute addressing modes in the set of alterable addressing modes. [Robb P. Matzke 2013-10-07] After implementing all the integer instructions, it looks like this table in the reference manual has an error: the table excludes the two absolute data addressing modes (as just mentioned), but includes the two program counter memory indirect modes (which are missing from the tables for most instructions that say they use alterable addressing modes). So it looks like someone at Motorola placed two "X"s in the wrong rows. I may change my table in the future. FIXME[Robb P. Matzke 2014-02-24]

Enumerator
m68k_eam_drd 

Data register direct: Dn.

m68k_eam_ard 

Address register direct: An.

m68k_eam_ari 

Address register indirect: (An)

m68k_eam_inc 

Address register indirect with post increment: (An)+.

m68k_eam_dec 

Address register indirect with pre decrement: -(An)

m68k_eam_dsp 

Address register indirect with displacement: (d_16,An)

m68k_eam_idx8 

Address register indirect with scaled index and 8-bit displacement.

m68k_eam_idxbd 

Address register indirect with scaled index and base displacement.

m68k_eam_mpost 

Memory indirect post indexed.

m68k_eam_mpre 

Memory indirect pre indexed.

m68k_eam_pcdsp 

Program counter indirect with displacement: (d_16,PC)

m68k_eam_pcidx8 

Program counter indirect with scaled index and 8-bit displacement.

m68k_eam_pcidxbd 

Program counter indirect with scaled index and base displacement.

m68k_eam_pcmpost 

Program counter memory indirect post indexed.

m68k_eam_pcmpre 

Program counter memory indirect pre indexed.

m68k_eam_absw 

Absolute data addressing short: (xxx).W.

m68k_eam_absl 

Absolute data addressing long: (xxx).L.

m68k_eam_imm 

Immediate data.

m68k_eam_all 

All addressing modes.

m68k_eam_rd 

Register direct addressing modes.

m68k_eam_ri 

Register indirect addressing modes.

m68k_eam_idx 

Address register indirect with scaled index.

m68k_eam_mi 

Memory indirect addressing modes.

m68k_eam_pci 

Program counter indirect.

m68k_eam_pcidx 

Program counter indirect with index.

m68k_eam_pcmi 

Program counter memory indirect.

m68k_eam_abs 

Absolute data addressing.

m68k_eam_data 

Data addressing modes.

All modes except address register direct.

m68k_eam_memory 

Memory addressing modes.

All modes except register direct.

m68k_eam_control 

Control addressing modes.

Memory modes except increment, decrement, and immediate.

m68k_eam_alter 

Alterable addressing modes.

All modes except immediate, program counter indirect with index, and program counter indirect. Note that the m68k documentation excludes absolute addressing modes from the definition of alterable modes, but then includes the absolute addressing modes in all the instructions that say they use alterable addressing modes.

m68k_eam_234 

Addressing modes specific to m680{20,30,40}.

m68k_eam_direct 

All register direct addressing modes.

m68k_eam_pc 

All PC address modes.

Definition at line 188 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kDataFormat

M68k data formats for floating-point operations.

The integer values are important: they are the bit patterns in floating point instruction encodings.

Enumerator
m68k_fmt_i32 

32-bit integer.

m68k_fmt_f32 

32-bit floating point, "single real".

m68k_fmt_f96 

96-bit floating point, "extended real".

m68k_fmt_p96 

Three 32-bit words of binary coded decimal.

m68k_fmt_i16 

16-bit integer.

m68k_fmt_f64 

64-bit floating point, "double real".

m68k_fmt_i8 

8-bit integer.

m68k_fmt_unknown 

Invalid format.

Definition at line 242 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::M68kInstructionKind

M68k instruction types.

Enumerator
m68k_abcd 

Add decimal with extended.

m68k_add 

Add.

m68k_adda 

Add address.

m68k_addi 

Add immediate.

m68k_addq 

Add quick.

m68k_addx 

Add extended.

m68k_and 

AND logical.

m68k_andi 

AND immediate.

m68k_asl 

Arithmetic shift left.

m68k_asr 

Arithmetic shift right.

m68k_bcc 

Branch carry clear (alias bhs)

m68k_bcs 

Branch carry set (alias blo)

m68k_beq 

Branch equal.

m68k_bge 

Branch greater or equal.

m68k_bgt 

Branch greater than.

m68k_bhi 

Branch high.

m68k_ble 

Branch less or equal.

m68k_bls 

Branch lower or same.

m68k_blt 

Branch less than.

m68k_bmi 

Branch minus.

m68k_bne 

Branch not equal.

m68k_bpl 

Branch plus.

m68k_bvc 

Branch overflow clear.

m68k_bvs 

Branch overflow set.

m68k_bchg 

Test a bit and change.

m68k_bclr 

Test a bit and clear.

m68k_bfchg 

Test bit field and change.

m68k_bfclr 

Test bit field and clear.

m68k_bfexts 

Extract bit field signed.

m68k_bfextu 

Extract bit field unsigned.

m68k_bfins 

Insert bit field.

m68k_bfset 

Test bit field and set.

m68k_bftst 

Test bit field.

m68k_bkpt 

Breakpoint.

m68k_bra 

Branch always.

m68k_bset 

Test a bit and set.

m68k_bsr 

Branch to subroutine.

m68k_btst 

Test a bit.

m68k_callm 

Call module.

m68k_cas 

Compare and swap with operand.

m68k_cas2 

Compare and swap with operands.

m68k_chk 

Check register against bounds.

m68k_chk2 

Check register against bounds.

m68k_clr 

Clear an operand.

m68k_cmp 

Compare.

m68k_cmp2 

Compare register against bounds.

m68k_cmpa 

Compare address.

m68k_cmpi 

Compare immediate.

m68k_cmpm 

Compare memory.

m68k_cpusha 

Push and invalidate all.

m68k_cpushl 

Push and invalidate cache lines.

m68k_cpushp 

Push and invalidate cache pages.

m68k_dbt 

Decrement and branch if true.

m68k_dbf 

Decrement and branch if false.

m68k_dbhi 

Decrement and branch if high.

m68k_dbls 

Decrement and branch if lower or same.

m68k_dbcc 

Decrement and branch if cary clear.

m68k_dbcs 

Decrement and branch if carry set.

m68k_dbne 

Decrement and branch if not equal.

m68k_dbeq 

Decrement and branch if equal.

m68k_dbvc 

Decrement and branch if overflow clear.

m68k_dbvs 

Decrement and branch if overflow set.

m68k_dbpl 

Decrement and branch if plus.

m68k_dbmi 

Decrement and branch if minus.

m68k_dbge 

Decrement and branch if greater or equal.

m68k_dblt 

Decrement and branch if less than.

m68k_dbgt 

Decrement and branch if greater than.

m68k_dble 

Decrement and branch if less than or equal.

m68k_divs 

Signed divide with optional remainder.

m68k_divsl 

Signed divide 32-bit quotient with remainder.

m68k_divu 

Unsigned divide with optional remainder.

m68k_divul 

Unsigned divide 32-bit quotient with remainder.

m68k_eor 

Exclusive-OR logical.

m68k_eori 

Exclusive-OR immediate.

m68k_exg 

Exchange registers.

m68k_ext 

Sign extend.

m68k_extb 

Sign extend byte to longword.

m68k_fabs 

Floating-point absolute value with FPCR rounding.

m68k_fadd 

Floating-point add with FPCR rounding.

m68k_fbeq 

Floating-point branch if equal.

m68k_fbne 

Floating-point branch if not equal.

m68k_fbgt 

Floating-point branch if greater than.

m68k_fbngt 

Floating-point branch if not greater than.

m68k_fbge 

Floating-point branch if greater than or equal.

m68k_fbnge 

Floating-point branch if not greater than or equal.

m68k_fblt 

Floating-point branch if less than.

m68k_fbnlt 

Floating-point branch if not less than.

m68k_fble 

Floating-point branch if less than or equal.

m68k_fbnle 

Floating-point branch if not less than or equal.

m68k_fbgl 

Floating-point branch if greater or less than.

m68k_fbngl 

Floating-point branch if not greater or less than.

m68k_fbgle 

Floating-point branch if greater, less, or equal.

m68k_fbngle 

Floating-point branch if not greater, less, or equal.

m68k_fbogt 

Floating-point branch if ordered greater than.

m68k_fbule 

Floating-point branch if unordered or less or equal.

m68k_fboge 

Floating-point branch if ordered greater than or equal.

m68k_fbult 

Floating-point branch if unordered less than.

m68k_fbolt 

Floating-point branch if ordered less than.

m68k_fbuge 

Floating-point branch if unordered or greater than or equal.

m68k_fbole 

Floating-point branch if ordered less than or equal.

m68k_fbugt 

Floating-point branch if unordered or greater than.

m68k_fbogl 

Floating-point branch if ordered greater or less than.

m68k_fbueq 

Floating-point branch if unordered or equal.

m68k_fbor 

Floating-point branch if ordered.

m68k_fbun 

Floating-point branch if unordered.

m68k_fbf 

Floating-point branch if false.

m68k_fbt 

Floating-point branch if true.

m68k_fbsf 

Floating-point branch if signaling false.

m68k_fbst 

Floating-point branch if signaling true.

m68k_fbseq 

Floating-point branch if signaling equal.

m68k_fbsne 

Floating-point branch if signaling not equal.

m68k_fcmp 

Floating-point compare.

m68k_fdabs 

Floating-point absolute value with double-precision rounding.

m68k_fdadd 

Floating-point add with double-precision rounding.

m68k_fddiv 

Floating-point divide with double-precision rounding.

m68k_fdiv 

Floating-point divide with FPCR rounding.

m68k_fdmove 

Move floating-point data with double-precision rounding.

m68k_fdmul 

Floating-point multiple with double-precision rounding.

m68k_fdneg 

Floating-point negation with double-precision rounding.

m68k_fdsqrt 

Floating-point square root with double-precision rounding.

m68k_fdsub 

Floating-point subtract with double-precision rounding.

m68k_fint 

Floating-point integer part.

m68k_fintrz 

Floating-point integer part rounded-to-zero.

m68k_fmove 

Move floating-point data with FPCR rounding.

m68k_fmovem 

Move multiple floating-point data registers.

m68k_fmul 

Floating-point multiply with FPCR rounding.

m68k_fneg 

Floating-pont negate with FPCR rounding.

m68k_fnop 

Floating-point no operation.

m68k_fsabs 

Floating-point absolute value with single-precision rounding.

m68k_fsadd 

Floating-point add with single-precision rounding.

m68k_fsdiv 

Floating-point divide with single-precision rounding.

m68k_fsmove 

Move floating-point data with single-precision rounding.

m68k_fsmul 

Floating-point multiply with single-precision rounding.

m68k_fsneg 

Floating-point negation with single-precision rounding.

m68k_fsqrt 

Floating-point square root with FPCR rounding.

m68k_fssqrt 

Floating-point square root with single-precision rounding.

m68k_fssub 

Floating-point subtract with single-precision rounding.

m68k_fsub 

Floating-point subtract with FPCR rounding.

m68k_ftst 

Floating point test.

m68k_illegal 

Take illegal instruction trap.

m68k_jmp 

Jump.

m68k_jsr 

Jump to subroutine.

m68k_lea 

Load effective address.

m68k_link 

Link and allocate.

m68k_lsl 

Logical shift left.

m68k_lsr 

Logical shift right.

m68k_mac 

Multiply accumulate.

m68k_mov3q 

Move 3-bit data quick.

m68k_movclr 

Move from MAC ACC register and clear.

m68k_move 

Move from source to destination (data, CCR, ACC, MACSR, MASK)

m68k_move_acc 

Move MAC ACC register.

m68k_move_accext 

Move MAC ACCext register.

m68k_move_ccr 

Move condition code register.

m68k_move_macsr 

Move MAC status register.

m68k_move_mask 

Move MAC MASK register.

m68k_move_sr 

Move status register.

m68k_move16 

Move 16-byte block.

m68k_movea 

Move address from source to destination.

m68k_movec 

Move control register.

m68k_movem 

Move multiple registers.

m68k_movep 

Move peripheral data.

m68k_moveq 

Move quick.

m68k_msac 

Multiply subtract.

m68k_muls 

Signed multiply.

m68k_mulu 

Unsigned multiply.

m68k_mvs 

Move with sign extend.

m68k_mvz 

Move with zero fill.

m68k_nbcd 

Negate decimal with extend.

m68k_neg 

Negate.

m68k_negx 

Negate with extend.

m68k_nop 

No operation.

m68k_not 

Logical complement.

m68k_or 

Inclusive-OR logical.

m68k_ori 

Inclusive-OR immediate.

m68k_pack 

Pack.

m68k_pea 

Push effective address.

m68k_rol 

Rotate left without extend.

m68k_ror 

Rotate right without extend.

m68k_roxl 

Rotate left with extend.

m68k_roxr 

Rotate right with extend.

m68k_rtd 

Return and deallocate.

m68k_rtm 

Return from module.

m68k_rtr 

Return and restore condition codes.

m68k_rts 

Return from subroutine.

m68k_sbcd 

Subtract decimal with extend.

m68k_st 

Set if true.

m68k_sf 

Set if false.

m68k_shi 

Set if high.

m68k_sls 

Set if lower or same.

m68k_scc 

Set if carry clear (HS)

m68k_scs 

Set if carry set (LO)

m68k_sne 

Set if not equal.

m68k_seq 

Set if equal.

m68k_svc 

Set if overflow clear.

m68k_svs 

Set if overflow set.

m68k_spl 

Set if plus.

m68k_smi 

Set if minus.

m68k_sge 

Set if greater or equal.

m68k_slt 

Set if less than.

m68k_sgt 

Set if greater than.

m68k_sle 

Set if less or equal.

m68k_sub 

Subtract.

m68k_suba 

Subtract address.

m68k_subi 

Subtract immediate.

m68k_subq 

Subtract quick.

m68k_subx 

Subtract extended.

m68k_swap 

Swap register halves.

m68k_tas 

Test and set an operand.

m68k_trap 

Trap.

m68k_trapt 

Trap if true.

m68k_trapf 

Trap if false.

m68k_traphi 

Trap if high.

m68k_trapls 

Trap if lower or same.

m68k_trapcc 

Trap if carry clear (HS)

m68k_trapcs 

Trap if carry set (LO)

m68k_trapne 

Trap if not equal.

m68k_trapeq 

Trap if equal.

m68k_trapvc 

Trap if overflow clear.

m68k_trapvs 

Trap if overflow set.

m68k_trappl 

Trap if plus.

m68k_trapmi 

Trap if minus.

m68k_trapge 

Trap if greater or equal.

m68k_traplt 

Trap if less than.

m68k_trapgt 

Trap if greater than.

m68k_traple 

Trap if less or equal.

m68k_trapv 

Trap on overflow.

m68k_tst 

Test an operand.

m68k_unlk 

Unlink.

m68k_unpk 

Unpack binary coded decimal.

Definition at line 254 of file InstructionEnumsM68k.h.

enum Rose::BinaryAnalysis::MipsRegisterClass

MIPS major register numbers.

Enumerator
mips_regclass_gpr 

General purpose registers.

Minors are 0..31.

mips_regclass_spr 

Special purpose registers.

Minors are the MipsSpecialPurposeRegisters enum members.

mips_regclass_fpr 

Floating point registers.

Minors are 0..31.

mips_regclass_fcsr 

Floating point control/status register.

Minors are MipsFcsrMinor.

mips_regclass_cp0gpr 

General purpose registers for coprocessor 0.

Minors are 0..31.

mips_regclass_cp2gpr 

Coprocessor 2 general purpose registers.

Minors are implementation defined.

mips_regclass_cp2spr 

Coprocessor 2 special purpose (i.e., control) registers.

Minors are implementation dfnd.

mips_regclass_sgpr 

Shadow general purpose registers.

mips_regclass_hw 

Hardware registers.

Definition at line 11 of file InstructionEnumsMips.h.

enum Rose::BinaryAnalysis::MipsFcsrMinors

Portions of the FCSR register.

These are the minor numbers for mips_regclass_fcsr.

Enumerator
mips_fcsr_all 

All bits of the FCSR.

mips_fcsr_fccr 

Bits that compose the FP condition codes register.

mips_fcsr_fexr 

Bits that compose the FP exceptions register.

mips_fcsr_fenr 

Bits that compose the FP enables register.

Definition at line 24 of file InstructionEnumsMips.h.

enum Rose::BinaryAnalysis::MipsSpecialPurposeRegister

MIPS special purpose register minor numbers.

Enumerator
mips_spr_hi 

Hi floating point result.

mips_spr_lo 

Lo floating point result.

mips_spr_pc 

Program counter.

mips_spr_fir 

Floating point implementation and revision register.

mips_spr_fcsr 

Floating point control/status register (used to be known as FCR31)

Definition at line 32 of file InstructionEnumsMips.h.

enum Rose::BinaryAnalysis::MipsInstructionKind

Kinds of MIPS instructions.

Enumerator
mips_abs_s 

Floating point absolute value single precision.

mips_abs_d 

Floating point absolute value double precision.

mips_abs_ps 

Floating point absolute value pair of single precision.

mips_add 

Add word.

mips_add_s 

Floating point add single precision.

mips_add_d 

Floating point add double precision.

mips_add_ps 

Floating point add pair of single precision.

mips_addi 

Add immediate word.

mips_addiu 

Add immediate unsigned word.

mips_addu 

Add unsigned word.

mips_alnv_ps 

Floating point align variable pair of single precision.

mips_and 

Bitwise logical AND.

mips_andi 

Bitwise logical AND immediate.

mips_bc1f 

Branch on FP false.

mips_bc1fl 

Branch on FP false likely.

mips_bc1t 

Branch on FP true.

mips_bc1tl 

Branch on FP true likely.

mips_bc2f 

Branch on COP2 false.

mips_bc2fl 

Branch on COP2 false likely.

mips_bc2t 

Branch on COP2 true.

mips_bc2tl 

Branch on COP2 true likely.

mips_beq 

Branch on equal.

mips_beql 

Branch on equal likely.

mips_bgez 

Branch on greater than or equal to zero.

mips_bgezal 

Branch on greater than or equal to zero and link.

mips_bgezall 

Branch on greater than or equal to zero and link likely.

mips_bgezl 

Branch on greater than or equal to zero likely.

mips_bgtz 

Branch on greater than zero.

mips_bgtzl 

Branch on greater than zero likely.

mips_blez 

Branch on less than or equal to zero.

mips_blezl 

Branch on less than or equal to zero likely.

mips_bltz 

Branch on less than zero.

mips_bltzal 

Branch on less than zero and link.

mips_bltzall 

Branch on less than zero and link likely.

mips_bltzl 

Branch on less than zero likely.

mips_bne 

Branch on not equal.

mips_bnel 

Branch on not equal likely.

mips_break 

Break point.

mips_c_f_s 

Floating point compare false single precision.

mips_c_un_s 

Floating point compare unordered single precision.

mips_c_eq_s 

Floating point compare equal single precision.

mips_c_ueq_s 

Floating point compare unordered equal.

mips_c_olt_s 

Floating point compare ordered or less than single precision.

mips_c_ult_s 

Floating point compare unordered or less than single precision.

mips_c_ole_s 

Floating point compare ordered or less than or equal single precision.

mips_c_ule_s 

Floating point compare unordered or less than or equal single precision.

mips_c_sf_s 

Floating point compare signaling false single precision.

mips_c_ngle_s 

Floating point compare not greater than or less than or equal single precision.

mips_c_seq_s 

Floating point compare signaling equal single precision.

mips_c_ngl_s 

Floating point compare not greater than or less than single precision.

mips_c_lt_s 

Floating point compare less than single precision.

mips_c_nge_s 

Floating point compare not greater than or equal single precision.

mips_c_le_s 

Floating point compare less than or equal single precision.

mips_c_ngt_s 

Floating point compare not greater than single precision.

mips_c_f_d 

Floating point compare false double precision.

mips_c_un_d 

Floating point compare unordered double precision.

mips_c_eq_d 

Floating point compare equal double precision.

mips_c_ueq_d 

Floating point compare unordered equal.

mips_c_olt_d 

Floating point compare ordered or less than double precision.

mips_c_ult_d 

Floating point compare unordered or less than double precision.

mips_c_ole_d 

Floating point compare ordered or less than or equal double precision.

mips_c_ule_d 

Floating point compare unordered or less than or equal double precision.

mips_c_sf_d 

Floating point compare signaling false double precision.

mips_c_ngle_d 

Floating point compare not greater than or less than or equal double precision.

mips_c_seq_d 

Floating point compare signaling equal double precision.

mips_c_ngl_d 

Floating point compare not greater than or less than double precision.

mips_c_lt_d 

Floating point compare less than double precision.

mips_c_nge_d 

Floating point compare not greater than or equal double precision.

mips_c_le_d 

Floating point compare less than or equal double precision.

mips_c_ngt_d 

Floating point compare not greater than double precision.

mips_c_f_ps 

Floating point compare false pair of single precision.

mips_c_un_ps 

Floating point compare unordered pair of single precision.

mips_c_eq_ps 

Floating point compare equal pair of single precision.

mips_c_ueq_ps 

Floating point compare unordered equal.

mips_c_olt_ps 

Floating point compare ordered or less than pair of single precision.

mips_c_ult_ps 

Floating point compare unordered or less than pair of single precision.

mips_c_ole_ps 

Floating point compare ordered or less than or equal pair of single precision.

mips_c_ule_ps 

Floating point compare unordered or less than or equal pair of single precision.

mips_c_sf_ps 

Floating point compare signaling false pair of single precision.

mips_c_ngle_ps 

Floating point compare not greater than or less than or equal pair of single precision.

mips_c_seq_ps 

Floating point compare signaling equal pair of single precision.

mips_c_ngl_ps 

Floating point compare not greater than or less than pair of single precision.

mips_c_lt_ps 

Floating point compare less than pair of single precision.

mips_c_nge_ps 

Floating point compare not greater than or equal pair of single precision.

mips_c_le_ps 

Floating point compare less than or equal pair of single precision.

mips_c_ngt_ps 

Floating point compare not greater than pair of single precision.

mips_cache 

Perform cache operation.

mips_cachee 

Perform cache operation EVA.

mips_ceil_l_s 

Fixed point ceiling convert to long fixed point.

mips_ceil_l_d 

Fixed point ceiling convert to long fixed point.

mips_ceil_w_s 

Fixed point ceiling convert to word fixed point.

mips_ceil_w_d 

Fixed point ceiling convert to word fixed point.

mips_cfc1 

Move control word from floating point.

mips_cfc2 

Move control word from coprocessor 2.

mips_clo 

Count leading ones in word.

mips_clz 

Count leading zeros in word.

mips_cop2 

Coprocessor operation to coprocessor 2.

mips_ctc1 

Move control word to floating point.

mips_ctc2 

Move control word to coprocessor 2.

mips_cvt_d_s 

Floating point convert to double floating point.

mips_cvt_d_w 

Floating point convert to double floating point.

mips_cvt_d_l 

Floating point convert to double floating point.

mips_cvt_l_s 

Floating point convert to long fixed point.

mips_cvt_l_d 

Floating point convert to long fixed point.

mips_cvt_ps_s 

Floating point convert to paired single.

mips_cvt_s_d 

Floating point convert to single floating point.

mips_cvt_s_w 

Floating point convert to single floating point.

mips_cvt_s_l 

Floating point convert to single floating point.

mips_cvt_s_pl 

Floating point convert pair lower to single floating point.

mips_cvt_s_pu 

Floating point convert pair upper to single floating point.

mips_cvt_w_s 

Floating point convert to word fixed point.

mips_cvt_w_d 

Floating point convert to word fixed point.

mips_di 

Disable interrupts.

mips_div 

Divide word.

mips_div_s 

Floating point divide.

mips_div_d 

Floating point divide.

mips_divu 

Divide unsigned word.

mips_ehb 

Execution hazard barrier.

mips_ei 

Enable interrupts.

mips_eret 

Exception return.

mips_ext 

Extract bit field.

mips_floor_l_s 

Floating point floor convert to long fixed point.

mips_floor_l_d 

Floating point floor convert to long fixed point.

mips_floor_w_s 

Floating point floor convert to word fixed point.

mips_floor_w_d 

Floating point floor convert to word fixed point.

mips_ins 

Insert bit field.

mips_j 

Jump.

mips_jal 

Jump and link.

mips_jalr 

Jump and link register.

mips_jalr_hb 

Jump and link register with hazard barrier.

mips_jalx 

Jump and link exchange.

mips_jr 

Jump register.

mips_jr_hb 

Jump register with hazard barrier.

mips_lb 

Load byte.

mips_lbe 

Load byte EVA.

mips_lbu 

Load byte unsigned.

mips_lbue 

Load byte unsigned EVA.

mips_ldc1 

Load doubleword to floating point.

mips_ldc2 

Load doubleword to coprocessor 2.

mips_ldxc1 

Load doubleword indexed to floating point.

mips_lh 

Load halfword.

mips_lhe 

Load halfword EVA.

mips_lhu 

Load halfword unsigned.

mips_lhue 

Load halfword unsigned EVA.

mips_ll 

Load linked word.

mips_lle 

Load linked word EVA.

mips_lui 

Load upper immediate.

mips_luxc1 

Load doubleword indexed unaligned to floating point.

mips_lw 

Load word.

mips_lwc1 

Load word to floating point.

mips_lwc2 

Load word to coprocessor 2.

mips_lwe 

Load word EVA.

mips_lwl 

Load word left.

mips_lwle 

Load word left EVA.

mips_lwr 

Load word right.

mips_lwre 

Load word right EVA.

mips_lwxc1 

Load word indexed to floating point.

mips_madd 

Multiply and add word to hi, lo.

mips_madd_s 

Floating point multiply add.

mips_madd_d 

Floating point multiply add.

mips_madd_ps 

Floating point multiply add.

mips_maddu 

Multiply and add unsigned word to hi, lo.

mips_mfc0 

Move from coprocessor 0.

mips_mfc1 

Move word from coprocessor 1.

mips_mfc2 

Move word from coprocessor 2.

mips_mfhc1 

Move word from high half of floating point register.

mips_mfhc2 

Move word from high half of coprocessor 2.

mips_mfhi 

Move from hi register.

mips_mflo 

Move from lo register.

mips_mov_s 

Floating point move.

mips_mov_d 

Floating point move.

mips_mov_ps 

Floating point move.

mips_movf 

Move conditional on floating point false.

mips_movf_s 

Floating point move conditional on floating point false.

mips_movf_d 

Floating point move conditional on floating point false.

mips_movf_ps 

Floating point move conditional on floating point false.

mips_movn 

Move conditional on not zero.

mips_movn_s 

Move floating point conditional on not zero.

mips_movn_d 

Move floating point conditional on not zero.

mips_movn_ps 

Move floating point conditional on not zero.

mips_movt 

Move conditional on floating piont true.

mips_movt_s 

Floating point move conditional on floating point true.

mips_movt_d 

Floating point move conditional on floating point true.

mips_movt_ps 

Floating point move conditional on floating point true.

mips_movz 

Move conditional on zero.

mips_movz_s 

Floating point move conditional on zero.

mips_movz_d 

Floating point move conditional on zero.

mips_movz_ps 

Floating point move conditional on zero.

mips_msub 

Multiply and subtract word.

mips_msub_s 

Floating point multiple and subtract.

mips_msub_d 

Floating point multiple and subtract.

mips_msub_ps 

Floating point multiple and subtract.

mips_msubu 

Multiply and subtract word to hi, lo.

mips_mtc0 

Move to coprocessor 0.

mips_mtc1 

Move word to floating point.

mips_mtc2 

Move word to coprocessor 2.

mips_mthc1 

Move word to high half of floating point register.

mips_mthc2 

Move word to high half of coprocessor 2 register.

mips_mthi 

Move to hi register.

mips_mtlo 

Move to lo register.

mips_mul 

Multiply word to GPR.

mips_mul_s 

Floating point multiply.

mips_mul_d 

Floating point multiply.

mips_mul_ps 

Floating point multiply.

mips_mult 

Multiply word.

mips_multu 

Multiply unsigned word.

mips_neg_s 

Floating point negate.

mips_neg_d 

Floating point negate.

mips_neg_ps 

Floating point negate.

mips_nmadd_s 

Floating point negative multiply add.

mips_nmadd_d 

Floating point negative multiply add.

mips_nmadd_ps 

Floating point negative multiply add.

mips_nmsub_s 

Floating point negative multply subtract.

mips_nmsub_d 

Floating point negative multply subtract.

mips_nmsub_ps 

Floating point negative multply subtract.

mips_nop 

No operation.

mips_nor 

Not OR.

mips_or 

Bitwise OR.

mips_ori 

Bitwise OR immediate.

mips_pause 

Wait for the LLBit to clear.

mips_pll_ps 

Pair lower lower.

mips_plu_ps 

Pair lower upper.

mips_pref 

Prefetch.

mips_prefe 

Prefetch EVA.

mips_prefx 

Prefetch indexed.

mips_pul_ps 

Pair upper lower.

mips_puu_ps 

Pair upper upper.

mips_rdhwr 

Read hardware register.

mips_rdpgpr 

Read GPR from previous shadow set.

mips_recip_s 

Reciprocal approximation.

mips_recip_d 

Reciprocal approximation.

mips_rotr 

Rotate word right.

mips_rotrv 

Rotate word right variable.

mips_round_l_s 

Floating point round to long fixed point.

mips_round_l_d 

Floating point round to long fixed point.

mips_round_w_s 

Floating point round to word fixed point.

mips_round_w_d 

Floating point round to word fixed point.

mips_rsqrt_s 

Reciprocal square root approximation.

mips_rsqrt_d 

Reciprocal square root approximation.

mips_sb 

Store byte.

mips_sbe 

Store byte EVA.

mips_sc 

Store conditional word.

mips_sce 

Store conditional word EVA.

mips_sdc1 

Store doubleword from floating point.

mips_sdc2 

Store doubleword from coprocessor 2.

mips_sdxc1 

Store doubleword indexed from floating point.

mips_seb 

Sign extend byte.

mips_seh 

Sign extend halfword.

mips_sh 

Store halfword.

mips_she 

Store halfword EVA.

mips_sll 

Shift word left logical.

mips_sllv 

Shift word left logical variable.

mips_slt 

Set on less than.

mips_slti 

Set on less than immediate.

mips_sltiu 

Set on less than immediate unsigned.

mips_sltu 

Set on less than unsigned.

mips_sqrt_s 

Floating point square root.

mips_sqrt_d 

Floating point square root.

mips_sra 

Shift word right arithmetic.

mips_srav 

Shift word right arithmetic variable.

mips_srl 

Shift right logical.

mips_srlv 

Shift right logical value.

mips_ssnop 

Superscalar no operation.

mips_sub 

Subtract word.

mips_sub_s 

Subtract floating point.

mips_sub_d 

Subtract floating point.

mips_sub_ps 

Subtract floating point.

mips_subu 

Subtract unsigned word.

mips_suxc1 

Store doubleword indexed unaligned from floating point.

mips_sw 

Store word.

mips_swc1 

Store word from floating point.

mips_swc2 

Store word from coprocessor 2.

mips_swe 

Store word EVA.

mips_swl 

Store word left.

mips_swle 

Store word left EVA.

mips_swr 

Store word right.

mips_swre 

Store word right EVA.

mips_swxc1 

Store word indexed from floating point.

mips_sync 

Synchronize.

mips_synci 

Synchronize caches to make instruction writes effective.

mips_syscall 

System call.

mips_teq 

Trap if equal.

mips_teqi 

Trap if equal immediate.

mips_tge 

Trap if greater or equal.

mips_tgei 

Trap if greater or equal immediate.

mips_tgeiu 

Trap if greater or equal immediate unsigned.

mips_tgeu 

Trap if greater or equal unsigned.

mips_tlbinv 

TLB invalidate.

mips_tlbinvf 

TLB invalidate flush.

mips_tlbp 

Probe TLB for matching entry.

mips_tlbr 

Read indexed TLB entry.

mips_tlbwi 

Write indexed TLB entry.

mips_tlbwr 

Write random TLB entry.

mips_tlt 

Trap if less than.

mips_tlti 

Trap if less than immediate.

mips_tltiu 

Trap if less than immediate unsigned.

mips_tltu 

Trap if less than unsigned.

mips_tne 

Trap if not equal.

mips_tnei 

Trap if not equal immediate.

mips_trunc_l_s 

Floating point truncate to long fixed point.

mips_trunc_l_d 

Floating point truncate to long fixed point.

mips_trunc_w_s 

Floating point truncate to word fixed point.

mips_trunc_w_d 

Floating point truncate to word fixed point.

mips_wait 

Enter standby mode.

mips_wrpgpr 

Write to GPR in previous shadow set.

mips_wsbh 

Word swap bytes within halfwords.

mips_xor 

Exclusive OR.

mips_xori 

Exclusive OR immediate.

Definition at line 41 of file InstructionEnumsMips.h.

enum Rose::BinaryAnalysis::PowerpcWordSize

PowerPC word size.

Enumerator
powerpc_32 

32 bits per word.

powerpc_64 

64 bits per word.

Definition at line 12 of file InstructionEnumsPowerpc.h.

enum Rose::BinaryAnalysis::PowerpcInstructionKind

PowerPC instruction types.

Enumerator
powerpc_add 

Add.

powerpc_add_record 

Add.

powerpc_addo 

Add.

powerpc_addo_record 

Add.

powerpc_addc 

Add Carrying.

powerpc_addc_record 

Add Carrying.

powerpc_addco 

Add Carrying.

powerpc_addco_record 

Add Carrying.

powerpc_adde 

Add Extended.

powerpc_adde_record 

Add Extended.

powerpc_addeo 

Add Extended.

powerpc_addeo_record 

Add Extended.

powerpc_addi 

Add Immediate.

powerpc_addic 

Add Immediate Carrying.

powerpc_addic_record 

Add Immediate Carrying and Record.

powerpc_addis 

Add Immediate Shifted.

powerpc_addme 

Add to Minus One Extended.

powerpc_addme_record 

Add to Minus One Extended.

powerpc_addmeo 

Add to Minus One Extended.

powerpc_addmeo_record 

Add to Minus One Extended.

powerpc_addze 

Add to Zero Extended.

powerpc_addze_record 

Add to Zero Extended.

powerpc_addzeo 

Add to Zero Extended.

powerpc_addzeo_record 

Add to Zero Extended.

powerpc_and 

AND.

powerpc_and_record 

AND.

powerpc_andc 

AND with Complement.

powerpc_andc_record 

AND with Complement.

powerpc_andi_record 

AND Immediate.

powerpc_andis_record 

AND Immediate Shifted.

powerpc_b 

Branch.

powerpc_ba 

Branch.

powerpc_bl 

Branch.

powerpc_bla 

Branch.

powerpc_bc 

Branch Conditional.

powerpc_bca 

Branch Conditional.

powerpc_bcl 

Branch Conditional.

powerpc_bcla 

Branch Conditional.

powerpc_bcctr 

Branch Conditional to Count Register.

powerpc_bcctrl 

Branch Conditional to Count Register.

powerpc_bclr 

Branch Conditional Link Register.

powerpc_bclrl 

Branch Conditional Link Register.

powerpc_cmp 

Compare.

powerpc_cmpi 

Compare Immediate.

powerpc_cmpl 

Compare Logical.

powerpc_cmpli 

Compare Logical Immediate.

powerpc_cntlzd 

Count Leading Zeros Doubleword.

powerpc_cntlzd_record 

Count Leading Zeros Doubleword.

powerpc_cntlzw 

Count Leading Zeros Word.

powerpc_cntlzw_record 

Count Leading Zeros Word.

powerpc_crand 

Condition Register AND.

powerpc_crandc 

Condition Register AND with Complement.

powerpc_creqv 

Condition Register Equivalent.

powerpc_crnand 

Condition Register NAND.

powerpc_crnor 

Condition Register NOR.

powerpc_cror 

Condition Register OR.

powerpc_crorc 

Condition Register OR with Complement.

powerpc_crxor 

Condition Register XOR.

powerpc_dcbf 

Data Cache Block Flush.

powerpc_dcba 

Data Cache Block Allocate.

powerpc_dcbi 

Data Cache Block Invalidate.

powerpc_dcbst 

Data Cache Block Store.

powerpc_dcbt 

Data Cache Block Touch.

powerpc_dcbtst 

Data Cache Block Touch for Store.

powerpc_dcbz 

Data Cache Block Set to Zero.

powerpc_divd 

Divide Doubleword.

powerpc_divd_record 

Divide Doubleword.

powerpc_divdo 

Divide Doubleword.

powerpc_divdo_record 

Divide Doubleword.

powerpc_divdu 

Divide Doubleword Unsigned.

powerpc_divdu_record 

Divide Doubleword Unsigned.

powerpc_divduo 

Divide Doubleword Unsigned.

powerpc_divduo_record 

Divide Doubleword Unsigned.

powerpc_divw 

Divide Word.

powerpc_divw_record 

Divide Word.

powerpc_divwo 

Divide Word.

powerpc_divwo_record 

Divide Word.

powerpc_divwu 

Divide Word Unsigned.

powerpc_divwu_record 

Divide Word Unsigned.

powerpc_divwuo 

Divide Word Unsigned.

powerpc_divwuo_record 

Divide Word Unsigned.

powerpc_dst 

Data Stream Touch.

powerpc_dstt 

Data Stream Touch.

powerpc_dstst 

Data Stream Touch for store.

powerpc_dststt 

Data Stream Touch for store.

powerpc_dss 

Data Stream Stop.

powerpc_dssall 

Data Stream Stop All.

powerpc_eciwx 

External Control in Word Indexed (opt.).

powerpc_ecowx 

External Control out Word Indexed (opt.).

powerpc_eieio 

Enforce In-order Execution of I/O.

powerpc_eqv 

Equivalent.

powerpc_eqv_record 

Equivalent.

powerpc_extsb 

Extend Sign Byte.

powerpc_extsb_record 

Extend Sign Byte.

powerpc_extsh 

Extend Sign Halfword.

powerpc_extsh_record 

Extend Sign Halfword.

powerpc_extsw 

Extend Sign Word.

powerpc_extsw_record 

Extend Sign Word.

powerpc_fabs 

Floating Absolute Value.

powerpc_fabs_record 

Floating Absolute Value.

powerpc_fadd 

Floating Add.

powerpc_fadd_record 

Floating Add.

powerpc_fadds 

Floating Add Single.

powerpc_fadds_record 

Floating Add Single.

powerpc_fcfid 

Floating Convert from Integer Doubleword.

powerpc_fcfid_record 

Floating Convert from Integer Doubleword.

powerpc_fcmpo 

Floating Compare Ordered.

powerpc_fcmpu 

Floating Compare Unordered.

powerpc_fctid 

Floating Convert to Integer Doubleword.

powerpc_fctid_record 

Floating Convert to Integer Doubleword.

powerpc_fctidz 

Floating Convert to Integer Doubleword with Round Toward Zero.

powerpc_fctidz_record 

Floating Convert to Integer Doubleword with Round Toward Zero.

powerpc_fctiw 

Floating Convert to Integer Word.

powerpc_fctiw_record 

Floating Convert to Integer Word.

powerpc_fctiwz 

Floating Convert to Integer Word with Round to Zero.

powerpc_fctiwz_record 

Floating Convert to Integer Word with Round to Zero.

powerpc_fdiv 

Floating Divide.

powerpc_fdiv_record 

Floating Divide.

powerpc_fdivs 

Floating Divide Single.

powerpc_fdivs_record 

Floating Divide Single.

powerpc_fmadd 

Floating Multiply-Add.

powerpc_fmadd_record 

Floating Multiply-Add.

powerpc_fmadds 

Floating Multiply-Add Single.

powerpc_fmadds_record 

Floating Multiply-Add Single.

powerpc_fmr 

Floating Move Register.

powerpc_fmr_record 

Floating Move Register.

powerpc_fmsub 

Floating Multiply-Subtract.

powerpc_fmsub_record 

Floating Multiply-Subtract.

powerpc_fmsubs 

Floating Multiply-Subtract Single.

powerpc_fmsubs_record 

Floating Multiply-Subtract Single.

powerpc_fmul 

Floating Multiply.

powerpc_fmul_record 

Floating Multiply.

powerpc_fmuls 

Floating Multiply Single.

powerpc_fmuls_record 

Floating Multiply Single.

powerpc_fnabs 

Floating Negative Absolute Value.

powerpc_fnabs_record 

Floating Negative Absolute Value.

powerpc_fneg 

Floating Negate.

powerpc_fneg_record 

Floating Negate.

powerpc_fnmadd 

Floating Negative Multiply-Add.

powerpc_fnmadd_record 

Floating Negative Multiply-Add.

powerpc_fnmadds 

Floating Negative Multiply-Add Single.

powerpc_fnmadds_record 

Floating Negative Multiply-Add Single.

powerpc_fnmsub 

Floating Negative Multiply-Subtract.

powerpc_fnmsub_record 

Floating Negative Multiply-Subtract.

powerpc_fnmsubs 

Floating Negative Multiply-Subtract Single.

powerpc_fnmsubs_record 

Floating Negative Multiply-Subtract Single.

powerpc_fpmul 

FP2 Floating Parallel Multiply (BGL specific).

powerpc_fxmul 

FP2 Floating Cross Multiply (BGL specific).

powerpc_fxpmul 

FP2 Floating Cross Copy-Primary Multiply (BGL specific).

powerpc_fxsmul 

FP2 Floating Cross Copy-Secondary Multiply (BGL specific).

powerpc_fpadd 

FP2 Floating Parallel Add (BGL specific).

powerpc_fpsub 

FP2 Floating Parallel Subtract (BGL specific).

powerpc_fpre 

FP2 Floating Parallel Reciprocal Estimate (BGL specific).

powerpc_fprsqrte 

FP2 Floating Parallel Reciprocal Square Root Estimate (BGL specific).

powerpc_fxcxnms 

Last FP2 specific enum value.

powerpc_fre 

Floating Reciprocal Estimate Single (optional).

powerpc_fre_record 

Floating Reciprocal Estimate Single (optional).

powerpc_fres 

Floating Reciprocal Estimate Single (optional).

powerpc_fres_record 

Floating Reciprocal Estimate Single (optional).

powerpc_frsp 

Floating Round to Single Precision.

powerpc_frsp_record 

Floating Round to Single Precision.

powerpc_frsqrte 

Floating Reciprocal Square Root Estimate (optional).

powerpc_frsqrte_record 

Floating Reciprocal Square Root Estimate (optional).

powerpc_frsqrtes 

Floating Reciprocal Square Root Estimate (optional).

powerpc_frsqrtes_record 

Floating Reciprocal Square Root Estimate (optional).

powerpc_fsel 

Floating-Point Select (optional).

powerpc_fsel_record 

Floating-Point Select (optional).

powerpc_fsqrt 

Floating-Point Square Root (optional).

powerpc_fsqrt_record 

Floating-Point Square Root (optional).

powerpc_fsqrts 

Floating-Point Square Root (optional).

powerpc_fsqrts_record 

Floating-Point Square Root (optional).

powerpc_fsub 

Floating Subtract.

powerpc_fsub_record 

Floating Subtract.

powerpc_fsubs 

Floating Subtract Single.

powerpc_fsubs_record 

Floating Subtract Single.

powerpc_icbi 

Instruction Cache Block Invalidate.

powerpc_isync 

Instruction Synchronize.

powerpc_lbz 

Load Byte and Zero.

powerpc_lbzu 

Load Byte and Zero with Update.

powerpc_lbzux 

Load Byte and Zero with Update Indexed.

powerpc_lbzx 

Load Byte and Zero Indexed.

powerpc_ld 

Load Doubleword.

powerpc_ldarx 

Load Doubleword and Reserve Indexed.

powerpc_ldu 

Load Doubleword with Update.

powerpc_ldux 

Load Doubleword with Update Indexed.

powerpc_ldx 

Load Doubleword Indexed.

powerpc_lfd 

Load Floating-Point Double.

powerpc_lfdu 

Load Floating-Point Double with Update.

powerpc_lfdux 

Load Floating-Point Double with Update Indexed.

powerpc_lfdx 

Load Floating-Point Double Indexed.

powerpc_lfs 

Load Floating-Point Single.

powerpc_lfsu 

Load Floating-Point Single with Update.

powerpc_lfsux 

Load Floating-Point Single with Update Indexed.

powerpc_lfsx 

Load Floating-Point Single Indexed.

powerpc_lha 

Load Half Algebraic.

powerpc_lhau 

Load Half Algebraic with Update.

powerpc_lhaux 

Load Half Algebraic with Update Indexed.

powerpc_lhax 

Load Half Algebraic Indexed.

powerpc_lhbrx 

Load Half Byte-Reversed Indexed.

powerpc_lhz 

Load Half and Zero.

powerpc_lhzu 

Load Half and Zero with Update.

powerpc_lhzux 

Load Half and Zero with Update Indexed.

powerpc_lhzx 

Load Half and Zero Indexed.

powerpc_lmw 

Load Multiple Word.

powerpc_lswi 

Load String Word Immediate.

powerpc_lswx 

Load String Word Indexed.

powerpc_lwa 

Load Word Algebraic.

powerpc_lwarx 

Load Word and Reserve Indexed.

powerpc_lwaux 

Load Word Algebraic with Update Indexed.

powerpc_lwax 

Load Word Algebraic Indexed.

powerpc_lwbrx 

Load Word Byte-Reversed Indexed.

powerpc_lwz 

Load Word and Zero.

powerpc_lwzu 

Load Word with Zero Update.

powerpc_lwzux 

Load Word and Zero with Update Indexed.

powerpc_lwzx 

Load Word and Zero Indexed.

powerpc_mcrf 

Move Condition Register Field.

powerpc_mcrfs 

Move to Condition Register from FPSCR.

powerpc_mcrxr 

Move to Condition Register from XER.

powerpc_mfcr 

Move from Condition Register.

powerpc_mffs 

Move from FPSCR.

powerpc_mffs_record 

Move from FPSCR.

powerpc_mfmsr 

Move from Machine State Register.

powerpc_mfspr 

Move from Special-Purpose Register.

powerpc_mfsr 

Move from Segment Register.

powerpc_mfsrin 

Move from Segment Register Indirect.

powerpc_mftb 

Move from Time Base.

powerpc_mtcrf 

Move to Condition Register Fields.

powerpc_mtfsb0 

Move to FPSCR Bit 0.

powerpc_mtfsb0_record 

Move to FPSCR Bit 0.

powerpc_mtfsb1 

Move to FPSCR Bit 1.

powerpc_mtfsb1_record 

Move to FPSCR Bit 1.

powerpc_mtfsf 

Move to FPSCR Fields.

powerpc_mtfsf_record 

Move to FPSCR Fields.

powerpc_mtfsfi 

Move to FPSCR Field Immediate.

powerpc_mtfsfi_record 

Move to FPSCR Field Immediate.

powerpc_mtmsr 

Move to Machine State Register.

powerpc_mtmsrd 

Move to Machine State Register.

powerpc_mtspr 

Move to Special-Purpose Register.

powerpc_mtsr 

Move to Segment Register.

powerpc_mtsrd 

Move to Segment Register.

powerpc_mtsrdin 

Move to Segment Register Indirect.

powerpc_mtsrin 

Move to Segment Register Indirect.

powerpc_mulhd 

Multiply High Doubleword.

powerpc_mulhd_record 

Multiply High Doubleword.

powerpc_mulhdu 

Multiply High Doubleword Unsigned.

powerpc_mulhdu_record 

Multiply High Doubleword Unsigned.

powerpc_mulhw 

Multiply High Word.

powerpc_mulhw_record 

Multiply High Word.

powerpc_mulhwu 

Multiply High Word Unsigned.

powerpc_mulhwu_record 

Multiply High Word Unsigned.

powerpc_mulld 

Multiply Low Doubleword.

powerpc_mulld_record 

Multiply Low Doubleword.

powerpc_mulldo 

Multiply Low Doubleword.

powerpc_mulldo_record 

Multiply Low Doubleword.

powerpc_mulli 

Multiply Low Immediate.

powerpc_mullw 

Multiply Low Word.

powerpc_mullw_record 

Multiply Low Word.

powerpc_mullwo 

Multiply Low Word.

powerpc_mullwo_record 

Multiply Low Word.

powerpc_nand 

NAND.

powerpc_nand_record 

NAND.

powerpc_neg 

Negate.

powerpc_neg_record 

Negate.

powerpc_nego 

Negate.

powerpc_nego_record 

Negate.

powerpc_nor 

NOR.

powerpc_nor_record 

NOR.

powerpc_or 

OR.

powerpc_or_record 

OR.

powerpc_orc 

OR with Complement.

powerpc_orc_record 

OR with Complement.

powerpc_ori 

OR Immediate.

powerpc_oris 

OR Immediate Shifted.

powerpc_popcntb 

Population count bytes.

powerpc_rfi 

Return from Interrupt.

powerpc_rfid 

Return from Interrupt.

powerpc_rldcl 

Rotate Left Doubleword then Clear Left.

powerpc_rldcl_record 

Rotate Left Doubleword then Clear Left.

powerpc_rldcr 

Rotate Left Doubleword then Clear Right.

powerpc_rldcr_record 

Rotate Left Doubleword then Clear Right.

powerpc_rldic 

Rotate Left Doubleword Immediate then Clear.

powerpc_rldic_record 

Rotate Left Doubleword Immediate then Clear.

powerpc_rldicl 

Rotate Left Doubleword Immediate then Clear Left.

powerpc_rldicl_record 

Rotate Left Doubleword Immediate then Clear Left.

powerpc_rldicr 

Rotate Left Doubleword Immediate then Clear Right.

powerpc_rldicr_record 

Rotate Left Doubleword Immediate then Clear Right.

powerpc_rldimi 

Rotate Left Doubleword Immediate then Mask Insert.

powerpc_rldimi_record 

Rotate Left Doubleword Immediate then Mask Insert.

powerpc_rlwimi 

Rotate Left Word Immediate then Mask Insert.

powerpc_rlwimi_record 

Rotate Left Word Immediate then Mask Insert.

powerpc_rlwinm 

Rotate Left Word Immediate then AND with Mask.

powerpc_rlwinm_record 

Rotate Left Word Immediate then AND with Mask.

powerpc_rlwnm 

Rotate Left Word then AND with Mask.

powerpc_rlwnm_record 

Rotate Left Word then AND with Mask.

powerpc_sc 

System Call.

powerpc_slbia 

SLB Invalidate All.

powerpc_slbie 

SLB Invalidate Entry.

powerpc_sld 

Shift Left Doubleword.

powerpc_sld_record 

Shift Left Doubleword.

powerpc_slw 

Shift Left Word.

powerpc_slw_record 

Shift Left Word.

powerpc_srad 

Shift Right Algebraic Doubleword.

powerpc_srad_record 

Shift Right Algebraic Doubleword.

powerpc_sradi 

Shift Right Algebraic Doubleword Immediate.

powerpc_sradi_record 

Shift Right Algebraic Doubleword Immediate.

powerpc_srd 

Shift Right Doubleword.

powerpc_srd_record 

Shift Right Doubleword.

powerpc_sraw 

Shift Right Algebraic Word.

powerpc_sraw_record 

Shift Right Algebraic Word.

powerpc_srawi 

Shift Right Algebraic Word Immediate.

powerpc_srawi_record 

Shift Right Algebraic Word Immediate.

powerpc_srw 

Shift Right Word.

powerpc_srw_record 

Shift Right Word.

powerpc_stb 

Store Byte.

powerpc_stbu 

Store Byte with Update.

powerpc_stbux 

Store Byte with Update Indexed.

powerpc_stbx 

Store Byte Indexed.

powerpc_std 

Store Doubleword.

powerpc_stdcx_record 

Store Doubleword Conditional Indexed.

powerpc_stdu 

Store Doubleword with Update.

powerpc_stdux 

Store Doubleword with Update Indexed.

powerpc_stdx 

Store Doubleword Indexed.

powerpc_stfd 

Store Floating-Point Double.

powerpc_stfdu 

Store Floating-Point Double with Update.

powerpc_stfdux 

Store Floating-Point Double with Update Indexed.

powerpc_stfdx 

Store Floating-Point Double Indexed.

powerpc_stfiwx 

Store Floating-Point as Integer Word Indexed (optional).

powerpc_stfs 

Store Floating-Point Single.

powerpc_stfsu 

Store Floating-Point Single with Update.

powerpc_stfsux 

Store Floating-Point Single with Update Indexed.

powerpc_stfsx 

Store Floating-Point Single Indexed.

powerpc_sth 

Store Half.

powerpc_sthbrx 

Store Half Byte-Reverse Indexed.

powerpc_sthu 

Store Half with Update.

powerpc_sthux 

Store Half with Update Indexed.

powerpc_sthx 

Store Half Indexed.

powerpc_stmw 

Store Multiple Word.

powerpc_stswi 

Store String Word Immediate.

powerpc_stswx 

Store String Word Indexed.

powerpc_stw 

Store.

powerpc_stwbrx 

Store Word Byte-Reversed Indexed.

powerpc_stwcx_record 

Store Word Conditional Indexed.

powerpc_stwu 

Store Word with Update.

powerpc_stwux 

Store Word with Update Indexed.

powerpc_stwx 

Store Word Indexed.

powerpc_subf 

Subtract from.

powerpc_subf_record 

Subtract from.

powerpc_subfo 

Subtract from.

powerpc_subfo_record 

Subtract from.

powerpc_subfc 

Subtract from Carrying.

powerpc_subfc_record 

Subtract from Carrying.

powerpc_subfco 

Subtract from Carrying.

powerpc_subfco_record 

Subtract from Carrying.

powerpc_subfe 

Subtract from Extended.

powerpc_subfe_record 

Subtract from Extended.

powerpc_subfeo 

Subtract from Extended.

powerpc_subfeo_record 

Subtract from Extended.

powerpc_subfic 

Subtract from Immediate Carrying.

powerpc_subfme 

Subtract from Minus One Extended.

powerpc_subfme_record 

Subtract from Minus One Extended.

powerpc_subfmeo 

Subtract from Minus One Extended.

powerpc_subfmeo_record 

Subtract from Minus One Extended.

powerpc_subfze 

Subtract from Zero Extended.

powerpc_subfze_record 

Subtract from Zero Extended.

powerpc_subfzeo 

Subtract from Zero Extended.

powerpc_subfzeo_record 

Subtract from Zero Extended.

powerpc_sync 

Synchronize.

powerpc_td 

Trap Doubleword.

powerpc_tdi 

Trap Doubleword Immediate.

powerpc_tlbia 

Translation Look-aside Buffer Invalidate All (optional).

powerpc_tlbie 

Translation Look-aside Buffer Invalidate Entry (optional).

powerpc_tlbsync 

Translation Look-aside Buffer Synchronize (optional).

powerpc_tw 

Trap Word.

powerpc_twi 

Trap Word Immediate.

powerpc_xor 

XOR.

powerpc_xor_record 

XOR.

powerpc_xori 

XOR Immediate.

powerpc_xoris 

XOR Immediate Shift.

Definition at line 18 of file InstructionEnumsPowerpc.h.

enum Rose::BinaryAnalysis::PowerpcRegisterClass

PowerPC register classes.

Enumerator
powerpc_regclass_gpr 

General Purpose Register (0..31).

powerpc_regclass_fpr 

Floating-Point Register (0..31; 64 bits each).

powerpc_regclass_cr 

Condition Register (only particular fields or bits may be used).

powerpc_regclass_fpscr 

Floating point status and control register.

powerpc_regclass_spr 

Special-purpose register (0..1023).

powerpc_regclass_tbr 

Time base register (0..1023).

powerpc_regclass_msr 

Machine state register.

powerpc_regclass_sr 

Segment register.

powerpc_regclass_iar 

instruction address (pseudo) register.

powerpc_regclass_pvr 

processor version register.

powerpc_last_register_class 

last enum value.

Definition at line 465 of file InstructionEnumsPowerpc.h.

enum Rose::BinaryAnalysis::PowerpcConditionRegisterAccessGranularity

PowerPC condition register access granularity.

Enumerator
powerpc_condreggranularity_whole 

Whole CR (or unknown or not using a CR).

powerpc_condreggranularity_field 

Four-bit field.

powerpc_condreggranularity_bit 

Single bit.

Definition at line 481 of file InstructionEnumsPowerpc.h.

enum Rose::BinaryAnalysis::PowerpcSpecialPurposeRegister

PowerPC special purpose registers.

Enumerator
powerpc_spr_xer 

fixed-point exception register.

powerpc_spr_lr 

link register.

powerpc_spr_ctr 

count register.

Definition at line 488 of file InstructionEnumsPowerpc.h.

enum Rose::BinaryAnalysis::PowerpcTimeBaseRegister

PowerPC time base registers.

Definition at line 499 of file InstructionEnumsPowerpc.h.

enum Rose::BinaryAnalysis::X86InstructionSize

Intel x86 instruction size constants.

Enumerator
x86_insnsize_16 

Instruction is for a 16-bit architecture.

x86_insnsize_32 

Instruction is for a 32-bit architecture.

x86_insnsize_64 

Instruction is for a 64-bit architecture.

Definition at line 13 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86RegisterClass

Intel x86 major register numbers.

Enumerator
x86_regclass_gpr 

Minors are X86GeneralPurposeRegister (ax,cx,dx,bx,sp,bp,si,di,r8..r15)

x86_regclass_segment 

Minors are X86SegmentRegister (es,cs,ss,ds,fs,gs)

x86_regclass_cr 

Control registers; Minors are 0-4, 8.

x86_regclass_dr 

Debug registers; Minors are 0-7.

x86_regclass_st 

Floating point stack or MM registers; Minors are 0-7.

x86_regclass_xmm 

128-bit xmmN; Minors are 0-7.

x86_regclass_ip 

Instruction pointer; Only allowed minor is zero.

x86_regclass_flags 

Status flags.

Definition at line 21 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86SegmentRegister

Intel x86 segment registers.

Definition at line 34 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86StRegister

Intel x86 ST-related registers.

These are the 8 80-bit floating point registers.

Definition at line 65 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86Flags

Minor numbers for x86_regclass_flag.

Definition at line 78 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86Flag

Intel x86 status flags.

These are the bit offsets in the x86_flags_status register.

Definition at line 87 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86BranchPrediction

Intel x86 branch prediction types.

Definition at line 108 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86RepeatPrefix

Intel x86 instruction repeat prefix.

Enumerator
x86_repeat_none 

No repeat prefix.

x86_repeat_repne 

Repeat not equal prefix 0xf2.

x86_repeat_repe 

Repeat equal prefix 0xf3.

Definition at line 116 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86Exception

Protected mode exceptions.

These strange names come directly from the Intel documentation, section 3.1.1.11 in the Instruction Set Reference (except for x86_exception_int, which ROSE uses internally for the INT instruction.

Enumerator
x86_exception_int 

INT instruction.

minor is the imm8 argument.

x86_exception_sysenter 

SYSENTER instruction.

x86_exception_syscall 

SYSCALL instruction.

x86_exception_de 

Divide error.

DIV and IDIV instructions.

x86_exception_db 

Debug.

Any code or data reference.

x86_exception_bp 

Breakpoint.

INT 3 instruction.

x86_exception_of 

Overflow.

INTO instruction.

x86_exception_br 

BOUND range exceeded.

BOUND instruction.

x86_exception_ud 

Invalid opcode.

UD2 insn or reserved opcode.

x86_exception_nm 

Device not available (no math coproc).

Floating-point or WAIT/FWAIT insn.

x86_exception_df 

Double fault.

Any insn that can generate an exception, or NMI, INTR instruction.

x86_exception_ts 

Invalid TSS.

Task switch or TSS access.

x86_exception_np 

Segment not present.

Loading segment regs or accessing system segments.

x86_exception_ss 

Stack segment fault.

Stack operations and SS register loads.

x86_exception_gp 

General protection.

Any memory reference and other protection checks.

x86_exception_pf 

Page fault.

Any memory reference.

x86_exception_mf 

Floating point error (math fault).

Floating-point or WAIT/FWAIT instruction.

x86_exception_ac 

Alignment check.

Any data reference in memory.

x86_exception_mc 

Machine check.

Model-dependent machine check errors.

x86_exception_xm 

SIMD floating-point numeric error.

SSE/SSE2/SSE3 floating-point instructions.

Definition at line 125 of file InstructionEnumsX86.h.

enum Rose::BinaryAnalysis::X86InstructionKind

List of all x86 instructions known to the ROSE disassembler/assembler.

There is one member of this enumeration for each instruction mnemonic. The AssemblerX86::to_str(X86InstructionKind) static method can be used convert the enumeration constant to a string for printing. Documentation for each instruction can be found on the specified page of the "Instruction Set Reference" available from the Intel web site, version March 2009.

Definition at line 27 of file AssemblerX86Init.h.

Function Documentation

template<class V , class E >
Sawyer::Container::Graph<V, E>::VertexValue Rose::BinaryAnalysis::get_ast_node ( const Sawyer::Container::Graph< V, E > &  cfg,
size_t  vertexId 
)

Return the AST node associated with a vertex.

The return value is either a basic block (SgAsmBlock) or instruction (SgAsmInstruction) depending on the graph type.

Definition at line 553 of file ControlFlow.h.

References Sawyer::Container::Graph< V, E, VKey, EKey, Alloc >::findVertex(), Rose::StringUtility::numberToString(), and Sawyer::Container::Graph< V, E, VKey, EKey, Alloc >::vertices().

Referenced by Rose::BinaryAnalysis::ControlFlow::apply_to_ast(), Rose::BinaryAnalysis::ControlFlow::build_block_cfg_from_ast(), Rose::BinaryAnalysis::FunctionCall::build_cg_from_ast(), Rose::BinaryAnalysis::FunctionCall::build_cg_from_cfg(), Rose::BinaryAnalysis::FunctionCall::cache_vertex_descriptors(), Rose::BinaryAnalysis::ControlFlow::cache_vertex_descriptors(), Rose::BinaryAnalysis::FunctionCall::copy(), Rose::BinaryAnalysis::ControlFlow::copy(), Rose::BinaryAnalysis::ControlFlow::explode_blocks(), Rose::BinaryAnalysis::ControlFlow::fixup_fcall_fret(), and Rose::BinaryAnalysis::ControlFlow::write_graphviz().

template<class V , class E , class AstNode >
void Rose::BinaryAnalysis::put_ast_node ( Sawyer::Container::Graph< V, E > &  cfg,
size_t  vertexId,
AstNode *  astNode 
)

Set the AST node associated with a vertex.

The value is either a basic block (SgAsmBlock) or instruction (SgAsmInstruction) depending on the graph type.

Definition at line 564 of file ControlFlow.h.

References Sawyer::Container::Graph< V, E, VKey, EKey, Alloc >::findVertex(), Rose::StringUtility::numberToString(), and Sawyer::Container::Graph< V, E, VKey, EKey, Alloc >::vertices().

Referenced by Rose::BinaryAnalysis::FunctionCall::build_cg_from_ast(), Rose::BinaryAnalysis::FunctionCall::build_cg_from_cfg(), Rose::BinaryAnalysis::FunctionCall::copy(), Rose::BinaryAnalysis::ControlFlow::copy(), and Rose::BinaryAnalysis::ControlFlow::explode_blocks().

template<typename T , typename U >
boost::enable_if_c<boost::is_integral<T>::value && boost::is_integral<U>::value, T>::type Rose::BinaryAnalysis::alignUp ( T  address,
U  alignment 
)

Align address downward to boundary.

Returns the smallest multiple of alignment which is greater than or equal to address. The alignment is cast to the same type as the address before any calculations are performed. Both arguments must be integral types. An alignment less than one has undefined behavior.

Definition at line 37 of file MemoryMap.h.

template<typename T , typename U >
boost::enable_if_c<boost::is_integral<T>::value && boost::is_integral<U>::value, T>::type Rose::BinaryAnalysis::alignDown ( T  address,
U  alignment 
)

Align address upward to boundary.

Returns the largest multiple of alignment which is less than or equal to address. The alignment is cast to the same type as the address before any calculations are performed. Both arguments must be integral types. An alignment less than one has undefined behavior. Returns zero if no such value can be returned due to overflow.

Definition at line 50 of file MemoryMap.h.

bool Rose::BinaryAnalysis::listSmtSolverNames ( std::ostream &  )

List known SMT solvers and their availability.

The names are listed alphabeticallly to the specified output stream. Returns true if any solvers are available, false if no solvers are available.

std::string Rose::BinaryAnalysis::validateSmtSolverName ( const std::string &  name)

Validate SMT solver name.

Returns an empty string if the name is valid, an error message otherwise.

std::string Rose::BinaryAnalysis::bestSmtSolverName ( )

SMT solver corresponding to "best".

Returns the name of the SMT solver that corresponds to the "best" solver. Returns an empty string if no solvers are available.

void Rose::BinaryAnalysis::checkSmtCommandLineArg ( const std::string &  arg,
const std::string &  listSwitch,
std::ostream &  errorStream = std::cerr 
)

Process SMT solver name from command-line.

Checks that the specified SMT solver name is valid, empty, "best", or "none". Returns if the check is successful, or prints an error message and exits if the check is unsuccessful. If an error occurs, and listSwitch is non-empty then a second error message is shown that says "use xxxx to get a list of supported solvers".

std::string Rose::BinaryAnalysis::smtSolverDocumentationString ( const std::string &  dfltSolver)

Documentation string for an SMT solver switch.

Generated on Mon Aug 7 2023 04:59:42 for ROSE by   doxygen 1.8.10