ROSE  0.9.12.28
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
 Concolic testing system.
 
 InstructionSemantics2
 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.
 
 SymbolicExpr
 Namespace supplying types and functions for symbolic expressions.
 

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  ControlFlow
 Binary control flow analysis. More...
 
class  DataFlow
 Various tools for data-flow analysis. More...
 
class  Debugger
 Simple debugger. More...
 
class  Demangler
 
class  Disassembler
 Virtual base class for instruction disassemblers. More...
 
class  DisassemblerArm
 Disassembler for the ARM architecture. More...
 
class  DisassemblerM68k
 Disassembler for Motorola M68k-based instruction set architectures. More...
 
class  DisassemblerMips
 
class  DisassemblerPowerpc
 Disassembler for the PowerPC architecture. More...
 
class  DisassemblerX86
 Disassembler for the x86 architecture. More...
 
class  Dominance
 
class  DwarfLineMapper
 Build mappings between source locations and virtual addresses. 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
 Prints a register name even when no dictionary is available or when the dictionary doesn't contain an entry for the specified descriptor. 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  SRecord
 S-Record hexadecimal data formats. More...
 
struct  StackVariable
 A multi-byte variable that appears on the stack. More...
 
struct  StackVariableLocation
 Information about the location of a stack variable. More...
 
struct  StackVariableMeta
 Meta information for a stack variable. More...
 
class  SymbolicExprParser
 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  YicesSolver
 Interface to the Yices Satisfiability Modulo Theory (SMT) Solver. More...
 
class  Z3Solver
 Interface to the Z3 SMT solver. More...
 

Typedefs

typedef Sawyer::SharedPointer< class BinaryLoaderBinaryLoaderPtr
 Reference counting pointer to BinaryLoader. More...
 
typedef Sawyer::SharedPointer< class BinaryLoaderElfBinaryLoaderElfPtr
 Reference counting pointer to BinaryLoaderElf. More...
 
typedef Sawyer::SharedPointer< class BinaryLoaderElfObjBinaryLoaderElfObjPtr
 Reference counting pointer to BinaryLoaderElfObj. More...
 
typedef Sawyer::SharedPointer< class BinaryLoaderPeBinaryLoaderPePtr
 Reference counting pointer to BinaryLoaderPe. More...
 
typedef Sawyer::SharedPointer< class DebuggerDebuggerPtr
 Shared-ownership pointer to Debugger. More...
 
typedef Sawyer::SharedPointer< class SmtSolverSmtSolverPtr
 Reference-counting pointer for SMT solvers. More...
 
typedef SmtSolver SMTSolver
 
typedef std::vector< StackVariableStackVariables
 Multiple stack variables. More...
 

Enumerations

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...
 
enum  ArmRegisterClass {
  arm_regclass_gpr,
  arm_regclass_psr
}
 ARM register classes. More...
 
enum  ArmProgramStatusRegister {
  arm_psr_current,
  arm_psr_saved
}
 ARM program status registers. More...
 
