/*

  *  Copyright (C) 2013-2019 Cisco Systems, Inc. and/or its affiliates. All rights reserved.

  *  Copyright (C) 2008-2013 Sourcefire, Inc.

  *
  *  Authors: Török Edvin
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  *  MA 02110-1301, USA.
  */
 
 #ifndef DISASM_BC_H
 #define DISASM_BC_H
 /** @file */
 /** X86 opcode */
 enum X86OPS {

     OP_INVALID,
     OP_AAA,   /**< Ascii Adjust after Addition */
     OP_AAD,   /**< Ascii Adjust AX before Division */
     OP_AAM,   /**< Ascii Adjust AX after Multiply */
     OP_AAS,   /**< Ascii Adjust AL after Subtraction */
     OP_ADD,   /**< Add */
     OP_ADC,   /**< Add with Carry */
     OP_AND,   /**< Logical And */
     OP_ARPL,  /**< Adjust Requested Privilege Level */
     OP_BOUND, /**< Check Array Index Against Bounds */
     OP_BSF,   /**< Bit Scan Forward */
     OP_BSR,   /**< Bit Scan Reverse */
     OP_BSWAP, /**< Byte Swap */
     OP_BT,    /**< Bit Test */
     OP_BTC,   /**< Bit Test and Complement */
     OP_BTR,   /**< Bit Test and Reset */
     OP_BTS,   /**< Bit Test and Set */
     OP_CALL,  /**< Call */
     OP_CDQ,   /**< Convert DoubleWord to QuadWord*/
     OP_CWD,
     OP_CWDE,        /**< Convert Word to DoubleWord */
     OP_CBW,         /**< Convert Byte to Word */
     OP_CLC,         /**< Clear Carry Flag */
     OP_CLD,         /**< Clear Direction Flag */
     OP_CLI,         /**< Clear Interrupt Flag */
     OP_CLTS,        /**< Clear Task-Switched Flag in CR0 */
     OP_CMC,         /**< Complement Carry Flag */
     OP_CMOVO,       /**< Conditional Move if Overflow */
     OP_CMOVNO,      /**< Conditional Move if Not Overflow */
     OP_CMOVC,       /**< Conditional Move if Carry */
     OP_CMOVNC,      /**< Conditional Move if Not Carry */
     OP_CMOVZ,       /**< Conditional Move if Zero */
     OP_CMOVNZ,      /**< Conditional Move if Non-Zero */
     OP_CMOVBE,      /**< Conditional Move if Below or Equal */
     OP_CMOVA,       /**< Conditional Move if Above */
     OP_CMOVS,       /**< Conditional Move if Sign */
     OP_CMOVNS,      /**< Conditional Move if Not Sign */
     OP_CMOVP,       /**< Conditional Move if Parity */
     OP_CMOVNP,      /**< Conditional Move if Not Parity */
     OP_CMOVL,       /**< Conditional Move if Less */
     OP_CMOVGE,      /**< Conditional Move if Greater or Equal */
     OP_CMOVLE,      /**< Conditional Move if Less than or Equal */
     OP_CMOVG,       /**< Conditional Move if Greater */
     OP_CMP,         /**< Compare */
     OP_CMPSD,       /**< Compare String DoubleWord */
     OP_CMPSW,       /**< Compare String Word */
     OP_CMPSB,       /**< Compare String Byte */
     OP_CMPXCHG,     /**< Compare and Exchange */
     OP_CMPXCHG8B,   /**< Compare and Exchange Bytes */
     OP_CPUID,       /**< CPU Identification */
     OP_DAA,         /**< Decimal Adjust AL after Addition */
     OP_DAS,         /**< Decimal Adjust AL after Subtraction */
     OP_DEC,         /**< Decrement by 1 */
     OP_DIV,         /**< Unsigned Divide */
     OP_ENTER,       /**< Make Stack Frame for Procedure Parameters */
     OP_FWAIT,       /**< Wait */
     OP_HLT,         /**< Halt */
     OP_IDIV,        /**< Signed Divide */
     OP_IMUL,        /**< Signed Multiply */
     OP_INC,         /**< Increment by 1 */
     OP_IN,          /**< INput from port */
     OP_INSD,        /**< INput from port to String Doubleword */
     OP_INSW,        /**< INput from port to String Word */
     OP_INSB,        /**< INput from port to String Byte */
     OP_INT,         /**< INTerrupt */
     OP_INT3,        /**< INTerrupt 3 (breakpoint) */
     OP_INTO,        /**< INTerrupt 4 if Overflow */
     OP_INVD,        /**< Invalidate Internal Caches */
     OP_INVLPG,      /**< Invalidate TLB Entry */
     OP_IRET,        /**< Interrupt Return */
     OP_JO,          /**< Jump if Overflow */
     OP_JNO,         /**< Jump if Not Overflow */
     OP_JC,          /**< Jump if Carry */
     OP_JNC,         /**< Jump if Not Carry */
     OP_JZ,          /**< Jump if Zero */
     OP_JNZ,         /**< Jump if Not Zero */
     OP_JBE,         /**< Jump if Below or Equal */
     OP_JA,          /**< Jump if Above */
     OP_JS,          /**< Jump if Sign */
     OP_JNS,         /**< Jump if Not Sign */
     OP_JP,          /**< Jump if Parity */
     OP_JNP,         /**< Jump if Not Parity */
     OP_JL,          /**< Jump if Less */
     OP_JGE,         /**< Jump if Greater or Equal */
     OP_JLE,         /**< Jump if Less or Equal */
     OP_JG,          /**< Jump if Greater */
     OP_JMP,         /**< Jump (unconditional) */
     OP_LAHF,        /**< Load Status Flags into AH Register */
     OP_LAR,         /**< load Access Rights Byte */
     OP_LDS,         /**< Load Far Pointer into DS */
     OP_LES,         /**< Load Far Pointer into ES */
     OP_LFS,         /**< Load Far Pointer into FS */
     OP_LGS,         /**< Load Far Pointer into GS */
     OP_LEA,         /**< Load Effective Address */
     OP_LEAVE,       /**< High Level Procedure Exit */
     OP_LGDT,        /**< Load Global Descript Table Register */
     OP_LIDT,        /**< Load Interrupt Descriptor Table Register */
     OP_LLDT,        /**< Load Local Descriptor Table Register */
     OP_PREFIX_LOCK, /**< Assert LOCK# Signal Prefix */
     OP_LODSD,       /**< Load String Dword*/
     OP_LODSW,       /**< Load String Word */
     OP_LODSB,       /**< Load String Byte */
     OP_LOOP,        /**< Loop According to ECX Counter */
     OP_LOOPE,       /**< Loop According to ECX Counter and ZF=1 */
     OP_LOOPNE,      /**< Loop According to ECX Counter and ZF=0 */
     OP_JECXZ,       /**< Jump if ECX is Zero */
     OP_LSL,         /**< Load Segment Limit */
     OP_LSS,         /**< Load Far Pointer into SS */
     OP_LTR,         /**< Load Task Register */
     OP_MOV,         /**< Move */
     OP_MOVSD,       /**< Move Data from String to String Doubleword */
     OP_MOVSW,       /**< Move Data from String to String Word */
     OP_MOVSB,       /**< Move Data from String to String Byte */
     OP_MOVSX,       /**< Move with Sign-Extension */
     OP_MOVZX,       /**< Move with Zero-Extension */
     OP_MUL,         /**< Unsigned Multiply */
     OP_NEG,         /**< Two's Complement Negation */
     OP_NOP,         /**< No Operation */
     OP_NOT,         /**< One's Complement Negation */
     OP_OR,          /**< Logical Inclusive OR */
     OP_OUT,         /**< Output to Port */
     OP_OUTSD,       /**< Output String to Port Doubleword */
     OP_OUTSW,       /**< Output String to Port Word */
     OP_OUTSB,       /**< Output String to Port Bytes */
     OP_PUSH,        /**< Push Onto the Stack */
     OP_PUSHAD,      /**< Push All Double General Purpose Registers */
     OP_PUSHA,
     OP_PUSHFD, /**< Push EFLAGS Register onto the Stack */
     OP_PUSHF,
     OP_POP,   /**< Pop a Value from the Stack */
     OP_POPAD, /**< Pop All Double General Purpose Registers from the Stack */
     OP_POPFD, /**< Pop Stack into EFLAGS Register */
     OP_POPF,
     OP_RCL,          /**< Rotate Carry Left */
     OP_RCR,          /**< Rotate Carry Right */
     OP_RDMSR,        /**< Read from Model Specific Register */
     OP_RDPMC,        /**< Read Performance Monitoring Counters */
     OP_RDTSC,        /**< Read Time-Stamp Counter */
     OP_PREFIX_REPE,  /**< Repeat String Operation Prefix while Equal */
     OP_PREFIX_REPNE, /**< Repeat String Operation Prefix while Not Equal */
     OP_RETF,         /**< Return from Far Procedure */
     OP_RETN,         /**< Return from Near Procedure */
     OP_ROL,          /**< Rotate Left */
     OP_ROR,          /**< Rotate Right */
     OP_RSM,          /**< Resume from System Management Mode */
     OP_SAHF,         /**< Store AH into Flags */
     OP_SAR,          /**< Shift Arithmetic Right */
     OP_SBB,          /**< Subtract with Borrow */
     OP_SCASD,        /**< Scan String Doubleword */
     OP_SCASW,        /**< Scan String Word */
     OP_SCASB,        /**< Scan String Byte */
     OP_SETO,         /**< Set Byte on Overflow */
     OP_SETNO,        /**< Set Byte on Not Overflow */
     OP_SETC,         /**< Set Byte on Carry */
     OP_SETNC,        /**< Set Byte on Not Carry */
     OP_SETZ,         /**< Set Byte on Zero */
     OP_SETNZ,        /**< Set Byte on Not Zero */
     OP_SETBE,        /**< Set Byte on Below or Equal */
     OP_SETA,         /**< Set Byte on Above */
     OP_SETS,         /**< Set Byte on Sign */
     OP_SETNS,        /**< Set Byte on Not Sign */
     OP_SETP,         /**< Set Byte on Parity */
     OP_SETNP,        /**< Set Byte on Not Parity */
     OP_SETL,         /**< Set Byte on Less */
     OP_SETGE,        /**< Set Byte on Greater or Equal */
     OP_SETLE,        /**< Set Byte on Less or Equal */
     OP_SETG,         /**< Set Byte on Greater */
     OP_SGDT,         /**< Store Global Descriptor Table Register */
     OP_SIDT,         /**< Store Interrupt Descriptor Table Register */
     OP_SHL,          /**< Shift Left */
     OP_SHLD,         /**< Double Precision Shift Left */
     OP_SHR,          /**< Shift Right */
     OP_SHRD,         /**< Double Precision Shift Right */
     OP_SLDT,         /**< Store Local Descriptor Table Register */
     OP_STOSD,        /**< Store String Doubleword */
     OP_STOSW,        /**< Store String Word */
     OP_STOSB,        /**< Store String Byte */
     OP_STR,          /**< Store Task Register */
     OP_STC,          /**< Set Carry Flag */
     OP_STD,          /**< Set Direction Flag */
     OP_STI,          /**< Set Interrupt Flag */
     OP_SUB,          /**< Subtract */
     OP_SYSCALL,      /**< Fast System Call */
     OP_SYSENTER,     /**< Fast System Call */
     OP_SYSEXIT,      /**< Fast Return from Fast System Call */
     OP_SYSRET,       /**< Return from Fast System Call */
     OP_TEST,         /**< Logical Compare */
     OP_UD2,          /**< Undefined Instruction */
     OP_VERR,         /**< Verify a Segment for Reading */
     OP_VERRW,        /**< Verify a Segment for Writing */
     OP_WBINVD,       /**< Write Back and Invalidate Cache */
     OP_WRMSR,        /**< Write to Model Specific Register */
     OP_XADD,         /**< Exchange and Add */
     OP_XCHG,         /**< Exchange Register/Memory with Register */
     OP_XLAT,         /**< Table Look-up Translation */
     OP_XOR,          /**< Logical Exclusive OR */
     OP_PREFIX_OPSIZE,
     OP_PREFIX_ADDRSIZE,
     OP_PREFIX_SEGMENT,
     OP_2BYTE,

     OP_FPU, /**< FPU operation */

     OP_F2XM1,    /**< Compute 2x-1 */
     OP_FABS,     /**< Absolute Value */
     OP_FADD,     /**< Floating Point Add */
     OP_FADDP,    /**< Floating Point Add, Pop */
     OP_FBLD,     /**< Load Binary Coded Decimal */
     OP_FBSTP,    /**< Store BCD Integer and Pop */
     OP_FCHS,     /**< Change Sign */
     OP_FCLEX,    /**< Clear Exceptions */
     OP_FCMOVB,   /**< Floating Point Move on Below */
     OP_FCMOVBE,  /**< Floating Point Move on Below or Equal */
     OP_FCMOVE,   /**< Floating Point Move on Equal */
     OP_FCMOVNB,  /**< Floating Point Move on Not Below */
     OP_FCMOVNBE, /**< Floating Point Move on Not Below or Equal */
     OP_FCMOVNE,  /**< Floating Point Move on Not Equal */
     OP_FCMOVNU,  /**< Floating Point Move on Not Unordered */
     OP_FCMOVU,   /**< Floating Point Move on Unordered */
     OP_FCOM,     /**< Compare Floating Pointer Values and Set FPU Flags */
     OP_FCOMI,    /**< Compare Floating Pointer Values and Set EFLAGS */
     OP_FCOMIP,   /**< Compare Floating Pointer Values and Set EFLAGS, Pop */
     OP_FCOMP,    /**< Compare Floating Pointer Values and Set FPU Flags, Pop */
     OP_FCOMPP,   /**< Compare Floating Pointer Values and Set FPU Flags, Pop Twice */
     OP_FCOS,     /**< Cosine */
     OP_FDECSTP,  /**< Decrement Stack Top Pointer */
     OP_FDIV,     /**< Floating Point Divide */
     OP_FDIVP,    /**< Floating Point Divide, Pop */
     OP_FDIVR,    /**< Floating Point Reverse Divide */
     OP_FDIVRP,   /**< Floating Point Reverse Divide, Pop */
     OP_FFREE,    /**< Free Floating Point Register */
     OP_FIADD,    /**< Floating Point Add */
     OP_FICOM,    /**< Compare Integer */
     OP_FICOMP,   /**< Compare Integer, Pop */
     OP_FIDIV,    /**< Floating Point Divide by Integer */
     OP_FIDIVR,   /**< Floating Point Reverse Divide by Integer */
     OP_FILD,     /**< Load Integer */
     OP_FIMUL,    /**< Floating Point Multiply with Integer */
     OP_FINCSTP,  /**< Increment Stack-Top Pointer */
     OP_FINIT,    /**< Initialize Floating-Point Unit */
     OP_FIST,     /**< Store Integer */
     OP_FISTP,    /**< Store Integer, Pop */
     OP_FISTTP,   /**< Store Integer with Truncation */
     OP_FISUB,    /**< Floating Point Integer Subtract */
     OP_FISUBR,   /**< Floating Point Reverse Integer Subtract */
     OP_FLD,      /**< Load Floating Point Value */
     OP_FLD1,     /**< Load Constant 1 */
     OP_FLDCW,    /**< Load x87 FPU Control Word */
     OP_FLDENV,   /**< Load x87 FPU Environment */
     OP_FLDL2E,   /**< Load Constant log_2(e) */
     OP_FLDL2T,   /**< Load Constant log_2(10) */
     OP_FLDLG2,   /**< Load Constant log_10(2) */
     OP_FLDLN2,   /**< Load Constant log_e(2) */
     OP_FLDPI,    /**< Load Constant PI */
     OP_FLDZ,     /**< Load Constant Zero */
     OP_FMUL,     /**< Floating Point Multiply */
     OP_FMULP,    /**< Floating Point Multiply, Pop */
     OP_FNOP,     /**< No Operation */
     OP_FPATAN,   /**< Partial Arctangent */
     OP_FPREM,    /**< Partial Remainder */
     OP_FPREM1,   /**< Partial Remainder */
     OP_FPTAN,    /**< Partial Tangent */
     OP_FRNDINT,  /**< Round to Integer */
     OP_FRSTOR,   /**< Restore x86 FPU State */
     OP_FSCALE,   /**< Scale */
     OP_FSIN,     /* Sine */
     OP_FSINCOS,  /**< Sine and Cosine */
     OP_FSQRT,    /**< Square Root */
     OP_FSAVE,    /**< Store x87 FPU State */
     OP_FST,      /**< Store Floating Point Value */
     OP_FSTCW,    /**< Store x87 FPU Control Word */
     OP_FSTENV,   /**< Store x87 FPU Environment */
     OP_FSTP,     /**< Store Floating Point Value, Pop */
     OP_FSTSW,    /**< Store x87 FPU Status Word */
     OP_FSUB,     /**< Floating Point Subtract */
     OP_FSUBP,    /**< Floating Point Subtract, Pop */
     OP_FSUBR,    /**< Floating Point Reverse Subtract */
     OP_FSUBRP,   /**< Floating Point Reverse Subtract, Pop */
     OP_FTST,     /**< Floating Point Test */
     OP_FUCOM,    /**< Floating Point Unordered Compare */
     OP_FUCOMI,   /**< Floating Point Unordered Compare with Integer */
     OP_FUCOMIP,  /**< Floating Point Unorder Compare with Integer, Pop */
     OP_FUCOMP,   /**< Floating Point Unorder Compare, Pop */
     OP_FUCOMPP,  /**< Floating Point Unorder Compare, Pop Twice */
     OP_FXAM,     /**< Examine ModR/M */
     OP_FXCH,     /**< Exchange Register Contents */
     OP_FXTRACT,  /**< Extract Exponent and Significand */
     OP_FYL2X,    /**< Compute y*log2x */
     OP_FYL2XP1   /**< Compute y*log2(x+1) */

 };
 
 /** Access type */
 enum DIS_ACCESS {

     ACCESS_NOARG, /**< arg not present */
     ACCESS_IMM,   /**< immediate */
     ACCESS_REL,   /**< +/- immediate */
     ACCESS_REG,   /**< register */
     ACCESS_MEM    /**< [memory] */

 };
 
 /** for mem access, immediate and relative */
 enum DIS_SIZE {

     SIZEB,  /**< Byte size access */
     SIZEW,  /**< Word size access */
     SIZED,  /**< Doubleword size access */
     SIZEF,  /**< 6-byte access (seg+reg pair)*/
     SIZEQ,  /**< Quadword access */
     SIZET,  /**< 10-byte access */
     SIZEPTR /** ptr */

 };
 
 /** X86 registers */
 enum X86REGS {

     X86_REG_EAX,
     X86_REG_ECX,
     X86_REG_EDX,
     X86_REG_EBX,
     X86_REG_ESP,
     X86_REG_EBP,
     X86_REG_ESI,
     X86_REG_EDI,
     X86_REG_AX,
     X86_REG_CX,
     X86_REG_DX,
     X86_REG_BX,
     X86_REG_SP,
     X86_REG_BP,
     X86_REG_SI,
     X86_REG_DI,
     X86_REG_AH,
     X86_REG_CH,
     X86_REG_DH,
     X86_REG_BH,
     X86_REG_AL,
     X86_REG_CL,
     X86_REG_DL,
     X86_REG_BL,
     X86_REG_ES,
     X86_REG_CS,
     X86_REG_SS,
     X86_REG_DS,
     X86_REG_FS,
     X86_REG_GS,
     X86_REG_CR0,
     X86_REG_CR1,
     X86_REG_CR2,
     X86_REG_CR3,
     X86_REG_CR4,
     X86_REG_CR5,
     X86_REG_CR6,
     X86_REG_CR7,
     X86_REG_DR0,
     X86_REG_DR1,
     X86_REG_DR2,
     X86_REG_DR3,
     X86_REG_DR4,
     X86_REG_DR5,
     X86_REG_DR6,
     X86_REG_DR7,
     X86_REG_ST0,
     X86_REG_ST1,
     X86_REG_ST2,
     X86_REG_ST3,
     X86_REG_ST4,
     X86_REG_ST5,
     X86_REG_ST6,
     X86_REG_ST7,
     X86_REG_INVALID

 };
 
 /** disassembly result, 64-byte, matched by type-8 signatures */
 struct DISASM_RESULT {
     uint16_t real_op;
     uint8_t opsize;
     uint8_t adsize;
     uint8_t segment;
     uint8_t arg[3][10];
     uint8_t extra[29];
 };
 #endif