开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
dsmLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：79k
源码类别：

VxWorks

开发平台：

C/C++

dsmLib.c：源码内容
  1. /* dsmLib.c - i80x86 disassembler */
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01k,27mar02,hdn  fixed the CALL/JMP ptr16:16/32 offset size (spr 73624)
  10. 01j,30aug01,hdn  added SIMD, sysenter/exit support.
  11.  always print the disassembled address on 8 digits with 0x.
  12. 01i,06may98,fle  added P5 and P6 related instructions and facilities
  13. 01h,14nov94,hdn  changed D->DISR, W->WFUL, S->SEXT, P->POP, A->AX, I->IMM.
  14. 01g,29may94,hdn  removed I80486.
  15. 01f,31aug93,hdn  changed a type of 1st parameter, from char to UCHAR.
  16. 01e,02aug93,hdn  fixed a case that has mod=0,rm=5,disp32 operand.
  17. 01d,01jun93,hdn  updated to 5.1
  18.   - changed functions to ansi style
  19.   - fixed #else and #endif
  20.   - changed VOID to void
  21.   - changed copyright notice
  22. 01c,18mar93,hdn  supported 486 instructions.
  23. 01b,05nov92,hdn  supported "16 bit operand","rep","repne","shift by 1".
  24.  fixed a bug that is about "empty index".
  25. 01a,23jun92,hdn  written. 
  26. */
  28. /*
  29. This library contains everything necessary to print i80x86 object code in
  30. assembly language format. 
  32. The programming interface is via dsmInst(), which prints a single disassembled
  33. instruction, and dsmNbytes(), which reports the size of an instruction.
  35. To disassemble from the shell, use l(), which calls this
  36. library to do the actual work.  See dbgLib for details.
  38. INCLUDE FILE: dsmLib.h
  40. SEE ALSO: dbgLib
  41. */
  43. #include "vxWorks.h"
  44. #include "dsmLib.h"
  45. #include "symLib.h"
  46. #include "string.h"
  47. #include "stdio.h"
  48. #include "errnoLib.h"
  50. /*
  51.  * This table is ordered by the number of bits in an instruction's 
  52.  * two word mask, beginning with the greatest number of bits in masks.  
  53.  * This scheme is used for avoiding conflicts between instructions 
  54.  * when matching bit patterns.  The instruction ops are arranged 
  55.  * sequentially within each group of instructions for a particular 
  56.  * mask so that uniqueness can be easily spotted.  
  57.  */
  59. /* globals */
  61. LOCAL INST inst [] =
  62.     {
  64.     /* OP3 instructions */
  66.     {"ADDSS", itAddss, OP3|MODRM,XMMREG|XMMRM,
  67.      0xf3, 0x0f, 0x58, /* opcode */
  68. 0xff, 0xff, 0xff}, /* mask */
  70.     {"CMPSS", itCmpss, OP3|MODRM|I8,XMMREG|XMMRM,
  71.      0xf3, 0x0f, 0xc2,  /* opcode */
  72. 0xff, 0xff, 0xff}, /* mask */
  74.     {"CVTSI2SS", itCvtsi2ss,    OP3|MODRM|REGRM,XMMREG,
  75.      0xf3, 0x0f, 0x2a,  /* opcode */
  76. 0xff, 0xff, 0xff}, /* mask */
  78.     {"CVTSS2SI", itCvtss2si, OP3|MODRM|REG,XMMRM,
  79.      0xf3, 0x0f, 0x2d,  /* opcode */
  80. 0xff, 0xff, 0xff}, /* mask */
  82.     {"CVTTSS2SI", itCvttss2si, OP3|MODRM|REG,XMMRM,
  83.      0xf3, 0x0f, 0x2c,  /* opcode */
  84. 0xff, 0xff, 0xff}, /* mask */
  86.     {"DIVSS", itDivss, OP3|MODRM,XMMREG|XMMRM,
  87.      0xf3, 0x0f, 0x5e,  /* opcode */
  88. 0xff, 0xff, 0xff}, /* mask */
  90.     {"MAXSS", itMaxss, OP3|MODRM,XMMREG|XMMRM,
  91.      0xf3, 0x0f, 0x5f,  /* opcode */
  92. 0xff, 0xff, 0xff}, /* mask */
  94.     {"MINSS", itMinss, OP3|MODRM,XMMREG|XMMRM,
  95.      0xf3, 0x0f, 0x5d,  /* opcode */
  96. 0xff, 0xff, 0xff}, /* mask */
  98.     {"MOVSS", itMovss,          OP3|MODRM|DISR,XMMREG|XMMRM,
  99.      0xf3, 0x0f, 0x10,  /* opcode */
  100. 0xff, 0xff, 0xfe}, /* mask */
  102.     {"MULSS", itMulss, OP3|MODRM,XMMREG|XMMRM,
  103.      0xf3, 0x0f, 0x59,  /* opcode */
  104. 0xff, 0xff, 0xff}, /* mask */
  106.     {"RCPSS", itRcpss, OP3|MODRM,XMMREG|XMMRM,
  107.      0xf3, 0x0f, 0x53,  /* opcode */
  108. 0xff, 0xff, 0xff}, /* mask */
  110.     {"RSQRTSS", itRsqrtss, OP3|MODRM,XMMREG|XMMRM,
  111.      0xf3, 0x0f, 0x52,  /* opcode */
  112. 0xff, 0xff, 0xff}, /* mask */
  114.     {"SQRTSS", itSqrtss, OP3|MODRM,XMMREG|XMMRM,
  115.      0xf3, 0x0f, 0x51,  /* opcode */
  116. 0xff, 0xff, 0xff}, /* mask */
  118.     {"SUBSS", itSubss, OP3|MODRM,XMMREG|XMMRM,
  119.      0xf3, 0x0f, 0x5c,  /* opcode */
  120. 0xff, 0xff, 0xff}, /* mask */
  122.     {"SFENCE", itSfence, OP3,0,
  123.      0x0f, 0xae, 0xc0, /* opcode */
  124. 0xff, 0xff, 0xc0}, /* mask */
  127.     /* OP2 instructions extended by bits 3,4,5 of MODRM */
  129.     {"BT", itBtI,        OP2|MODRM|I8,0,
  130.      0x0f, 0xba, 0x20,  /* opcode */
  131. 0xff, 0xff, 0x38}, /* mask */
  133.     {"BTC", itBtcI,      OP2|MODRM|I8,0,
  134.      0x0f, 0xba, 0x38, /* opcode */
  135. 0xff, 0xff, 0x38}, /* mask */
  137.     {"BTR", itBtrI,        OP2|MODRM|I8,0,
  138.      0x0f, 0xba, 0x30, /* opcode */
  139. 0xff, 0xff, 0x38}, /* mask */
  141.     {"BTS", itBtsI,       OP2|MODRM|I8,0,
  142.      0x0f, 0xba, 0x28, /* opcode */
  143. 0xff, 0xff, 0x38}, /* mask */
  145.     {"LGDT", itLgdt,     OP2|MODRM,0,
  146.      0x0f, 0x01, 0x10, /* opcode */
  147. 0xff, 0xff, 0x38}, /* mask */
  149.     {"LIDT", itLidt,      OP2|MODRM,0,
  150.      0x0f, 0x01, 0x18, /* opcode */
  151. 0xff, 0xff, 0x38}, /* mask */
  153.     {"LLDT", itLldt,      OP2|MODRM,0,
  154.      0x0f, 0x00, 0x10, /* opcode */
  155. 0xff, 0xff, 0x38}, /* mask */
  157.     {"LMSW", itLmsw,      OP2|MODRM,0,
  158.      0x0f, 0x01, 0x30, /* opcode */
  159. 0xff, 0xff, 0x38}, /* mask */
  161.     {"LTR", itLtr,        OP2|MODRM,0,
  162.      0x0f, 0x00, 0x08, /* opcode */
  163. 0xff, 0xff, 0x38}, /* mask */
  165.     {"SGDT", itSgdt,      OP2|MODRM,0,
  166.      0x0f, 0x01, 0x00, /* opcode */
  167. 0xff, 0xff, 0x38}, /* mask */
  169.     {"SIDT", itSidt,      OP2|MODRM,0,
  170.      0x0f, 0x01, 0x08, /* opcode */
  171. 0xff, 0xff, 0x38}, /* mask */
  173.     {"SLDT", itSldt,      OP2|MODRM,0,
  174.      0x0f, 0x00, 0x00, /* opcode */
  175. 0xff, 0xff, 0x38}, /* mask */
  177.     {"SMSW", itSmsw,      OP2|MODRM,0,
  178.      0x0f, 0x01, 0x20, /* opcode */
  179. 0xff, 0xff, 0x38}, /* mask */
  181.     {"STR", itStr,        OP2|MODRM,0,
  182.      0x0f, 0x00, 0x08, /* opcode */
  183. 0xff, 0xff, 0x38}, /* mask */
  185.     {"VERR", itVerr,       OP2|MODRM,0,
  186.      0x0f, 0x00, 0x20, /* opcode */
  187. 0xff, 0xff, 0x38}, /* mask */
  189.     {"VERW", itVerw,       OP2|MODRM,0,
  190.      0x0f, 0x00, 0x28, /* opcode */
  191. 0xff, 0xff, 0x38}, /* mask */
  193.     {"FXRSTOR", itFxrstor,      OP2|MODRM,0,
  194.                                 0x0f, 0xae, 0x08,       /* opcode */
  195. 0xff, 0xff, 0x38},      /* mask */
  197.     {"FXSAVE", itFxsave,        OP2|MODRM,0,
  198. 0x0f, 0xae, 0x00,       /* opcode */
  199. 0xff, 0xff, 0x38},      /* mask */
  201.     {"LDMXCSR", itLdmxcsr,      OP2|MODRM,0,
  202. 0x0f, 0xae, 0x10,       /* opcode */
  203. 0xff, 0xff, 0x38},      /* mask */
  204.     
  205.     {"STMXCSR", itStmxcsr,      OP2|MODRM,0,
  206. 0x0f, 0xae, 0x18,       /* opcode */
  207. 0xff, 0xff, 0x38},      /* mask */
  209.     {"PREFETCHT0", itPrefetcht0,        OP2|MODRM,0,
  210. 0x0f, 0x18, 0x08,       /* opcode */
  211. 0xff, 0xff, 0x38},      /* mask */
  213.     {"PREFETCHT1", itPrefetcht1,        OP2|MODRM,0,
  214. 0x0f, 0x18, 0x10,       /* opcode */
  215. 0xff, 0xff, 0x38},      /* mask */
  217.     {"PREFETCHT2", itPrefetcht2,        OP2|MODRM,0,
  218. 0x0f, 0x18, 0x18,       /* opcode */
  219. 0xff, 0xff, 0x38},      /* mask */
  221.     {"PREFETCHNTA", itPrefetchnta,      OP2|MODRM,0,
  222. 0x0f, 0x18, 0x00,       /* opcode */
  223. 0xff, 0xff, 0x38},      /* mask */
  225.     {"MOVHLPS", itMovhlps, OP2|MODRM,XMMREG|XMMRM,
  226.      0x0f, 0x12, 0xc0, /* opcode */
  227. 0xff, 0xff, 0xc0}, /* mask */
  229.     {"MOVLHPS", itMovlhps, OP2|MODRM,XMMREG|XMMRM,
  230.      0x0f, 0x16, 0xc0, /* opcode */
  231. 0xff, 0xff, 0xc0}, /* mask */
  233.     /* OP2 instructions */
  235.     {"AAD", itAad,        OP2,0,
  236.     0xd5, 0x0a, 0x00, /* opcode */
  237. 0xff, 0xff, 0x00}, /* mask */
  239.     {"AAM", itAam,        OP2,0,
  240.      0xd4, 0x0a, 0x00, /* opcode */
  241. 0xff, 0xff, 0x00}, /* mask */
  243.     {"BSF", itBsf,        OP2|MODRM|REG,0,
  244.      0x0f, 0xbc, 0x00, /* opcode */
  245. 0xff, 0xff, 0x00}, /* mask */
  247.     {"BSR", itBsr,        OP2|MODRM|REG,0,
  248.      0x0f, 0xbd, 0x00, /* opcode */
  249. 0xff, 0xff, 0x00}, /* mask */
  251.     {"BT", itBtR,         OP2|MODRM|REG,0,
  252.      0x0f, 0xa3, 0x00, /* opcode */
  253. 0xff, 0xff, 0x00}, /* mask */
  255.     {"BTC", itBtcR,       OP2|MODRM|REG,0,
  256.      0x0f, 0xbb, 0x00, /* opcode */
  257. 0xff, 0xff, 0x00}, /* mask */
  259.     {"BTR", itBtrR,       OP2|MODRM|REG,0,
  260.      0x0f, 0xb3, 0x00, /* opcode */
  261. 0xff, 0xff, 0x00}, /* mask */
  263.     {"BTS", itBtsR,       OP2|MODRM|REG,0,
  264.      0x0f, 0xab, 0x00, /* opcode */
  265. 0xff, 0xff, 0x00}, /* mask */
  267.     {"CLTS", itClts,      OP2,0,
  268.      0x0f, 0x06, 0x00, /* opcode */
  269. 0xff, 0xff, 0x00}, /* mask */
  271.     {"CMPXCHG8B", itCmpxchg8b, OP2|MODRM,0,
  272.      0x0f, 0xc7, 0x00, /* opcode */
  273. 0xff, 0xff, 0x00}, /* mask */
  275.     {"CPUID", itCpuid, OP2,0,
  276.      0x0f, 0xa2, 0x00, /* opcode */
  277. 0xff, 0xff, 0x00}, /* mask */
  279.     {"EMMS", itEmms, OP2,0,
  280.      0x0f, 0x77, 0x00, /* opcode */
  281. 0xff, 0xff, 0x00}, /* mask */
  283.     {"F2XM1", itF2xm1, OP2,0,
  284.      ESC|0x01, 0xf0, 0x00, /* opcode */
  285. 0xff, 0xff, 0x00}, /* mask */
  287.     {"FABS", itFabs, OP2,0,
  288.      ESC|0x01, 0xe1, 0x00, /* opcode */
  289. 0xff, 0xff, 0x00}, /* mask */
  291.     {"FCHS", itFchs, OP2,0,
  292.      ESC|0x01, 0xe0, 0x00, /* opcode */
  293. 0xff, 0xff, 0x00}, /* mask */
  295.     {"FCLEX", itFclex, OP2,0,
  296.      ESC|0x03, 0xe2, 0x00, /* opcode */
  297. 0xff, 0xff, 0x00}, /* mask */
  299.     {"FCOMPP", itFcompp, OP2,0,
  300.      ESC|0x06, 0xd9, 0x00, /* opcode */
  301. 0xff, 0xff, 0x00}, /* mask */
  303.     {"FCOS", itFcos, OP2,0,
  304.      ESC|0x01, 0xff, 0x00, /* opcode */
  305. 0xff, 0xff, 0x00}, /* mask */
  307.     {"FDECSTP", itFdecstp, OP2,0,
  308.      ESC|0x01, 0xf6, 0x00, /* opcode */
  309. 0xff, 0xff, 0x00}, /* mask */
  311.     {"FINCSTP", itFincstp, OP2,0,
  312.      ESC|0x01, 0xf7, 0x00, /* opcode */
  313. 0xff, 0xff, 0x00}, /* mask */
  315.     {"FINIT", itFinit, OP2,0,
  316.      ESC|0x03, 0xe3, 0x00, /* opcode */
  317. 0xff, 0xff, 0x00}, /* mask */
  319.     {"FLDZ", itFldZ, OP2,0,
  320.      ESC|0x01, 0xee, 0x00, /* opcode */
  321. 0xff, 0xff, 0x00}, /* mask */
  323.     {"FLD1", itFld1, OP2,0,
  324.      ESC|0x01, 0xe8, 0x00, /* opcode */
  325. 0xff, 0xff, 0x00}, /* mask */
  327.     {"FLDPI", itFldPI, OP2,0,
  328.      ESC|0x01, 0xeb, 0x00, /* opcode */
  329. 0xff, 0xff, 0x00}, /* mask */
  331.     {"FLDL2T", itFldL2T, OP2,0,
  332.      ESC|0x01, 0xe9, 0x00, /* opcode */
  333. 0xff, 0xff, 0x00}, /* mask */
  335.     {"FLDL2E", itFldL2E, OP2,0,
  336.      ESC|0x01, 0xea, 0x00, /* opcode */
  337. 0xff, 0xff, 0x00}, /* mask */
  339.     {"FLDLG2", itFldLG2, OP2,0,
  340.      ESC|0x01, 0xec, 0x00, /* opcode */
  341. 0xff, 0xff, 0x00}, /* mask */
  343.     {"FLDLN2", itFldLN2, OP2,0,
  344.      ESC|0x01, 0xed, 0x00, /* opcode */
  345. 0xff, 0xff, 0x00}, /* mask */
  347.     {"FNOP", itFnop, OP2,0,
  348.      ESC|0x01, 0xd0, 0x00, /* opcode */
  349. 0xff, 0xff, 0x00}, /* mask */
  351.     {"FPATAN", itFpatan, OP2,0,
  352.      ESC|0x01, 0xf3, 0x00, /* opcode */
  353. 0xff, 0xff, 0x00}, /* mask */
  355.     {"FPREM", itFprem, OP2,0,
  356.      ESC|0x01, 0xf8, 0x00, /* opcode */
  357. 0xff, 0xff, 0x00}, /* mask */
  359.     {"FPREM1", itFprem1, OP2,0,
  360.      ESC|0x01, 0xf5, 0x00, /* opcode */
  361. 0xff, 0xff, 0x00}, /* mask */
  363.     {"FPTAN", itFptan, OP2,0,
  364.      ESC|0x01, 0xf2, 0x00, /* opcode */
  365. 0xff, 0xff, 0x00}, /* mask */
  367.     {"FRNDINT", itFrndint, OP2,0,
  368.      ESC|0x01, 0xfc, 0x00, /* opcode */
  369. 0xff, 0xff, 0x00}, /* mask */
  371.     {"FSCALE", itFscale, OP2,0,
  372.      ESC|0x01, 0xfd, 0x00, /* opcode */
  373. 0xff, 0xff, 0x00}, /* mask */
  375.     {"FSIN", itFsin, OP2,0,
  376.      ESC|0x01, 0xfe, 0x00, /* opcode */
  377. 0xff, 0xff, 0x00}, /* mask */
  379.     {"FSINCOS", itFsincos, OP2,0,
  380.      ESC|0x01, 0xfb, 0x00, /* opcode */
  381. 0xff, 0xff, 0x00}, /* mask */
  383.     {"FSQRT", itFsqrt, OP2,0,
  384.      ESC|0x01, 0xfa, 0x00, /* opcode */
  385. 0xff, 0xff, 0x00}, /* mask */
  387.     {"FSTSW", itFstswA, OP2|AX,0,
  388.      ESC|0x07, 0xe0, 0x00, /* opcode */
  389. 0xff, 0xff, 0x00}, /* mask */
  391.     {"FTST", itFtst, OP2,0,
  392.      ESC|0x01, 0xe4, 0x00, /* opcode */
  393. 0xff, 0xff, 0x00}, /* mask */
  395.     {"FUCOMPP", itFucompp, OP2,0,
  396.      ESC|0x02, 0xe9, 0x00, /* opcode */
  397. 0xff, 0xff, 0x00}, /* mask */
  399.     {"FXAM", itFxam, OP2,0,
  400.      ESC|0x01, 0xe5, 0x00, /* opcode */
  401. 0xff, 0xff, 0x00}, /* mask */
  403.     {"FXTRACT", itFxtract, OP2,0,
  404.      ESC|0x01, 0xf4, 0x00, /* opcode */
  405. 0xff, 0xff, 0x00}, /* mask */
  407.     {"FYL2X", itFyl2x, OP2,0,
  408.      ESC|0x01, 0xf1, 0x00, /* opcode */
  409. 0xff, 0xff, 0x00}, /* mask */
  411.     {"FYL2XP1", itFyl2xp1, OP2,0,
  412.      ESC|0x01, 0xf9, 0x00, /* opcode */
  413. 0xff, 0xff, 0x00}, /* mask */
  415.     {"IMUL", itImulRwiRM,  OP2|MODRM|REG,0,
  416.      0x0f, 0xaf, 0x00, /* opcode */
  417. 0xff, 0xff, 0x00}, /* mask */
  419.     {"INVD", itInvd,        OP2,0,
  420.      0x0f, 0x08, 0x00, /* opcode */
  421. 0xff, 0xff, 0x00}, /* mask */
  423.     {"INVLPG", itInvlpg,        OP2|MODRM,0,
  424.      0x0f, 0x01, 0x00, /* opcode */
  425. 0xff, 0xff, 0x00}, /* mask */
  427.     {"LAR", itLar,        OP2|MODRM|REG,0,
  428.      0x0f, 0x02, 0x00, /* opcode */
  429. 0xff, 0xff, 0x00}, /* mask */
  431.     {"LFS", itLfs,        OP2|MODRM|REG,0,
  432.      0x0f, 0xb4, 0x00, /* opcode */
  433. 0xff, 0xff, 0x00}, /* mask */
  435.     {"LGS", itLgs,        OP2|MODRM|REG,0,
  436.      0x0f, 0xb5, 0x00, /* opcode */
  437. 0xff, 0xff, 0x00}, /* mask */
  439.     {"LSL", itLsl,        OP2|MODRM|REG,0,
  440.      0x0f, 0x03, 0x00, /* opcode */
  441. 0xff, 0xff, 0x00}, /* mask */
  443.     {"LSS", itLss,        OP2|MODRM|REG,0,
  444.      0x0f, 0xb2, 0x00, /* opcode */
  445. 0xff, 0xff, 0x00}, /* mask */
  447.     /* 
  448.      * MOV Changes
  449.      * see mask byte 2 changes on next entry.
  450.      * This change is only done on entries that are extact,
  451.      * with exception to opcode byte 2 bit 2
  452.      *
  453.      * {"MOV", itMovC,          OP2|DISR|EEE|MODRM,0,
  454.      *                          0x0f, 0x22, 0x00,
  455.      *                          0xff, 0xff, 0x00},
  456.      */
  458.     {"MOV", itMovC,       OP2|DISR|EEE|MODRM,0,
  459.      0x0f, 0x20, 0x00, /* opcode */
  460. 0xff, 0xfd, 0x00}, /* mask */
  462.     {"MOV", itMovD,       OP2|DISR|EEE|MODRM,0,
  463.      0x0f, 0x21, 0x00, /* opcode */
  464. 0xff, 0xfd, 0x00}, /* mask */
  466.     {"MOV", itMovT,       OP2|DISR|EEE|MODRM,0,
  467.      0x0f, 0x24, 0x00, /* opcode */
  468. 0xff, 0xfd, 0x00}, /* mask */
  470.     /* 
  471.      * MOV Changes
  472.      * see mask byte 2 changes on next entry.
  473.      * This change is only done on entries that are extact,
  474.      * with exception to opcode byte 2 bit 4
  475.      *
  476.      * {"MOVD", itMovd,         OP2|MMXREG|MODRM,0,
  477.      *                          0x0f, 0x7e, 0x00,
  478.      *                          0xff, 0xff, 0x00},
  479.      */
  481.     {"MOVD", itMovd,            OP2|MMXREG|MODRM|DISR,0,
  482.                                 0x0f, 0x6e, 0x00,       /* opcode */
  483. 0xff, 0xef, 0x00},      /* mask */
  485.     {"MOVQ", itMovq,            OP2|MMXREG|MMXRM|MODRM|DISR,0,
  486. 0x0f, 0x6f, 0x00,       /* opcode */
  487. 0xff, 0xef, 0x00},      /* mask */
  489.     {"PACKSSDW", itPackssdw, OP2|MMXREG|MMXRM|MODRM,0,
  490.      0x0f, 0x6b, 0x00, /* opcode */
  491. 0xff, 0xff, 0x00}, /* mask */
  493.     {"PACKSSWB", itPacksswb, OP2|MMXREG|MMXRM|MODRM,0,
  494.      0x0f, 0x63, 0x00, /* opcode */
  495. 0xff, 0xff, 0x00}, /* mask */
  497.     {"PACKUSWB", itPackuswb, OP2|MMXREG|MMXRM|MODRM,0,
  498.      0x0f, 0x67, 0x00, /* opcode */
  499. 0xff, 0xff, 0x00}, /* mask */
  501.     {"PAND", itPand, OP2|MMXREG|MMXRM|MODRM,0,
  502.      0x0f, 0xdb, 0x00, /* opcode */
  503. 0xff, 0xff, 0x00}, /* mask */
  505.     {"PANDN", itPandn, OP2|MMXREG|MMXRM|MODRM,0,
  506.      0x0f, 0xdf, 0x00, /* opcode */
  507. 0xff, 0xff, 0x00}, /* mask */
  509.     {"PMADD", itPmadd, OP2|MMXREG|MMXRM|MODRM,0,
  510.      0x0f, 0xf5, 0x00, /* opcode */
  511. 0xff, 0xff, 0x00}, /* mask */
  513.     {"PMULH", itPmulh, OP2|MMXREG|MMXRM|MODRM,0,
  514.      0x0f, 0xe5, 0x00, /* opcode */
  515. 0xff, 0xff, 0x00}, /* mask */
  517.     {"PMULL", itPmull, OP2|MMXREG|MMXRM|MODRM,0,
  518.      0x0f, 0xd5, 0x00, /* opcode */
  519. 0xff, 0xff, 0x00}, /* mask */
  521.     {"POR", itPor, OP2|MMXREG|MMXRM|MODRM,0,
  522.      0x0f, 0xeb, 0x00, /* opcode */
  523. 0xff, 0xff, 0x00}, /* mask */
  525.     {"PXOR", itPxor, OP2|MMXREG|MMXRM|MODRM,0,
  526.      0x0f, 0xef, 0x00, /* opcode */
  527. 0xff, 0xff, 0x00}, /* mask */
  529.     {"RDTSC", itRdtsc, OP2,0,
  530.      0x0f, 0x31, 0x00, /* opcode */
  531. 0xff, 0xff, 0x00}, /* mask */
  533.     {"RDMSR", itRdmsr, OP2,0,
  534.      0x0f, 0x32, 0x00, /* opcode */
  535. 0xff, 0xff, 0x00}, /* mask */
  537.     {"RDPMC", itRdpmc, OP2,0,
  538.      0x0f, 0x33, 0x00, /* opcode */
  539. 0xff, 0xff, 0x00}, /* mask */
  541.     {"RSM", itRsm, OP2,0,
  542.      0x0f, 0xaa, 0x00, /* opcode */
  543. 0xff, 0xff, 0x00}, /* mask */
  545.     {"SHLD", itShldRMbyI,  OP2|MODRM|REG|I8,0,
  546.      0x0f, 0xa4, 0x00, /* opcode */
  547. 0xff, 0xff, 0x00}, /* mask */
  549.     {"SHLD", itShldRMbyCL,  OP2|MODRM|REG|CL,0,
  550.      0x0f, 0xa5, 0x00, /* opcode */
  551. 0xff, 0xff, 0x00}, /* mask */
  553.     {"SHRD", itShrdRMbyI,  OP2|MODRM|REG|I8,0,
  554.      0x0f, 0xac, 0x00, /* opcode */
  555. 0xff, 0xff, 0x00}, /* mask */
  557.     {"SHRD", itShrdRMbyCL,  OP2|MODRM|REG|CL,0,
  558.      0x0f, 0xad, 0x00, /* opcode */
  559. 0xff, 0xff, 0x00}, /* mask */
  561.     {"SYSENTER", itSysenter, OP2,0,
  562.      0x0f, 0x34, 0x00, /* opcode */
  563. 0xff, 0xff, 0x00}, /* mask */
  565.     {"SYSEXIT", itSysexit, OP2,0,
  566.      0x0f, 0x35, 0x00, /* opcode */
  567. 0xff, 0xff, 0x00}, /* mask */
  569.     {"UD2", itUd2, OP2,0,
  570.      0x0f, 0x0b, 0x00, /* opcode */
  571. 0xff, 0xff, 0x00}, /* mask */
  573.     {"WBINVD", itWbinvd,        OP2,0,
  574.      0x0f, 0x09, 0x00, /* opcode */
  575. 0xff, 0xff, 0x00}, /* mask */
  577.     {"WRMSR", itWrmsr, OP2,0,
  578.      0x0f, 0x30, 0x00, /* opcode */
  579. 0xff, 0xff, 0x00}, /* mask */
  582.     /* SIMD Instructions - 16 bit */
  584.     {"ADDPS", itAddps, OP2|MODRM,XMMREG|XMMRM,
  585.      0x0f, 0x58, 0x00, /* opcode */
  586. 0xff, 0xff, 0x00}, /* mask */
  588.     {"ANDNPS", itAndnps, OP2|MODRM,XMMREG|XMMRM,
  589.      0x0f, 0x55, 0x00, /* opcode */
  590. 0xff, 0xff, 0x00}, /* mask */
  592.     {"ANDPS", itAndps, OP2|MODRM,XMMREG|XMMRM,
  593.      0x0f, 0x54, 0x00, /* opcode */
  594. 0xff, 0xff, 0x00}, /* mask */
  596.     {"CMPPS", itCmpps, OP2|MODRM|I8,XMMREG|XMMRM,
  597.      0x0f, 0xc2, 0x00, /* opcode */
  598. 0xff, 0xff, 0x00}, /* mask */
  600.     {"COMISS", itComiss, OP2|MODRM,XMMREG|XMMRM,
  601.      0x0f, 0x2f, 0x00, /* opcode */
  602. 0xff, 0xff, 0x00}, /* mask */
  604.     {"CVTPI2PS", itCvtpi2ps,    OP2|MODRM|MMXRM,XMMREG,
  605.      0x0f, 0x2a, 0x00, /* opcode */
  606. 0xff, 0xff, 0x00}, /* mask */
  608.     {"CVTPS2PI", itCvtps2pi, OP2|MODRM|MMXREG,XMMRM,
  609.      0x0f, 0x2d, 0x00, /* opcode */
  610. 0xff, 0xff, 0x00}, /* mask */
  612.     {"CVTTPS2PI", itCvttps2pi, OP2|MODRM|MMXREG,XMMRM,
  613.      0x0f, 0x2c, 0x00, /* opcode */
  614. 0xff, 0xff, 0x00}, /* mask */
  616.     {"DIVPS", itDivps, OP2|MODRM,XMMREG|XMMRM,
  617.      0x0f, 0x5e, 0x00, /* opcode */
  618. 0xff, 0xff, 0x00}, /* mask */
  620.     {"MAXPS", itMaxps, OP2|MODRM,XMMREG|XMMRM,
  621.      0x0f, 0x5f, 0x00, /* opcode */
  622. 0xff, 0xff, 0x00}, /* mask */
  624.     {"MINPS", itMinps, OP2|MODRM,XMMREG|XMMRM,
  625.      0x0f, 0x5d, 0x00, /* opcode */
  626. 0xff, 0xff, 0x00}, /* mask */
  628.     {"MOVAPS", itMovaps, OP2|MODRM|DISR,XMMREG|XMMRM,
  629.      0x0f, 0x28, 0x00, /* opcode */
  630. 0xff, 0xfe, 0x00}, /* mask */
  632.     {"MOVHPS", itMovhps, OP2|MODRM|DISR,XMMREG,
  633.      0x0f, 0x16, 0x00, /* opcode */
  634. 0xff, 0xfe, 0x00}, /* mask */
  636.     {"MOVLPS", itMovlps, OP2|MODRM|DISR,XMMREG,
  637.      0x0f, 0x12, 0x00, /* opcode */
  638. 0xff, 0xfe, 0x00}, /* mask */
  640.     {"MOVMSKPS", itMovmskps, OP2|MODRM|REG,XMMRM,
  641.      0x0f, 0x50, 0x00, /* opcode */
  642. 0xff, 0xff, 0x00}, /* mask */
  644.     {"MOVUPS", itMovups, OP2|MODRM|DISR,XMMREG|XMMRM,
  645.      0x0f, 0x10, 0x00, /* opcode */
  646. 0xff, 0xfe, 0x00}, /* mask */
  648.     {"MULPS", itMulps, OP2|MODRM,XMMREG|XMMRM,
  649.      0x0f, 0x59, 0x00, /* opcode */
  650. 0xff, 0xff, 0x00}, /* mask */
  652.     {"ORPS", itOrps, OP2|MODRM,XMMREG|XMMRM,
  653.      0x0f, 0x56, 0x00, /* opcode */
  654. 0xff, 0xff, 0x00}, /* mask */
  656.     {"RCPPS", itRcpps, OP2|MODRM,XMMREG|XMMRM,
  657.      0x0f, 0x53, 0x00, /* opcode */
  658. 0xff, 0xff, 0x00}, /* mask */
  660.     {"RSQRTPS", itRsqrtps, OP2|MODRM,XMMREG|XMMRM,
  661.      0x0f, 0x52, 0x00, /* opcode */
  662. 0xff, 0xff, 0x00}, /* mask */
  664.     {"SHUFPS", itShufps, OP2|MODRM|I8,XMMREG|XMMRM,
  665.      0x0f, 0xc6, 0x00, /* opcode */
  666. 0xff, 0xff, 0x00}, /* mask */
  668.     {"SQRTPS", itSqrtps, OP2|MODRM,XMMREG|XMMRM,
  669.      0x0f, 0x51, 0x00, /* opcode */
  670. 0xff, 0xff, 0x00}, /* mask */
  672.     {"SUBPS", itSubps, OP2|MODRM,XMMREG|XMMRM,
  673.      0x0f, 0x5c, 0x00, /* opcode */
  674. 0xff, 0xff, 0x00}, /* mask */
  676.     {"UCOMISS", itUcomiss, OP2|MODRM,XMMREG|XMMRM,
  677.      0x0f, 0x2e, 0x00, /* opcode */
  678. 0xff, 0xff, 0x00}, /* mask */
  680.     {"UNPCKHPS", itUnpckhps, OP2|MODRM,XMMREG|XMMRM,
  681.      0x0f, 0x15, 0x00, /* opcode */
  682. 0xff, 0xff, 0x00}, /* mask */
  684.     {"UNPCKLPS", itUnpcklps, OP2|MODRM,XMMREG|XMMRM,
  685.      0x0f, 0x14, 0x00, /* opcode */
  686. 0xff, 0xff, 0x00}, /* mask */
  688.     {"XORPS", itXorps, OP2|MODRM,XMMREG|XMMRM,
  689.      0x0f, 0x57, 0x00, /* opcode */
  690. 0xff, 0xff, 0x00}, /* mask */
  692.     {"PAVGB", itPavgb, OP2|MODRM|MMXREG|MMXRM,0,
  693.      0x0f, 0xe0, 0x00, /* opcode */
  694. 0xff, 0xff, 0x00}, /* mask */
  696.     {"PAVGW", itPavgw, OP2|MODRM|MMXREG|MMXRM,0,
  697.      0x0f, 0xe3, 0x00, /* opcode */
  698. 0xff, 0xff, 0x00}, /* mask */
  700.     {"PEXTRW", itPextrw, OP2|DISR|MODRM|MMXREG|REGRM|I8,0,
  701.      0x0f, 0xc5, 0x00, /* opcode */
  702. 0xff, 0xff, 0x00}, /* mask */
  704.     {"PINSRW", itPinsrw, OP2|MODRM|MMXREG|REGRM|I8,0,
  705.      0x0f, 0xc4, 0x00, /* opcode */
  706. 0xff, 0xff, 0x00}, /* mask */
  708.     {"PMAXSW", itPmaxsw, OP2|MODRM|MMXREG|MMXRM,0,
  709.      0x0f, 0xee, 0x00, /* opcode */
  710. 0xff, 0xff, 0x00}, /* mask */
  712.     {"PMAXUB", itPmaxub, OP2|MODRM|MMXREG|MMXRM,0,
  713.      0x0f, 0xde, 0x00, /* opcode */
  714. 0xff, 0xff, 0x00}, /* mask */
  716.     {"PMINSW", itPminsw, OP2|MODRM|MMXREG|MMXRM,0,
  717.      0x0f, 0xea, 0x00, /* opcode */
  718. 0xff, 0xff, 0x00}, /* mask */
  720.     {"PMINUB", itPminub, OP2|MODRM|MMXREG|MMXRM,0,
  721.      0x0f, 0xda, 0x00, /* opcode */
  722. 0xff, 0xff, 0x00}, /* mask */
  724.     {"PMOVMSKB", itPmovmskb, OP2|MODRM|MMXREG|REGRM|DISR,0,
  725.      0x0f, 0xd7, 0x00, /* opcode */
  726. 0xff, 0xff, 0x00}, /* mask */
  728.     {"PMULHUW", itPmulhuw, OP2|MODRM|MMXREG|MMXRM,0,
  729.      0x0f, 0xe4, 0x00, /* opcode */
  730. 0xff, 0xff, 0x00}, /* mask */
  732.     {"PSADBW", itPsadbw, OP2|MODRM|MMXREG|MMXRM,0,
  733.      0x0f, 0xf6, 0x00, /* opcode */
  734. 0xff, 0xff, 0x00}, /* mask */
  736.     {"PSHUFW", itPshufw, OP2|MODRM|MMXREG|MMXRM|I8,0,
  737.      0x0f, 0x70, 0x00, /* opcode */
  738. 0xff, 0xff, 0x00}, /* mask */
  740.     {"MASKMOVQ", itMaskmovq, OP2|MODRM|MMXREG|MMXRM,0,
  741.      0x0f, 0xf7, 0x00, /* opcode */
  742. 0xff, 0xff, 0x00}, /* mask */
  744.     {"MOVNTPS", itMovntps, OP2|MODRM|DISR,XMMREG|XMMRM,
  745.      0x0f, 0x2b, 0x00, /* opcode */
  746. 0xff, 0xff, 0x00}, /* mask */
  748.     {"MOVNTQ", itMovntq, OP2|MODRM|DISR,XMMREG|XMMRM,
  749.      0x0f, 0xe7, 0x00, /* opcode */
  750. 0xff, 0xff, 0x00}, /* mask */
  752.     /* 15 bits mask */
  754.     {"CMPXCHG", itCmpxchg,      OP2|WFUL|MODRM|REG,0,
  755.      0x0f, 0xb0, 0x00, /* opcode */
  756. 0xff, 0xfe, 0x00}, /* mask */
  758.     {"MOVSX", itMovsx,    OP2|WFUL|MODRM|REG,0,
  759.      0x0f, 0xbe, 0x00, /* opcode */
  760. 0xff, 0xfe, 0x00}, /* mask */
  762.     {"MOVZX", itMovzx,    OP2|WFUL|MODRM|REG,0,
  763.      0x0f, 0xb6, 0x00, /* opcode */
  764. 0xff, 0xfe, 0x00}, /* mask */
  766.     {"REP INS", itRins,       OP2|WFUL,0,
  767.      0xf3, 0x6c, 0x00, /* opcode */
  768. 0xff, 0xfe, 0x00}, /* mask */
  770.     {"REP LODS", itRlods,     OP2|WFUL,0,
  771.      0xf3, 0xac, 0x00, /* opcode */
  772. 0xff, 0xfe, 0x00}, /* mask */
  774.     {"REP MOVS", itRmovs,     OP2|WFUL,0,
  775.      0xf3, 0xa4, 0x00, /* opcode */
  776. 0xff, 0xfe, 0x00}, /* mask */
  778.     {"REP OUTS", itRouts,     OP2|WFUL,0,
  779.      0xf3, 0x6e, 0x00, /* opcode */
  780. 0xff, 0xfe, 0x00}, /* mask */
  782.     {"REP STOS", itRstos,     OP2|WFUL,0,
  783.      0xf3, 0xaa, 0x00, /* opcode */
  784. 0xff, 0xfe, 0x00}, /* mask */
  786.     {"REPE CMPS", itRcmps,    OP2|WFUL,0,
  787.      0xf3, 0xa6, 0x00, /* opcode */
  788. 0xff, 0xfe, 0x00}, /* mask */
  790.     {"REPE SCAS", itRscas,    OP2|WFUL,0,
  791.      0xf3, 0xae, 0x00, /* opcode */
  792. 0xff, 0xfe, 0x00}, /* mask */
  794.     {"REPNE CMPS", itRNcmps,  OP2|WFUL,0,
  795.      0xf2, 0xa6, 0x00, /* opcode */
  796. 0xff, 0xfe, 0x00}, /* mask */
  798.     {"REPNE SCAS", itRNscas,  OP2|WFUL,0,
  799.      0xf2, 0xae, 0x00, /* opcode */
  800. 0xff, 0xfe, 0x00}, /* mask */
  802.     {"XADD", itXadd,        OP2|WFUL|MODRM|REG,0,
  803.      0x0f, 0xc0, 0x00, /* opcode */
  804. 0xff, 0xfe, 0x00}, /* mask */
  806.     /* 14 + 5 bits mask */
  808.     {"PSLL", itPsll, OP2|GG|MODRM|MMXRM|I8,0,
  809.      0x0f, 0x70, 0xf0, /* opcode */
  810. 0xff, 0xfc, 0xf8}, /* mask */
  812.     {"PSRA", itPsra, OP2|GG|MODRM|MMXRM|I8,0,
  813.      0x0f, 0x70, 0xe0, /* opcode */
  814. 0xff, 0xfc, 0xf8}, /* mask */
  816.     {"PSRL", itPsrl, OP2|GG|MODRM|MMXRM|I8,0,
  817.      0x0f, 0x70, 0xd0, /* opcode */
  818. 0xff, 0xfc, 0xf8}, /* mask */
  820.     /* 14 bits mask */
  822.     {"PADD", itPadd, OP2|GG|MMXREG|MMXRM|MODRM,0,
  823.      0x0f, 0xfc, 0x00, /* opcode */
  824. 0xff, 0xfc, 0x00}, /* mask */
  826.     {"PADDS", itPadds, OP2|GG|MMXREG|MMXRM|MODRM,0,
  827.      0x0f, 0xec, 0x00, /* opcode */
  828. 0xff, 0xfc, 0x00}, /* mask */
  830.     {"PADDUS", itPaddus, OP2|GG|MMXREG|MMXRM|MODRM,0,
  831.      0x0f, 0xdc, 0x00, /* opcode */
  832. 0xff, 0xfc, 0x00}, /* mask */
  834.     {"PCMPEQ", itPcmpeq, OP2|GG|MMXREG|MMXRM|MODRM,0,
  835.      0x0f, 0x74, 0x00, /* opcode */
  836. 0xff, 0xfc, 0x00}, /* mask */
  838.     {"PCMPGT", itPcmpgt, OP2|GG|MMXREG|MMXRM|MODRM,0,
  839.      0x0f, 0x64, 0x00, /* opcode */
  840. 0xff, 0xfc, 0x00}, /* mask */
  842.     {"PSLL", itPsll, OP2|GG|MMXREG|MMXRM|MODRM,0,
  843.      0x0f, 0xf0, 0x00, /* opcode */
  844. 0xff, 0xfc, 0x00}, /* mask */
  846.     {"PSRA", itPsra, OP2|GG|MMXREG|MMXRM|MODRM,0,
  847.      0x0f, 0xe0, 0x00, /* opcode */
  848. 0xff, 0xfc, 0x00}, /* mask */
  850.     {"PSRL", itPsrl, OP2|GG|MMXREG|MMXRM|MODRM,0,
  851.      0x0f, 0xd0, 0x00, /* opcode */
  852. 0xff, 0xfc, 0x00}, /* mask */
  854.     {"PSUB", itPsub, OP2|GG|MMXREG|MMXRM|MODRM,0,
  855.      0x0f, 0xf8, 0x00, /* opcode */
  856. 0xff, 0xfc, 0x00}, /* mask */
  858.     {"PSUBS", itPsubs, OP2|GG|MMXREG|MMXRM|MODRM,0,
  859.      0x0f, 0xe8, 0x00, /* opcode */
  860. 0xff, 0xfc, 0x00}, /* mask */
  862.     {"PSUBUS", itPsubus, OP2|GG|MMXREG|MMXRM|MODRM,0,
  863.      0x0f, 0xd8, 0x00, /* opcode */
  864. 0xff, 0xfc, 0x00}, /* mask */
  866.     {"PUNPCKH", itPunpckh, OP2|GG|MMXREG|MMXRM|MODRM,0,
  867.      0x0f, 0x68, 0x00, /* opcode */
  868. 0xff, 0xfc, 0x00}, /* mask */
  870.     {"PUNPCKL", itPunpckl, OP2|GG|MMXREG|MMXRM|MODRM,0,
  871.      0x0f, 0x60, 0x00, /* opcode */
  872. 0xff, 0xfc, 0x00},
  874.     /* 13 bits mask */
  876.     {"BSWAP", itBswap,        OP1|MODRM,0,
  877.      0x0f, 0xc8, 0x00, /* opcode */
  878. 0xff, 0xf8, 0x00}, /* mask */
  880.     {"FCMOVB", itFcmovb, OP2|ST,0,
  881.      ESC|0x02, 0xc0, 0x00, /* opcode */
  882. 0xff, 0xf8, 0x00}, /* mask */
  884.     {"FCMOVBE", itFcmovbe, OP2|ST,0,
  885.      ESC|0x02, 0xd0, 0x00, /* opcode */
  886. 0xff, 0xf8, 0x00}, /* mask */
  888.     {"FCMOVE", itFcmove, OP2|ST,0,
  889.      ESC|0x02, 0xc8, 0x00, /* opcode */
  890. 0xff, 0xf8, 0x00}, /* mask */
  892.     {"FCMOVU", itFcmovu, OP2|ST,0,
  893.      ESC|0x02, 0xd8, 0x00, /* opcode */
  894. 0xff, 0xf8, 0x00}, /* mask */
  896.     {"FCMOVNB", itFcmovnb, OP2|ST,0,
  897.      ESC|0x03, 0xc0, 0x00, /* opcode */
  898. 0xff, 0xf8, 0x00}, /* mask */
  900.     {"FCMOVNBE", itFcmovnbe, OP2|ST,0,
  901.      ESC|0x03, 0xd0, 0x00, /* opcode */
  902. 0xff, 0xf8, 0x00}, /* mask */
  904.     {"FCMOVNE", itFcmovne, OP2|ST,0,
  905.      ESC|0x03, 0xc8, 0x00, /* opcode */
  906. 0xff, 0xf8, 0x00}, /* mask */
  908.     {"FCMOVNU", itFcmovnu, OP2|ST,0,
  909.      ESC|0x03, 0xd8, 0x00, /* opcode */
  910. 0xff, 0xf8, 0x00}, /* mask */
  912.     {"FCOM", itFcomST, OP2|ST,0,
  913.      ESC|0x00, 0xd0, 0x00, /* opcode */
  914. 0xff, 0xf8, 0x00}, /* mask */
  916.     {"FCOMI", itFcomi, OP2|ST,0,
  917.      ESC|0x03, 0xf0, 0x00, /* opcode */
  918. 0xff, 0xf8, 0x00}, /* mask */
  920.     {"FCOMP", itFcompST, OP2|ST,0,
  921.      ESC|0x00, 0xd8, 0x00, /* opcode */
  922. 0xff, 0xf8, 0x00}, /* mask */
  924.     {"FFREE", itFfree, OP2|ST,0,
  925.      ESC|0x05, 0xc0, 0x00, /* opcode */
  926. 0xff, 0xf8, 0x00}, /* mask */
  928.     {"FLD", itFldST, OP2|ST,0,
  929.      ESC|0x01, 0xc0, 0x00, /* opcode */
  930. 0xff, 0xf8, 0x00}, /* mask */
  932.     {"FST", itFstST, OP2|ST,0,
  933.      ESC|0x05, 0xd0, 0x00, /* opcode */
  934. 0xff, 0xf8, 0x00}, /* mask */
  936.     {"FSTP", itFstpST, OP2|ST,0,
  937.      ESC|0x05, 0xd8, 0x00, /* opcode */
  938. 0xff, 0xf8, 0x00}, /* mask */
  940.     {"FUCOM", itFucom, OP2|ST,0,
  941.      ESC|0x05, 0xe0, 0x00, /* opcode */
  942. 0xff, 0xf8, 0x00}, /* mask */
  944.     {"FUCOMP", itFucomp, OP2|ST,0,
  945.      ESC|0x05, 0xe8, 0x00, /* opcode */
  946. 0xff, 0xf8, 0x00}, /* mask */
  948.     {"FXCH", itFxch, OP2|ST,0,
  949.      ESC|0x01, 0xc8, 0x00, /* opcode */
  950. 0xff, 0xf8, 0x00}, /* mask */
  952.     {"POP", itPopS,       OP2|SREG3,0,
  953.      0x0f, 0x81, 0x00, /* opcode */
  954. 0xff, 0xc7, 0x00}, /* mask */
  956.     {"PUSH", itPushS,     OP1|SREG3,0,
  957.      0x0f, 0x80, 0x00, /* opcode */
  958. 0xff, 0xc7, 0x00}, /* mask */
  960.     /* 12 + 3 bits mask */
  962.     {"CMOV", itCmovcc, OP2|TTTN|MODRM|REG,0,
  963.      0x0f, 0x40, 0x00, /* opcode */
  964. 0xff, 0xf0, 0x00}, /* mask */
  966.     {"CSET", itCset,      OP2|TTTN|MODRM,0,
  967.      0x0f, 0x90, 0x00, /* opcode */
  968. 0xff, 0xf0, 0x38}, /* mask */
  970.     /* 12 bits mask */
  972.     {"CJMPF", itCjmp,     OP2|TTTN|DIS,0,
  973.      0x0f, 0x80, 0x00, /* opcode */
  974. 0xff, 0xf0, 0x00}, /* mask */
  976.     /* 11 bits mask */
  978.     {"CALL", itCallRM,    OP1|MODRM,0,
  979.      0xff, 0x10, 0x00, /* opcode */
  980. 0xff, 0x38, 0x00}, /* mask */
  982.     {"CALL", itCallSegRM,  OP1|MODRM,0,
  983.      0xff, 0x18, 0x00, /* opcode */
  984. 0xff, 0x38, 0x00}, /* mask */
  986.     {"FADD", itFaddST, OP2|POP|FD|ST,0,
  987.      ESC|0x00, 0xc0, 0x00, /* opcode */
  988. 0xf9, 0xf8, 0x00}, /* mask */
  990.     {"FLDbcd", itFldBCDM, OP1|MODRM,0,
  991.      ESC|0x07, 0x20, 0x00, /* opcode */
  992. 0xff, 0x38, 0x00}, /* mask */
  994.     {"FLDCW", itFldcw, OP1|MODRM,0,
  995.      ESC|0x01, 0x28, 0x00, /* opcode */
  996. 0xff, 0x38, 0x00}, /* mask */
  998.     {"FLDENV", itFldenv, OP1|MODRM,0,
  999.      ESC|0x01, 0x20, 0x00, /* opcode */
  1000. 0xff, 0x38, 0x00}, /* mask */
  1002.     {"FLDext", itFldERM, OP1|MODRM,0,
  1003.      ESC|0x03, 0x28, 0x00, /* opcode */
  1004. 0xff, 0x38, 0x00}, /* mask */
  1006.     {"FLDint", itFldLIM, OP1|MODRM,0,
  1007.      ESC|0x07, 0x28, 0x00, /* opcode */
  1008. 0xff, 0x38, 0x00}, /* mask */
  1010.     {"FMUL", itFmulST, OP2|POP|FD|ST,0,
  1011.      ESC|0x00, 0xc8, 0x00, /* opcode */
  1012. 0xf9, 0xf8, 0x00}, /* mask */
  1014.     {"FRSTOR", itFrstor, OP1|MODRM,0,
  1015.      ESC|0x05, 0x20, 0x00, /* opcode */
  1016. 0xff, 0x38, 0x00}, /* mask */
  1018.     {"FSAVE", itFsave, OP1|MODRM,0,
  1019.      ESC|0x05, 0x30, 0x00, /* opcode */
  1020. 0xff, 0x38, 0x00}, /* mask */
  1022.     {"FSTCW", itFstcw, OP1|MODRM,0,
  1023.      ESC|0x01, 0x38, 0x00, /* opcode */
  1024. 0xff, 0x38, 0x00}, /* mask */
  1026.     {"FSTENV", itFstenv, OP1|MODRM,0,
  1027.      ESC|0x01, 0x30, 0x00, /* opcode */
  1028. 0xff, 0x38, 0x00}, /* mask */
  1030.     {"FSTPbcd", itFstpBCDM, OP1|MODRM,0,
  1031.      ESC|0x07, 0x30, 0x00, /* opcode */
  1032. 0xff, 0x38, 0x00}, /* mask */
  1034.     {"FSTPext", itFstpERM, OP1|MODRM,0,
  1035.      ESC|0x03, 0x38, 0x00, /* opcode */
  1036. 0xff, 0x38, 0x00}, /* mask */
  1038.     {"FSTPint", itFstpLIM, OP1|MODRM,0,
  1039.      ESC|0x07, 0x38, 0x00, /* opcode */
  1040. 0xff, 0x38, 0x00}, /* mask */
  1042.     {"FSTSW", itFstsw, OP1|MODRM,0,
  1043.      ESC|0x05, 0x38, 0x00, /* opcode */
  1044. 0xff, 0x38, 0x00}, /* mask */
  1046.     {"IMUL", itImulAwiRM,  OP1|WFUL|MODRM|AX,0,
  1047.      0xf6, 0x28, 0x00, /* opcode */
  1048. 0xff, 0x38, 0x00}, /* mask */
  1050.     {"JMP", itJmpRM,      OP1|MODRM,0,
  1051.      0xff, 0x20, 0x00, /* opcode */
  1052. 0xff, 0x38, 0x00}, /* mask */
  1054.     {"JMP", itJmpSegRM,   OP1|MODRM,0,
  1055.      0xff, 0x28, 0x00, /* opcode */
  1056. 0xff, 0x38, 0x00}, /* mask */
  1058.     {"POP", itPopRM,      OP1|MODRM,0,
  1059.      0x8f, 0x00, 0x00, /* opcode */
  1060. 0xff, 0x38, 0x00}, /* mask */
  1062.     {"PUSH", itPushRM,    OP1|MODRM,0,
  1063.      0xff, 0x30, 0x00, /* opcode */
  1064. 0xff, 0x38, 0x00}, /* mask */
  1066.     /* 10 bits mask */
  1068.     {"DEC", itDecRM,      OP1|WFUL|MODRM,0,
  1069.      0xfe, 0x08, 0x00, /* opcode */
  1070. 0xfe, 0x38, 0x00}, /* mask */
  1072.     {"DIV", itDiv,        OP1|WFUL|MODRM|AX,0,
  1073.      0xf6, 0x30, 0x00, /* opcode */
  1074. 0xfe, 0x38, 0x00}, /* mask */
  1076.     {"FDIV", itFdivST, OP2|POP|FD|ST,0,
  1077.      ESC|0x00, 0xf0, 0x00, /* opcode */
  1078. 0xf9, 0xf0, 0x00}, /* mask */
  1080.     {"FSUB", itFsubST, OP2|POP|FD|ST,0,
  1081.      ESC|0x00, 0xe0, 0x00, /* opcode */
  1082. 0xf9, 0xf0, 0x00}, /* mask */
  1084.     {"IDIV", itIdiv,      OP1|WFUL|MODRM|AX,0,
  1085.      0xf6, 0x38, 0x00, /* opcode */
  1086. 0xfe, 0x38, 0x00}, /* mask */
  1088.     {"INC", itIncRM,      OP1|WFUL|MODRM,0,
  1089.      0xfe, 0x00, 0x00, /* opcode */
  1090. 0xfe, 0x38, 0x00}, /* mask */
  1092.     {"MOV", itMovItoRM,   OP1|WFUL|MODRM|IMM,0,
  1093.      0xc6, 0x00, 0x00, /* opcode */
  1094. 0xfe, 0x38, 0x00}, /* mask */
  1096.     {"MUL", itMulAwiRM,   OP1|WFUL|MODRM|AX,0,
  1097.      0xf6, 0x20, 0x00, /* opcode */
  1098. 0xfe, 0x38, 0x00}, /* mask */
  1100.     {"NEG", itNeg,        OP1|WFUL|MODRM,0,
  1101.      0xf6, 0x18, 0x00, /* opcode */
  1102. 0xfe, 0x38, 0x00}, /* mask */
  1104.     {"NOT", itNot,        OP1|WFUL|MODRM,0,
  1105.      0xf6, 0x10, 0x00, /* opcode */
  1106. 0xfe, 0x38, 0x00}, /* mask */
  1108.     {"TEST", itTestIanRM,  OP1|WFUL|MODRM|IMM,0,
  1109.      0xf6, 0x00, 0x00, /* opcode */
  1110. 0xfe, 0x38, 0x00}, /* mask */
  1112.     /* 9 bits mask */
  1114.     {"ADD", itAddItoRM,   OP1|SEXT|WFUL|MODRM|IMM,0,
  1115.      0x80, 0x00, 0x00, /* opcode */
  1116. 0xfc, 0x38, 0x00}, /* mask */
  1118.     {"ADC", itAdcItoRM,   OP1|SEXT|WFUL|MODRM|IMM,0,
  1119.      0x80, 0x10, 0x00, /* opcode */
  1120. 0xfc, 0x38, 0x00}, /* mask */
  1122.     {"AND", itAndItoRM,   OP1|SEXT|WFUL|MODRM|IMM,0,
  1123.      0x80, 0x20, 0x00, /* opcode */
  1124. 0xfc, 0x38, 0x00}, /* mask */
  1126.     {"CMP", itCmpIwiRM,   OP1|SEXT|WFUL|MODRM|IMM,0,
  1127.      0x80, 0x38, 0x00, /* opcode */
  1128. 0xfc, 0x38, 0x00}, /* mask */
  1130.     {"FADD", itFaddIRM, OP1|MF|MODRM,0,
  1131.      ESC|0x00, 0x00, 0x00, /* opcode */
  1132. 0xf9, 0x38, 0x00}, /* mask */
  1134.     {"FCOM", itFcomIRM, OP1|MF|MODRM,0,
  1135.      ESC|0x00, 0x10, 0x00, /* opcode */
  1136. 0xf9, 0x38, 0x00}, /* mask */
  1138.     {"FCOMP", itFcompIRM, OP1|MF|MODRM,0,
  1139.      ESC|0x00, 0x18, 0x00, /* opcode */
  1140. 0xf9, 0x38, 0x00}, /* mask */
  1142.     {"FLD", itFldIRM, OP1|MF|MODRM,0,
  1143.      ESC|0x01, 0x00, 0x00, /* opcode */
  1144. 0xf9, 0x38, 0x00}, /* mask */
  1146.     {"FMUL", itFmulIRM, OP1|MF|MODRM,0,
  1147.      ESC|0x00, 0x08, 0x00, /* opcode */
  1148. 0xf9, 0x38, 0x00}, /* mask */
  1150.     {"FST", itFstIRM, OP1|MF|MODRM,0,
  1151.      ESC|0x01, 0x10, 0x00, /* opcode */
  1152. 0xf9, 0x38, 0x00}, /* mask */
  1154.     {"FSTP", itFstpIRM, OP1|MF|MODRM,0,
  1155.      ESC|0x01, 0x18, 0x00, /* opcode */
  1156. 0xf9, 0x38, 0x00}, /* mask */
  1158.     {"OR", itOrItoRM,     OP1|SEXT|WFUL|MODRM|IMM,0,
  1159.      0x80, 0x08, 0x00, /* opcode */
  1160. 0xfc, 0x38, 0x00}, /* mask */
  1162.     {"SBB", itSbbIfrRM,   OP1|SEXT|WFUL|MODRM|IMM,0,
  1163.      0x80, 0x18, 0x00, /* opcode */
  1164. 0xfc, 0x38, 0x00}, /* mask */
  1166.     {"SUB", itSubIfrRM,   OP1|SEXT|WFUL|MODRM|IMM,0,
  1167.      0x80, 0x28, 0x00, /* opcode */
  1168. 0xfc, 0x38, 0x00}, /* mask */
  1170.     {"XOR", itXorItoRM,    OP1|SEXT|WFUL|MODRM|IMM,0,
  1171.      0x80, 0x30, 0x00, /* opcode */
  1172. 0xfc, 0x38, 0x00}, /* mask */
  1175.     /* 8 bits mask */
  1177.     {"AAA", itAaa,        OP1,0,
  1178.      0x37, 0x00, 0x00, /* opcode */
  1179. 0xff, 0x00, 0x00}, /* mask */
  1181.     {"AAS", itAas,        OP1,0,
  1182.      0x3f, 0x00, 0x00, /* opcode */
  1183. 0xff, 0x00, 0x00}, /* mask */
  1185.     {"ARPL", itArpl,      OP1|MODRM|REG,0,
  1186.      0x63, 0x00, 0x00, /* opcode */
  1187. 0xff, 0x00, 0x00}, /* mask */
  1189.     {"ASIZE", itAsize,    OP1,0,
  1190.      0x67, 0x00, 0x00, /* opcode */
  1191. 0xff, 0x00, 0x00}, /* mask */
  1193.     {"BOUND", itBound,    OP1|MODRM|REG,0,
  1194.      0x62, 0x00, 0x00, /* opcode */
  1195. 0xff, 0x00, 0x00}, /* mask */
  1197.     {"CALL", itCall,      OP1|DIS,0,
  1198.      0xe8, 0x00, 0x00, /* opcode */
  1199. 0xff, 0x00, 0x00}, /* mask */
  1201.     {"CALL", itCallSeg,   OP1|OFFSEL,0,
  1202.      0x9a, 0x00, 0x00, /* opcode */
  1203. 0xff, 0x00, 0x00}, /* mask */
  1205.     {"CBW", itCbw,        OP1,0,
  1206.      0x98, 0x00, 0x00, /* opcode */
  1207. 0xff, 0x00, 0x00}, /* mask */
  1209.     {"CLC", itClc,        OP1,0,
  1210.      0xf8, 0x00, 0x00, /* opcode */
  1211. 0xff, 0x00, 0x00}, /* mask */
  1213.     {"CLD", itCld,        OP1,0,
  1214.      0xfc, 0x00, 0x00, /* opcode */
  1215. 0xff, 0x00, 0x00}, /* mask */
  1217.     {"CLI", itCli,        OP1,0,
  1218.      0xfa, 0x00, 0x00, /* opcode */
  1219. 0xff, 0x00, 0x00}, /* mask */
  1221.     {"CMC", itCmc,        OP1,0,
  1222.      0xf5, 0x00, 0x00, /* opcode */
  1223. 0xff, 0x00, 0x00}, /* mask */
  1225.     {"CS", itCs,          OP1,0,
  1226.      0x2e, 0x00, 0x00, /* opcode */
  1227. 0xff, 0x00, 0x00}, /* mask */
  1229.     {"CWD", itCwd,        OP1,0,
  1230.      0x99, 0x00, 0x00, /* opcode */
  1231. 0xff, 0x00, 0x00}, /* mask */
  1233.     {"DAA", itDaa,        OP1,0,
  1234.      0x27, 0x00, 0x00, /* opcode */
  1235. 0xff, 0x00, 0x00}, /* mask */
  1237.     {"DAS", itDas,        OP1,0,
  1238.      0x2f, 0x00, 0x00, /* opcode */
  1239. 0xff, 0x00, 0x00}, /* mask */
  1241.     {"DS", itDs,          OP1,0,
  1242.      0x3e, 0x00, 0x00, /* opcode */
  1243. 0xff, 0x00, 0x00}, /* mask */
  1245.     {"ENTER", itEnter,    OP1|D16L8,0,
  1246.      0xc8, 0x00, 0x00, /* opcode */
  1247. 0xff, 0x00, 0x00}, /* mask */
  1249.     {"ES", itEs,          OP1,0,
  1250.      0x26, 0x00, 0x00, /* opcode */
  1251. 0xff, 0x00, 0x00}, /* mask */
  1253.     {"FDIV", itFdivIRM, OP1|MF|MODRM,0,
  1254.      ESC|0x00, 0x30, 0x00, /* opcode */
  1255. 0xf9, 0x30, 0x00}, /* mask */
  1257.     {"FS", itFs,          OP1,0,
  1258.      0x64, 0x00, 0x00, /* opcode */
  1259. 0xff, 0x00, 0x00}, /* mask */
  1261.     {"FSUB", itFsubIRM, OP1|MF|MODRM,0,
  1262.      ESC|0x00, 0x20, 0x00, /* opcode */
  1263. 0xf9, 0x30, 0x00}, /* mask */
  1265.     {"GS", itGs,          OP1,0,
  1266.      0x65, 0x00, 0x00, /* opcode */
  1267. 0xff, 0x00, 0x00}, /* mask */
  1269.     {"HLT", itHlt,        OP1,0,
  1270.      0xf4, 0x00, 0x00, /* opcode */
  1271. 0xff, 0x00, 0x00}, /* mask */
  1273.     {"INT", itInt,        OP1|I8,0,
  1274.      0xcd, 0x00, 0x00, /* opcode */
  1275. 0xff, 0x00, 0x00}, /* mask */
  1277.     {"INT", itInt3,       OP1,0,
  1278.      0xcc, 0x00, 0x00, /* opcode */
  1279. 0xff, 0x00, 0x00}, /* mask */
  1281.     {"INTO", itInto,      OP1,0,
  1282.      0xce, 0x00, 0x00, /* opcode */
  1283. 0xff, 0x00, 0x00}, /* mask */
  1285.     {"IRET", itIret,      OP1,0,
  1286.      0xcf, 0x00, 0x00, /* opcode */
  1287. 0xff, 0x00, 0x00}, /* mask */
  1289.     {"JECXZ", itJcxz,      OP1|D8,0,
  1290.      0xe3, 0x00, 0x00, /* opcode */
  1291. 0xff, 0x00, 0x00}, /* mask */
  1293.     {"JMP", itJmpS,       OP1|D8,0,
  1294.      0xeb, 0x00, 0x00, /* opcode */
  1295. 0xff, 0x00, 0x00}, /* mask */
  1297.     {"JMP", itJmpD,       OP1|DIS,0,
  1298.      0xe9, 0x00, 0x00, /* opcode */
  1299. 0xff, 0x00, 0x00}, /* mask */
  1301.     {"JMP", itJmpSeg,     OP1|OFFSEL,0,
  1302.      0xea, 0x00, 0x00, /* opcode */
  1303. 0xff, 0x00, 0x00}, /* mask */
  1305.     {"LAHF", itLahf,      OP1,0,
  1306.      0x9f, 0x00, 0x00, /* opcode */
  1307. 0xff, 0x00, 0x00}, /* mask */
  1309.     {"LDS", itLds,        OP1|MODRM|REG,0,
  1310.      0xc5, 0x00, 0x00, /* opcode */
  1311. 0xff, 0x00, 0x00}, /* mask */
  1313.     {"LEA", itLea,        OP1|MODRM|REG,0,
  1314.      0x8d, 0x00, 0x00, /* opcode */
  1315. 0xff, 0x00, 0x00}, /* mask */
  1317.     {"LEAVE", itLeave,    OP1,0,
  1318.      0xc9, 0x00, 0x00, /* opcode */
  1319. 0xff, 0x00, 0x00}, /* mask */
  1321.     {"LES", itLes,        OP1|MODRM|REG,0,
  1322.      0xc4, 0x00, 0x00, /* opcode */
  1323. 0xff, 0x00, 0x00}, /* mask */
  1325.     {"LOCK", itLock,      OP1,0,
  1326.      0xf0, 0x00, 0x00, /* opcode */
  1327. 0xff, 0x00, 0x00}, /* mask */
  1329.     {"LOOP", itLoop,      OP1|D8,0,
  1330.      0xe2, 0x00, 0x00, /* opcode */
  1331. 0xff, 0x00, 0x00}, /* mask */
  1333.     {"LOOPZ", itLoopz,    OP1|D8,0,
  1334.      0xe1, 0x00, 0x00, /* opcode */
  1335. 0xff, 0x00, 0x00}, /* mask */
  1337.     {"LOOPNZ", itLoopnz,  OP1|D8,0,
  1338.      0xe0, 0x00, 0x00, /* opcode */
  1339. 0xff, 0x00, 0x00}, /* mask */
  1341.     {"NOP", itNop,        OP1,0,
  1342.      0x90, 0x00, 0x00, /* opcode */
  1343. 0xff, 0x00, 0x00}, /* mask */
  1345.     {"OSIZE", itOsize,    OP1,0,
  1346.      0x66, 0x00, 0x00, /* opcode */
  1347. 0xff, 0x00, 0x00}, /* mask */
  1349.     {"POPA", itPopa,      OP1,0,
  1350.      0x61, 0x00, 0x00, /* opcode */
  1351. 0xff, 0x00, 0x00}, /* mask */
  1353.     {"POPF", itPopf,      OP1,0,
  1354.      0x9d, 0x00, 0x00, /* opcode */
  1355. 0xff, 0x00, 0x00}, /* mask */
  1357.     {"PUSHA", itPusha,    OP1,0,
  1358.      0x60, 0x00, 0x00, /* opcode */
  1359. 0xff, 0x00, 0x00}, /* mask */
  1361.     {"PUSHF", itPushf,    OP1,0,
  1362.      0x9c, 0x00, 0x00, /* opcode */
  1363. 0xff, 0x00, 0x00}, /* mask */
  1365.     {"REP", itRep, OP1,0,
  1366.      0xf3, 0x00, 0x00, /* opcode */
  1367. 0xff, 0x00, 0x00}, /* mask */
  1369.     {"REPNE", itRepNe, OP1,0,
  1370.      0xf2, 0x00, 0x00, /* opcode */
  1371. 0xff, 0x00, 0x00}, /* mask */
  1373.     {"RET", itRet,        OP1,0,
  1374.      0xc3, 0x00, 0x00, /* opcode */
  1375. 0xff, 0x00, 0x00}, /* mask */
  1377.     {"RET", itRetI,       OP1|D16,0,
  1378.      0xc2, 0x00, 0x00, /* opcode */
  1379. 0xff, 0x00, 0x00}, /* mask */
  1381.     {"RET", itRetSeg,     OP1,0,
  1382.      0xcb, 0x00, 0x00, /* opcode */
  1383. 0xff, 0x00, 0x00}, /* mask */
  1385.     {"RET", itRetSegI,    OP1|D16,0,
  1386.      0xca, 0x00, 0x00, /* opcode */
  1387. 0xff, 0x00, 0x00}, /* mask */
  1389.     {"SAHF", itSahf,      OP1,0,
  1390.      0x9e, 0x00, 0x00, /* opcode */
  1391. 0xff, 0x00, 0x00}, /* mask */
  1393.     {"SS", itSs,          OP1,0,
  1394.      0x36, 0x00, 0x00, /* opcode */
  1395. 0xff, 0x00, 0x00}, /* mask */
  1397.     {"STC", itStc,        OP1,0,
  1398.      0xf9, 0x00, 0x00, /* opcode */
  1399. 0xff, 0x00, 0x00}, /* mask */
  1401.     {"STD", itStd,        OP1,0,
  1402.      0xfd, 0x00, 0x00, /* opcode */
  1403. 0xff, 0x00, 0x00}, /* mask */
  1405.     {"STI", itSti,        OP1,0,
  1406.      0xfb, 0x00, 0x00, /* opcode */
  1407. 0xff, 0x00, 0x00}, /* mask */
  1409.     {"WAIT", itWait,      OP1,0,
  1410.      0x9b, 0x00, 0x00, /* opcode */
  1411. 0xff, 0x00, 0x00}, /* mask */
  1413.     {"XLAT", itXlat,      OP1|WFUL,0,
  1414.      0xd7, 0x00, 0x00, /* opcode */
  1415. 0xff, 0x00, 0x00}, /* mask */
  1417.     /* 7 bits mask */
  1419.     {"ADC", itAdcItoA,    SF|WFUL|IMM|AX,0,
  1420.      0x14, 0x00, 0x00, /* opcode */
  1421. 0xfe, 0x00, 0x00}, /* mask */
  1423.     {"ADD", itAddItoA,    SF|WFUL|IMM|AX,0,
  1424.      0x04, 0x00, 0x00, /* opcode */
  1425. 0xfe, 0x00, 0x00}, /* mask */
  1427.     {"AND", itAndItoA,    SF|WFUL|IMM|AX,0,
  1428.      0x24, 0x00, 0x00, /* opcode */
  1429. 0xfe, 0x00, 0x00}, /* mask */
  1431.     {"CMP", itCmpIwiA,    SF|WFUL|IMM|AX,0,
  1432.      0x3c, 0x00, 0x00, /* opcode */
  1433. 0xfe, 0x00, 0x00}, /* mask */
  1435.     {"CMPS", itCmps,      OP1|WFUL,0,
  1436.      0xa6, 0x00, 0x00, /* opcode */
  1437. 0xfe, 0x00, 0x00}, /* mask */
  1439.     {"IMUL", itImulRMwiI,  OP1|SEXT|MODRM|REG|IMM,0,
  1440.      0x69, 0x00, 0x00, /* opcode */
  1441. 0xfd, 0x00, 0x00}, /* mask */
  1443.     {"IN", itInF,         OP1|WFUL|PORT|AX,0,
  1444.      0xe4, 0x00, 0x00, /* opcode */
  1445. 0xfe, 0x00, 0x00}, /* mask */
  1447.     {"IN", itInV,         OP1|WFUL|AX,0,
  1448.      0xec, 0x00, 0x00, /* opcode */
  1449. 0xfe, 0x00, 0x00}, /* mask */
  1451.     {"INS", itIns,        OP1|WFUL,0,
  1452.      0x6c, 0x00, 0x00, /* opcode */
  1453. 0xfe, 0x00, 0x00}, /* mask */
  1455.     {"LODS", itLods,      OP1|WFUL,0,
  1456.      0xac, 0x00, 0x00, /* opcode */
  1457. 0xfe, 0x00, 0x00}, /* mask */
  1459.     {"MOV", itMovRMtoS,   OP1|DISR|MODRM|SREG3,0,
  1460.      0x8c, 0x00, 0x00, /* opcode */
  1461. 0xfd, 0x00, 0x00}, /* mask */
  1463.     {"MOVS", itMovs,      OP1|WFUL,0,
  1464.      0xa4, 0x00, 0x00, /* opcode */
  1465. 0xfe, 0x00, 0x00}, /* mask */
  1467.     {"OR", itOrItoA,      SF|WFUL|IMM|AX,0,
  1468.      0x0c, 0x00, 0x00, /* opcode */
  1469. 0xfe, 0x00, 0x00}, /* mask */
  1471.     {"OUT", itOutF,       OP1|WFUL|PORT|AX,0,
  1472.      0xe6, 0x00, 0x00, /* opcode */
  1473. 0xfe, 0x00, 0x00}, /* mask */
  1475.     {"OUT", itOutV,       OP1|WFUL|AX,0,
  1476.      0xee, 0x00, 0x00, /* opcode */
  1477. 0xfe, 0x00, 0x00}, /* mask */
  1479.     {"OUTS", itOuts,      OP1|WFUL,0,
  1480.      0x6e, 0x00, 0x00, /* opcode */
  1481. 0xfe, 0x00, 0x00}, /* mask */
  1483.     {"PUSH", itPushI,     OP1|SEXT|IMM,0,
  1484.      0x68, 0x00, 0x00, /* opcode */
  1485. 0xfd, 0x00, 0x00}, /* mask */
  1487.     {"SBB", itSbbIfrA,    SF|WFUL|IMM|AX,0,
  1488.      0x1c, 0x00, 0x00, /* opcode */
  1489. 0xfe, 0x00, 0x00}, /* mask */
  1491.     {"SCAS", itScas,      OP1|WFUL,0,
  1492.      0xae, 0x00, 0x00, /* opcode */
  1493. 0xfe, 0x00, 0x00}, /* mask */
  1495.     {"SHRO", itRolRMby1,  OP1|WFUL|MODRM|TTT,0,
  1496.      0xd0, 0x00, 0x00, /* opcode */
  1497. 0xfe, 0x00, 0x00}, /* mask */
  1499.     {"SHRO", itRolRMbyCL,  OP1|WFUL|MODRM|TTT|CL,0,
  1500.      0xd2, 0x00, 0x00, /* opcode */
  1501. 0xfe, 0x00, 0x00}, /* mask */
  1503.     {"SHRO", itRolRMbyI,  OP1|WFUL|MODRM|TTT|I8,0,
  1504.      0xc0, 0x00, 0x00, /* opcode */
  1505. 0xfe, 0x00, 0x00}, /* mask */
  1507.     {"STOS", itStos,      OP1|WFUL,0,
  1508.      0xaa, 0x00, 0x00, /* opcode */
  1509. 0xfe, 0x00, 0x00}, /* mask */
  1511.     {"SUB", itSubIfrA,    SF|WFUL|IMM|AX,0,
  1512.      0x2c, 0x00, 0x00, /* opcode */
  1513. 0xfe, 0x00, 0x00}, /* mask */
  1515.     {"TEST", itTestRManR,  OP1|WFUL|MODRM|REG,0,
  1516.      0x84, 0x00, 0x00, /* opcode */
  1517. 0xfe, 0x00, 0x00}, /* mask */
  1519.     {"TEST", itTestIanA,  SF|WFUL|IMM|AX,0,
  1520.      0xa8, 0x00, 0x00, /* opcode */
  1521. 0xfe, 0x00, 0x00}, /* mask */
  1523.     {"XCHG", itXchgRM,    OP1|WFUL|MODRM|REG,0,
  1524.      0x86, 0x00, 0x00, /* opcode */
  1525. 0xfe, 0x00, 0x00}, /* mask */
  1527.     {"XOR", itXorItoA,     SF|WFUL|IMM|AX,0,
  1528.      0x34, 0x00, 0x00, /* opcode */
  1529. 0xfe, 0x00, 0x00}, /* mask */
  1531.     /* 6 bits mask */
  1533.     {"ADC", itAdcRMtoRM,  OP1|DISR|WFUL|MODRM|REG,0,
  1534.      0x10, 0x00, 0x00, /* opcode */
  1535. 0xfc, 0x00, 0x00}, /* mask */
  1537.     {"ADD", itAddRMtoRM,  OP1|DISR|WFUL|MODRM|REG,0,
  1538.      0x00, 0x00, 0x00, /* opcode */
  1539. 0xfc, 0x00, 0x00}, /* mask */
  1541.     {"AND", itAndRMtoRM,  OP1|DISR|WFUL|MODRM|REG,0,
  1542.      0x20, 0x00, 0x00, /* opcode */
  1543. 0xfc, 0x00, 0x00}, /* mask */
  1545.     {"CMP", itCmpRMwiRM,  OP1|DISR|WFUL|MODRM|REG,0,
  1546.      0x38, 0x00, 0x00, /* opcode */
  1547. 0xfc, 0x00, 0x00}, /* mask */
  1549.     {"MOV", itMovRMtoMR,  OP1|DISR|WFUL|MODRM|REG,0,
  1550.      0x88, 0x00, 0x00, /* opcode */
  1551. 0xfc, 0x00, 0x00}, /* mask */
  1553.     {"MOV", itMovAMtoMA,  SF|DISR|WFUL|DIS|AX,0,
  1554.      0xa0, 0x00, 0x00, /* opcode */
  1555. 0xfc, 0x00, 0x00}, /* mask */
  1557.     {"OR", itOrRMtoRM,    OP1|DISR|WFUL|MODRM|REG,0,
  1558.      0x08, 0x00, 0x00, /* opcode */
  1559. 0xfc, 0x00, 0x00}, /* mask */
  1561.     {"POP", itPopS,       OP1|REG,0,
  1562.      0x07, 0x00, 0x00, /* opcode */
  1563. 0xe7, 0x00, 0x00}, /* mask */
  1565.     {"PUSH", itPushS,     OP1|SREG2,0,
  1566.      0x06, 0x00, 0x00, /* opcode */
  1567. 0xe7, 0x00, 0x00}, /* mask */
  1569.     {"SBB", itSbbRMfrRM,  OP1|DISR|WFUL|MODRM|REG,0,
  1570.      0x18, 0x00, 0x00, /* opcode */
  1571. 0xfc, 0x00, 0x00}, /* mask */
  1573.     {"SUB", itSubRMfrRM,  OP1|DISR|WFUL|MODRM|REG,0,
  1574.      0x28, 0x00, 0x00, /* opcode */
  1575. 0xfc, 0x00, 0x00}, /* mask */
  1577.     {"XOR", itXorRMtoRM,   OP1|DISR|WFUL|MODRM|REG,0,
  1578.      0x30, 0x00, 0x00, /* opcode */
  1579. 0xfc, 0x00, 0x00}, /* mask */
  1581.     /* 5 bits mask */
  1583.     {"DEC", itDecR,       SF|REG,0,
  1584.      0x48, 0x00, 0x00, /* opcode */
  1585. 0xf8, 0x00, 0x00}, /* mask */
  1587.     {"INC", itIncR,       SF|REG,0,
  1588.      0x40, 0x00, 0x00, /* opcode */
  1589. 0xf8, 0x00, 0x00}, /* mask */
  1591.     {"POP", itPopR,       SF|REG,0,
  1592.      0x58, 0x00, 0x00, /* opcode */
  1593. 0xf8, 0x00, 0x00}, /* mask */
  1595.     {"PUSH", itPushR,     SF|REG,0,
  1596.      0x50, 0x00, 0x00, /* opcode */
  1597. 0xf8, 0x00, 0x00}, /* mask */
  1599.     {"XCHG", itXchgA,     SF|REG|AX,0,
  1600.      0x90, 0x00, 0x00, /* opcode */
  1601. 0xf8, 0x00, 0x00}, /* mask */
  1603.     /* 4 bits mask */
  1605.     {"CJMPS", itCjmp,     OP1|TTTN|D8,0,
  1606.      0x70, 0x00, 0x00, /* opcode */
  1607. 0xf0, 0x00, 0x00}, /* mask */
  1609.     {"MOV", itMovItoR,    SF|WFUL|REG|IMM,0,
  1610.      0xb0, 0x00, 0x00, /* opcode */
  1611. 0xf0, 0x00, 0x00}, /* mask */
  1614.     {NULL, 0, 0,0,
  1615.      0x00, 0x00, 0x00, /* opcode */
  1616. 0x00, 0x00, 0x00}, /* mask */
  1618.     };
  1620. /* reg[d32=0,1][reg field=0 - 7] */
  1622. LOCAL char *reg[2][8] = 
  1623.     {
  1624.     {"AX",  "CX",  "DX",  "BX",  "SP",  "BP",  "SI",  "DI"},
  1625.     {"EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"},
  1626.     };
  1628. /* regw[d32=0,1][w bit=0,1][reg field=0 - 7] */
  1630. LOCAL char *regw[2][2][8] = 
  1631.     {
  1632.     {{"AL",  "CL",  "DL",  "BL",  "AH",  "CH",  "DH",  "BH"},
  1633.      {"AX",  "CX",  "DX",  "BX",  "SP",  "BP",  "SI",  "DI"}},
  1634.     {{"AL",  "CL",  "DL",  "BL",  "AH",  "CH",  "DH",  "BH"},
  1635.      {"EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"}},
  1636.     };
  1638. LOCAL char * regmmx[8] = /* MMX registers */
  1639.     {
  1640.     "MM0", "MM1", "MM2", "MM3", "MM4", "MM5", "MM6", "MM7"
  1641.     };
  1642.     
  1643. LOCAL char * regxmm[8] = /* XMM registers */
  1644.     {
  1645.     "XMM0", "XMM1", "XMM2", "XMM3", "XMM4", "XMM5", "XMM6", "XMM7"
  1646.     };    
  1648. LOCAL char * gg[4] = /* MMX instructions packed granularities */
  1649.     {
  1650.     "B", /* packed bytes                          */
  1651.     "W", /* packed words                          */
  1652.     "D", /* packed double words                   */
  1653.     "Q" /* packed quad words                     */
  1654.     };
  1656. /* immL[d32=0,1][w bit=0,1] */
  1658. LOCAL char immL[2][2] = { {1,2},{1,4} };
  1660. /* segment registers, sreg3[sreg3=0-7] */
  1662. LOCAL char *sreg3[8] = { "ES","CS","SS","DS","FS","GS","--","--" };
  1664. /* segment registers, sreg2[sreg2=0-3] */
  1666. LOCAL char *sreg2[4] = { "ES","CS","SS","DS" };
  1668. /* shift rotate opecodes, ttt[ttt=0-7] */
  1670. LOCAL char *ttt[8] = { "ROL","ROR","RCL","RCR","SHL","SHR","---","SAR" };
  1672. /* conditional jump opecodes, tttn[tttn=0-15] */
  1674. LOCAL char *tttn[16] = 
  1675.     { 
  1676.     "O","NO","B","NB","E","NE","BE","NBE",
  1677.     "S","NS","P","NP","L","NL","LE","NLE"
  1678.     };
  1680. /* control registers, */
  1682. LOCAL char *eeec[8] = { "CR0","---","CR2","CR3","CR4","---","---","---" };
  1684. /* debug registers, */
  1686. LOCAL char *eeed[8] = { "DR0","DR1","DR2","DR3","DR4","DR5","DR6","DR7" };
  1688. /* test registers, */
  1690. LOCAL char *eeet[8] = { "---","---","---","---","---","---","TR6","TR7" };
  1692. /* modrm format */
  1694. LOCAL char *modrm[2][3][8] = 
  1695.     {
  1696.     {{"[BX+SI]", "[BX+DI]",
  1697.       "[BP+SI]", "[BP+DI]",
  1698.       "[SI]", "[DI]",
  1699.       "0x%04x", "[BX]"},
  1700.      {"[BX+SI+%d]", "[BX+DI+%d]", 
  1701.       "[BX+SI+%d]", "[BX+DI+%d]", 
  1702.       "[SI+%d]", "[DI+%d]", 
  1703.       "[BP+%d]", "[BX+%d]"},
  1704.      {"[BX+SI+%d]", "[BX+DI+%d]", 
  1705.       "[BX+SI+%d]", "[BX+DI+%d]",
  1706.       "[SI+%d]", "[DI+%d]", 
  1707.       "[BP+%d]", "[BX+%d]"}},
  1708.     {{"[EAX]", "[ECX]", 
  1709.       "[EDX]", "[EBX]",
  1710.       "sib", "0x%08x", 
  1711.       "[ESI]", "[EDI]"},
  1712.      {"[EAX+%d]", "[ECX+%d]", 
  1713.       "[EDX+%d]", "[EBX+%d]",
  1714.       "sib", "[EBP+%d]", 
  1715.       "[ESI+%d]", "[EDI+%d]"},
  1716.      {"[EAX+%d]", "[ECX+%d]", 
  1717.       "[EDX+%d]", "[EBX+%d]",
  1718.       "sib", "[EBP+%d]", 
  1719.       "[ESI+%d]", "[EDI+%d]"}}
  1720.     };
  1722. /* sib format */
  1724. LOCAL char *sib[3][8] = 
  1725.     {
  1726.     {"[EAX+(%3s%2s)]", "[ECX+(%3s%2s)]", 
  1727.      "[EDX+(%3s%2s)]", "[EBX+(%3s%2s)]",
  1728.      "[ESP+(%3s%2s)]", "[0x%08x+(%3s%2s)]",
  1729.      "[ESI+(%3s%2s)]", "[EDI+(%3s%2s)]"},
  1730.     {"[EAX+(%3s%2s)+%d]", "[ECX+(%3s%2s)+%d]",
  1731.      "[EDX+(%3s%2s)+%d]", "[EBX+(%3s%2s)+%d]",
  1732.      "[ESP+(%3s%2s)+%d]", "[EBP+(%3s%2s)+%d]",
  1733.      "[ESI+(%3s%2s)+%d]", "[EDI+(%3s%2s)+%d]"},
  1734.     {"[EAX+(%3s%2s)+%d]", "[ECX+(%3s%2s)+%d]",
  1735.      "[EDX+(%3s%2s)+%d]", "[EBX+(%3s%2s)+%d]",
  1736.      "[ESP+(%3s%2s)+%d]", "[EBP+(%3s%2s)+%d]",
  1737.      "[ESI+(%3s%2s)+%d]", "[EDI+(%3s%2s)+%d]"}
  1738.     };
  1740. /* scale */
  1742. LOCAL char *scale[4] = { "x1","x2","x4","x8" };
  1744. /* indexR */
  1746. LOCAL char *indexR[8] = { "EAX","ECX","EDX","EBX","no-","EBP","ESI","EDI" };
  1748. /* st */
  1750. LOCAL char *st = "ST(%d)";
  1752. /* mf */
  1754. LOCAL char *mf[4] = { "r32", "---", "r64", "---" };
  1756. /* CMPSS variations */
  1757. LOCAL char *cmpss[8] = { "CMPEQSS",            /* imm = 0 */
  1758.                          "CMPLTSS",            /* imm = 1 */
  1759.                          "CMPLESS",            /* imm = 2 */
  1760.                          "CMPUNORDSS",         /* imm = 3 */
  1761.                          "CMPNEQSS",           /* imm = 4 */
  1762.                          "CMPNLTSS",           /* imm = 5 */
  1763.                          "CMPNLESS",           /* imm = 6 */
  1764.                          "CMPORDSS" };         /* imm = 7 */
  1766. LOCAL char *cmpps[8] = { "CMPEQPS",            /* imm = 0 */
  1767.                          "CMPLTPS",            /* imm = 1 */
  1768.                          "CMPLEPS",            /* imm = 2 */
  1769.                          "CMPUNORDPS",         /* imm = 3 */
  1770.                          "CMPNEQPS",           /* imm = 4 */
  1771.                          "CMPNLTPS",           /* imm = 5 */
  1772.                          "CMPNLEPS",           /* imm = 6 */
  1773.                          "CMPORDPS" };         /* imm = 7 */
  1775. LOCAL int prefixAsize = 0; /* prefix Address Size, 0x67 */
  1776. LOCAL int prefixOsize = 0; /* prefix Operand Size, 0x66 */
  1778. int dsmAsize = 1; /* 32 bits address size */
  1779. int dsmDsize = 1; /* 32 bits data size */
  1780. int dsmDebug = 0; /* debug flag */
  1782. char * instKeeper = NULL; /* keeps instruction string */
  1784. /* forward declarations */
  1786. LOCAL void dsmPass1 (FORMAT_X *pX, FORMAT_Y *pY);
  1787. LOCAL void dsmPass2 (FORMAT_X *pX, FORMAT_Y *pY);
  1789. /*******************************************************************************
  1790. *
  1791. * dsmFind - disassemble one instruction
  1792. *
  1793. * This routine figures out which instruction is pointed to by pD.
  1794. *
  1795. * RETURNS: N/A
  1796. */
  1798. LOCAL void dsmFind
  1799.     (
  1800.     FAST UCHAR *pD, /* Pointer to the instruction */
  1801.     FORMAT_X *pX, /* Pointer to the FORMAT_X */
  1802.     FORMAT_Y *pY  /* Pointer to the FORMAT_Y */
  1803.     )
  1804.     {
  1805.     INST *pI;
  1806.     
  1807.     pX->pD = (char *)pD;
  1809.     if (prefixAsize)
  1810.         pX->a32 = ~dsmAsize & 0x1;
  1811.     else
  1812.         pX->a32 = dsmAsize;
  1814.     if (prefixOsize)
  1815.         pX->d32 = ~dsmDsize & 0x1;
  1816.     else
  1817.         pX->d32 = dsmDsize;
  1819.     pX->w = 1;
  1821.     for (pI = &inst[0]; pI->mask0 != 0; pI++)
  1822.         {
  1823.         if ((pI->op0 == (*pD & pI->mask0)) &&
  1824.          (pI->op1 == (*(pD + 1) & pI->mask1)) &&
  1825.          (pI->op2 == (*(pD + 2) & pI->mask2)))
  1826.          {
  1827.     break;
  1828.          }
  1829. }
  1830.     
  1831.     if (pI->mask0 == 0)
  1832. {
  1833.         errnoSet (S_dsmLib_UNKNOWN_INSTRUCTION);
  1834. if (dsmDebug)
  1835.             printf ("unknown instruction.  pD = 0x%x %x %x %xn",(UCHAR)*pD,
  1836.                 (UCHAR)*(pD + 1), (UCHAR)*(pD + 2), (UCHAR)*(pD + 3));
  1837.         return;
  1838. }
  1839.     
  1840.     pX->pI = pI;
  1841.     
  1842.     dsmPass1 (pX, pY);
  1844.     if (pX->pI->type == itAsize) /* set prefixAsize for next inst. */
  1845. prefixAsize = 1;
  1846.     else
  1847. prefixAsize = 0;
  1849.     if (pX->pI->type == itOsize) /* set prefixOsize for next inst. */
  1850. prefixOsize = 1;
  1851.     else
  1852. prefixOsize = 0;
  1854.     if (dsmDebug)
  1855. {
  1856.         printf ("FORMAT_X INST   pOpc = %sn", pX->pI->pOpc);
  1857.         printf ("                type = 0x%xn", pX->pI->type);
  1858.         printf ("                flag = 0x%xn", pX->pI->flag);
  1859.         printf ("        pD = 0x%x %x %x %xn", (UCHAR)*pX->pD,
  1860.             (UCHAR)*(pX->pD + 1), (UCHAR)*(pX->pD + 2), (UCHAR)*(pX->pD + 3));
  1861.         printf ("        lenO, lenD, lenI = %d, %d, %dn", pX->lenO,
  1862.             pX->lenD, pX->lenI);
  1863.         printf ("        d32, a32 = %d, %dn", pX->d32, pX->a32);
  1864.         printf ("        modrm, sib = %d, %dn", pX->modrm, pX->sib);
  1865.         printf ("        w s d = %d %d %dn", pX->w, pX->s, pX->d);
  1866.         printf ("        mod reg rm = %d %d %dn", pX->mod, pX->reg, pX->rm);
  1867.         printf ("        ss index base = %d %d %dn", pX->ss, pX->index,
  1868.     pX->base);
  1869. }
  1870.     
  1871.     dsmPass2 (pX, pY);
  1872.     
  1873.     if (dsmDebug)
  1874. {
  1875.         printf ("FORMAT_Y len = %dn", pY->len);
  1876.         printf ("        obuf = %sn", pY->obuf);
  1877.         printf ("        rbuf = %sn", pY->rbuf);
  1878.         printf ("        mbuf = %sn", pY->mbuf);
  1879.         printf ("        ibuf = %sn", pY->ibuf);
  1880.         printf ("        dbuf = %sn", pY->dbuf);
  1881. }
  1883.     return;
  1884.     }
  1886. /*******************************************************************************
  1887. *
  1888. * dsmPass1 - fill FORMAT_X structure.
  1889. *
  1890. * RETURNS: N/A
  1891. */
  1893. LOCAL void dsmPass1
  1894.     (
  1895.     FORMAT_X *pX,
  1896.     FORMAT_Y *pY 
  1897.     )
  1898.     {
  1899.     char *pS;
  1901.     /* pX->lenO = size of Opcode in bytes = 1, 2, or 3 */
  1903.     if (pX->pI->flag & OP3)
  1904.         pX->lenO = 3;
  1905.     else if (pX->pI->flag & OP2) 
  1906. pX->lenO = 2;
  1907.     else
  1908. pX->lenO = 1;
  1910.     /* get a Opecode */
  1912.     if (pX->pI->flag & TTTN)
  1913. {
  1914. instKeeper = pX->pI->pOpc;
  1915. pS = tttn[*(pX->pD + pX->lenO - 1) & 0x0f];
  1916. if (pX->pI->type == itCjmp)
  1917.     {
  1918.     bcopy ("J  ", pY->obuf, 3);
  1919.     bcopy (pS, &pY->obuf[1], strlen (pS));
  1920.     }
  1921. if (pX->pI->type == itCset)
  1922.     {
  1923.     bcopy ("SET", pY->obuf, 3);
  1924.     bcopy (pS, &pY->obuf[3], strlen (pS));
  1925.     }
  1926. if (pX->pI->type == itCmovcc)
  1927.     {
  1928.     bcopy ("CMOV", pY->obuf, 4);
  1929.     bcopy (pS, &pY->obuf[4], strlen (pS));
  1930.     }
  1931. pX->pI->pOpc = pY->obuf;
  1932. }
  1934.     if (pX->pI->flag & TTT)
  1935. pX->pI->pOpc = ttt[(*(pX->pD + pX->lenO) & 0x38) >> 3];
  1937.     /* get an MMX granularity */
  1939.     if (pX->pI->flag & GG)
  1940. {
  1941. instKeeper = pX->pI->pOpc;
  1942. pS = gg[*(pX->pD + pX->lenO - 1) & 0x03];
  1943. bcopy (pX->pI->pOpc, pY->obuf, strlen (pX->pI->pOpc));
  1944. bcopy (pS, &pY->obuf[strlen (pX->pI->pOpc)], strlen (pS));
  1945. pX->pI->pOpc = pY->obuf;
  1946. }
  1948.     /* get a W */
  1950.     if (pX->pI->flag & WFUL)
  1951. {
  1952. pX->w = *(pX->pD + pX->lenO - 1) & 0x01;
  1953. if (pX->pI->type == itMovItoR)
  1954.     pX->w = (*pX->pD & 0x08) >> 3;
  1955. }
  1957.     /* get a S */
  1959.     if (pX->pI->flag & SEXT)
  1960. pX->s = (*(pX->pD + pX->lenO - 1) & 0x02) >> 1;
  1962.     /* 
  1963.      * get a D 
  1964.      *
  1965.      * jhw - for our representation of data direction:
  1966.      *           pX->d = 0 is an r/m -> reg transfer 
  1967.      *           pX->d = 1 is a  reg -> r/m transfer
  1968.      */
  1970.     if (pX->pI->flag & DISR)
  1971.         {
  1973.         /* 
  1974.  * MMX instructions reference least significant opcode byte bit 4 for 
  1975.          * data direction information.
  1976.          *
  1977.          * for Intel's representation:
  1978.          *    D bit = 0 is an r/m -> reg transfer 
  1979.          *    D bit = 1 is a  reg -> r/m transfer 
  1980.          */
  1981.                
  1982.         if (pX->pI->flag & (MMXREG|MMXRM))
  1983.             pX->d = (*(pX->pD + pX->lenO - 1) & 0x10) >> 4;
  1985.         /* 
  1986.  * XMM instructions reference least significant opcode byte bit 0 for 
  1987.          * data direction information.
  1988.          *
  1989.          * for Intel's representation:
  1990.          *    D bit = 0 is an r/m -> reg transfer 
  1991.          *    D bit = 1 is a  reg -> r/m transfer 
  1992.          */
  1993.       
  1994.         else if (pX->pI->flag2 & (XMMREG|XMMRM))
  1995.              pX->d = (*(pX->pD + pX->lenO - 1) & 0x01);
  1997.         /* 
  1998.  * all others use least significant byte bit 1 for 
  1999.          * data direction information.
  2000.          * 
  2001.          * BUT... all other instructions use the opposite representation!
  2002.          *
  2003.  * for Intel's representation:
  2004.          *    D bit = 1 is an r/m -> reg transfer 
  2005.          *    D bit = 0 is a  reg -> r/m transfer 
  2006.          */
  2008.         else
  2009.             /* invert the state */
  2010.             pX->d = (*(pX->pD + pX->lenO - 1) & 0x02) ? 0 : 1;
  2012. /* evaluate the special case instructions! */
  2014. /*
  2015.  * PEXTRW is a SIMD instruction, but it operates on MMX
  2016.  * register. Therefore it deviates from the above rules.
  2017.  * The DISR flag is included in the definition because
  2018.  * the data dir is reg -> r/m regardless.
  2019.  */
  2021. if (pX->pI->type == itPextrw)
  2022.             pX->d = 1;
  2023. }
  2025.     /* get a REG */
  2027.     if (pX->pI->flag & SREG2)
  2028.         pX->reg = (*pX->pD & 0x18) >> 3;
  2029.     if (pX->pI->flag & SREG3)
  2030.         pX->reg = (*(pX->pD + pX->lenO) & 0x38) >> 3;
  2031.     if ( (pX->pI->flag & REG) || 
  2032.       (pX->pI->flag & MMXREG) ||
  2033.  (pX->pI->flag2 & XMMREG))    
  2034. {
  2035. if (pX->pI->flag & SF)
  2036.     pX->reg = *pX->pD & 0x07;
  2037. else if (pX->pI->flag & MODRM)
  2038.     pX->reg = (*(pX->pD + pX->lenO) & 0x38) >> 3;
  2039.         else
  2040.             {
  2041.             printf ("dsmLib.c error 0: Invalid opcode flag definition.n");
  2042.             printf ("top = 0x%02x 0x%02x 0x%02x 0x%02xn",
  2043.                     (UCHAR)*pX->pD, (UCHAR)*(pX->pD + 1),
  2044.                     (UCHAR)*(pX->pD + 2), (UCHAR)*(pX->pD + 3));
  2045.             }
  2046. }
  2047.     if (pX->pI->flag & EEE)
  2048.         pX->reg = (*(pX->pD + pX->lenO) & 0x38) >> 3;
  2050.     /* get a ST for 387*/
  2052.     if (pX->pI->flag & ST)
  2053. pX->st = *(pX->pD + pX->lenO - 1) & 0x07;
  2055.     /* get a MF for 387*/
  2057.     if (pX->pI->flag & MF)
  2058. pX->mf = (*pX->pD & 0x06) >> 1;
  2060.     /* get a FD for 387 */
  2062.     if (pX->pI->flag & FD)
  2063. pX->fd = *pX->pD & 0x04;
  2065.     /* get a size of Immediate, 0, 1, 2, 4 */
  2067.     if (pX->pI->flag & I8)
  2068. pX->lenI = 1;
  2070.     if (pX->pI->flag & IMM)
  2071. {
  2072. if (pX->s)
  2073.     pX->lenI = 1;
  2074. else
  2075.     pX->lenI = immL[(int)pX->d32][(int)pX->w];
  2076. }
  2078.     if (pX->pI->flag & OFFSEL)
  2079. {
  2081. /* 
  2082.  * CALL/JMP ptr16:16/32
  2083.  * The operand size attribute determines the size of offset (16/32).
  2084.  * The operand size attribute is the D flag in the segment desc.
  2085.  * The instruction prefix 0x66 can be used to select an operand
  2086.  * size other than the default.
  2087.  */
  2089. if (pX->d32)
  2090.     pX->lenI = 4;
  2091. else
  2092.     pX->lenI = 2;
  2093. }
  2095.     if ((pX->pI->flag & D16L8) || (pX->pI->flag & PORT))
  2096. pX->lenI = 2;
  2098.     /* get a size of Displacement, 0, 1, 2, 4 */
  2100.     if (pX->pI->flag & D8)
  2101. pX->lenD = 1;
  2103.     if (pX->pI->flag & (DIS|D16))
  2104. {
  2105. if (pX->pI->flag & WFUL)
  2106.     {
  2107.     if (pX->pI->type == itMovAMtoMA)
  2108. pX->lenD = immL[(int)pX->a32][(int)pX->w];
  2109.     else
  2110. pX->lenD = immL[(int)pX->d32][(int)pX->w];
  2111.     }
  2112. else
  2113.     pX->lenD = immL[(int)pX->d32][(int)pX->w];
  2114. }
  2116.     if (pX->pI->flag & OFFSEL)
  2117. pX->lenD = 2;
  2119.     if (pX->pI->flag & D16L8)
  2120. pX->lenD = 1;
  2122.     if (pX->pI->flag & MODRM)
  2123. {
  2124. pX->modrm = 1;
  2125. pY->pD = pX->pD + pX->lenO;
  2126. pX->mod = (*pY->pD & 0xc0) >> 6;
  2127. pX->rm = *pY->pD & 0x07;
  2128. if ((pX->a32 == 0) && (pX->mod != 3))
  2129.     {
  2130.     if (pX->mod == 1)
  2131. pX->lenD = 1;
  2132.     else if ((pX->mod == 2) || ((pX->mod == 0) && (pX->rm == 6)))
  2133. pX->lenD = 2;
  2134.     }
  2135. if ((pX->a32 == 1) && (pX->mod != 3))
  2136.     {
  2137.     if (pX->rm == 4)
  2138. {
  2139.         pX->sib = 1;
  2140.         pY->pD = pX->pD + pX->lenO + pX->modrm;
  2141.         pX->ss = (*pY->pD & 0xc0) >> 6;
  2142.         pX->index = (*pY->pD & 0x38) >> 3;
  2143.         pX->base = *pY->pD & 0x07;
  2144.         if (pX->mod == 1)
  2145.     pX->lenD = 1;
  2146.         else if ((pX->mod == 2) || ((pX->mod == 0) && (pX->base == 5)))
  2147.     pX->lenD = 4;
  2148. }
  2149.     else
  2150. {
  2151.         if (pX->mod == 1)
  2152.     pX->lenD = 1;
  2153.         else if ((pX->mod == 2) || ((pX->mod == 0) && (pX->rm == 5)))
  2154.     pX->lenD = 4;
  2155. }
  2156.     }
  2157. }
  2158.     }
  2159.     
  2160. /*******************************************************************************
  2161. *
  2162. * dsmPass2 - fill FORMAT_Y structure.
  2163. *
  2164. * RETURNS: N/A
  2165. */
  2167. LOCAL void dsmPass2
  2168.     (
  2169.     FORMAT_X *pX,
  2170.     FORMAT_Y *pY 
  2171.     )
  2172.     {
  2173.     FAST char *pS = 0;
  2175.     /* get an instruction length, pY->len */
  2177.     pY->len = pX->lenO + pX->modrm + pX->sib + pX->lenD + pX->lenI;
  2179.     /* get an opecode pointer, pY->pOpc */
  2181.     pY->pOpc = pX->pI->pOpc;
  2183.     if (pX->pI->flag & MF)
  2184.         {
  2185.         pS = pY->obuf;
  2186.         if (pX->mf & 1)
  2187.     {
  2188.     bcopy (pX->pI->pOpc, pS + 1, strlen (pX->pI->pOpc));
  2189.     bcopy ("FI", pS, 2);
  2190.     }
  2191.         else
  2192.     {
  2193.     bcopy (pX->pI->pOpc, pS, strlen (pX->pI->pOpc));
  2194.     strcat (pS, mf[(int)pX->mf]);
  2195.     }
  2196.         pY->pOpc = pY->obuf;
  2197.         }
  2199.     if (pX->pI->flag & POP)
  2200.         {
  2201.         bcopy (pX->pI->pOpc, pY->obuf, strlen (pX->pI->pOpc));
  2202.         strcat (pY->obuf, "P");
  2203.         pY->pOpc = pY->obuf;
  2204.         }
  2206.     /* get a register operand buffer, pY->rbuf */
  2208.     if (pX->pI->flag & SREG2)
  2209.         bcopy (sreg2[(int)pX->reg], pY->rbuf, strlen (sreg2[(int)pX->reg]));
  2211.     if (pX->pI->flag & SREG3)
  2212.         bcopy (sreg3[(int)pX->reg], pY->rbuf, strlen (sreg3[(int)pX->reg]));
  2214.     /* get register number */
  2216.     if (pX->pI->flag & REG)
  2217.         {
  2218.         if (pX->pI->flag & WFUL)
  2219.     pS = regw[(int)pX->d32][(int)pX->w][(int)pX->reg];
  2220.         else
  2221.     pS = reg[(int)pX->d32][(int)pX->reg];
  2222.         bcopy (pS, pY->rbuf, strlen (pS));
  2223.         }
  2225.     /* get MMX register number */
  2227.     if (pX->pI->flag & MMXREG)
  2228. {
  2229. pS = regmmx[ (int) pX->reg];
  2230. bcopy (pS, pY->rbuf, strlen (pS));
  2231. }
  2233.     /* XMM register */
  2235.     if (pX->pI->flag2 & XMMREG)
  2236.         {
  2237. pS = regxmm[ (int) pX->reg];
  2238. memcpy ((void *) pY->rbuf, (void *) pS, strlen (pS));
  2239.         }
  2242.     if (pX->pI->flag & EEE)
  2243.         {
  2244.         if (pX->pI->type == itMovC)
  2245.             pS = eeec[(int)pX->reg];
  2246.         else if (pX->pI->type == itMovD)
  2247.             pS = eeed[(int)pX->reg];
  2248.         else if (pX->pI->type == itMovT)
  2249.             pS = eeet[(int)pX->reg];
  2250.         bcopy (pS, pY->rbuf, strlen (pS));
  2251.         pS = reg[(int)pX->d32][(int)pX->rm];
  2252.         bcopy (pS, pY->mbuf, strlen (pS));
  2253.         }
  2255.     if (pX->pI->flag & AX)
  2256.         {
  2257.         if (pX->pI->flag & WFUL)
  2258.     {
  2259.     if (pX->pI->type == itMovAMtoMA)
  2260.         pS = regw[(int)pX->a32][(int)pX->w][0];
  2261.     else
  2262.         pS = regw[(int)pX->d32][(int)pX->w][0];
  2263.     }
  2264.         else
  2265.     pS = reg[(int)pX->d32][0];
  2267.         if (pX->pI->flag & REG)
  2268.             bcopy (pS, pY->ibuf, strlen (pS));
  2269. else
  2270.             bcopy (pS, pY->rbuf, strlen (pS));
  2271.         }
  2273.     if (pX->pI->flag & ST)
  2274.         sprintf (pY->rbuf, st, pX->st);
  2275.     
  2276.     /* get a displacement operand buffer, pY->dbuf */
  2278.     if (pX->pI->flag & (D8|D16|DIS))
  2279.         {
  2280.         pY->pD = pX->pD + pX->lenO + pX->modrm + pX->sib;
  2281.         if (pX->lenD == 1)
  2282.     pY->addr = *(pY->pD);
  2283.         else if (pX->lenD == 2)
  2284.     pY->addr = *(short *)pY->pD;
  2285.         else if (pX->lenD == 4)
  2286.     {
  2287.     if (pX->pI->flag & D16)
  2288.         pY->addr = *(int *)pY->pD & 0x0000ffff;
  2289.     else
  2290.         pY->addr = *(int *)pY->pD;
  2291.     }
  2292. sprintf (pY->dbuf, "0x%x", pY->addr);
  2293.         }
  2295.     if (pX->pI->flag & OFFSEL)
  2296.         sprintf (pY->dbuf, "0x%x", *(USHORT *)(pX->pD + pX->lenO + pX->lenI));
  2297.     
  2298.     if (pX->pI->flag & D16L8)
  2299.         sprintf (pY->dbuf, "0x%x", *(UCHAR *)(pX->pD + pX->lenO + pX->lenI));
  2301.     /* get an immediate operand buffer, pY->ibuf */
  2303.     if (pX->pI->flag & (IMM|I8))
  2304.         {
  2305.         pY->pD = pX->pD + pX->lenO + pX->modrm + pX->sib + pX->lenD;
  2306.         if (pX->lenI == 1)
  2307.     {
  2308.     if (pX->s)
  2309.         sprintf (pY->ibuf, "%d", *pY->pD);
  2310.     else
  2311.         sprintf (pY->ibuf, "0x%x", *(UCHAR *)pY->pD);
  2312.     }
  2313.         if (pX->lenI == 2)
  2314.     sprintf (pY->ibuf, "0x%x", *(USHORT *)pY->pD);
  2315.         if (pX->lenI == 4)
  2316.     sprintf (pY->ibuf, "0x%x", *(UINT *)pY->pD);
  2317.        
  2318.         /* 
  2319.          * CMPSS and CMPPS opcode string is modified based on 
  2320.  * the imm value.
  2321.  */
  2323. if ((pX->pI->type == itCmpps) || (pX->pI->type == itCmpss))
  2324.             {
  2326.             /* verify that (0 < imm < 8) */
  2328.             if (*(UCHAR *)pY->pD < 8)
  2329.                 {
  2330.                 if (pX->pI->type == itCmpps)
  2331.                     pY->pOpc = cmpps[*(UCHAR *)pY->pD];
  2332.                 else 
  2333.                     pY->pOpc = cmpss[*(UCHAR *)pY->pD];
  2334.                 }
  2335.             }
  2336. }
  2338.     if (pX->pI->flag & PORT)
  2339.         sprintf (pY->ibuf, "0x%04x", *(USHORT *)(pX->pD + pX->lenO));
  2341.     if (pX->pI->flag & OFFSEL)
  2342.         {
  2343.         if (pX->lenI == 2)
  2344.             sprintf (pY->ibuf, "0x%x", *(USHORT *)(pX->pD + pX->lenO));
  2345.         else
  2346.             sprintf (pY->ibuf, "0x%x", *(UINT *)(pX->pD + pX->lenO));
  2347.         }
  2349.     if (pX->pI->flag & D16L8)
  2350.         sprintf (pY->ibuf, "0x%x", *(USHORT *)(pX->pD + pX->lenO));
  2352.     if (pX->pI->type == itRolRMby1)
  2353.         sprintf (pY->ibuf, "0x1");
  2355.     /* get a memory operand buffer, pY->mbuf */
  2357.     if (pX->modrm) 
  2358. {
  2359. if (pX->mod == 3)
  2360.             {
  2361.     if (pX->pI->flag & WFUL)
  2362. pS = regw[(int)pX->d32][(int)pX->w][(int)pX->rm];
  2363.     else if (pX->pI->flag & MMXRM)
  2364. pS = regmmx[(int)pX->rm];
  2365.     else if (pX->pI->flag2 & XMMRM)
  2366. pS = regxmm[(int)pX->rm];
  2367.     else /* REGRM defaults to here */
  2368.         pS = reg[(int)pX->d32][(int)pX->rm];
  2369.             bcopy (pS, pY->mbuf, strlen (pS));
  2370.             }
  2371. else
  2372.     {
  2373.     if (pX->a32 == 0)
  2374.                 {
  2375.                 pY->pD = pX->pD + pX->lenO + pX->modrm;
  2376.         pS = modrm[(int)pX->a32][(int)pX->mod][(int)pX->rm];
  2377.                 if (pX->mod == 0)
  2378.             {
  2379.             if (pX->rm == 6)
  2380.                 sprintf (pY->mbuf, pS, *(USHORT *)pY->pD);
  2381.         /* see 01e, pY->addr = *(USHORT *)pY->pD; */
  2382.             else
  2383.                 sprintf (pY->mbuf, pS);
  2384.             }
  2385.                 else if (pX->mod == 1)
  2386.             sprintf (pY->mbuf, pS, *pY->pD);
  2387.                 else if (pX->mod == 2)
  2388.             sprintf (pY->mbuf, pS, *(USHORT *)pY->pD);
  2389.                 }
  2390.     else
  2391.                 {
  2392.                 pY->pD = pX->pD + pX->lenO + pX->modrm;
  2393.         pS = modrm[(int)pX->a32][(int)pX->mod][(int)pX->rm];
  2394.                 if ((pX->sib) && (pX->rm == 4))
  2395.             {
  2396.                     pY->pD += pX->sib;
  2397.             pS = sib[(int)pX->mod][(int)pX->base];
  2398.             if (pX->mod == 0)
  2399.         {
  2400.         if (pX->base == 5)
  2401.                     sprintf (pY->mbuf, pS, *(int *)pY->pD, 
  2402.      indexR[(int)pX->index],
  2403.      scale[(int)pX->ss]);
  2404.                 else
  2405.                     sprintf (pY->mbuf, pS, indexR[(int)pX->index], 
  2406.      scale[(int)pX->ss]);
  2407.         }
  2408.             else if (pX->mod == 1)
  2409.                 sprintf (pY->mbuf, pS, indexR[(int)pX->index],
  2410.  scale[(int)pX->ss], *pY->pD);
  2411.             else if (pX->mod == 2)
  2412.                 sprintf (pY->mbuf, pS, indexR[(int)pX->index],
  2413.  scale[(int)pX->ss], *(int *)pY->pD);
  2414.             }
  2415.                 else 
  2416.             {
  2417.                     if (pX->mod == 0)
  2418.                 {
  2419.                         if (pX->rm == 5)
  2420.                     sprintf (pY->mbuf, pS, *(int *)pY->pD);
  2421.             /* see 01e, pY->addr = *(int *)pY->pD; */
  2422.                 else
  2423.                     sprintf (pY->mbuf, pS);
  2424.                 }
  2425.                     else if (pX->mod == 1)
  2426.                 sprintf (pY->mbuf, pS, *pY->pD);
  2427.             else if (pX->mod == 2)
  2428.                 sprintf (pY->mbuf, pS, *(int *)pY->pD);
  2429.             }
  2430.                 }
  2431.             }
  2432.         }
  2433.     }
  2435. /*******************************************************************************
  2436. *
  2437. * dsmPrint - print FORMAT_Y structure.
  2438. *
  2439. * RETUERNS: N/A
  2440. */
  2442. LOCAL void dsmPrint
  2443.     (
  2444.     FORMAT_X *pX, /* Pointer to the FORMAT_X */
  2445.     FORMAT_Y *pY, /* Pointer to the FORMAT_Y */
  2446.     VOIDFUNCPTR prtAddress  /* Address printing function */
  2447.     )
  2448.     {
  2449.     int flag;
  2450.     char *pS;
  2451.     char *pD = pX->pD;
  2452.     int bytesToPrint;
  2453.     int ix;
  2455.     if (pY->len == 0)
  2456.         pY->len = 1;
  2458.     bytesToPrint = (((pY->len - 1) >> 3) + 1) << 3;
  2460.     /* print out an address */
  2462.     printf ("0x%08x  ", (UINT)pX->pD);
  2464.     /* print out a data */
  2466.     for (ix=0; ix < bytesToPrint; ix++)
  2467. {
  2468. if ((ix & ~0x07) && ((ix & 0x07) == 0))
  2469.     printf ("n          ");
  2470. printf ((ix < pY->len) ? "%02x " : "   ", (UCHAR)*pD++);
  2471. }
  2473.     /* print out the unknown instruction */
  2475.     if (pX->pI == NULL)
  2476. {
  2477. printf (".BYTE          0x%02xn", (UCHAR)*pX->pD);
  2478. return;
  2479. }
  2481.     /* set the operand pointers */
  2483.     flag = pX->pI->flag & 0xfffff;
  2485.     switch (flag)
  2486.         {
  2487.         case REG:
  2488.         case SREG3:
  2489.         case SREG2:
  2490.         case ST:
  2491.             pY->pOpr0 = pY->rbuf;
  2492.     break;
  2494.         case MODRM:
  2495.             pY->pOpr0 = pY->mbuf;
  2496.     if (pX->pI->type == itRolRMby1)
  2497. pY->pOpr1 = pY->ibuf;
  2498.     break;
  2500.         case I8:
  2501.         case IMM:
  2502.             pY->pOpr0 = pY->ibuf;
  2503.     break;
  2505.         case D8:
  2506.         case DIS:
  2507.             pY->pOpr0 = (char *)&pY->addr;
  2508.     break;
  2510.         case D16:
  2511.             pY->pOpr0 = pY->dbuf;
  2512.     break;
  2514.         case (REG|IMM):
  2515.             pY->pOpr0 = pY->rbuf;
  2516.             pY->pOpr1 = pY->ibuf;
  2517.     break;
  2518.         
  2519.         case (MODRM|IMM):
  2520.         case (MODRM|I8):
  2521. case (MODRM|MMXRM|I8):
  2522.             if ((pX->pI->type == itCmpps) || (pX->pI->type == itCmpss))
  2523.                 {
  2524.                 pY->pOpr0 = pY->rbuf;
  2525.                 pY->pOpr1 = pY->mbuf;
  2526.                 }
  2527.             else if (pX->pI->flag2 & XMMREG)
  2528.                 {
  2529.                 pY->pOpr0 = pY->mbuf;
  2530.                 pY->pOpr1 = pY->rbuf;
  2531.                 pY->pOpr2 = pY->ibuf;
  2532.                 }
  2533.             else
  2534. {
  2535. pY->pOpr0 = pY->mbuf;
  2536. pY->pOpr1 = pY->ibuf;
  2537. }
  2538.     break;
  2539.         
  2540.         case (MODRM|REG):
  2541.         case (MODRM|REGRM):
  2542.         case (MODRM|SREG3):
  2543.         case (MODRM|EEE):
  2544.         case (MODRM|MMXREG):
  2545.         case (MODRM|MMXREG|REGRM):
  2546.         case (MODRM|MMXREG|MMXRM):
  2547.         case (MODRM|MMXRM):
  2548.             if (pX->d)
  2549.             {
  2550.                 pY->pOpr0 = pY->mbuf; /* data dir = reg to r/m */
  2551.                 pY->pOpr1 = pY->rbuf;
  2552.             }
  2553.             else
  2554.             {
  2555.                 pY->pOpr0 = pY->rbuf; /* data dir = r/m to reg */
  2556.                 pY->pOpr1 = pY->mbuf;
  2557.             }
  2558.     break;
  2560.         case (MODRM|REG|I8):
  2561. case (MODRM|MMXRM|REG|I8):
  2562.         case (MODRM|MMXREG|REGRM|I8):
  2563.         case (MODRM|MMXREG|MMXRM|I8):
  2564.         case (MODRM|REG|IMM):
  2565.             if ((pX->pI->type == itShldRMbyI) || (pX->pI->type == itShrdRMbyI))
  2566.         {
  2567.         pY->pOpr0 = pY->mbuf;
  2568.         pY->pOpr1 = pY->rbuf;
  2569.         pY->pOpr2 = pY->ibuf;
  2570.         }
  2571.             else if (pX->d)
  2572.         {
  2573.         pY->pOpr0 = pY->mbuf;
  2574.         pY->pOpr1 = pY->rbuf;
  2575.         pY->pOpr2 = pY->ibuf;
  2576. }
  2577.             else
  2578.         {
  2579.         pY->pOpr0 = pY->rbuf;
  2580.         pY->pOpr1 = pY->mbuf;
  2581.         pY->pOpr2 = pY->ibuf;
  2582.         }
  2583.     break;
  2585.         case (MODRM|REG|CL):
  2586.             pY->pOpr0 = pY->mbuf;
  2587.             pY->pOpr1 = pY->rbuf;
  2588.             pY->pOpr2 = "CL";
  2589.     break;
  2591.         case (IMM|AX):
  2592.             pY->pOpr0 = pY->rbuf;
  2593.             pY->pOpr1 = pY->ibuf;
  2594.     break;
  2596.         case (MODRM|AX):
  2597.             pY->pOpr0 = pY->rbuf;
  2598.             pY->pOpr1 = pY->mbuf;
  2599.     break;
  2601.         case (MODRM|CL):
  2602.             pY->pOpr0 = pY->mbuf;
  2603.             pY->pOpr1 = "CL";
  2604.     break;
  2606.         case (DIS|AX):
  2607.             if (pX->d)
  2608.         {
  2609.                 pY->pOpr0 = pY->dbuf;
  2610.                 pY->pOpr1 = pY->rbuf;
  2611.         }
  2612.             else
  2613.         {
  2614.                 pY->pOpr0 = pY->rbuf;
  2615.                 pY->pOpr1 = pY->dbuf;
  2616.         }
  2617.     break;
  2619.         case OFFSEL:
  2620.         case D16L8:
  2621.             pY->pOpr0 = pY->ibuf;
  2622.             pY->pOpr1 = pY->dbuf;
  2623.     break;
  2625.         case (FD|ST):
  2626.             if (pX->fd)
  2627.         {
  2628.                 pY->pOpr0 = pY->rbuf;
  2629.                 pY->pOpr1 = "ST";
  2630.         }
  2631.             else
  2632.         {
  2633.                 pY->pOpr0 = "ST";
  2634.                 pY->pOpr1 = pY->rbuf;
  2635.         }
  2636.     break;
  2638.         case (PORT|AX):
  2639.     if (pX->pI->type == itInF)
  2640. {
  2641. pY->pOpr0 = pY->rbuf;
  2642. pY->pOpr1 = pY->ibuf;
  2643. }
  2644.     else
  2645. {
  2646. pY->pOpr0 = pY->ibuf;
  2647. pY->pOpr1 = pY->rbuf;
  2648. }
  2649.     break;
  2651.         case (REG|AX):
  2652.     pY->pOpr0 = pY->ibuf;
  2653.     pY->pOpr1 = pY->rbuf;
  2654.     break;
  2656.         case AX:
  2657.     if (pX->pI->type == itInV)
  2658. {
  2659. pY->pOpr0 = pY->rbuf;
  2660. pY->pOpr1 = "DX";
  2661. }
  2662.     else if (pX->pI->type == itOutV)
  2663. {
  2664. pY->pOpr0 = "DX";
  2665. pY->pOpr1 = pY->rbuf;
  2666. }
  2667.     else
  2668.                 pY->pOpr0 = pY->rbuf;
  2669.     break;
  2671.         case 0:
  2672.     break;
  2674.         default:
  2675.     printf ("dsmI86.c error 1: Invalid opcode flag definition.n");
  2676.             printf ("top = 0x%02x 0x%02x 0x%02x 0x%02xn",
  2677.      (UCHAR)*pX->pD, (UCHAR)*(pX->pD + 1),
  2678.      (UCHAR)*(pX->pD + 2), (UCHAR)*(pX->pD + 3));
  2679.         }
  2681.     if ((pX->pI->flag2 & XMMREG) || (pX->pI->flag2 & XMMRM))
  2682.         {
  2683.         if (pX->d)
  2684.             {
  2685.             pY->pOpr0 = pY->mbuf; /* data dir = reg to r/m */
  2686.             pY->pOpr1 = pY->rbuf;
  2687.             }
  2688.         else
  2689.             {
  2690.             pY->pOpr0 = pY->rbuf; /* data dir = r/m to reg */
  2691.             pY->pOpr1 = pY->mbuf;
  2692.             }
  2693.         }
  2694.     else if (pX->pI->flag2 != 0)
  2695.         {
  2696. printf ("dsmI86.c error 2: Invalid opcode flag definition.n");
  2697.         printf ("top = 0x%02x 0x%02x 0x%02x 0x%02xn",
  2698.           (UCHAR)*pX->pD, (UCHAR)*(pX->pD + 1),
  2699.         (UCHAR)*(pX->pD + 2), (UCHAR)*(pX->pD + 3));
  2700.         }
  2702.     /* tune up for the special case */
  2704.     if ((pY->pOpr0 == pY->mbuf) && (pY->mbuf[0] == 0))
  2705. pY->pOpr0 = (char *)&pY->addr;
  2707.     if ((pY->pOpr1 == pY->mbuf) && (pY->mbuf[0] == 0))
  2708. pY->pOpr1 = (char *)&pY->addr;
  2710.     if ((pY->pOpr2 == pY->mbuf) && (pY->mbuf[0] == 0))
  2711. pY->pOpr2 = (char *)&pY->addr;
  2713.     /* tune up for "+(no-x1)" */
  2715.     if (pY->mbuf[0] != 0)
  2716. {
  2717.         pS = pY->mbuf;
  2718.         pD = pY->temp;
  2719.         for (ix = 0 ; ix < (int) (strlen (pY->mbuf)) ; ix++)
  2720.     {
  2721.     if ((*pS == '(') && (*(pS+1) == 'n') && (*(pS+2) == 'o'))
  2722. {
  2723.         pS += 7;
  2724. pD -= 1;
  2725. }
  2726.     *pD++ = *pS++;
  2728.     if (*pS == 0)
  2729. break;
  2730.     }
  2732.         bcopy (pY->temp, pY->mbuf, DSM_BUFSIZE32);
  2733. }
  2735.     /* tune up for "+-" */
  2737.     bzero ((char *)pY->temp, DSM_BUFSIZE32);
  2739.     if (pY->mbuf[0] != 0)
  2740. {
  2741.         pS = pY->mbuf;
  2742.         pD = pY->temp;
  2743.         for (ix = 0 ; ix < (int) (strlen (pY->mbuf)) ; ix++)
  2744.     {
  2745.     if ((*pS == '+') && (*(pS+1) == '-'))
  2746.         pS += 1;
  2747.     *pD++ = *pS++;
  2749.     if (*pS == 0)
  2750. break;
  2751.     }
  2753.         bcopy (pY->temp, pY->mbuf, DSM_BUFSIZE32);
  2754. }
  2756.     /* print out the instruction */
  2758.     printf ("%-12s   ", pY->pOpc);
  2760.     if (pY->pOpr0 != 0)
  2761. {
  2762.         if (pY->pOpr0 == (char *)&pY->addr)
  2763.     (*prtAddress) ((int)pX->pD + pY->len + pY->addr);
  2764. else
  2765.     printf ("%s", pY->pOpr0);
  2766. }
  2768.     if (pY->pOpr1 != 0)
  2769. {
  2770. printf (", ");
  2771.         if (pY->pOpr1 == (char *)&pY->addr)
  2772.     (*prtAddress) ((int)pX->pD + pY->len + pY->addr);
  2773. else
  2774.     printf ("%s", pY->pOpr1);
  2775. }
  2777.     if (pY->pOpr2 != 0)
  2778. {
  2779. printf (", ");
  2780.         if (pY->pOpr2 == (char *)&pY->addr)
  2781.     (*prtAddress) ((int)pX->pD + pY->len + pY->addr);
  2782. else
  2783.     printf ("%s", pY->pOpr2);
  2784. }
  2786.     printf ("n");
  2788.     return;
  2789.     }
  2790. /*******************************************************************************
  2791. *
  2792. * nPrtAddress - print addresses as numbers
  2793. *
  2794. * RETURNS: N/A
  2795. */
  2797. LOCAL void nPrtAddress
  2798.     (
  2799.     int address /* address to print */
  2800.     )
  2801.     {
  2802.     printf ("%#x", address); 
  2803.     }
  2804. /**************************************************************************
  2805. *
  2806. * dsmData - disassemble and print a byte as data
  2807. *
  2808. * This routine disassembles and prints a single byte as data (that is,
  2809. * as a .BYTE assembler directive) on standard out.  The disassembled data will
  2810. * be prepended with the address passed as a parameter.
  2811. * 
  2812. * RETURNS : The number of words occupied by the data (always 1).
  2813. */
  2815. int dsmData
  2816.     (
  2817.     FAST UCHAR *pD, /* pointer to the data       */
  2818.     int address  /* address prepended to data */
  2819.     )
  2820.     {
  2821.     FORMAT_X formatx;
  2822.     FORMAT_Y formaty;
  2824.     bzero ((char *)&formatx, sizeof (FORMAT_X));
  2825.     bzero ((char *)&formaty, sizeof (FORMAT_Y));
  2826.     
  2827.     formatx.pD = (char *)pD;
  2828.     formaty.len = 1;
  2830.     dsmPrint (&formatx, &formaty, nPrtAddress);
  2832.     return (1);
  2833.     }
  2834. /*******************************************************************************
  2835. *
  2836. * dsmInst - disassemble and print a single instruction
  2837. *
  2838. * This routine disassembles and prints a single instruction on standard
  2839. * output.  The function passed as parameter <prtAddress> is used to print any
  2840. * operands that might be construed as addresses.  The function could be a
  2841. * subroutine that prints a number or looks up the address in a
  2842. * symbol table.  The disassembled instruction will be prepended with the
  2843. * address passed as a parameter.
  2844. * 
  2845. * If <prtAddress> is zero, dsmInst() will use a default routine that prints 
  2846. * addresses as hex numbers.
  2847. *
  2848. * ADDRESS PRINTING ROUTINE
  2849. * Many assembly language operands are addresses.  In order to print these
  2850. * addresses symbolically, dsmInst() calls a user-supplied routine, passed as a
  2851. * parameter, to do the actual printing.  The routine should be declared as:
  2852. * .CS
  2853. *     void prtAddress 
  2854. *         (
  2855. *         int    address   /@ address to print @/
  2856. *         )
  2857. * .CE
  2858. * When called, the routine prints the address on standard out in either
  2859. * numeric or symbolic form.  For example, the address-printing routine used
  2860. * by l() looks up the address in the system symbol table and prints the
  2861. * symbol associated with it, if there is one.  If not, it prints the address
  2862. * as a hex number.
  2863. * 
  2864. * If the <prtAddress> argument to dsmInst is NULL, a default print routine is
  2865. * used, which prints the address as a hexadecimal number.
  2866. * 
  2867. * The directive .DATA.H (DATA SHORT) is printed for unrecognized instructions.
  2868. * 
  2869. * The effective address mode is not checked since when the instruction with
  2870. * invalid address mode executed, an exception would happen.
  2871. * 
  2872. * INCLUDE FILE: dsmLib.h
  2873. * 
  2874. * INTERNAL  
  2875. * The instruction type is defined by the format of instruction's argument 
  2876. * list.  So the order of argument list table should not be changed.  The 
  2877. * default value of size field is defined with a special bit set in the size 
  2878. * offset field.  To distinguish FPU instructions, a special bit is set in 
  2879. * the type field in the instruction table.
  2880. *
  2881. * RETURNS: The number of bytes occupied by the instruction.
  2882. */
  2884. int dsmInst
  2885.     (
  2886.     FAST UCHAR *pD, /* Pointer to the instruction       */
  2887.     int address, /* Address prepended to instruction */
  2888.     VOIDFUNCPTR prtAddress /* Address printing function        */
  2889.     )
  2890.     {
  2891.     FORMAT_X formatx;
  2892.     FORMAT_Y formaty;
  2894.     if (prtAddress == NULL)
  2895.         prtAddress = nPrtAddress;
  2897.     bzero ((char *)&formatx, sizeof (FORMAT_X));
  2898.     bzero ((char *)&formaty, sizeof (FORMAT_Y));
  2899.     
  2900.     dsmFind (pD, &formatx, &formaty);
  2902.     dsmPrint (&formatx, &formaty, prtAddress);
  2904.     if (instKeeper != NULL)
  2905. {
  2906. formatx.pI->pOpc = instKeeper;
  2907. instKeeper = NULL;
  2908. }
  2909.     
  2910.     return ((formaty.len == 0) ? 1 : formaty.len);
  2911.     }
  2913. /*******************************************************************************
  2914. *
  2915. * dsmNbytes - determine the size of an instruction
  2916. *
  2917. * This routine reports the size, in bytes, of an instruction.
  2918. *
  2919. * RETURNS: The size of the instruction, or 0 if the instruction is unrecognized.
  2920. */
  2922. int dsmNbytes
  2923.     (
  2924.     FAST UCHAR *pD  /* Pointer to the instruction */
  2925.     )
  2926.     {
  2927.     FORMAT_X formatx;
  2928.     FORMAT_Y formaty;
  2930.     bzero ((char *)&formatx, sizeof (FORMAT_X));
  2931.     bzero ((char *)&formaty, sizeof (FORMAT_Y));
  2932.     
  2933.     dsmFind (pD, &formatx, &formaty);
  2935.     if (instKeeper != NULL)
  2936. {
  2937. formatx.pI->pOpc = instKeeper;
  2938. instKeeper = NULL;
  2939. }
  2941.     return (formaty.len);
  2942.     }