enum  ArmInstructionKind {
  arm_unknown_instruction = 0,
  arm_adc,
  arm_adcs,
  arm_add,
  arm_adds,
  arm_and,
  arm_ands,
  arm_b,
  arm_bic,
  arm_bics,
  arm_bkpt,
  arm_bl,
  arm_blx,
  arm_bx,
  arm_bxj,
  arm_clz,
  arm_cmn,
  arm_cmp,
  arm_eor,
  arm_eors,
  arm_ldm,
  arm_ldmda,
  arm_ldmdb,
  arm_ldmia,
  arm_ldmib,
  arm_ldr,
  arm_ldrb,
  arm_ldrbt,
  arm_ldrd,
  arm_ldrsb,
  arm_ldrsh,
  arm_ldrt,
  arm_ldruh,
  arm_mla,
  arm_mlas,
  arm_mov,
  arm_movs,
  arm_mrs,
  arm_msr,
  arm_mul,
  arm_muls,
  arm_mvn,
  arm_mvns,
  arm_orr,
  arm_orrs,
  arm_qadd,
  arm_qdadd,
  arm_qdsub,
  arm_qsub,
  arm_rsb,
  arm_rsbs,
  arm_rsc,
  arm_rscs,
  arm_sbc,
  arm_sbcs,
  arm_setend,
  arm_smlabb,
  arm_smlabt,
  arm_smlal,
  arm_smlalbb,
  arm_smlalbt,
  arm_smlals,
  arm_smlaltb,
  arm_smlaltt,
  arm_smlatb,
  arm_smlatt,
  arm_smlawb,
  arm_smlawt,
  arm_smluwb,
  arm_smluwt,
  arm_smulbb,
  arm_smulbt,
  arm_smull,
  arm_smulls,
  arm_smultb,
  arm_smultt,
  arm_stm,
  arm_stmda,
  arm_stmdb,
  arm_stmia,
  arm_stmib,
  arm_str,
  arm_strb,
  arm_strbt,
  arm_strd,
  arm_strh,
  arm_strt,
  arm_sub,
  arm_subs,
  arm_swi,
  arm_swp,
  arm_teq,
  arm_tst,
  arm_umaal,
  arm_umlal,
  arm_umlals,
  arm_umull,
  arm_umulls,
  arm_undefined,
  arm_last_instruction
}
 ARM instruction types. More...
 
enum  ArmInstructionCondition {
  arm_cond_unknown = 0,
  arm_cond_eq = 1,
  arm_cond_ne = 2,
  arm_cond_hs = 3,
  arm_cond_lo = 4,
  arm_cond_mi = 5,
  arm_cond_pl = 6,
  arm_cond_vs = 7,
  arm_cond_vc = 8,
  arm_cond_hi = 9,
  arm_cond_ls = 10,
  arm_cond_ge = 11,
  arm_cond_lt = 12,
  arm_cond_gt = 13,
  arm_cond_le = 14,
  arm_cond_al = 15,
  arm_cond_nv = 16
}
 ARM condition fields. 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 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...
 

Functions

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)
 
std::ostream & operator<< (std::ostream &, const BinaryLoaderElf::VersionedSymbol &)
 
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 AbstractLocation &)
 
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 Debugger::Specimen &)
 
std::ostream & operator<< (std::ostream &, const FunctionSimilarity &)
 
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 SymbolicExprParser::SyntaxError &)
 
std::ostream & operator<< (std::ostream &, const SymbolicExprParser::SubstitutionError &)
 
std::ostream & operator<< (std::ostream &out, const TaintedFlow::State &state)
 
std::ostream & operator<< (std::ostream &, const DwarfLineMapper::SrcInfo &)
 
std::ostream & operator<< (std::ostream &, const DwarfLineMapper &)
 

Typedef Documentation

Reference counting pointer to BinaryLoader.

Definition at line 13 of file BinaryLoader.h.

Reference counting pointer to BinaryLoaderElf.

Definition at line 10 of file BinaryLoaderElf.h.

Reference counting pointer to BinaryLoaderElfObj.

Definition at line 10 of file BinaryLoaderElfObj.h.

Reference counting pointer to BinaryLoaderPe.

Definition at line 10 of file BinaryLoaderPe.h.

Shared-ownership pointer to Debugger.

See Shared ownership.

Definition at line 14 of file BinaryDebugger.h.

Reference-counting pointer for SMT solvers.

Definition at line 22 of file BinarySmtSolver.h.

Multiple stack variables.

Definition at line 88 of file BinaryStackVariable.h.

Enumeration Type Documentation

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 24 of file AssemblerX86Init.h.

ARM register classes.

Enumerator
arm_regclass_gpr 

General purpose registers.

arm_regclass_psr 

Program status registers.

Definition at line 10 of file InstructionEnumsArm.h.

ARM program status registers.

Enumerator
arm_psr_current 

Current program status register.

arm_psr_saved 

Saved program status register.

