Subversion Repositories Kolibri OS

Rev

Rev 7626 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "tok.h"
  2.  
  3. #include "table.h"
  4.  
  5. #include <stdarg.h>
  6.  
  7. #define _DISASM_
  8.  
  9.  
  10.  
  11. /* Percent tokens in strings:
  12.  
  13.    First char after '%':
  14.  
  15.         A - direct address
  16.  
  17.         C - reg of r/m picks control register
  18.  
  19.         D - reg of r/m picks debug register
  20.  
  21.         E - r/m picks operand
  22.  
  23.         F - second operand for mmx instruction reg/mem
  24.  
  25.         G - reg of r/m picks general register
  26.  
  27.         I - immediate data
  28.  
  29.         J - relative IP offset
  30.  
  31. +      K - call/jmp distance
  32.  
  33.         L - first operand for mmx instruction
  34.  
  35.         M - r/m picks memory
  36.  
  37.         O - no r/m, offset only
  38.  
  39.         R - mod of r/m picks register only
  40.  
  41.         S - reg of r/m picks segment register
  42.  
  43.         T - reg of r/m picks test register
  44.  
  45.         X - DS:ESI
  46.  
  47.         Y - ES:EDI
  48.  
  49.         2 - prefix of two-byte opcode
  50.  
  51. +       e - put in 'e' if use32 (second char is part of reg name)
  52.  
  53. +           put in 'w' for use16 or 'd' for use32 (second char is 'w')
  54.  
  55. +       j - put in 'e' in jcxz if prefix==0x66
  56.  
  57.         f - floating point (second char is esc value)
  58.  
  59.         g - do r/m group 'n', n==0..7
  60.  
  61.         p - prefix
  62.  
  63.         s - size override (second char is a,o)
  64.  
  65. +       d - put d if double arg, nothing otherwise (pushfd, popfd &c)
  66.  
  67. +       w - put w if word, d if double arg, nothing otherwise (lodsw/lodsd)
  68.  
  69. +       P - simple prefix
  70.  
  71.  
  72.  
  73.    Second char after '%':
  74.  
  75.         a - two words in memory (BOUND)
  76.  
  77.         b - byte
  78.  
  79.         c - byte or word
  80.  
  81.         d - dword
  82.  
  83. +       f - far call/jmp
  84.  
  85. +       n - near call/jmp
  86.  
  87.         p - 32 or 48 bit pointer
  88.  
  89. +       q - byte/word thingy
  90.  
  91.         s - six byte pseudo-descriptor
  92.  
  93.         v - word or dword
  94.  
  95.         w - word
  96.  
  97. +       x - sign extended byte
  98.  
  99.         y - qword
  100.  
  101.         F - use floating regs in mod/rm
  102.  
  103.         M - use MMX regs
  104.  
  105.         1-8 - group number, esc value, etc
  106.  
  107.         m - no size memory operand
  108.  
  109. */
  110.  
  111.  
  112.  
  113. /* watch out for aad && aam with odd operands */
  114.  
  115. char *opmap1[256]={
  116.  
  117. /* 0 */
  118.  
  119.   "add %Eb,%Rb",      "add %Ev,%Rv",     "add %Rb,%Eb",    "add %Rv,%Ev",
  120.  
  121.   "add al,%Ib",       "add %eax,%Iv",    "push es",        "pop es",
  122.  
  123.   "or %Eb,%Rb",       "or %Ev,%Rv",      "or %Rb,%Eb",     "or %Rv,%Ev",
  124.  
  125.   "or al,%Ib",        "or %eax,%Iv",     "push cs",        "%2 ",
  126.  
  127. /* 1 */
  128.  
  129.   "adc %Eb,%Rb",      "adc %Ev,%Rv",     "adc %Rb,%Eb",    "adc %Rv,%Ev",
  130.  
  131.   "adc al,%Ib",       "adc %eax,%Iv",    "push ss",        "pop ss",
  132.  
  133.   "sbb %Eb,%Rb",      "sbb %Ev,%Rv",     "sbb %Rb,%Eb",    "sbb %Rv,%Ev",
  134.  
  135.   "sbb al,%Ib",       "sbb %eax,%Iv",    "push ds",        "pop ds",
  136.  
  137. /* 2 */
  138.  
  139.   "and %Eb,%Rb",      "and %Ev,%Rv",     "and %Rb,%Eb",    "and %Rv,%Ev",
  140.  
  141.   "and al,%Ib",       "and %eax,%Iv",    "%pe",            "daa",
  142.  
  143.   "sub %Eb,%Rb",      "sub %Ev,%Rv",     "sub %Rb,%Eb",    "sub %Rv,%Ev",
  144.  
  145.   "sub al,%Ib",       "sub %eax,%Iv",    "%pc",            "das",
  146.  
  147. /* 3 */
  148.  
  149.   "xor %Eb,%Rb",      "xor %Ev,%Rv",     "xor %Rb,%Eb",    "xor %Rv,%Ev",
  150.  
  151.   "xor al,%Ib",       "xor %eax,%Iv",    "%ps",            "aaa",
  152.  
  153.   "cmp %Eb,%Rb",      "cmp %Ev,%Rv",     "cmp %Rb,%Eb",    "cmp %Rv,%Ev",
  154.  
  155.   "cmp al,%Ib",       "cmp %eax,%Iv",    "%pd",            "aas",
  156.  
  157. /* 4 */
  158.  
  159.   "inc %eax",         "inc %ecx",        "inc %edx",       "inc %ebx",
  160.  
  161.   "inc %esp",         "inc %ebp",        "inc %esi",       "inc %edi",
  162.  
  163.   "dec %eax",         "dec %ecx",        "dec %edx",       "dec %ebx",
  164.  
  165.   "dec %esp",         "dec %ebp",        "dec %esi",       "dec %edi",
  166.  
  167. /* 5 */
  168.  
  169.   "push %eax",        "push %ecx",       "push %edx",      "push %ebx",
  170.  
  171.   "push %esp",        "push %ebp",       "push %esi",      "push %edi",
  172.  
  173.   "pop %eax",         "pop %ecx",        "pop %edx",       "pop %ebx",
  174.  
  175.   "pop %esp",         "pop %ebp",        "pop %esi",       "pop %edi",
  176.  
  177. /* 6 */
  178.  
  179.   "pusha%d ",         "popa%d ",         "bound %Rv,%Ma",  "arpl %Ew,%Rw",
  180.  
  181.   "%pf",              "%pg",             "%so",            "%sa",
  182.  
  183.   "push %Iv",         "imul %Rv,%Ev,%Iv","push %Ix",       "imul %Rv,%Ev,%Ib",
  184.  
  185.   "insb",             "ins%ew",          "outsb",          "outs%ew",
  186.  
  187. /* 7 */
  188.  
  189.   "jo %Jb",           "jno %Jb",         "jc %Jb",         "jnc %Jb",
  190.  
  191.   "je %Jb",           "jne %Jb",         "jbe %Jb",        "ja %Jb",
  192.  
  193.   "js %Jb",           "jns %Jb",         "jpe %Jb",        "jpo %Jb",
  194.  
  195.   "jl %Jb",           "jge %Jb",         "jle %Jb",        "jg %Jb",
  196.  
  197. /* 8 */
  198.  
  199. /*  "%g0 %Eb,%Ib",      "%g0 %Ev,%Iv",     "%g0 %Ev,%Ib",    "%g0 %Ev,%Ib", */
  200.  
  201.   "%g0 %Eb,%Ib",      "%g0 %Ev,%Iv",     "%g0 %Ev,%Ix",    "%g0 %Ev,%Ix",
  202.  
  203.   "test %Eb,%Rb",     "test %Ev,%Rv",    "xchg %Eb,%Rb",   "xchg %Ev,%Rv",
  204.  
  205.   "mov %Eb,%Rb",      "mov %Ev,%Rv",     "mov %Rb,%Eb",    "mov %Rv,%Ev",
  206.  
  207.   "mov %Ew,%Sw",      "lea %Rv,%M ",     "mov %Sw,%Ew",    "pop %Ev",
  208.  
  209. /* 9 */
  210.  
  211.   "nop",              "xchg %ecx,%eax",  "xchg %edx,%eax", "xchg %ebx,%eax",
  212.  
  213.   "xchg %esp,%eax",   "xchg %ebp,%eax",  "xchg %esi,%eax", "xchg %edi,%eax",
  214.  
  215.   "cbw",              "cwd",             "call %Ap",       "fwait",
  216.  
  217.   "pushf%d ",         "popf%d ",         "sahf",           "lahf",
  218.  
  219. /* a */
  220.  
  221.   "mov al,%Oc",       "mov %eax,%Ov",    "mov %Oc,al",     "mov %Ov,%eax",
  222.  
  223.   "%P movsb",         "%P movs%w",       "%P cmpsb",       "%P cmps%w ",
  224.  
  225.   "test al,%Ib",      "test %eax,%Iv",   "%P stosb",       "%P stos%w ",
  226.  
  227.   "%P lodsb",         "%P lods%w ",      "%P scasb",       "%P scas%w ",
  228.  
  229. /* b */
  230.  
  231.   "mov al,%Ib",       "mov cl,%Ib",      "mov dl,%Ib",     "mov bl,%Ib",
  232.  
  233.   "mov ah,%Ib",       "mov ch,%Ib",      "mov dh,%Ib",     "mov bh,%Ib",
  234.  
  235.   "mov %eax,%Iv",     "mov %ecx,%Iv",    "mov %edx,%Iv",   "mov %ebx,%Iv",
  236.  
  237.   "mov %esp,%Iv",     "mov %ebp,%Iv",    "mov %esi,%Iv",   "mov %edi,%Iv",
  238.  
  239. /* c */
  240.  
  241.   "%g1 %Eb,%Ib",      "%g1 %Ev,%Ib",     "ret %Iw",        "ret",
  242.  
  243.   "les %Rv,%Mp",      "lds %Rv,%Mp",     "mov %Eb,%Ib",    "mov %Ev,%Iv",
  244.  
  245.   "enter %Iw,%Ib",    "leave",           "retf %Iw",       "retf",
  246.  
  247.   "int 03",           "int %Ib",         "into",           "iret",
  248.  
  249. /* d */
  250.  
  251.   "%g1 %Eb,1",        "%g1 %Ev,1",       "%g1 %Eb,cl",     "%g1 %Ev,cl",
  252.  
  253.   "aam ; %Ib",        "aad ; %Ib",       "setalc",         "xlat",
  254.  
  255. /*#if 0
  256.  
  257.   "esc 0,%Ib",        "esc 1,%Ib",       "esc 2,%Ib",      "esc 3,%Ib",
  258.  
  259.   "esc 4,%Ib",        "esc 5,%Ib",       "esc 6,%Ib",      "esc 7,%Ib",
  260.  
  261. #else  */
  262.  
  263.   "%f0",              "%f1",             "%f2",            "%f3",
  264.  
  265.   "%f4",              "%f5",             "%f6",            "%f7",
  266.  
  267. //#endif
  268.  
  269. /* e */
  270.  
  271.   "loopne %Jb",       "loope %Jb",       "loop %Jb",       "j%j cxz %Jb",
  272.  
  273.   "in al,%Ib",        "in %eax,%Ib",     "out %Ib,al",     "out %Ib,%eax",
  274.  
  275.   "call %Jv",         "jmp %Jv",         "jmp %Ap",        "jmp %Ks%Jb",
  276.  
  277.   "in al,dx",         "in %eax,dx",      "out dx,al",      "out dx,%eax",
  278.  
  279. /* f */
  280.  
  281.   "lock %p ",         0,                 "repne %p ",      "repe %p ",
  282.  
  283.   "hlt",              "cmc",             "%g2",            "%g2",
  284.  
  285.   "clc",              "stc",             "cli",            "sti",
  286.  
  287.   "cld",              "std",             "%g3",            "%g4"
  288.  
  289. };
  290.  
  291.  
  292.  
  293. char *second[] = {
  294.  
  295. /* 0 */
  296.  
  297.   "%g5",              "%g6",             "lar %Rv,%Ew",    "lsl %Rv,%Ew",
  298.  
  299.   0,                  "loadall",         "clts",           "loadall",
  300.  
  301.   "invd",             "wbinvd",          0,                "ud2",
  302.  
  303.   0,                  0,                 0,                0,
  304.  
  305. /* 1 */
  306.  
  307.   "movups %RX,%EX",   "movups %Md,%RX",  "%x0",             "movlps %Md,%RX",
  308.  
  309.   "unpcklps %RX,%EX", "unpckhps %RX,%EX","%x1",             "movhps %Md,%RX",
  310.  
  311.   "%g7",              0,                 0,                0,
  312.  
  313.   0,                  0,                 0,                0,
  314.  
  315. /* 2 */
  316.  
  317.   "mov %Ed,%Cd",      "mov %Ed,%Dd",     "mov %Cd,%Ed",     "mov %Dd,%Ed",
  318.  
  319.   "mov %Ed,%Td",      0,                 "mov %Td,%Ed",     0,
  320.  
  321.   "movaps %RX,%EX",   "movaps %Md,%RX",  "cvtpi2ps %RX,%EM","movntps %Md,%RX",
  322.  
  323.   "cvttps2pi %RM,%EX","cvtps2pi %RM,%EX","ucomiss %RX,%EX", "comiss %RX,%EX",
  324.  
  325. /* 3 */
  326.  
  327.   "wrmsr", "rdtsc", "rdmsr", "rdpmc", "sysenter", "sysexit", 0, 0,
  328.  
  329.   0, 0, 0, 0, 0, 0, 0, 0,
  330.  
  331. /* 4 */
  332.  
  333.   "cmovo %Rv,%Ev",    "cmovno %Rv,%Ev",  "cmovc %Rv,%Ev",  "cmovnc %Rv,%Ev",
  334.  
  335.   "cmovz %Rv,%Ev",    "cmovnz %Rv,%Ev",  "cmovbe %Rv,%Ev", "cmovnbe %Rv,%Ev",
  336.  
  337.   "cmovs %Rv,%Ev",    "cmovns %Rv,%Ev",  "cmovp %Rv,%Ev",  "cmovnp %Rv,%Ev",
  338.  
  339.   "cmovl %Rv,%Ev",    "cmovge %Rv,%Ev",  "cmovle %Rv,%Ev", "cmovg %Rv,%Ev",
  340.  
  341. /* 5 */
  342.  
  343.   "movmskps %Rd,%GX", "sqrtps %RX,%EX", "rsqrtps %RX,%EX", "rcpps %RX,%EX",
  344.  
  345.         "andps %RX,%EX",    "andnps %RX,%EX", "orps %RX,%EX",    "xorps %RX,%EX",
  346.  
  347.   "addps %RX,%EX",    "mulps %RX,%EX",  "cvtps2pd %RX,%EX","cvtdq2ps %RX,%EX",
  348.  
  349.         "subps %RX,%EX",    "minps %RX,%EX",  "divps %RX,%EX",   "maxps %RX,%EX",
  350.  
  351. /* 6 */
  352.  
  353.   "punpcklbw %RM,%EM", "punpcklwd %RM,%EM", "punpckldq %RM,%EM", "packsswb %RM,%EM",
  354.  
  355.         "pcmpgtb %RM,%EM",   "pcmpgtw %RM,%EM",   "pcmpgtd %RM,%EM",   "packuswb %RM,%EM",
  356.  
  357.   "punpckhbw %RM,%EM", "punpckhwd %RM,%EM", "punpckhdq %RM,%EM", "packssdw %RM,%EM",
  358.  
  359.         0,                   0,                   "movd %RM,%Md",      "movq %RM,%EM",
  360.  
  361. /* 7 */
  362.  
  363.   "pshufw %LM,%FM,%Ib","%g3w %EM,%Ib",    "%g3d %EM,%Ib",    "%g3q %EM,%Ib",
  364.  
  365.         "pcmpeqb %RM,%EM",  "pcmpeqw %RM,%EM", "pcmpeqd %RM,%EM", "emms",
  366.  
  367.   0,                  0,                 0,                 0,
  368.  
  369.         0,                  0,                 "movd %Md,%RM",    "movq %Md,%RM",
  370.  
  371. /* 8 */
  372.  
  373.   "jo %Jv",           "jno %Jv",         "jb %Jv",         "jnb %Jv",
  374.  
  375.   "jz %Jv",           "jnz %Jv",         "jbe %Jv",        "ja %Jv",
  376.  
  377.   "js %Jv",           "jns %Jv",         "jp %Jv",         "jnp %Jv",
  378.  
  379.   "jl %Jv",           "jge %Jv",         "jle %Jv",        "jg %Jv",
  380.  
  381. /* 9 */
  382.  
  383.   "seto %Eb",         "setno %Eb",       "setc %Eb",       "setnc %Eb",
  384.  
  385.   "setz %Eb",         "setnz %Eb",       "setbe %Eb",      "setnbe %Eb",
  386.  
  387.   "sets %Eb",         "setns %Eb",       "setp %Eb",       "setnp %Eb",
  388.  
  389.   "setl %Eb",         "setge %Eb",       "setle %Eb",      "setg %Eb",
  390.  
  391. /* a */
  392.  
  393.   "push fs",          "pop fs",          "cpuid",          "bt %Ev,%Rv",
  394.  
  395.   "shld %Ev,%Rv,%Ib", "shld %Ev,%Rv,cl", 0,                0,
  396.  
  397.   "push gs",          "pop gs",          "rsm",            "bts %Ev,%Rv",
  398.  
  399.   "shrd %Ev,%Rv,%Ib", "shrd %Ev,%Rv,cl", "%g8",            "imul %Rv,%Ev",
  400.  
  401. /* b */
  402.  
  403.   "cmpxchg %Eb,%Rb",  "cmpxchg %Ev,%Rv", "lss %Rv,%Mp",    "btr %Ev,%Rv",
  404.  
  405.   "lfs %Rv,%Mp",      "lgs %Rv,%Mp",     "movzx %Rv,%Eb",  "movzx %Rv,%Ew",
  406.  
  407.   0,                  0,                 "%g7 %Ev,%Ib",    "btc %Ev,%Rv",
  408.  
  409.   "bsf %Rv,%Ev",      "bsr %Rv,%Ev",     "movsx %Rv,%Eb",  "movsx %Rv,%Ew",
  410.  
  411. /* c */
  412.  
  413.   "xadd %Eb,%Rb",     "xadd %Ev,%Rv",    "cmpps %RX,%EX,%Ib","movnti %Md,%Rd",
  414.  
  415.   "pinsrw %LM,%Fd,%Ib","pextrw %Gd,%RM,%Ib","shufps %RX,%EX,%Ib","cmpxchg8b %Myv",
  416.  
  417.   "bswap eax",        "bswap ecx",       "bswap edx",      "bswap ebx",
  418.  
  419.   "bswap esp",        "bswap ebp",       "bswap esi",      "bswap edi",
  420.  
  421. /* d */
  422.  
  423.   0,                  "psrlw %RM,%EM",   "psrld %RM,%EM",  "psrlq %RM,%EM",
  424.  
  425.         "paddq %RM,%EM",    "pmullw %RM,%EM",  0,                "pmovmskb %Rd,%GM",
  426.  
  427.   "psubusb %RM,%EM",  "psubusw %RM,%EM", "pminub %RM,%EM", "pand %RM,%EM",
  428.  
  429.         "paddusb %RM,%EM",  "paddusw %RM,%EM", "pmaxub %RM,%EM", "pandn %RM,%EM",
  430.  
  431. /* e */
  432.  
  433.   "pavgb %RM,%EM",    "psraw %RM,%EM",   "psrad %RM,%EM",  "pavgw %RM,%EM",
  434.  
  435.         "pmulhuw %RM,%EM",  "pmulhw %RM,%EM",  0,                "movntq %Myv,%RM",
  436.  
  437.   "psubsb %RM,%EM",   "psubsw %RM,%EM",  "pminsw %RM,%EM", "por %RM,%EM",
  438.  
  439.         "paddsb %RM,%EM",   "paddsw %RM,%EM",  "pmaxsw %RM,%EM", "pxor %RM,%EM",
  440.  
  441. /* f */
  442.  
  443.   0,                  "psllw %RM,%EM",   "pslld %RM,%EM",  "psllq %RM,%EM",
  444.  
  445.         "pmuludq %RM,%EM",  "pmaddwd %RM,%EM", "psadbw %RM,%EM", "maskmovq %GM,%RM",
  446.  
  447.   "psubb %RM,%EM",    "psubw %RM,%EM",   "psubd %RM,%EM",  "psubq %RM,%EM",
  448.  
  449.         "paddb %RM,%EM",    "paddw %RM,%EM",   "paddd %RM,%EM",  0
  450.  
  451. };
  452.  
  453.  
  454.  
  455. char *second_f30f[]={
  456.  
  457. // 0
  458.  
  459.         0,0,0,0,0,0,0,0,
  460.  
  461.         0,0,0,0,0,0,0,0,
  462.  
  463. // 1
  464.  
  465.         "movss %RX,%EX","movss %Md,%RX","movsldup %RX,%MX",0,
  466.  
  467.         0,0,"movshdup %RX,%MX",0,
  468.  
  469.         0,0,0,0,0,0,0,0,
  470.  
  471. // 2
  472.  
  473.         0,0,0,0,
  474.  
  475.         0,0,0,0,
  476.  
  477.         0,                  0,                 "cvtsi2ss %RX,%Ed",0,
  478.  
  479.         "cvttss2si %Rd,%EX","cvtss2si %Rd,%EX",0,                 0,
  480.  
  481. // 3
  482.  
  483.         0,0,0,0,0,0,0,0,
  484.  
  485.         0,0,0,0,0,0,0,0,
  486.  
  487. // 4
  488.  
  489.         0,0,0,0,0,0,0,0,
  490.  
  491.         0,0,0,0,0,0,0,0,
  492.  
  493. // 5
  494.  
  495.         0,              "sqrtss %RX,%EX","rsqrtss %RX,%EX", "rcpss %RX,%EX",
  496.  
  497.         0,              0,               0,                 0,
  498.  
  499.         "addss %RX,%EX","mulss %RX,%EX", "cvtss2sd %RX,%EX","cvttps2dq %RX,%EX",
  500.  
  501.         "subss %RX,%EX","minss %RX,%EX", "divss %RX,%EX",   "maxss %RX,%EX",
  502.  
  503. // 6
  504.  
  505.         0,0,0,0,0,0,0,0,
  506.  
  507.         0,0,0,0,0,0,0,"movdqu %RX,%EX",
  508.  
  509. // 7
  510.  
  511.         "pshufhw %RX,%EX,%Ib",0,0,0,
  512.  
  513.         0,0,0,0,
  514.  
  515.         0,0,0,0,
  516.  
  517.         0,0,"movq %RX,%EX","movdqu %Md,%RX",
  518.  
  519. // 8
  520.  
  521.         0,0,0,0,0,0,0,0,
  522.  
  523.         0,0,0,0,0,0,0,0,
  524.  
  525. // 9
  526.  
  527.         0,0,0,0,0,0,0,0,
  528.  
  529.         0,0,0,0,0,0,0,0,
  530.  
  531. // a
  532.  
  533.         0,0,0,0,0,0,0,0,
  534.  
  535.         0,0,0,0,0,0,0,0,
  536.  
  537. // b
  538.  
  539.         0,0,0,0,0,0,0,0,
  540.  
  541.         0,0,0,0,0,0,0,0,
  542.  
  543. // c
  544.  
  545.         0,0,"cmpss %RX,%EX,%Ib",0,
  546.  
  547.         0,0,0,                  0,
  548.  
  549.         0,0,0,                  0,
  550.  
  551.         0,0,0,                  0,
  552.  
  553. // d
  554.  
  555.         0,0,0,0,
  556.  
  557.         0,0,"movq2dq RX,RM",0,
  558.  
  559.         0,0,0,0,0,0,0,0,
  560.  
  561. // e
  562.  
  563.         0,0,0,0,
  564.  
  565.         0,0,"cvtdq2pd %RX,%EX",0,
  566.  
  567.         0,0,0,0,0,0,0,0,
  568.  
  569. // f
  570.  
  571.         0,0,0,0,0,0,0,0,
  572.  
  573.         0,0,0,0,0,0,0,0
  574.  
  575. };
  576.  
  577.  
  578.  
  579. char *second_f20f[]={
  580.  
  581. // 0
  582.  
  583.         0,0,0,0,0,0,0,0,
  584.  
  585.         0,0,0,0,0,0,0,0,
  586.  
  587. // 1
  588.  
  589.         "movsd %RX,%Md","movsd %Md,%RX","movddup %RX,%MX",0,
  590.  
  591.         0,0,0,0,
  592.  
  593.         0,0,0,0,0,0,0,0,
  594.  
  595. // 2
  596.  
  597.         0,0,0,0,
  598.  
  599.         0,0,0,0,
  600.  
  601.         0,0,"cvtsi2sd %RX,%Md",0,
  602.  
  603.         "cvttsd2si %Rd,%EX","cvtsd2si %Rd,%EX",0,0,
  604.  
  605. // 3
  606.  
  607.         0,0,0,0,0,0,0,0,
  608.  
  609.         0,0,0,0,0,0,0,0,
  610.  
  611. // 4
  612.  
  613.         0,0,0,0,0,0,0,0,
  614.  
  615.         0,0,0,0,0,0,0,0,
  616.  
  617. // 5
  618.  
  619.         0,"sqrtsd %RX,%EX",0,0,
  620.  
  621.         0,0,0,0,
  622.  
  623.         "addsd %RX,%EX","mulsd %RX,%MX","cvtsd2ss %RX,%EX",0,
  624.  
  625.         "subsd %RX,%EX","minsd %RX,%EX","divsd %RX,%EX","maxsd %RX,%EX",
  626.  
  627. // 6
  628.  
  629.         0,0,0,0,0,0,0,0,
  630.  
  631.         0,0,0,0,0,0,0,0,
  632.  
  633. // 7
  634.  
  635.         "pshuflw %RX,%EX,%Ib",0,0,0,
  636.  
  637.         0,0,0,0,
  638.  
  639.         0,0,0,0,
  640.  
  641.         "haddps %RX,%EX","hsubps %RX,%EX",0,0,
  642.  
  643. // 8
  644.  
  645.         0,0,0,0,0,0,0,0,
  646.  
  647.         0,0,0,0,0,0,0,0,
  648.  
  649. // 9
  650.  
  651.         0,0,0,0,0,0,0,0,
  652.  
  653.         0,0,0,0,0,0,0,0,
  654.  
  655. // a
  656.  
  657.         0,0,0,0,0,0,0,0,
  658.  
  659.         0,0,0,0,0,0,0,0,
  660.  
  661. // b
  662.  
  663.         0,0,0,0,0,0,0,0,
  664.  
  665.         0,0,0,0,0,0,0,0,
  666.  
  667. // c
  668.  
  669.         0,0,"cmpsd %RX,%EX,%Ib",0,
  670.  
  671.         0,0,0,0,
  672.  
  673.         0,0,0,0,
  674.  
  675.         0,0,0,0,
  676.  
  677. // d
  678.  
  679.         "addsubps %RX,%EX",0,0,0,
  680.  
  681.         0,0,"movdq2q %RM,%RX",0,
  682.  
  683.         0,0,0,0,
  684.  
  685.         0,0,0,0,
  686.  
  687. // e
  688.  
  689.         0,0,0,0,
  690.  
  691.         0,0,"cvtpd2dq %RX,%EX",0,
  692.  
  693.         0,0,0,0,0,0,0,0,
  694.  
  695. // f
  696.  
  697.         "lddqu %Md,%RX",0,0,0,
  698.  
  699.         0,0,0,0,
  700.  
  701.         0,0,0,0,
  702.  
  703.         0,0,0,0
  704.  
  705. };
  706.  
  707.  
  708.  
  709. const char *second_660f[]={
  710.  
  711. // 0
  712.  
  713.         0,0,0,0,
  714.  
  715.         0,0,0,0,
  716.  
  717.         0,0,0,0,
  718.  
  719.         0,0,0,0,
  720.  
  721. // 1
  722.  
  723.         "movupd %RX,%Md","movupd %Md,%RX","movlpd %RX,%Md","movlpd %Md,%RX",
  724.  
  725.         "unpcklpd %RX,%EX","unpckhpd %RX,%EX","movhpd %RX,%Md","movhpd %Md,%RX",
  726.  
  727.         0,0,0,0,
  728.  
  729.         0,0,0,0,
  730.  
  731. // 2
  732.  
  733.         0,0,0,0,
  734.  
  735.         0,0,0,0,
  736.  
  737.         "movapd %RX,%EX",   "movapd %Md,%RX",  "cvtpi2pd %RX,%EM","movntpd %Md,%RX",
  738.  
  739.         "cvttpd2pi %RM,%EX","cvtpd2pi %RM,%EX","ucomisd %RX,%EX","comisd %RX,%EX",
  740.  
  741. // 3
  742.  
  743.         0,0,0,0,0,0,0,0,
  744.  
  745.         0,0,0,0,0,0,0,0,
  746.  
  747. // 4
  748.  
  749.         0,0,0,0,0,0,0,0,
  750.  
  751.         0,0,0,0,0,0,0,0,
  752.  
  753. // 5
  754.  
  755.         "movmskpd %Rd,%GX","sqrtpd %RX,%EX",0,0,
  756.  
  757.         "andpd %RX,%EX","andnpd %RX,%EX","orpd %RX,%MX","xorpd %RX,%EX",
  758.  
  759.         "addpd %RX,%EX","mulpd %RX,%MX","cvtpd2ps %RX,%EX","cvtps2dq %RX,%EX",
  760.  
  761.         "subpd %RX,%EX","minpd %RX,%EX","divpd %RX,%EX","maxpd %RX,%EX",
  762.  
  763. // 6
  764.  
  765.         "punpcklbw %RX,%EX", "punpcklwd %RX,%EX", "punpckldq %RX,%EX","packsswb %RX,%EX",
  766.  
  767.         "pcmpgtb %RX,%EX",   "pcmpgtw %RX,%EX",   "pcmpgtd %RX,%EX",  "packuswb %RX,%EX",
  768.  
  769.         "punpckhbw %RX,%EX", "punpckhwd %RX,%EX", "punpckhdq %RX,%EX","packssdw %RX,%EX",
  770.  
  771.         "punpcklqdq %RX,%EX","punpckhqdq %RX,%EX","movd %RX,%Md",     "movdqa %RX,%EX",
  772.  
  773. // 7
  774.  
  775.         "pshufd %RX,%EX,%Ib","%g3w %EX,%Ib",    "%g3d %EX,%Ib","%g9",
  776.  
  777.         "pcmpeqb %RX,%EX",  "pcmpeqw %RX,%EX", "pcmpeqd %RX,%EX",0,
  778.  
  779.         0,0,0,0,
  780.  
  781.         "haddpd %RX,%EX","hsubpd %RX,%EX","movd %Md,%RX","movdqa %Md,%RX",
  782.  
  783. // 8
  784.  
  785.         0,0,0,0,0,0,0,0,
  786.  
  787.         0,0,0,0,0,0,0,0,
  788.  
  789. // 9
  790.  
  791.         0,0,0,0,0,0,0,0,
  792.  
  793.         0,0,0,0,0,0,0,0,
  794.  
  795. // a
  796.  
  797.         0,0,0,0,0,0,0,0,
  798.  
  799.         0,0,0,0,0,0,0,0,
  800.  
  801. // b
  802.  
  803.         0,0,0,0,0,0,0,0,
  804.  
  805.         0,0,0,0,0,0,0,0,
  806.  
  807. // c
  808.  
  809.         0,0,"cmppd %RX,%EX,%Ib",0,
  810.  
  811.         "pinsrw %LX,%Fd,%Ib","pextrw %Gd,%RX,%Ib","shufpd %RX,%EX,%Ib",0,
  812.  
  813.         0,0,0,0,
  814.  
  815.         0,0,0,0,
  816.  
  817. // d
  818.  
  819.         "addsubpd %RX,%EX","psrlw %RX,%EX",  "psrld %RX,%EX", "psrlq %RX,%EX",
  820.  
  821.         "paddq %RX,%EX",   "pmullw %RX,%EX", "movq %Md,%RX",  "pmovmskb %Rd,%GX",
  822.  
  823.         "psubusb %RX,%EX", "psubusw %RX,%EX","pminub %RX,%EX","pand %RX,%EX",
  824.  
  825.         "paddusb %RX,%EX", "paddusw %RX,%EX","pmaxub %RX,%EX","pandn %RX,%EX",
  826.  
  827. // e
  828.  
  829.         "pavgb %RX,%EX",   "psraw %RX,%EX", "psrad %RX,%EX",    "pavgw %RX,%EX",
  830.  
  831.         "pmulhuw %RX,%EX", "pmulhw %RX,%EX","cvttpd2dq %RX,%EX","movntdq %Md,%RX",
  832.  
  833.         "psubsb %RX,%EX",  "psubsw %RX,%EX","pminsw %RX,%EX",   "por %RX,%EX",
  834.  
  835.         "paddsb %RX,%EX",  "paddsw %RX,%EX","pmaxsw %RX,%EX",   "pxor %RX,%EX",
  836.  
  837. // f
  838.  
  839.         0,                 "psllw %RX,%EX",  "pslld %RX,%EX", "psllq %RX,%EX",
  840.  
  841.         "pmuludq %RX,%EX", "pmaddwd %RX,%EX","psadbw %RX,%EX","maskmovdqu %RX,%RX",
  842.  
  843.         "psubb %RX,%EX",   "psubw %RX,%EX",  "psubd %RX,%EX", "psubq %RX,%EX",
  844.  
  845.         "paddb %RX,%EX",   "paddw %RX,%EX",  "paddd %RX,%EX", 0
  846.  
  847. };
  848.  
  849.  
  850.  
  851. char *groups[][8] = {   /* group 0 is group 3 for %Ev set */
  852.  
  853. /* 0 */
  854.  
  855.   { "add",            "or",              "adc",            "sbb",
  856.  
  857.     "and",            "sub",             "xor",            "cmp"           },
  858.  
  859. /* 1 */
  860.  
  861.   { "rol",            "ror",             "rcl",            "rcr",
  862.  
  863.     "shl",            "shr",             "shl",            "sar"           },
  864.  
  865. /* 2 */  /* v   v*/
  866.  
  867.   { "test %Eq,%Iq",   0/*"test %Eq,%Iq"*/,    "not %Ec",        "neg %Ec",
  868.  
  869.     "mul %Ec",        "imul %Ec",        "div %Ec",        "idiv %Ec" },
  870.  
  871. /* 3 */
  872.  
  873.   { "inc %Eb",        "dec %Eb",         "psrl",           0,
  874.  
  875.     "psra",           0,                 "psll",           0          },
  876.  
  877. /* 4 */
  878.  
  879.   { "inc %Ev",        "dec %Ev",         "call %Kn%Ev",  "call %Kf%Ep",
  880.  
  881.     "jmp %Kn%Ev",     "jmp %Kf%Ep",      "push %Ev",       0               },
  882.  
  883. /* 5 */
  884.  
  885.   { "sldt %Ew",       "str %Ew",         "lldt %Ew",       "ltr %Ew",
  886.  
  887.     "verr %Ew",       "verw %Ew",        0,                0               },
  888.  
  889. /* 6 */
  890.  
  891.   { "sgdt %Ms",       "sidt %Ms",        "lgdt %Ms",       "lidt %Ms",
  892.  
  893.     "smsw %Ew",       0,                 "lmsw %Ew",       "invlpg %Em"    },
  894.  
  895. /* 7 */
  896.  
  897.   { "prefetchnta %Em","prefetcht0 %Em",  "prefetcht1 %Em", "prefetcht2 %Em",
  898.  
  899.     "bt",             "bts",             "btr",            "btc"           },
  900.  
  901. /* 8 */
  902.  
  903.         { "fxsave %Em",    "fxrstor %Em",      "ldmxcsr %Em",    "stmxcsr %Em",
  904.  
  905.                 0,               "lfence",           "mfence",         "%x2"        },
  906.  
  907. /* 9 */
  908.  
  909.         {
  910.  
  911.                 0,0,"psrlq %RX,%Ib","psrldq %RX,%Ib",
  912.  
  913.                 0,0,"psllq %RX,%Ib","pslldq %RX,%Ib"
  914.  
  915.         }
  916.  
  917.  
  918.  
  919. };
  920.  
  921.  
  922.  
  923. /* zero here means invalid.  If first entry starts with '*', use st(i) */
  924.  
  925. /* no assumed %EFs here.  Indexed by RM(modrm())                       */
  926.  
  927. char *f0[]     = { 0, 0, 0, 0, 0, 0, 0, 0};
  928.  
  929. char *fop_9[]  = { "*fxch st,%GF",0,0,0,0,0,0,0 };
  930.  
  931. char *fop_10[] = { "fnop", 0, 0, 0, 0, 0, 0, 0 };
  932.  
  933. char *fop_12[] = { "fchs", "fabs", 0, 0, "ftst", "fxam", 0, 0 };
  934.  
  935. char *fop_13[] = { "fld1", "fldl2t", "fldl2e", "fldpi",
  936.  
  937.                    "fldlg2", "fldln2", "fldz", 0 };
  938.  
  939. char *fop_14[] = { "f2xm1", "fyl2x", "fptan", "fpatan",
  940.  
  941.                    "fxtract", "fprem1", "fdecstp", "fincstp" };
  942.  
  943. char *fop_15[] = { "fprem", "fyl2xp1", "fsqrt", "fsincos",
  944.  
  945.                    "frndint", "fscale", "fsin", "fcos" };
  946.  
  947. char *fop_21[] = { 0, "fucompp", 0, 0, 0, 0, 0, 0 };
  948.  
  949. char *fop_28[] = { "fneni", "fndisi", "fnclex", "fninit", "fnsetpm", 0, 0, 0 };
  950.  
  951. char *fop_32[] = { "*fadd %GF,st",0,0,0,0,0,0,0 };
  952.  
  953. char *fop_33[] = { "*fmul %GF,st",0,0,0,0,0,0,0 };
  954.  
  955. char *fop_36[] = { "*fsubr %GF,st",0,0,0,0,0,0,0 };
  956.  
  957. char *fop_37[] = { "*fsub %GF,st",0,0,0,0,0,0,0 };
  958.  
  959. char *fop_38[] = { "*fdivr %GF,st",0,0,0,0,0,0,0 };
  960.  
  961. char *fop_39[] = { "*fdiv %GF,st",0,0,0,0,0,0,0 };
  962.  
  963. char *fop_40[] = { "*ffree %GF",0,0,0,0,0,0,0 };
  964.  
  965. char *fop_42[] = { "*fst %GF",0,0,0,0,0,0,0 };
  966.  
  967. char *fop_43[] = { "*fstp %GF",0,0,0,0,0,0,0 };
  968.  
  969. char *fop_44[] = { "*fucom %GF",0,0,0,0,0,0,0 };
  970.  
  971. char *fop_45[] = { "*fucomp %GF",0,0,0,0,0,0,0 };
  972.  
  973. char *fop_48[] = { "*faddp %GF,st",0,0,0,0,0,0,0 };
  974.  
  975. char *fop_49[] = { "*fmulp %GF,st",0,0,0,0,0,0,0 };
  976.  
  977. char *fop_51[] = { 0, "fcompp", 0, 0, 0, 0, 0, 0 };
  978.  
  979. char *fop_52[] = { "*fsubrp %GF,st",0,0,0,0,0,0,0 };
  980.  
  981. char *fop_53[] = { "*fsubp %GF,st",0,0,0,0,0,0,0 };
  982.  
  983. char *fop_54[] = { "*fdivrp %GF,st",0,0,0,0,0,0,0 };
  984.  
  985. char *fop_55[] = { "*fdivp %GF,st",0,0,0,0,0,0,0 };
  986.  
  987. char *fop_60[] = { "fnstsw ax", 0, 0, 0, 0, 0, 0, 0 };
  988.  
  989. char *fop_16[]={"*fcmovb st,%GF",0,0,0,0,0,0,0};
  990.  
  991. char *fop_17[]={"*fcmove st,%GF",0,0,0,0,0,0,0};
  992.  
  993. char *fop_18[]={"*fcmovbe st,%GF",0,0,0,0,0,0,0};
  994.  
  995. char *fop_19[]={"*fcmovu st,%GF",0,0,0,0,0,0,0};
  996.  
  997. char *fop_24[]={"*fcmovnb st,%GF",0,0,0,0,0,0,0};
  998.  
  999. char *fop_25[]={"*fcmovne st,%GF",0,0,0,0,0,0,0};
  1000.  
  1001. char *fop_26[]={"*fcmovnbe st,%GF",0,0,0,0,0,0,0};
  1002.  
  1003. char *fop_27[]={"*fcmovnu st,%GF",0,0,0,0,0,0,0};
  1004.  
  1005. char *fop_29[]={"*fucomi st,%GF",0,0,0,0,0,0,0};
  1006.  
  1007. char *fop_30[]={"*fcomi st,%GF",0,0,0,0,0,0,0};
  1008.  
  1009. char *fop_61[]={"*fucomip st,%GF",0,0,0,0,0,0,0};
  1010.  
  1011. char *fop_62[]={"*fcomip st,%GF",0,0,0,0,0,0,0};
  1012.  
  1013.  
  1014.  
  1015. char **fspecial[] = { /* 0=use st(i), 1=undefined 0 in fop_* means undefined */
  1016.  
  1017.   0, 0, 0, 0, 0, 0, 0, 0,
  1018.  
  1019.   0, fop_9, fop_10, 0, fop_12, fop_13, fop_14, fop_15,
  1020.  
  1021.   fop_16, fop_17, fop_18, fop_19, f0, fop_21, f0, f0,
  1022.  
  1023.   fop_24, fop_25, fop_26, fop_27, fop_28, fop_29, fop_30, f0,
  1024.  
  1025.   fop_32, fop_33, f0, f0, fop_36, fop_37, fop_38, fop_39,
  1026.  
  1027.   fop_40, f0, fop_42, fop_43, fop_44, fop_45, f0, f0,
  1028.  
  1029.   fop_48, fop_49, f0, fop_51, fop_52, fop_53, fop_54, fop_55,
  1030.  
  1031.   f0, f0, f0, f0, fop_60, fop_61, fop_62, f0
  1032.  
  1033. };
  1034.  
  1035.  
  1036.  
  1037. char *floatops[] = { /* assumed " %EF" at end of each.  mod != 3 only */
  1038.  
  1039. /*00*/ "fadd", "fmul", "fcom", "fcomp",
  1040.  
  1041.        "fsub", "fsubr", "fdiv", "fdivr",
  1042.  
  1043. /*08*/ "fld", 0, "fst", "fstp",
  1044.  
  1045.        "fldenv", "fldcw", "fnstenv", "fnstcw",
  1046.  
  1047. /*16*/ "fiadd", "fimul", "ficomw", "ficompw",
  1048.  
  1049.        "fisub", "fisubr", "fidiv", "fidivr",
  1050.  
  1051. /*24*/ "fild", 0, "fist", "fistp",
  1052.  
  1053.        "frstor", "fldt", 0, "fstpt",
  1054.  
  1055. /*32*/ "faddq", "fmulq", "fcomq", "fcompq",
  1056.  
  1057.        "fsubq", "fsubrq", "fdivq", "fdivrq",
  1058.  
  1059. /*40*/ "fldq", 0, "fstq", "fstpq",
  1060.  
  1061.        0, 0, "fnsave", "fnstsw",
  1062.  
  1063. /*48*/ "fiaddw", "fimulw", "ficomw", "ficompw",
  1064.  
  1065.        "fisubw", "fisubrw", "fidivw", "fidivr",
  1066.  
  1067. /*56*/ "fildw", 0, "fistw", "fistpw",
  1068.  
  1069.        "fbldt", "fildq", "fbstpt", "fistpq"
  1070.  
  1071. };
  1072.  
  1073.  
  1074.  
  1075. /* variables controlled by command line flags */
  1076.  
  1077. unsigned char seg_size=16;   /* default size is 16 */
  1078.  
  1079. unsigned char must_do_size;
  1080.  
  1081.  
  1082.  
  1083. unsigned int wordop,qwordop;           /* dealing with word or byte operand */
  1084.  
  1085. unsigned long instruction_offset;
  1086.  
  1087. unsigned short done_space; /* for opcodes with > one space */
  1088.  
  1089.  
  1090.  
  1091. char ubuf[100],*ubufp;
  1092.  
  1093. int col;               /* output column */
  1094.  
  1095. unsigned int prefix;            /* segment override prefix byte */
  1096.  
  1097. unsigned int modrmv;            /* flag for getting modrm byte */
  1098.  
  1099. unsigned int sibv;              /* flag for getting sib byte   */
  1100.  
  1101. unsigned int opsize;            /* just like it says ...       */
  1102.  
  1103. unsigned int addrsize;
  1104.  
  1105.  
  1106.  
  1107. void printbyte(unsigned char c)
  1108.  
  1109. {
  1110.  
  1111.         if(c<10)uprintf("%u",(unsigned char)c);
  1112.  
  1113.         else if(c<16||c>0x9F)uprintf("0%Xh",(unsigned char)c);
  1114.  
  1115.         else uprintf("%Xh",(unsigned char)c);
  1116.  
  1117. }
  1118.  
  1119.  
  1120.  
  1121. void printword(unsigned short c)
  1122.  
  1123. {
  1124.  
  1125.         if(c<256)printbyte(c);
  1126.  
  1127.         else if(c<0xA00||(c>0xFFF&&c<0xA000))uprintf("%Xh",c);
  1128.  
  1129.         else uprintf("0%Xh",c);
  1130.  
  1131. }
  1132.  
  1133.  
  1134.  
  1135. void printdword(unsigned int c)
  1136.  
  1137. {
  1138.  
  1139.         if(c<65536)printword((unsigned short)c);
  1140.  
  1141.         else if(c<0xA0000L||(c>0xFFFFFL&&c<0xA00000L)||(c>0xFFFFFFL&&c<0xA000000L)||
  1142.  
  1143.                         (c>0xFFFFFFFL&&c<0xA0000000L))uprintf("%lXh",c);
  1144.  
  1145.         else uprintf("0%lXh",c);
  1146.  
  1147. }
  1148.  
  1149.  
  1150.  
  1151. void addr_to_hex(long addr, unsigned char splitup)
  1152.  
  1153. {
  1154.  
  1155. static char buffer[25];
  1156.  
  1157. WORD32 adr;
  1158.  
  1159.   adr.dword=addr;
  1160.  
  1161.   if(splitup){
  1162.  
  1163.     if(adr.w.seg==0/*||adr.w.seg==0xffff*/)printword(adr.w.ofs);//sprintf(buffer,"%04Xh",adr.w.ofs);
  1164.  
  1165.     else{
  1166.  
  1167.                         sprintf(buffer,"%04Xh:%04Xh",adr.w.seg,adr.w.ofs);
  1168.  
  1169.                         uprintf("%s",buffer);
  1170.  
  1171.                 }
  1172.  
  1173.   }
  1174.  
  1175.         else{
  1176.  
  1177.     if(adr.w.seg==0/*||adr.w.seg==0xffff*/)printword(adr.w.ofs);//sprintf(buffer,"%04Xh",adr.w.ofs);
  1178.  
  1179.     else printdword(addr);//sprintf(buffer, "%08lXh",addr);
  1180.  
  1181.   }
  1182.  
  1183. }
  1184.  
  1185.  
  1186.  
  1187. unsigned char getbyte(void)
  1188.  
  1189. {
  1190.  
  1191. short c;
  1192.  
  1193.   c=output[outptr++];
  1194.  
  1195.   fprintf(hout,"%02X", c);   /* print out byte */
  1196.  
  1197.   col+=2;
  1198.  
  1199.   instruction_offset++;
  1200.  
  1201.   return c;
  1202.  
  1203. }
  1204.  
  1205.  
  1206.  
  1207. int modrm()
  1208.  
  1209. {
  1210.  
  1211.   if (modrmv == -1) modrmv = getbyte();
  1212.  
  1213.   return modrmv;
  1214.  
  1215. }
  1216.  
  1217.  
  1218.  
  1219. int sib()
  1220.  
  1221. {
  1222.  
  1223.   if (sibv == -1) sibv = getbyte();
  1224.  
  1225.   return sibv;
  1226.  
  1227. }
  1228.  
  1229.  
  1230.  
  1231. /*------------------------------------------------------------------------*/
  1232.  
  1233. void uprintf(char *s, ...)
  1234.  
  1235. {
  1236.  
  1237. va_list argptr;
  1238.  
  1239.         va_start(argptr,s);
  1240.  
  1241.         vsprintf(ubufp,s,argptr);
  1242.  
  1243.         va_end(argptr);
  1244.  
  1245.   while (*ubufp) ubufp++;
  1246.  
  1247. }
  1248.  
  1249.  
  1250.  
  1251. void uputchar(char c)
  1252.  
  1253. {
  1254.  
  1255.   if (c == '\t') {
  1256.  
  1257.     if(done_space)uputchar(' ');
  1258.  
  1259.                 else {
  1260.  
  1261.       done_space=1;
  1262.  
  1263.       do {
  1264.  
  1265.         *ubufp++ = ' ';
  1266.  
  1267.       } while ((ubufp-ubuf) % 8);
  1268.  
  1269.     }
  1270.  
  1271.   }
  1272.  
  1273.         else *ubufp++ = c;
  1274.  
  1275.   *ubufp = 0;
  1276.  
  1277. }
  1278.  
  1279.  
  1280.  
  1281. /*------------------------------------------------------------------------*/
  1282.  
  1283. int bytes(char c)
  1284.  
  1285. {
  1286.  
  1287.   switch (c){
  1288.  
  1289.   case 'b': return 1;
  1290.  
  1291.   case 'w': return 2;
  1292.  
  1293.   case 'd': return 4;
  1294.  
  1295.   case 'v':
  1296.  
  1297.        if (opsize == 32) return 4;
  1298.  
  1299.        else return 2;
  1300.  
  1301.   }
  1302.  
  1303.   return 0;
  1304.  
  1305. }
  1306.  
  1307.  
  1308.  
  1309. /*------------------------------------------------------------------------*/
  1310.  
  1311. void outhex(char subtype, int extend, int optional, int defsize, int sign)
  1312.  
  1313. {
  1314.  
  1315. int n=0, s=0, i;
  1316.  
  1317. long delta;
  1318.  
  1319. unsigned char buff[6];
  1320.  
  1321. //char *name;
  1322.  
  1323. char  signchar;
  1324.  
  1325.   switch (subtype) {
  1326.  
  1327.   case 'q':
  1328.  
  1329.        if (wordop) {
  1330.  
  1331.          if (opsize==16) n = 2;
  1332.  
  1333.                                  else n = 4;
  1334.  
  1335.        }
  1336.  
  1337.                          else n = 1;
  1338.  
  1339.        break;
  1340.  
  1341.  
  1342.  
  1343.   case 'a': break;
  1344.  
  1345.   case 'x':
  1346.  
  1347.        extend = defsize/8;//2;
  1348.  
  1349.        n = 1;
  1350.  
  1351.        break;
  1352.  
  1353.   case 'b':
  1354.  
  1355.        n = 1;
  1356.  
  1357.        break;
  1358.  
  1359.   case 'w':
  1360.  
  1361.        n = 2;
  1362.  
  1363.        break;
  1364.  
  1365.   case 'd':
  1366.  
  1367.        n = 4;
  1368.  
  1369.        break;
  1370.  
  1371.   case 's':
  1372.  
  1373.        n = 6;
  1374.  
  1375.        break;
  1376.  
  1377.   case 'c':
  1378.  
  1379.   case 'v':
  1380.  
  1381.        if (defsize == 32) n = 4;
  1382.  
  1383.        else n = 2;
  1384.  
  1385.        break;
  1386.  
  1387.   case 'p':
  1388.  
  1389.        if (defsize == 32) n = 6;
  1390.  
  1391.        else n = 4;
  1392.  
  1393.        s = 1;
  1394.  
  1395.        break;
  1396.  
  1397.   }
  1398.  
  1399.   for (i=0; i<n; i++) buff[i] = getbyte();
  1400.  
  1401.   for(;i<extend;i++)buff[i]=(buff[i-1]&0x80)?(unsigned char)0xff:(unsigned char)0;
  1402.  
  1403.   if (s) {
  1404.  
  1405.     uprintf("%02X%02X:", buff[n-1], buff[n-2]);
  1406.  
  1407.     n -= 2;
  1408.  
  1409.   }
  1410.  
  1411.   switch (n) {
  1412.  
  1413.   case 1:
  1414.  
  1415.        delta = *(signed char *)buff;
  1416.  
  1417.        break;
  1418.  
  1419.   case 2:
  1420.  
  1421.        delta = *(signed short *)buff;
  1422.  
  1423.        break;
  1424.  
  1425.   case 4:
  1426.  
  1427.        delta = *(signed long *)buff;
  1428.  
  1429.        break;
  1430.  
  1431.   }
  1432.  
  1433.   if (extend > n) {
  1434.  
  1435.     if (subtype!='x') {
  1436.  
  1437.       if ((long)delta<0) {
  1438.  
  1439.         delta = -delta;
  1440.  
  1441.         signchar = '-';
  1442.  
  1443.       }
  1444.  
  1445.                         else signchar = '+';
  1446.  
  1447.       if (delta || !optional){
  1448.  
  1449.                                 uprintf("%c",signchar);
  1450.  
  1451.                                 printdword(delta);
  1452.  
  1453. //        uprintf("%c%0*lXh", signchar, extend+1, delta);
  1454.  
  1455.                         }
  1456.  
  1457.     }
  1458.  
  1459.                 else {
  1460.  
  1461.       if (extend==2)
  1462.  
  1463.         delta = (unsigned short) delta;
  1464.  
  1465.                         printdword(delta);
  1466.  
  1467. //     uprintf("%0.*lXh", 2*extend+1, delta);
  1468.  
  1469.     }
  1470.  
  1471.     return;
  1472.  
  1473.   }
  1474.  
  1475.   if ((n == 4) && !sign) {
  1476.  
  1477.     addr_to_hex(delta, 0);
  1478.  
  1479.     return;
  1480.  
  1481.   }
  1482.  
  1483.   switch (n) {
  1484.  
  1485.   case 1:
  1486.  
  1487.        if (sign && (char)delta<0) {
  1488.  
  1489.          delta = -delta;
  1490.  
  1491.          signchar = '-';
  1492.  
  1493.        }
  1494.  
  1495.                          else signchar = '+';
  1496.  
  1497.                         if(sign)uprintf("%c",signchar);
  1498.  
  1499.                         printbyte((unsigned char)delta);
  1500.  
  1501. //       if (sign)uprintf("%c%03Xh",signchar,(unsigned char)delta);
  1502.  
  1503. //       else uprintf("%03Xh", (unsigned char)delta);
  1504.  
  1505.        break;
  1506.  
  1507.   case 2:
  1508.  
  1509.        if (sign && (int)delta<0) {
  1510.  
  1511.          signchar = '-';
  1512.  
  1513.          delta = -delta;
  1514.  
  1515.        }
  1516.  
  1517.                          else signchar = '+';
  1518.  
  1519.                         if(sign)uprintf("%c",signchar);
  1520.  
  1521.                         printword((unsigned short)delta);
  1522.  
  1523. //       if (sign) uprintf("%c%05Xh", signchar,(int)delta);
  1524.  
  1525. //       else uprintf("%05Xh", (unsigned int)delta);
  1526.  
  1527.        break;
  1528.  
  1529.   case 4:
  1530.  
  1531.        if (sign && (long)delta<0) {
  1532.  
  1533.          delta = -delta;
  1534.  
  1535.          signchar = '-';
  1536.  
  1537.        }
  1538.  
  1539.                          else signchar = '+';
  1540.  
  1541.                         if(sign)uprintf("%c",signchar);
  1542.  
  1543.                         printdword(delta);
  1544.  
  1545. //       if (sign)uprintf("%c%09lXh", signchar, (unsigned long)delta);
  1546.  
  1547. //       else uprintf("%09lXh", (unsigned long)delta);
  1548.  
  1549.        break;
  1550.  
  1551.   }
  1552.  
  1553. }
  1554.  
  1555.  
  1556.  
  1557. /*------------------------------------------------------------------------*/
  1558.  
  1559. void reg_name(int regnum, char size)
  1560.  
  1561. {
  1562.  
  1563.   if (size == 'F') { /* floating point register? */
  1564.  
  1565.     uprintf("st(%d)", regnum);
  1566.  
  1567.     return;
  1568.  
  1569.   }
  1570.  
  1571.   if (size == 'M') { /* multimedia register? */
  1572.  
  1573.     uprintf("mm%d", regnum);
  1574.  
  1575.     return;
  1576.  
  1577.   }
  1578.  
  1579.   if(size=='X'){ /* xmm register? */
  1580.  
  1581.     uprintf("xmm%d",regnum);
  1582.  
  1583.     return;
  1584.  
  1585.   }
  1586.  
  1587.   if (((size == 'v') && (opsize == 32)) ||
  1588.  
  1589.              (size == 'd')||
  1590.  
  1591.                          ((size=='c'||size=='q')&&wordop&&opsize==32)
  1592.  
  1593.                          ) uputchar('e');
  1594.  
  1595. //      printf("size=%c wordop=%d opsize=%d\n",size,wordop,opsize);
  1596.  
  1597.   if(size=='b'||((size=='q'||size=='c')&&!wordop)){
  1598.  
  1599.     uputchar("acdbacdb"[regnum]);
  1600.  
  1601.     uputchar("llllhhhh"[regnum]);
  1602.  
  1603.   }
  1604.  
  1605.         else {
  1606.  
  1607.     uputchar("acdbsbsd"[regnum]);
  1608.  
  1609.     uputchar("xxxxppii"[regnum]);
  1610.  
  1611.   }
  1612.  
  1613. }
  1614.  
  1615.  
  1616.  
  1617. /*------------------------------------------------------------------------*/
  1618.  
  1619. void do_sib(int m)
  1620.  
  1621. {
  1622.  
  1623. int s, i, b;
  1624.  
  1625.   s = SCALE(sib());
  1626.  
  1627.   i = INDEX(sib());
  1628.  
  1629.   b = BASE(sib());
  1630.  
  1631.   switch (b) {     /* pick base */
  1632.  
  1633.   case 0: ua_str("%p:[eax"); break;
  1634.  
  1635.   case 1: ua_str("%p:[ecx"); break;
  1636.  
  1637.   case 2: ua_str("%p:[edx"); break;
  1638.  
  1639.   case 3: ua_str("%p:[ebx"); break;
  1640.  
  1641.   case 4: ua_str("%p:[esp"); break;
  1642.  
  1643.   case 5:
  1644.  
  1645.        if (m == 0) {
  1646.  
  1647.          ua_str("%p:[");
  1648.  
  1649.          outhex('d', 4, 0, addrsize, 0);
  1650.  
  1651.        }
  1652.  
  1653.                          else ua_str("%p:[ebp");
  1654.  
  1655.        break;
  1656.  
  1657.   case 6: ua_str("%p:[esi"); break;
  1658.  
  1659.   case 7: ua_str("%p:[edi"); break;
  1660.  
  1661.   }
  1662.  
  1663.   switch (i) {     /* and index */
  1664.  
  1665.   case 0: uprintf("+eax"); break;
  1666.  
  1667.   case 1: uprintf("+ecx"); break;
  1668.  
  1669.   case 2: uprintf("+edx"); break;
  1670.  
  1671.   case 3: uprintf("+ebx"); break;
  1672.  
  1673.   case 4: break;
  1674.  
  1675.   case 5: uprintf("+ebp"); break;
  1676.  
  1677.   case 6: uprintf("+esi"); break;
  1678.  
  1679.   case 7: uprintf("+edi"); break;
  1680.  
  1681.   }
  1682.  
  1683.   if (i != 4) {
  1684.  
  1685.     switch (s) {    /* and scale */
  1686.  
  1687.       case 0: uprintf(""); break;
  1688.  
  1689.       case 1: uprintf("*2"); break;
  1690.  
  1691.       case 2: uprintf("*4"); break;
  1692.  
  1693.       case 3: uprintf("*8"); break;
  1694.  
  1695.     }
  1696.  
  1697.   }
  1698.  
  1699. }
  1700.  
  1701.  
  1702.  
  1703. /*------------------------------------------------------------------------*/
  1704.  
  1705. void do_modrm(char subtype)
  1706.  
  1707. {
  1708.  
  1709. int mod = MOD(modrm());
  1710.  
  1711. int rm = RM(modrm());
  1712.  
  1713. int extend = (addrsize == 32) ? 4 : 2;
  1714.  
  1715.   if (mod == 3) { /* specifies two registers */
  1716.  
  1717.     reg_name(rm, subtype);
  1718.  
  1719.     return;
  1720.  
  1721.   }
  1722.  
  1723.   if (must_do_size) {
  1724.  
  1725.                 if(qwordop)ua_str("qword ptr ");
  1726.  
  1727.                 else{
  1728.  
  1729.             if (wordop) {
  1730.  
  1731.             if (/*addrsize==32 ||*/ opsize==32) {       /* then must specify size */
  1732.  
  1733.             ua_str("dword ptr ");
  1734.  
  1735.         }
  1736.  
  1737.                                 else ua_str("word ptr ");
  1738.  
  1739.           }
  1740.  
  1741.                         else ua_str("byte ptr ");
  1742.  
  1743.                 }
  1744.  
  1745.   }
  1746.  
  1747.   if ((mod == 0) && (rm == 5) && (addrsize == 32)) {/* mem operand with 32 bit ofs */
  1748.  
  1749.     ua_str("%p:[");
  1750.  
  1751.     outhex('d', extend, 0, addrsize, 0);
  1752.  
  1753.     uputchar(']');
  1754.  
  1755.     return;
  1756.  
  1757.   }
  1758.  
  1759.   if ((mod == 0) && (rm == 6) && (addrsize == 16)) { /* 16 bit dsplcmnt */
  1760.  
  1761.     ua_str("%p:[");
  1762.  
  1763.     outhex('w', extend, 0, addrsize, 0);
  1764.  
  1765.     uputchar(']');
  1766.  
  1767.     return;
  1768.  
  1769.   }
  1770.  
  1771.   if ((addrsize != 32) || (rm != 4)) ua_str("%p:[");
  1772.  
  1773.   if (addrsize == 16) {
  1774.  
  1775.     switch (rm) {
  1776.  
  1777.     case 0: uprintf("bx+si"); break;
  1778.  
  1779.     case 1: uprintf("bx+di"); break;
  1780.  
  1781.     case 2: uprintf("bp+si"); break;
  1782.  
  1783.     case 3: uprintf("bp+di"); break;
  1784.  
  1785.     case 4: uprintf("si"); break;
  1786.  
  1787.     case 5: uprintf("di"); break;
  1788.  
  1789.     case 6: uprintf("bp"); break;
  1790.  
  1791.     case 7: uprintf("bx"); break;
  1792.  
  1793.     }
  1794.  
  1795.   }
  1796.  
  1797.         else {
  1798.  
  1799.     switch (rm) {
  1800.  
  1801.     case 0: uprintf("eax"); break;
  1802.  
  1803.     case 1: uprintf("ecx"); break;
  1804.  
  1805.     case 2: uprintf("edx"); break;
  1806.  
  1807.     case 3: uprintf("ebx"); break;
  1808.  
  1809.     case 4: do_sib(mod); break;
  1810.  
  1811.     case 5: uprintf("ebp"); break;
  1812.  
  1813.     case 6: uprintf("esi"); break;
  1814.  
  1815.     case 7: uprintf("edi"); break;
  1816.  
  1817.     }
  1818.  
  1819.   }
  1820.  
  1821.   switch (mod) {
  1822.  
  1823.   case 1:
  1824.  
  1825.        outhex('b', extend, 1, addrsize, 0);
  1826.  
  1827.        break;
  1828.  
  1829.   case 2:
  1830.  
  1831.        outhex('v', extend, 1, addrsize, 1);
  1832.  
  1833.        break;
  1834.  
  1835.   }
  1836.  
  1837.   uputchar(']');
  1838.  
  1839. }
  1840.  
  1841.  
  1842.  
  1843. /*------------------------------------------------------------------------*/
  1844.  
  1845. void floating_point(int e1)
  1846.  
  1847. {
  1848.  
  1849. int esc = e1*8 + REG(modrm());
  1850.  
  1851.   if(MOD(modrm())==3){  //2-\89 \81\80\89\92>C0
  1852.  
  1853.     if (fspecial[esc]) {
  1854.  
  1855.       if (fspecial[esc][0]!=NULL&&fspecial[esc][0][0] == '*')ua_str(fspecial[esc][0]+1);
  1856.  
  1857.       else ua_str(fspecial[esc][RM(modrm())]);
  1858.  
  1859.     }
  1860.  
  1861.                 else {
  1862.  
  1863.       ua_str(floatops[esc]);
  1864.  
  1865.       ua_str(" %EF");
  1866.  
  1867.     }
  1868.  
  1869.   }
  1870.  
  1871.         else {
  1872.  
  1873.     ua_str(floatops[esc]);
  1874.  
  1875.     ua_str(" %EF");
  1876.  
  1877.   }
  1878.  
  1879. }
  1880.  
  1881.  
  1882.  
  1883. /*------------------------------------------------------------------------*/
  1884.  
  1885. /* Main table driver                                                      */
  1886.  
  1887. void percent(char type, char subtype)
  1888.  
  1889. {
  1890.  
  1891. long vofs;
  1892.  
  1893. int extend =(addrsize==32)?4:2;
  1894.  
  1895. unsigned char c;
  1896.  
  1897.         switch (type) {
  1898.  
  1899.         case 'A':                          /* direct address */
  1900.  
  1901.                 outhex(subtype,extend,0,addrsize,0);
  1902.  
  1903.                 break;
  1904.  
  1905.         case 'C':                          /* reg(r/m) picks control reg */
  1906.  
  1907.                 uprintf("CR%d",REG(modrm()));
  1908.  
  1909.                 must_do_size=0;
  1910.  
  1911.                 break;
  1912.  
  1913.   case 'D':                          /* reg(r/m) picks debug reg */
  1914.  
  1915.        uprintf("DR%d", REG(modrm()));
  1916.  
  1917.        must_do_size = 0;
  1918.  
  1919.        break;
  1920.  
  1921.   case 'E':                          /* r/m picks operand */
  1922.  
  1923.                          if(subtype=='m')must_do_size=0;
  1924.  
  1925.        do_modrm(subtype);
  1926.  
  1927.        break;
  1928.  
  1929.         case 'F':
  1930.  
  1931.                          if(MOD(modrm())!=3)do_modrm(subtype);
  1932.  
  1933.                          else reg_name(REG(modrm()),subtype);
  1934.  
  1935.                          break;
  1936.  
  1937.   case 'G':                          /* reg(r/m) picks register */
  1938.  
  1939. /*       if (subtype == 'F'||subtype == 'M')
  1940.  
  1941.          reg_name(RM(modrm()), subtype);
  1942.  
  1943.        else reg_name(REG(modrm()), subtype);*/
  1944.  
  1945.        reg_name(RM(modrm()),subtype);
  1946.  
  1947.        must_do_size = 0;
  1948.  
  1949.        break;
  1950.  
  1951.   case 'I':                            /* immed data */
  1952.  
  1953.        outhex(subtype, 0, 0, opsize, 0);
  1954.  
  1955.        break;
  1956.  
  1957.   case 'J':                            /* relative IP offset */
  1958.  
  1959.        switch(bytes(subtype)) {              /* sizeof offset value */
  1960.  
  1961.        case 1:
  1962.  
  1963.                                                 vofs=(signed char)getbyte();
  1964.  
  1965.             break;
  1966.  
  1967.        case 2:
  1968.  
  1969.             vofs = getbyte();
  1970.  
  1971.             vofs += getbyte()<<8;
  1972.  
  1973.             vofs = (short)vofs;
  1974.  
  1975.             break;
  1976.  
  1977.        case 4:
  1978.  
  1979.             vofs = (unsigned long)getbyte();           /* yuk! */
  1980.  
  1981.             vofs |= (unsigned long)getbyte() << 8;
  1982.  
  1983.             vofs |= (unsigned long)getbyte() << 16;
  1984.  
  1985.             vofs |= (unsigned long)getbyte() << 24;
  1986.  
  1987.             break;
  1988.  
  1989.        }
  1990.  
  1991.        addr_to_hex(vofs+instruction_offset,seg_size==16?(unsigned char)1:(unsigned char)0);
  1992.  
  1993.        break;
  1994.  
  1995.   case 'K':
  1996.  
  1997.                          if(seg_size==16){
  1998.  
  1999.                switch(subtype){
  2000.  
  2001.              case 'f':
  2002.  
  2003.                 ua_str("far ");
  2004.  
  2005.               break;
  2006.  
  2007.                case 'n':
  2008.  
  2009.                   ua_str("near ");
  2010.  
  2011.                 break;
  2012.  
  2013.          case 's':
  2014.  
  2015.                     ua_str("short ");
  2016.  
  2017.                   break;
  2018.  
  2019.                }
  2020.  
  2021.                          }
  2022.  
  2023.                          else if(subtype=='s')ua_str("short ");
  2024.  
  2025.        break;
  2026.  
  2027.         case 'L':
  2028.  
  2029.                          if(MOD(modrm())!=3)reg_name(REG(modrm()),subtype);
  2030.  
  2031.                          else reg_name(RM(modrm()),subtype);
  2032.  
  2033.                          break;
  2034.  
  2035.   case 'M':                            /* r/m picks memory */
  2036.  
  2037.        do_modrm(subtype);
  2038.  
  2039.        break;
  2040.  
  2041.   case 'O':                            /* offset only */
  2042.  
  2043.        ua_str("%p:[");
  2044.  
  2045.        outhex(subtype, extend, 0, addrsize, 0);
  2046.  
  2047.        uputchar(']');
  2048.  
  2049.        break;
  2050.  
  2051.   case 'P':                            /* prefix byte (rh) */
  2052.  
  2053.        ua_str("%p:");
  2054.  
  2055.        break;
  2056.  
  2057.   case 'R':                            /* mod(r/m) picks register */
  2058.  
  2059.        reg_name(REG(modrm()), subtype);      /* rh */
  2060.  
  2061.        must_do_size = 0;
  2062.  
  2063.        break;
  2064.  
  2065.   case 'S':                            /* reg(r/m) picks segment reg */
  2066.  
  2067.        uputchar("ecsdfg"[REG(modrm())]);
  2068.  
  2069.        uputchar('s');
  2070.  
  2071.        must_do_size = 0;
  2072.  
  2073.        break;
  2074.  
  2075.   case 'T':                            /* reg(r/m) picks T reg */
  2076.  
  2077.        uprintf("tr%d", REG(modrm()));
  2078.  
  2079.        must_do_size = 0;
  2080.  
  2081.        break;
  2082.  
  2083.   case 'X':                            /* ds:si type operator */
  2084.  
  2085.        uprintf("ds:[");
  2086.  
  2087.        if (addrsize == 32) uputchar('e');
  2088.  
  2089.        uprintf("si]");
  2090.  
  2091.        break;
  2092.  
  2093.   case 'Y':                            /* es:di type operator */
  2094.  
  2095.        uprintf("es:[");
  2096.  
  2097.        if (addrsize == 32) uputchar('e');
  2098.  
  2099.        uprintf("di]");
  2100.  
  2101.        break;
  2102.  
  2103.   case '2':
  2104.  
  2105.                          c=getbyte();          /* old [pop cs]! now indexes */
  2106.  
  2107.                         wordop = c & 1;
  2108.  
  2109.        ua_str(second[c]);      /* instructions in 386/486   */
  2110.  
  2111.        break;
  2112.  
  2113.   case 'd':                             /* sizeof operand==dword? */
  2114.  
  2115.        if (opsize == 32) uputchar('d');
  2116.  
  2117.        uputchar(subtype);
  2118.  
  2119.        break;
  2120.  
  2121.   case 'e':                         /* extended reg name */
  2122.  
  2123.        if (opsize == 32) {
  2124.  
  2125.          if (subtype == 'w')uputchar('d');
  2126.  
  2127.          else {
  2128.  
  2129.            uputchar('e');
  2130.  
  2131.            uputchar(subtype);
  2132.  
  2133.          }
  2134.  
  2135.        }
  2136.  
  2137.                          else uputchar(subtype);
  2138.  
  2139.        break;
  2140.  
  2141.   case 'f':                    /* '87 opcode */
  2142.  
  2143.        floating_point(subtype-'0');
  2144.  
  2145.        break;
  2146.  
  2147.   case 'j':
  2148.  
  2149.        if (/*addrsize==32 ||*/ opsize==32) /* both of them?! */
  2150.  
  2151.          uputchar('e');
  2152.  
  2153.        break;
  2154.  
  2155.   case 'g':                            /* modrm group `subtype' (0--7) */
  2156.  
  2157.                          switch(subtype){
  2158.  
  2159.                                 case '9':
  2160.  
  2161.                                         vofs=REG(modrm());
  2162.  
  2163.                                         modrmv=(modrmv&0xC7)|((modrmv&7)<<3);
  2164.  
  2165.                                         ua_str(groups[9][vofs]);
  2166.  
  2167.                                         break;
  2168.  
  2169.                                 case '6':
  2170.  
  2171.                                          if(MOD(modrm())!=3)goto defg;
  2172.  
  2173.                                          switch(modrmv){
  2174.  
  2175.                                                 case 0xc8:
  2176.  
  2177.                                                         ua_str("monitor");
  2178.  
  2179.                                                         break;
  2180.  
  2181.                                                 case 0xc9:
  2182.  
  2183.                                                         ua_str("mwait");
  2184.  
  2185.                                                         break;
  2186.  
  2187.                                                 default:
  2188.  
  2189.                                             uprintf("<invalid>");
  2190.  
  2191.                                                         break;
  2192.  
  2193.                                          }
  2194.  
  2195.                                         break;
  2196.  
  2197.                                 case '5':
  2198.  
  2199.                                         opsize=16;
  2200.  
  2201.                                 case '7':
  2202.  
  2203.                                         wordop=1;
  2204.  
  2205.                                 default:
  2206.  
  2207. defg:
  2208.  
  2209.                ua_str(groups[subtype-'0'][REG(modrm())]);
  2210.  
  2211.                                  break;
  2212.  
  2213.                          }
  2214.  
  2215.        break;
  2216.  
  2217.   case 'p':                    /* prefix byte */
  2218.  
  2219.        switch (subtype)  {
  2220.  
  2221.        case 'c':
  2222.  
  2223.        case 'd':
  2224.  
  2225.        case 'e':
  2226.  
  2227.        case 'f':
  2228.  
  2229.        case 'g':
  2230.  
  2231.        case 's':
  2232.  
  2233.             prefix = subtype;
  2234.  
  2235.             c = getbyte();
  2236.  
  2237.             wordop = c & 1;
  2238.  
  2239.             ua_str(opmap1[c]);
  2240.  
  2241.             break;
  2242.  
  2243.        case ':':
  2244.  
  2245.             if (prefix) uprintf("%cs:", prefix);
  2246.  
  2247.             break;
  2248.  
  2249.        case ' ':
  2250.  
  2251.             c = getbyte();
  2252.  
  2253.             wordop = c & 1;
  2254.  
  2255.             ua_str(opmap1[c]);
  2256.  
  2257.             break;
  2258.  
  2259.        }
  2260.  
  2261.        break;
  2262.  
  2263.   case 's':                           /* size override */
  2264.  
  2265.        switch (subtype) {
  2266.  
  2267.        case 'a':
  2268.  
  2269.             addrsize = 48 - addrsize;
  2270.  
  2271.             c = getbyte();
  2272.  
  2273.             wordop = c & 1;
  2274.  
  2275.             ua_str(opmap1[c]);
  2276.  
  2277.             break;
  2278.  
  2279.        case 'o':
  2280.  
  2281.             opsize = 48 - opsize;
  2282.  
  2283.             c = getbyte();
  2284.  
  2285.             wordop = c & 1;
  2286.  
  2287.             ua_str(opmap1[c]);
  2288.  
  2289.             break;
  2290.  
  2291.        }
  2292.  
  2293.        break;
  2294.  
  2295.   case 'w':                             /* insert explicit size specifier */
  2296.  
  2297.        if (opsize == 32)uputchar('d');
  2298.  
  2299.        else uputchar('w');
  2300.  
  2301.        uputchar(subtype);
  2302.  
  2303.        break;
  2304.  
  2305.   case 'x':
  2306.  
  2307.                          if(MOD(modrm())==3){
  2308.  
  2309.                                 switch(subtype-'0'){
  2310.  
  2311.                                         case 0:
  2312.  
  2313.                                                 ua_str("movhlps %RX,%GX");
  2314.  
  2315.                                                 break;
  2316.  
  2317.                                         case 1:
  2318.  
  2319.                                                 ua_str("movlhps %RX,%GX");
  2320.  
  2321.                                                 break;
  2322.  
  2323.                                         case 2:
  2324.  
  2325.                                                 ua_str("sfence");
  2326.  
  2327.                                                 break;
  2328.  
  2329.                                 }
  2330.  
  2331.                          }
  2332.  
  2333.                          else{
  2334.  
  2335.                                 switch(subtype-'0'){
  2336.  
  2337.                                         case 0:
  2338.  
  2339.                                                 ua_str("movlps %RX,%Md");
  2340.  
  2341.                                                 break;
  2342.  
  2343.                                         case 1:
  2344.  
  2345.                                                 ua_str("movhps %RX,%Md");
  2346.  
  2347.                                                 break;
  2348.  
  2349.                                         case 2:
  2350.  
  2351.                                                 ua_str("clflush %Em");
  2352.  
  2353.                                                 break;
  2354.  
  2355.                                 }
  2356.  
  2357.                          }
  2358.  
  2359.        break;
  2360.  
  2361.         default:
  2362.  
  2363.                          preerror("uncnown operand for dizassemler");
  2364.  
  2365.                          break;
  2366.  
  2367.    }
  2368.  
  2369. }
  2370.  
  2371.  
  2372.  
  2373. void ua_str(char *str)
  2374.  
  2375. {
  2376.  
  2377. char c;
  2378.  
  2379.   if (str == NULL) {
  2380.  
  2381.     uprintf("<invalid>");
  2382.  
  2383.     return;
  2384.  
  2385.   }
  2386.  
  2387.   if (strpbrk(str, "CDFGRST")) /* specifiers for registers=>no size 2b specified */
  2388.  
  2389.     must_do_size = 0;
  2390.  
  2391.   while ((c = *str++) != 0) {
  2392.  
  2393.     if (c == '%') {
  2394.  
  2395.       c = *str++;
  2396.  
  2397.                         if(*str=='y'){
  2398.  
  2399.                                 qwordop=1;
  2400.  
  2401.                                 str++;
  2402.  
  2403.                         }
  2404.  
  2405.       percent(c,*str++);
  2406.  
  2407.     }
  2408.  
  2409.                 else {
  2410.  
  2411.       if (c == ' ') uputchar('\t');
  2412.  
  2413.                         else uputchar(c);
  2414.  
  2415.     }
  2416.  
  2417.   }
  2418.  
  2419. }
  2420.  
  2421.  
  2422.  
  2423. void unassemble(unsigned long ofs)
  2424.  
  2425. {
  2426.  
  2427. char *str;
  2428.  
  2429. int c;
  2430.  
  2431.   fprintf(hout,seg_size==16?"%04X ":"%08lX ",ofs);
  2432.  
  2433.   prefix = 0;
  2434.  
  2435.   modrmv = sibv = 0xFFFFFFFF;     /* set modrm and sib flags */
  2436.  
  2437.   opsize = addrsize = seg_size;
  2438.  
  2439.   col = 0;
  2440.  
  2441.   ubufp = ubuf;
  2442.  
  2443.   done_space = 0;
  2444.  
  2445.   c = getbyte();
  2446.  
  2447.         if(c==0x9B){
  2448.  
  2449.                 switch(*(short *)&output[outptr]){
  2450.  
  2451.                         case 0xE0DB:
  2452.  
  2453.                         case 0xE1DB:
  2454.  
  2455.                         case 0xE2DB:
  2456.  
  2457.                         case 0xE3DB:
  2458.  
  2459.                         case 0xE4DB:
  2460.  
  2461.                                 getbyte();
  2462.  
  2463.                           c=getbyte();
  2464.  
  2465.                                 switch(c){
  2466.  
  2467.                                         case 0xE0:
  2468.  
  2469.                                                 ua_str("feni");
  2470.  
  2471.                                                 break;
  2472.  
  2473.                                         case 0xE1:
  2474.  
  2475.                                                 ua_str("fdisi");
  2476.  
  2477.                                                 break;
  2478.  
  2479.                                         case 0xE2:
  2480.  
  2481.                                                 ua_str("fclex");
  2482.  
  2483.                                                 break;
  2484.  
  2485.                                         case 0xE3:
  2486.  
  2487.                                                 ua_str("finit");
  2488.  
  2489.                                                 break;
  2490.  
  2491.                                         case 0xE4:
  2492.  
  2493.                                                 ua_str("fsetpm");
  2494.  
  2495.                                                 break;
  2496.  
  2497.                                 }
  2498.  
  2499.                                 goto endp;
  2500.  
  2501.                 }
  2502.  
  2503.         }
  2504.  
  2505.         else if(c==0x98){
  2506.  
  2507.                 if(am32){
  2508.  
  2509.                         ua_str("cwde");
  2510.  
  2511.                         goto endp;
  2512.  
  2513.                 }
  2514.  
  2515.         }
  2516.  
  2517.         else if(c==0x99){
  2518.  
  2519.                 if(am32){
  2520.  
  2521.                         ua_str("cdq");
  2522.  
  2523.                         goto endp;
  2524.  
  2525.                 }
  2526.  
  2527.         }
  2528.  
  2529.         else if(c==0x66&&am32==0){
  2530.  
  2531.                 if(output[outptr]==0x98){
  2532.  
  2533.                         ua_str("cwde");
  2534.  
  2535.                         getbyte();
  2536.  
  2537.                         goto endp;
  2538.  
  2539.                 }
  2540.  
  2541.                 if(output[outptr]==0x99){
  2542.  
  2543.                         ua_str("cdq");
  2544.  
  2545.                         getbyte();
  2546.  
  2547.                         goto endp;
  2548.  
  2549.                 }
  2550.  
  2551.         }
  2552.  
  2553.         else if(c==0xF3&&output[outptr]==0x90){
  2554.  
  2555.                 ua_str("pause");
  2556.  
  2557.                 getbyte();
  2558.  
  2559.                 goto endp;
  2560.  
  2561.         }
  2562.  
  2563.         if(output[outptr]==0x0f){
  2564.  
  2565.                 int c2=output[outptr+1];
  2566.  
  2567.                 switch(c){
  2568.  
  2569.                         case 0x66:
  2570.  
  2571.                                 if(second_660f[c2]){
  2572.  
  2573.                                         getbyte();
  2574.  
  2575.                                         ua_str((char *)second_660f[getbyte()]);
  2576.  
  2577.                                         goto endp;
  2578.  
  2579.                                 }
  2580.  
  2581.                                 break;
  2582.  
  2583.                         case 0xf2:
  2584.  
  2585.                                 if(second_f20f[c2]){
  2586.  
  2587.                                         getbyte();
  2588.  
  2589.                                         ua_str(second_f20f[getbyte()]);
  2590.  
  2591.                                         goto endp;
  2592.  
  2593.                                 }
  2594.  
  2595.                                 break;
  2596.  
  2597.                         case 0xf3:
  2598.  
  2599.                                 if(second_f30f[c2]){
  2600.  
  2601.                                         getbyte();
  2602.  
  2603.                                         ua_str(second_f30f[getbyte()]);
  2604.  
  2605.                                         goto endp;
  2606.  
  2607.                                 }
  2608.  
  2609.                                 break;
  2610.  
  2611.                 }
  2612.  
  2613.         }
  2614.  
  2615.   wordop = c & 1;
  2616.  
  2617.         qwordop=0;
  2618.  
  2619.   must_do_size = 1;
  2620.  
  2621.   if ((str = opmap1[c])==NULL) {    /* invalid instruction? */
  2622.  
  2623.     uputchar('d');                  /* then output byte defines */
  2624.  
  2625.     uputchar('b');
  2626.  
  2627.     uputchar('\t');
  2628.  
  2629.     uprintf("%02Xh",c);
  2630.  
  2631.   }
  2632.  
  2633.         else ua_str(str);                      /* valid instruction */
  2634.  
  2635. endp:
  2636.  
  2637.   fprintf(hout,"%*s", 25-col, " ");
  2638.  
  2639.   fprintf(hout,"%s\n", ubuf);
  2640.  
  2641. }
  2642.  
  2643.  
  2644.  
  2645. #define MAXSTR 12
  2646.  
  2647.  
  2648.  
  2649. void undata(unsigned ofs,unsigned long len,unsigned int type)
  2650.  
  2651. {
  2652.  
  2653. unsigned int sizet,c,i,j;
  2654.  
  2655. unsigned long total,d;
  2656.  
  2657. unsigned char data[MAXSTR];
  2658.  
  2659.         if(type==3)sizet=1;
  2660.  
  2661.         else sizet=type;
  2662.  
  2663.         for(total=0;total<len;){
  2664.  
  2665.                 col=0;
  2666.  
  2667.                 ubufp=ubuf;
  2668.  
  2669.           fprintf(hout,seg_size==16?"%04X ":"%08lX ",ofs);
  2670.  
  2671.                 if((total+sizet)>len){
  2672.  
  2673.                         type=sizet=1;
  2674.  
  2675.                 }
  2676.  
  2677.                 for(i=0;i<MAXSTR;){
  2678.  
  2679.                         switch(sizet){
  2680.  
  2681.                                 case 1:
  2682.  
  2683.                                 data[i++]=getbyte();
  2684.  
  2685.                                         break;
  2686.  
  2687.                                 case 2:
  2688.  
  2689.                                 data[i++]=getbyte();
  2690.  
  2691.                                 data[i++]=getbyte();
  2692.  
  2693.                                         total++;
  2694.  
  2695.                                         break;
  2696.  
  2697.                                 case 4:
  2698.  
  2699.                                 data[i++]=getbyte();
  2700.  
  2701.                                 data[i++]=getbyte();
  2702.  
  2703.                                 data[i++]=getbyte();
  2704.  
  2705.                                 data[i++]=getbyte();
  2706.  
  2707.                                         total+=3;
  2708.  
  2709.                                         break;
  2710.  
  2711.                                 case 8:
  2712.  
  2713.                                 data[i++]=getbyte();
  2714.  
  2715.                                 data[i++]=getbyte();
  2716.  
  2717.                                 data[i++]=getbyte();
  2718.  
  2719.                                 data[i++]=getbyte();
  2720.  
  2721.                                 data[i++]=getbyte();
  2722.  
  2723.                                 data[i++]=getbyte();
  2724.  
  2725.                                 data[i++]=getbyte();
  2726.  
  2727.                                 data[i++]=getbyte();
  2728.  
  2729.                                         total+=7;
  2730.  
  2731.                                         break;
  2732.  
  2733.                         }
  2734.  
  2735.                         total++;
  2736.  
  2737.                         if((total+sizet)>len)break;
  2738.  
  2739.                         if(sizet==8)break;
  2740.  
  2741.                 }
  2742.  
  2743.     uputchar(sizet==8?'q':'d');
  2744.  
  2745.                 switch(sizet){
  2746.  
  2747.                         case 1:
  2748.  
  2749.                     uputchar('b');
  2750.  
  2751.                                 break;
  2752.  
  2753.                         case 2:
  2754.  
  2755.                         case 8:
  2756.  
  2757.                     uputchar('w');
  2758.  
  2759.                                 break;
  2760.  
  2761.                         case 4:
  2762.  
  2763.                     uputchar('d');
  2764.  
  2765.                                 break;
  2766.  
  2767.                 }
  2768.  
  2769.           done_space=0;
  2770.  
  2771.     uputchar('\t');
  2772.  
  2773.                 switch(type){
  2774.  
  2775.                         case 1:
  2776.  
  2777.                                 for(j=0;j<i;j++){
  2778.  
  2779.                                         printbyte(data[j]);
  2780.  
  2781.                                         if((j+1)!=i)uputchar(',');
  2782.  
  2783.                                 }
  2784.  
  2785.                                 break;
  2786.  
  2787.                         case 2:
  2788.  
  2789.                                 for(j=0;j<i;){
  2790.  
  2791.                                         d=data[j++];
  2792.  
  2793.                                         d+=data[j++]<<8;
  2794.  
  2795.                                         printword((unsigned short)d);
  2796.  
  2797. //                                      uprintf("%05Xh",(unsigned int)d);
  2798.  
  2799.                                         if(j!=i)uputchar(',');
  2800.  
  2801.                                 }
  2802.  
  2803.                                 break;
  2804.  
  2805.                         case 3:
  2806.  
  2807.                                 c=0;
  2808.  
  2809.                                 for(j=0;j<i;j++){
  2810.  
  2811.                                         if(data[j]>=0x20){
  2812.  
  2813.                                                 if(c==0){
  2814.  
  2815.                                                         c++;
  2816.  
  2817.                                                         if(j!=0)uputchar(',');
  2818.  
  2819.                                                         uputchar(0x27);
  2820.  
  2821.                                                 }
  2822.  
  2823.                                                 uputchar(data[j]);
  2824.  
  2825.                                         }
  2826.  
  2827.                                         else{
  2828.  
  2829.                                                 if(c!=0){
  2830.  
  2831.                                                         c=0;
  2832.  
  2833.                                                         uputchar(0x27);
  2834.  
  2835.                                                 }
  2836.  
  2837.                                                 if(j!=0)uputchar(',');
  2838.  
  2839.                                                 printbyte(data[j]);
  2840.  
  2841.                                         }
  2842.  
  2843.                                 }
  2844.  
  2845.                                 if(c)uputchar(0x27);
  2846.  
  2847.                                 break;
  2848.  
  2849.                         case 4:
  2850.  
  2851.                                 for(j=0;j<i;){
  2852.  
  2853.                                         d=data[j++];
  2854.  
  2855.                                         d+=data[j++]<<8;
  2856.  
  2857.                                         d+=data[j++]<<16;
  2858.  
  2859.                                         d+=data[j++]<<24;
  2860.  
  2861.                                         printdword((unsigned int)d);
  2862.  
  2863. //                                      uprintf("%09lXh",(unsigned int)d);
  2864.  
  2865.                                         if(j!=i)uputchar(',');
  2866.  
  2867.                                 }
  2868.  
  2869.                                 break;
  2870.  
  2871.                         case 8:
  2872.  
  2873.                                 for(j=0;j<i;){
  2874.  
  2875.                                         j+=4;
  2876.  
  2877.                                         d=data[j++];
  2878.  
  2879.                                         d+=data[j++]<<8;
  2880.  
  2881.                                         d+=data[j++]<<16;
  2882.  
  2883.                                         d+=data[j++]<<24;
  2884.  
  2885.                                         if(d)uprintf("%lX",d);
  2886.  
  2887.                                         unsigned long d2;
  2888.  
  2889.                                         d2=d;
  2890.  
  2891.                                         j-=8;
  2892.  
  2893.                                         d=data[j++];
  2894.  
  2895.                                         d+=data[j++]<<8;
  2896.  
  2897.                                         d+=data[j++]<<16;
  2898.  
  2899.                                         d+=data[j++]<<24;
  2900.  
  2901.                                         if(d2==0)
  2902.  
  2903.                                                 uprintf("%lXh",(char)d);
  2904.  
  2905.                                         else
  2906.  
  2907.                                                 uprintf("%08lXh",(char)d);
  2908.  
  2909.                                         j+=4;
  2910.  
  2911.                                         if(j!=i)uputchar(',');
  2912.  
  2913.                                 }
  2914.  
  2915.                                 break;
  2916.  
  2917.                 }
  2918.  
  2919.           fprintf(hout,"%*s",25-col," ");
  2920.  
  2921.         fprintf(hout,"%s\n", ubuf);
  2922.  
  2923.                 ofs+=i;
  2924.  
  2925.         }
  2926.  
  2927. }
  2928.  
  2929.