Definition at line 16 of file InstructionEnumsArm.h.

ARM instruction types.

Enumerator
arm_adc 

add with carry

arm_adcs 

add with carry and update condition word

arm_add 

add

arm_adds 

add and update condition word

arm_and 

bitwise AND

arm_ands 

bitwise AND and update condition word

arm_b 

branch

arm_bic 

bit clear (op1 AND NOT op2)

arm_bics 

bit clear and update condition word

arm_bkpt 

breakpoint

arm_bl 

branch with link

arm_blx 

branch with link and exchange

arm_bx 

branch and exchange

arm_bxj 

branch and change to Java state

arm_clz 

count leading zeros

arm_cmn 

compare negative

arm_cmp 

compare

arm_eor 

bitwise exclusive-OR

arm_eors 

bitwise exclusive-EOR and update condition word

arm_ldm 

pop or block data load

arm_ldmda 

pop or block data load, decrement after

arm_ldmdb 

pop or block data load, decrement before

arm_ldmia 

pop or block data load, increment after

arm_ldmib 

pop or block data load, increment before

arm_ldr 

load word

arm_ldrb 

load byte

arm_ldrbt 

load byte user mode privilege

arm_ldrd 

load doubleword

arm_ldrsb 

load signed byte

arm_ldrsh 

load signed halfword

arm_ldrt 

load word user mode privilege

arm_mla 

multiply and accumulate

arm_mlas 

multiply and accumulate and update condition word

arm_mov 

move

arm_movs 

move and update condition word

arm_mrs 

move PSR to register

arm_msr 

move register to PSR

arm_mul 

multiply

arm_muls 

multiply and update condition word

arm_mvn 

move NOT

arm_mvns 

move NOT and update condition word

arm_orr 

bitwise OR

arm_orrs 

bitwise OR and update condition word

arm_qadd 

saturating add

arm_qdadd 

double saturating add

arm_qdsub 

double saturating subtract

arm_qsub 

saturating subtract

arm_rsb 

reverse subtract

arm_rsbs 

reverse subtract and update condition word

arm_rsc 

reverse subtract with carry

arm_rscs 

reverse subtract with carry and update condition word

arm_sbc 

subtract with carry

arm_sbcs 

subtract with carry and update condition word

arm_setend 

set endianness

arm_smlabb 

signed multiply long and accumulate 16 * 16 bit

arm_smlabt 

signed multiply long and accumulate 16 * 16 bit

arm_smlal 

signed multiply long and accumulate long

arm_smlalbb 

signed multiply long 16 * 16 bit and accumulate long

arm_smlalbt 

signed multiply long 16 * 16 bit and accumulate long

arm_smlals 

signed multiply long and accumulate long and update condition word

arm_smlaltb 

signed multiply long 16 * 16 bit and accumulate long

arm_smlaltt 

signed multiply long 16 * 16 bit and accumulate long

arm_smlatb 

signed multiply long and accumulate 16 * 16 bit

arm_smlatt 

signed multiply long and accumulate 16 * 16 bit

arm_smlawb 

signed multiply long and accumulate 32 * 16 bit

arm_smlawt 

signed multiply long and accumulate 32 * 16 bit

arm_smulbb 

signed multiply long 16 * 16 bit

arm_smulbt 

signed multiply long 16 * 16 bit

arm_smull 

signed multiply long

arm_smulls 

signed multiply long and update condition word

arm_smultb 

signed multiply long 16 * 16 bit

arm_smultt 

signed multiply long 16 * 16 bit

arm_stm 

push or block data store

arm_stmda 

push or block data store, decrement after

arm_stmdb 

push or block data store, decrement before

arm_stmia 

push or block data store, increment after

arm_stmib 

push or block data store, increment before

arm_str 

store word

arm_strb 

store byte

arm_strbt 

store byte user mode privilege

arm_strd 

store doubleword

arm_strh 

store halfword

arm_strt 

store word user mode privilege

arm_sub 

subtract

arm_subs 

subtract and update condition word

arm_swi 

software interrupt

arm_swp 

swap word

arm_teq 

test equivalence

arm_tst 

test

arm_umaal 

multiply double accumulate long

arm_umlal 

multiply unsigned accumulate long

arm_umlals 

multiply unsigned accumulate long and update condition word

arm_umull 

multiply unsigned long

arm_umulls 

multiply unsigned long and update condition word

Definition at line 22 of file InstructionEnumsArm.h.

ARM condition fields.

Enumerator
arm_cond_eq 

equal

arm_cond_ne 

not equal

arm_cond_hs 

carry set/unsigned higher or same (greater than or equal, or unordered)

arm_cond_lo 

carry clear/unsigned lower (less than)

arm_cond_mi 

negative (less than)

arm_cond_pl 

positive or zero (greater than or equal, or unordered)

arm_cond_vs 

overflow (unordered [at least one NaN operand)

arm_cond_vc 

no overflow (not unordered)

arm_cond_hi 

unsigned higher (greater than, or unordered)

arm_cond_ls 

unsigned lower or same (less than or equal)

arm_cond_ge 

signed greater than or equal (greater than or equal)

arm_cond_lt 

signed less than (less than, or unordered)

arm_cond_gt 

signed greater than (greater than)

arm_cond_le 

signed less than or equal (less than or equal, or unordered)

arm_cond_al 

always (normally omitted)

Definition at line 127 of file InstructionEnumsArm.h.

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 15 of file InstructionEnumsM68k.h.

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 53 of file InstructionEnumsM68k.h.

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 63 of file InstructionEnumsM68k.h.

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 72 of file InstructionEnumsM68k.h.

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 88 of file InstructionEnumsM68k.h.

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 98 of file InstructionEnumsM68k.h.

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 185 of file InstructionEnumsM68k.h.

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 239 of file InstructionEnumsM68k.h.

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 251 of file InstructionEnumsM68k.h.

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.

Definition at line 9 of file InstructionEnumsMips.h.

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 21 of file InstructionEnumsMips.h.

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 29 of file InstructionEnumsMips.h.

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 38 of file InstructionEnumsMips.h.

PowerPC word size.

Enumerator
powerpc_32 

32 bits per word.

powerpc_64 

64 bits per word.

Definition at line 10 of file InstructionEnumsPowerpc.h.

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 16 of file InstructionEnumsPowerpc.h.

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 463 of file InstructionEnumsPowerpc.h.

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 479 of file InstructionEnumsPowerpc.h.

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 486 of file InstructionEnumsPowerpc.h.

PowerPC time base registers.

Definition at line 497 of file InstructionEnumsPowerpc.h.

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 12 of file InstructionEnumsX86.h.

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 20 of file InstructionEnumsX86.h.

Intel x86 segment registers.

Definition at line 33 of file InstructionEnumsX86.h.

Intel x86 ST-related registers.

These are the 8 80-bit floating point registers.

Definition at line 64 of file InstructionEnumsX86.h.

Minor numbers for x86_regclass_flag.

Definition at line 77 of file InstructionEnumsX86.h.

Intel x86 status flags.

These are the bit offsets in the x86_flags_status register.

Definition at line 86 of file InstructionEnumsX86.h.

Intel x86 branch prediction types.

Definition at line 107 of file InstructionEnumsX86.h.

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 115 of file InstructionEnumsX86.h.

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 124 of file InstructionEnumsX86.h.

Function Documentation

template<typename T , typename U >
boost::enable_if_c<boost::is_integral<T>::value && boost::is_integral<U>::value, T>::type Rose::BinaryAnalysis::alignUp ( address,
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 33 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 ( address,
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 46 of file MemoryMap.h.

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 
)
template<class V , class E , class AstNode >
void Rose::BinaryAnalysis::put_ast_node ( Sawyer::Container::Graph< V, E > &  cfg,
size_t  vertexId,
AstNode *  astNode 
)
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.