root / i386-dis.c @ 4b16eb9d
History | View | Annotate | Download (159.2 kB)
1 |
/* opcodes/i386-dis.c r1.126 */
|
---|---|
2 |
/* Print i386 instructions for GDB, the GNU debugger.
|
3 |
Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
4 |
2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
|
5 |
|
6 |
This file is part of GDB.
|
7 |
|
8 |
This program is free software; you can redistribute it and/or modify
|
9 |
it under the terms of the GNU General Public License as published by
|
10 |
the Free Software Foundation; either version 2 of the License, or
|
11 |
(at your option) any later version.
|
12 |
|
13 |
This program is distributed in the hope that it will be useful,
|
14 |
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
16 |
GNU General Public License for more details.
|
17 |
|
18 |
You should have received a copy of the GNU General Public License
|
19 |
along with this program; if not, write to the Free Software
|
20 |
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
|
21 |
|
22 |
/* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
|
23 |
July 1988
|
24 |
modified by John Hassey (hassey@dg-rtp.dg.com)
|
25 |
x86-64 support added by Jan Hubicka (jh@suse.cz)
|
26 |
VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
|
27 |
|
28 |
/* The main tables describing the instructions is essentially a copy
|
29 |
of the "Opcode Map" chapter (Appendix A) of the Intel 80386
|
30 |
Programmers Manual. Usually, there is a capital letter, followed
|
31 |
by a small letter. The capital letter tell the addressing mode,
|
32 |
and the small letter tells about the operand size. Refer to
|
33 |
the Intel manual for details. */
|
34 |
|
35 |
#include <stdlib.h> |
36 |
#include "dis-asm.h" |
37 |
/* include/opcode/i386.h r1.78 */
|
38 |
|
39 |
/* opcode/i386.h -- Intel 80386 opcode macros
|
40 |
Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
41 |
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
42 |
Free Software Foundation, Inc.
|
43 |
|
44 |
This file is part of GAS, the GNU Assembler, and GDB, the GNU Debugger.
|
45 |
|
46 |
This program is free software; you can redistribute it and/or modify
|
47 |
it under the terms of the GNU General Public License as published by
|
48 |
the Free Software Foundation; either version 2 of the License, or
|
49 |
(at your option) any later version.
|
50 |
|
51 |
This program is distributed in the hope that it will be useful,
|
52 |
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
53 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
54 |
GNU General Public License for more details.
|
55 |
|
56 |
You should have received a copy of the GNU General Public License
|
57 |
along with this program; if not, write to the Free Software
|
58 |
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
|
59 |
|
60 |
/* The SystemV/386 SVR3.2 assembler, and probably all AT&T derived
|
61 |
ix86 Unix assemblers, generate floating point instructions with
|
62 |
reversed source and destination registers in certain cases.
|
63 |
Unfortunately, gcc and possibly many other programs use this
|
64 |
reversed syntax, so we're stuck with it.
|
65 |
|
66 |
eg. `fsub %st(3),%st' results in st = st - st(3) as expected, but
|
67 |
`fsub %st,%st(3)' results in st(3) = st - st(3), rather than
|
68 |
the expected st(3) = st(3) - st
|
69 |
|
70 |
This happens with all the non-commutative arithmetic floating point
|
71 |
operations with two register operands, where the source register is
|
72 |
%st, and destination register is %st(i).
|
73 |
|
74 |
The affected opcode map is dceX, dcfX, deeX, defX. */
|
75 |
|
76 |
#ifndef SYSV386_COMPAT
|
77 |
/* Set non-zero for broken, compatible instructions. Set to zero for
|
78 |
non-broken opcodes at your peril. gcc generates SystemV/386
|
79 |
compatible instructions. */
|
80 |
#define SYSV386_COMPAT 1 |
81 |
#endif
|
82 |
#ifndef OLDGCC_COMPAT
|
83 |
/* Set non-zero to cater for old (<= 2.8.1) versions of gcc that could
|
84 |
generate nonsense fsubp, fsubrp, fdivp and fdivrp with operands
|
85 |
reversed. */
|
86 |
#define OLDGCC_COMPAT SYSV386_COMPAT
|
87 |
#endif
|
88 |
|
89 |
#define MOV_AX_DISP32 0xa0 |
90 |
#define POP_SEG_SHORT 0x07 |
91 |
#define JUMP_PC_RELATIVE 0xeb |
92 |
#define INT_OPCODE 0xcd |
93 |
#define INT3_OPCODE 0xcc |
94 |
/* The opcode for the fwait instruction, which disassembler treats as a
|
95 |
prefix when it can. */
|
96 |
#define FWAIT_OPCODE 0x9b |
97 |
#define ADDR_PREFIX_OPCODE 0x67 |
98 |
#define DATA_PREFIX_OPCODE 0x66 |
99 |
#define LOCK_PREFIX_OPCODE 0xf0 |
100 |
#define CS_PREFIX_OPCODE 0x2e |
101 |
#define DS_PREFIX_OPCODE 0x3e |
102 |
#define ES_PREFIX_OPCODE 0x26 |
103 |
#define FS_PREFIX_OPCODE 0x64 |
104 |
#define GS_PREFIX_OPCODE 0x65 |
105 |
#define SS_PREFIX_OPCODE 0x36 |
106 |
#define REPNE_PREFIX_OPCODE 0xf2 |
107 |
#define REPE_PREFIX_OPCODE 0xf3 |
108 |
|
109 |
#define TWO_BYTE_OPCODE_ESCAPE 0x0f |
110 |
#define NOP_OPCODE (char) 0x90 |
111 |
|
112 |
/* register numbers */
|
113 |
#define EBP_REG_NUM 5 |
114 |
#define ESP_REG_NUM 4 |
115 |
|
116 |
/* modrm_byte.regmem for twobyte escape */
|
117 |
#define ESCAPE_TO_TWO_BYTE_ADDRESSING ESP_REG_NUM
|
118 |
/* index_base_byte.index for no index register addressing */
|
119 |
#define NO_INDEX_REGISTER ESP_REG_NUM
|
120 |
/* index_base_byte.base for no base register addressing */
|
121 |
#define NO_BASE_REGISTER EBP_REG_NUM
|
122 |
#define NO_BASE_REGISTER_16 6 |
123 |
|
124 |
/* modrm.mode = REGMEM_FIELD_HAS_REG when a register is in there */
|
125 |
#define REGMEM_FIELD_HAS_REG 0x3/* always = 0x3 */ |
126 |
#define REGMEM_FIELD_HAS_MEM (~REGMEM_FIELD_HAS_REG)
|
127 |
|
128 |
/* x86-64 extension prefix. */
|
129 |
#define REX_OPCODE 0x40 |
130 |
|
131 |
/* Indicates 64 bit operand size. */
|
132 |
#define REX_W 8 |
133 |
/* High extension to reg field of modrm byte. */
|
134 |
#define REX_R 4 |
135 |
/* High extension to SIB index field. */
|
136 |
#define REX_X 2 |
137 |
/* High extension to base field of modrm or SIB, or reg field of opcode. */
|
138 |
#define REX_B 1 |
139 |
|
140 |
/* max operands per insn */
|
141 |
#define MAX_OPERANDS 4 |
142 |
|
143 |
/* max immediates per insn (lcall, ljmp, insertq, extrq) */
|
144 |
#define MAX_IMMEDIATE_OPERANDS 2 |
145 |
|
146 |
/* max memory refs per insn (string ops) */
|
147 |
#define MAX_MEMORY_OPERANDS 2 |
148 |
|
149 |
/* max size of insn mnemonics. */
|
150 |
#define MAX_MNEM_SIZE 16 |
151 |
|
152 |
/* max size of register name in insn mnemonics. */
|
153 |
#define MAX_REG_NAME_SIZE 8 |
154 |
|
155 |
/* opcodes/i386-dis.c r1.126 */
|
156 |
#include "qemu-common.h" |
157 |
|
158 |
#include <setjmp.h> |
159 |
|
160 |
static int fetch_data (struct disassemble_info *, bfd_byte *); |
161 |
static void ckprefix (void); |
162 |
static const char *prefix_name (int, int); |
163 |
static int print_insn (bfd_vma, disassemble_info *); |
164 |
static void dofloat (int); |
165 |
static void OP_ST (int, int); |
166 |
static void OP_STi (int, int); |
167 |
static int putop (const char *, int); |
168 |
static void oappend (const char *); |
169 |
static void append_seg (void); |
170 |
static void OP_indirE (int, int); |
171 |
static void print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp); |
172 |
static void print_displacement (char *, bfd_vma); |
173 |
static void OP_E (int, int); |
174 |
static void OP_G (int, int); |
175 |
static bfd_vma get64 (void); |
176 |
static bfd_signed_vma get32 (void); |
177 |
static bfd_signed_vma get32s (void); |
178 |
static int get16 (void); |
179 |
static void set_op (bfd_vma, int); |
180 |
static void OP_REG (int, int); |
181 |
static void OP_IMREG (int, int); |
182 |
static void OP_I (int, int); |
183 |
static void OP_I64 (int, int); |
184 |
static void OP_sI (int, int); |
185 |
static void OP_J (int, int); |
186 |
static void OP_SEG (int, int); |
187 |
static void OP_DIR (int, int); |
188 |
static void OP_OFF (int, int); |
189 |
static void OP_OFF64 (int, int); |
190 |
static void ptr_reg (int, int); |
191 |
static void OP_ESreg (int, int); |
192 |
static void OP_DSreg (int, int); |
193 |
static void OP_C (int, int); |
194 |
static void OP_D (int, int); |
195 |
static void OP_T (int, int); |
196 |
static void OP_R (int, int); |
197 |
static void OP_MMX (int, int); |
198 |
static void OP_XMM (int, int); |
199 |
static void OP_EM (int, int); |
200 |
static void OP_EX (int, int); |
201 |
static void OP_EMC (int,int); |
202 |
static void OP_MXC (int,int); |
203 |
static void OP_MS (int, int); |
204 |
static void OP_XS (int, int); |
205 |
static void OP_M (int, int); |
206 |
static void OP_VMX (int, int); |
207 |
static void OP_0fae (int, int); |
208 |
static void OP_0f07 (int, int); |
209 |
static void NOP_Fixup1 (int, int); |
210 |
static void NOP_Fixup2 (int, int); |
211 |
static void OP_3DNowSuffix (int, int); |
212 |
static void OP_SIMD_Suffix (int, int); |
213 |
static void SIMD_Fixup (int, int); |
214 |
static void PNI_Fixup (int, int); |
215 |
static void SVME_Fixup (int, int); |
216 |
static void INVLPG_Fixup (int, int); |
217 |
static void BadOp (void); |
218 |
static void VMX_Fixup (int, int); |
219 |
static void REP_Fixup (int, int); |
220 |
static void CMPXCHG8B_Fixup (int, int); |
221 |
static void XMM_Fixup (int, int); |
222 |
static void CRC32_Fixup (int, int); |
223 |
|
224 |
struct dis_private {
|
225 |
/* Points to first byte not fetched. */
|
226 |
bfd_byte *max_fetched; |
227 |
bfd_byte the_buffer[MAX_MNEM_SIZE]; |
228 |
bfd_vma insn_start; |
229 |
int orig_sizeflag;
|
230 |
jmp_buf bailout; |
231 |
}; |
232 |
|
233 |
enum address_mode
|
234 |
{ |
235 |
mode_16bit, |
236 |
mode_32bit, |
237 |
mode_64bit |
238 |
}; |
239 |
|
240 |
static enum address_mode address_mode; |
241 |
|
242 |
/* Flags for the prefixes for the current instruction. See below. */
|
243 |
static int prefixes; |
244 |
|
245 |
/* REX prefix the current instruction. See below. */
|
246 |
static int rex; |
247 |
/* Bits of REX we've already used. */
|
248 |
static int rex_used; |
249 |
/* Mark parts used in the REX prefix. When we are testing for
|
250 |
empty prefix (for 8bit register REX extension), just mask it
|
251 |
out. Otherwise test for REX bit is excuse for existence of REX
|
252 |
only in case value is nonzero. */
|
253 |
#define USED_REX(value) \
|
254 |
{ \ |
255 |
if (value) \
|
256 |
{ \ |
257 |
if ((rex & value)) \
|
258 |
rex_used |= (value) | REX_OPCODE; \ |
259 |
} \ |
260 |
else \
|
261 |
rex_used |= REX_OPCODE; \ |
262 |
} |
263 |
|
264 |
/* Flags for prefixes which we somehow handled when printing the
|
265 |
current instruction. */
|
266 |
static int used_prefixes; |
267 |
|
268 |
/* Flags stored in PREFIXES. */
|
269 |
#define PREFIX_REPZ 1 |
270 |
#define PREFIX_REPNZ 2 |
271 |
#define PREFIX_LOCK 4 |
272 |
#define PREFIX_CS 8 |
273 |
#define PREFIX_SS 0x10 |
274 |
#define PREFIX_DS 0x20 |
275 |
#define PREFIX_ES 0x40 |
276 |
#define PREFIX_FS 0x80 |
277 |
#define PREFIX_GS 0x100 |
278 |
#define PREFIX_DATA 0x200 |
279 |
#define PREFIX_ADDR 0x400 |
280 |
#define PREFIX_FWAIT 0x800 |
281 |
|
282 |
/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
|
283 |
to ADDR (exclusive) are valid. Returns 1 for success, longjmps
|
284 |
on error. */
|
285 |
#define FETCH_DATA(info, addr) \
|
286 |
((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
|
287 |
? 1 : fetch_data ((info), (addr)))
|
288 |
|
289 |
static int |
290 |
fetch_data (struct disassemble_info *info, bfd_byte *addr)
|
291 |
{ |
292 |
int status;
|
293 |
struct dis_private *priv = (struct dis_private *) info->private_data; |
294 |
bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); |
295 |
|
296 |
if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
|
297 |
status = (*info->read_memory_func) (start, |
298 |
priv->max_fetched, |
299 |
addr - priv->max_fetched, |
300 |
info); |
301 |
else
|
302 |
status = -1;
|
303 |
if (status != 0) |
304 |
{ |
305 |
/* If we did manage to read at least one byte, then
|
306 |
print_insn_i386 will do something sensible. Otherwise, print
|
307 |
an error. We do that here because this is where we know
|
308 |
STATUS. */
|
309 |
if (priv->max_fetched == priv->the_buffer)
|
310 |
(*info->memory_error_func) (status, start, info); |
311 |
longjmp (priv->bailout, 1);
|
312 |
} |
313 |
else
|
314 |
priv->max_fetched = addr; |
315 |
return 1; |
316 |
} |
317 |
|
318 |
#define XX { NULL, 0 } |
319 |
|
320 |
#define Eb { OP_E, b_mode }
|
321 |
#define Ev { OP_E, v_mode }
|
322 |
#define Ed { OP_E, d_mode }
|
323 |
#define Edq { OP_E, dq_mode }
|
324 |
#define Edqw { OP_E, dqw_mode }
|
325 |
#define Edqb { OP_E, dqb_mode }
|
326 |
#define Edqd { OP_E, dqd_mode }
|
327 |
#define indirEv { OP_indirE, stack_v_mode }
|
328 |
#define indirEp { OP_indirE, f_mode }
|
329 |
#define stackEv { OP_E, stack_v_mode }
|
330 |
#define Em { OP_E, m_mode }
|
331 |
#define Ew { OP_E, w_mode }
|
332 |
#define M { OP_M, 0 } /* lea, lgdt, etc. */ |
333 |
#define Ma { OP_M, v_mode }
|
334 |
#define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */ |
335 |
#define Mq { OP_M, q_mode }
|
336 |
#define Gb { OP_G, b_mode }
|
337 |
#define Gv { OP_G, v_mode }
|
338 |
#define Gd { OP_G, d_mode }
|
339 |
#define Gdq { OP_G, dq_mode }
|
340 |
#define Gm { OP_G, m_mode }
|
341 |
#define Gw { OP_G, w_mode }
|
342 |
#define Rd { OP_R, d_mode }
|
343 |
#define Rm { OP_R, m_mode }
|
344 |
#define Ib { OP_I, b_mode }
|
345 |
#define sIb { OP_sI, b_mode } /* sign extened byte */ |
346 |
#define Iv { OP_I, v_mode }
|
347 |
#define Iq { OP_I, q_mode }
|
348 |
#define Iv64 { OP_I64, v_mode }
|
349 |
#define Iw { OP_I, w_mode }
|
350 |
#define I1 { OP_I, const_1_mode }
|
351 |
#define Jb { OP_J, b_mode }
|
352 |
#define Jv { OP_J, v_mode }
|
353 |
#define Cm { OP_C, m_mode }
|
354 |
#define Dm { OP_D, m_mode }
|
355 |
#define Td { OP_T, d_mode }
|
356 |
|
357 |
#define RMeAX { OP_REG, eAX_reg }
|
358 |
#define RMeBX { OP_REG, eBX_reg }
|
359 |
#define RMeCX { OP_REG, eCX_reg }
|
360 |
#define RMeDX { OP_REG, eDX_reg }
|
361 |
#define RMeSP { OP_REG, eSP_reg }
|
362 |
#define RMeBP { OP_REG, eBP_reg }
|
363 |
#define RMeSI { OP_REG, eSI_reg }
|
364 |
#define RMeDI { OP_REG, eDI_reg }
|
365 |
#define RMrAX { OP_REG, rAX_reg }
|
366 |
#define RMrBX { OP_REG, rBX_reg }
|
367 |
#define RMrCX { OP_REG, rCX_reg }
|
368 |
#define RMrDX { OP_REG, rDX_reg }
|
369 |
#define RMrSP { OP_REG, rSP_reg }
|
370 |
#define RMrBP { OP_REG, rBP_reg }
|
371 |
#define RMrSI { OP_REG, rSI_reg }
|
372 |
#define RMrDI { OP_REG, rDI_reg }
|
373 |
#define RMAL { OP_REG, al_reg }
|
374 |
#define RMAL { OP_REG, al_reg }
|
375 |
#define RMCL { OP_REG, cl_reg }
|
376 |
#define RMDL { OP_REG, dl_reg }
|
377 |
#define RMBL { OP_REG, bl_reg }
|
378 |
#define RMAH { OP_REG, ah_reg }
|
379 |
#define RMCH { OP_REG, ch_reg }
|
380 |
#define RMDH { OP_REG, dh_reg }
|
381 |
#define RMBH { OP_REG, bh_reg }
|
382 |
#define RMAX { OP_REG, ax_reg }
|
383 |
#define RMDX { OP_REG, dx_reg }
|
384 |
|
385 |
#define eAX { OP_IMREG, eAX_reg }
|
386 |
#define eBX { OP_IMREG, eBX_reg }
|
387 |
#define eCX { OP_IMREG, eCX_reg }
|
388 |
#define eDX { OP_IMREG, eDX_reg }
|
389 |
#define eSP { OP_IMREG, eSP_reg }
|
390 |
#define eBP { OP_IMREG, eBP_reg }
|
391 |
#define eSI { OP_IMREG, eSI_reg }
|
392 |
#define eDI { OP_IMREG, eDI_reg }
|
393 |
#define AL { OP_IMREG, al_reg }
|
394 |
#define CL { OP_IMREG, cl_reg }
|
395 |
#define DL { OP_IMREG, dl_reg }
|
396 |
#define BL { OP_IMREG, bl_reg }
|
397 |
#define AH { OP_IMREG, ah_reg }
|
398 |
#define CH { OP_IMREG, ch_reg }
|
399 |
#define DH { OP_IMREG, dh_reg }
|
400 |
#define BH { OP_IMREG, bh_reg }
|
401 |
#define AX { OP_IMREG, ax_reg }
|
402 |
#define DX { OP_IMREG, dx_reg }
|
403 |
#define zAX { OP_IMREG, z_mode_ax_reg }
|
404 |
#define indirDX { OP_IMREG, indir_dx_reg }
|
405 |
|
406 |
#define Sw { OP_SEG, w_mode }
|
407 |
#define Sv { OP_SEG, v_mode }
|
408 |
#define Ap { OP_DIR, 0 } |
409 |
#define Ob { OP_OFF64, b_mode }
|
410 |
#define Ov { OP_OFF64, v_mode }
|
411 |
#define Xb { OP_DSreg, eSI_reg }
|
412 |
#define Xv { OP_DSreg, eSI_reg }
|
413 |
#define Xz { OP_DSreg, eSI_reg }
|
414 |
#define Yb { OP_ESreg, eDI_reg }
|
415 |
#define Yv { OP_ESreg, eDI_reg }
|
416 |
#define DSBX { OP_DSreg, eBX_reg }
|
417 |
|
418 |
#define es { OP_REG, es_reg }
|
419 |
#define ss { OP_REG, ss_reg }
|
420 |
#define cs { OP_REG, cs_reg }
|
421 |
#define ds { OP_REG, ds_reg }
|
422 |
#define fs { OP_REG, fs_reg }
|
423 |
#define gs { OP_REG, gs_reg }
|
424 |
|
425 |
#define MX { OP_MMX, 0 } |
426 |
#define XM { OP_XMM, 0 } |
427 |
#define EM { OP_EM, v_mode }
|
428 |
#define EMd { OP_EM, d_mode }
|
429 |
#define EMq { OP_EM, q_mode }
|
430 |
#define EXd { OP_EX, d_mode }
|
431 |
#define EXq { OP_EX, q_mode }
|
432 |
#define EXx { OP_EX, x_mode }
|
433 |
#define MS { OP_MS, v_mode }
|
434 |
#define XS { OP_XS, v_mode }
|
435 |
#define EMC { OP_EMC, v_mode }
|
436 |
#define MXC { OP_MXC, 0 } |
437 |
#define VM { OP_VMX, q_mode }
|
438 |
#define OPSUF { OP_3DNowSuffix, 0 } |
439 |
#define OPSIMD { OP_SIMD_Suffix, 0 } |
440 |
#define XMM0 { XMM_Fixup, 0 } |
441 |
|
442 |
/* Used handle "rep" prefix for string instructions. */
|
443 |
#define Xbr { REP_Fixup, eSI_reg }
|
444 |
#define Xvr { REP_Fixup, eSI_reg }
|
445 |
#define Ybr { REP_Fixup, eDI_reg }
|
446 |
#define Yvr { REP_Fixup, eDI_reg }
|
447 |
#define Yzr { REP_Fixup, eDI_reg }
|
448 |
#define indirDXr { REP_Fixup, indir_dx_reg }
|
449 |
#define ALr { REP_Fixup, al_reg }
|
450 |
#define eAXr { REP_Fixup, eAX_reg }
|
451 |
|
452 |
#define cond_jump_flag { NULL, cond_jump_mode } |
453 |
#define loop_jcxz_flag { NULL, loop_jcxz_mode } |
454 |
|
455 |
/* bits in sizeflag */
|
456 |
#define SUFFIX_ALWAYS 4 |
457 |
#define AFLAG 2 |
458 |
#define DFLAG 1 |
459 |
|
460 |
#define b_mode 1 /* byte operand */ |
461 |
#define v_mode 2 /* operand size depends on prefixes */ |
462 |
#define w_mode 3 /* word operand */ |
463 |
#define d_mode 4 /* double word operand */ |
464 |
#define q_mode 5 /* quad word operand */ |
465 |
#define t_mode 6 /* ten-byte operand */ |
466 |
#define x_mode 7 /* 16-byte XMM operand */ |
467 |
#define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */ |
468 |
#define cond_jump_mode 9 |
469 |
#define loop_jcxz_mode 10 |
470 |
#define dq_mode 11 /* operand size depends on REX prefixes. */ |
471 |
#define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */ |
472 |
#define f_mode 13 /* 4- or 6-byte pointer operand */ |
473 |
#define const_1_mode 14 |
474 |
#define stack_v_mode 15 /* v_mode for stack-related opcodes. */ |
475 |
#define z_mode 16 /* non-quad operand size depends on prefixes */ |
476 |
#define o_mode 17 /* 16-byte operand */ |
477 |
#define dqb_mode 18 /* registers like dq_mode, memory like b_mode. */ |
478 |
#define dqd_mode 19 /* registers like dq_mode, memory like d_mode. */ |
479 |
|
480 |
#define es_reg 100 |
481 |
#define cs_reg 101 |
482 |
#define ss_reg 102 |
483 |
#define ds_reg 103 |
484 |
#define fs_reg 104 |
485 |
#define gs_reg 105 |
486 |
|
487 |
#define eAX_reg 108 |
488 |
#define eCX_reg 109 |
489 |
#define eDX_reg 110 |
490 |
#define eBX_reg 111 |
491 |
#define eSP_reg 112 |
492 |
#define eBP_reg 113 |
493 |
#define eSI_reg 114 |
494 |
#define eDI_reg 115 |
495 |
|
496 |
#define al_reg 116 |
497 |
#define cl_reg 117 |
498 |
#define dl_reg 118 |
499 |
#define bl_reg 119 |
500 |
#define ah_reg 120 |
501 |
#define ch_reg 121 |
502 |
#define dh_reg 122 |
503 |
#define bh_reg 123 |
504 |
|
505 |
#define ax_reg 124 |
506 |
#define cx_reg 125 |
507 |
#define dx_reg 126 |
508 |
#define bx_reg 127 |
509 |
#define sp_reg 128 |
510 |
#define bp_reg 129 |
511 |
#define si_reg 130 |
512 |
#define di_reg 131 |
513 |
|
514 |
#define rAX_reg 132 |
515 |
#define rCX_reg 133 |
516 |
#define rDX_reg 134 |
517 |
#define rBX_reg 135 |
518 |
#define rSP_reg 136 |
519 |
#define rBP_reg 137 |
520 |
#define rSI_reg 138 |
521 |
#define rDI_reg 139 |
522 |
|
523 |
#define z_mode_ax_reg 149 |
524 |
#define indir_dx_reg 150 |
525 |
|
526 |
#define FLOATCODE 1 |
527 |
#define USE_GROUPS 2 |
528 |
#define USE_PREFIX_USER_TABLE 3 |
529 |
#define X86_64_SPECIAL 4 |
530 |
#define IS_3BYTE_OPCODE 5 |
531 |
|
532 |
#define FLOAT NULL, { { NULL, FLOATCODE } } |
533 |
|
534 |
#define GRP1a NULL, { { NULL, USE_GROUPS }, { NULL, 0 } } |
535 |
#define GRP1b NULL, { { NULL, USE_GROUPS }, { NULL, 1 } } |
536 |
#define GRP1S NULL, { { NULL, USE_GROUPS }, { NULL, 2 } } |
537 |
#define GRP1Ss NULL, { { NULL, USE_GROUPS }, { NULL, 3 } } |
538 |
#define GRP2b NULL, { { NULL, USE_GROUPS }, { NULL, 4 } } |
539 |
#define GRP2S NULL, { { NULL, USE_GROUPS }, { NULL, 5 } } |
540 |
#define GRP2b_one NULL, { { NULL, USE_GROUPS }, { NULL, 6 } } |
541 |
#define GRP2S_one NULL, { { NULL, USE_GROUPS }, { NULL, 7 } } |
542 |
#define GRP2b_cl NULL, { { NULL, USE_GROUPS }, { NULL, 8 } } |
543 |
#define GRP2S_cl NULL, { { NULL, USE_GROUPS }, { NULL, 9 } } |
544 |
#define GRP3b NULL, { { NULL, USE_GROUPS }, { NULL, 10 } } |
545 |
#define GRP3S NULL, { { NULL, USE_GROUPS }, { NULL, 11 } } |
546 |
#define GRP4 NULL, { { NULL, USE_GROUPS }, { NULL, 12 } } |
547 |
#define GRP5 NULL, { { NULL, USE_GROUPS }, { NULL, 13 } } |
548 |
#define GRP6 NULL, { { NULL, USE_GROUPS }, { NULL, 14 } } |
549 |
#define GRP7 NULL, { { NULL, USE_GROUPS }, { NULL, 15 } } |
550 |
#define GRP8 NULL, { { NULL, USE_GROUPS }, { NULL, 16 } } |
551 |
#define GRP9 NULL, { { NULL, USE_GROUPS }, { NULL, 17 } } |
552 |
#define GRP11_C6 NULL, { { NULL, USE_GROUPS }, { NULL, 18 } } |
553 |
#define GRP11_C7 NULL, { { NULL, USE_GROUPS }, { NULL, 19 } } |
554 |
#define GRP12 NULL, { { NULL, USE_GROUPS }, { NULL, 20 } } |
555 |
#define GRP13 NULL, { { NULL, USE_GROUPS }, { NULL, 21 } } |
556 |
#define GRP14 NULL, { { NULL, USE_GROUPS }, { NULL, 22 } } |
557 |
#define GRP15 NULL, { { NULL, USE_GROUPS }, { NULL, 23 } } |
558 |
#define GRP16 NULL, { { NULL, USE_GROUPS }, { NULL, 24 } } |
559 |
#define GRPAMD NULL, { { NULL, USE_GROUPS }, { NULL, 25 } } |
560 |
#define GRPPADLCK1 NULL, { { NULL, USE_GROUPS }, { NULL, 26 } } |
561 |
#define GRPPADLCK2 NULL, { { NULL, USE_GROUPS }, { NULL, 27 } } |
562 |
|
563 |
#define PREGRP0 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } } |
564 |
#define PREGRP1 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } } |
565 |
#define PREGRP2 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } } |
566 |
#define PREGRP3 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } } |
567 |
#define PREGRP4 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } } |
568 |
#define PREGRP5 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } } |
569 |
#define PREGRP6 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } } |
570 |
#define PREGRP7 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } } |
571 |
#define PREGRP8 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } } |
572 |
#define PREGRP9 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } } |
573 |
#define PREGRP10 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } } |
574 |
#define PREGRP11 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } } |
575 |
#define PREGRP12 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } } |
576 |
#define PREGRP13 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } } |
577 |
#define PREGRP14 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } } |
578 |
#define PREGRP15 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } } |
579 |
#define PREGRP16 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } } |
580 |
#define PREGRP17 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } } |
581 |
#define PREGRP18 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } } |
582 |
#define PREGRP19 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } } |
583 |
#define PREGRP20 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } } |
584 |
#define PREGRP21 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } } |
585 |
#define PREGRP22 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } } |
586 |
#define PREGRP23 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } } |
587 |
#define PREGRP24 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } } |
588 |
#define PREGRP25 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } } |
589 |
#define PREGRP26 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } } |
590 |
#define PREGRP27 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } } |
591 |
#define PREGRP28 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } } |
592 |
#define PREGRP29 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } } |
593 |
#define PREGRP30 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } } |
594 |
#define PREGRP31 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } } |
595 |
#define PREGRP32 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } } |
596 |
#define PREGRP33 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } } |
597 |
#define PREGRP34 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } } |
598 |
#define PREGRP35 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } } |
599 |
#define PREGRP36 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } } |
600 |
#define PREGRP37 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } } |
601 |
#define PREGRP38 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } } |
602 |
#define PREGRP39 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 39 } } |
603 |
#define PREGRP40 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 40 } } |
604 |
#define PREGRP41 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 41 } } |
605 |
#define PREGRP42 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 42 } } |
606 |
#define PREGRP43 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 43 } } |
607 |
#define PREGRP44 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 44 } } |
608 |
#define PREGRP45 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 45 } } |
609 |
#define PREGRP46 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 46 } } |
610 |
#define PREGRP47 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 47 } } |
611 |
#define PREGRP48 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 48 } } |
612 |
#define PREGRP49 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 49 } } |
613 |
#define PREGRP50 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 50 } } |
614 |
#define PREGRP51 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 51 } } |
615 |
#define PREGRP52 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 52 } } |
616 |
#define PREGRP53 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 53 } } |
617 |
#define PREGRP54 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 54 } } |
618 |
#define PREGRP55 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 55 } } |
619 |
#define PREGRP56 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 56 } } |
620 |
#define PREGRP57 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 57 } } |
621 |
#define PREGRP58 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 58 } } |
622 |
#define PREGRP59 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 59 } } |
623 |
#define PREGRP60 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 60 } } |
624 |
#define PREGRP61 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 61 } } |
625 |
#define PREGRP62 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 62 } } |
626 |
#define PREGRP63 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 63 } } |
627 |
#define PREGRP64 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 64 } } |
628 |
#define PREGRP65 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 65 } } |
629 |
#define PREGRP66 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 66 } } |
630 |
#define PREGRP67 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 67 } } |
631 |
#define PREGRP68 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 68 } } |
632 |
#define PREGRP69 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 69 } } |
633 |
#define PREGRP70 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 70 } } |
634 |
#define PREGRP71 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 71 } } |
635 |
#define PREGRP72 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 72 } } |
636 |
#define PREGRP73 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 73 } } |
637 |
#define PREGRP74 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 74 } } |
638 |
#define PREGRP75 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 75 } } |
639 |
#define PREGRP76 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 76 } } |
640 |
#define PREGRP77 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 77 } } |
641 |
#define PREGRP78 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 78 } } |
642 |
#define PREGRP79 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 79 } } |
643 |
#define PREGRP80 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 80 } } |
644 |
#define PREGRP81 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 81 } } |
645 |
#define PREGRP82 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 82 } } |
646 |
#define PREGRP83 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 83 } } |
647 |
#define PREGRP84 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 84 } } |
648 |
#define PREGRP85 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 85 } } |
649 |
#define PREGRP86 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 86 } } |
650 |
#define PREGRP87 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 87 } } |
651 |
#define PREGRP88 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 88 } } |
652 |
#define PREGRP89 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 89 } } |
653 |
#define PREGRP90 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 90 } } |
654 |
#define PREGRP91 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 91 } } |
655 |
#define PREGRP92 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 92 } } |
656 |
#define PREGRP93 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 93 } } |
657 |
#define PREGRP94 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 94 } } |
658 |
#define PREGRP95 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 95 } } |
659 |
#define PREGRP96 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 96 } } |
660 |
#define PREGRP97 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 97 } } |
661 |
|
662 |
|
663 |
#define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } } |
664 |
#define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } } |
665 |
#define X86_64_2 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } } |
666 |
#define X86_64_3 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } } |
667 |
|
668 |
#define THREE_BYTE_0 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } } |
669 |
#define THREE_BYTE_1 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } } |
670 |
|
671 |
typedef void (*op_rtn) (int bytemode, int sizeflag); |
672 |
|
673 |
struct dis386 {
|
674 |
const char *name; |
675 |
struct
|
676 |
{ |
677 |
op_rtn rtn; |
678 |
int bytemode;
|
679 |
} op[MAX_OPERANDS]; |
680 |
}; |
681 |
|
682 |
/* Upper case letters in the instruction names here are macros.
|
683 |
'A' => print 'b' if no register operands or suffix_always is true
|
684 |
'B' => print 'b' if suffix_always is true
|
685 |
'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
|
686 |
. size prefix
|
687 |
'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
|
688 |
. suffix_always is true
|
689 |
'E' => print 'e' if 32-bit form of jcxz
|
690 |
'F' => print 'w' or 'l' depending on address size prefix (loop insns)
|
691 |
'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
|
692 |
'H' => print ",pt" or ",pn" branch hint
|
693 |
'I' => honor following macro letter even in Intel mode (implemented only
|
694 |
. for some of the macro letters)
|
695 |
'J' => print 'l'
|
696 |
'K' => print 'd' or 'q' if rex prefix is present.
|
697 |
'L' => print 'l' if suffix_always is true
|
698 |
'N' => print 'n' if instruction has no wait "prefix"
|
699 |
'O' => print 'd' or 'o' (or 'q' in Intel mode)
|
700 |
'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
|
701 |
. or suffix_always is true. print 'q' if rex prefix is present.
|
702 |
'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
|
703 |
. is true
|
704 |
'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
|
705 |
'S' => print 'w', 'l' or 'q' if suffix_always is true
|
706 |
'T' => print 'q' in 64bit mode and behave as 'P' otherwise
|
707 |
'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
|
708 |
'V' => print 'q' in 64bit mode and behave as 'S' otherwise
|
709 |
'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
|
710 |
'X' => print 's', 'd' depending on data16 prefix (for XMM)
|
711 |
'Y' => 'q' if instruction has an REX 64bit overwrite prefix
|
712 |
'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
|
713 |
|
714 |
Many of the above letters print nothing in Intel mode. See "putop"
|
715 |
for the details.
|
716 |
|
717 |
Braces '{' and '}', and vertical bars '|', indicate alternative
|
718 |
mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
|
719 |
modes. In cases where there are only two alternatives, the X86_64
|
720 |
instruction is reserved, and "(bad)" is printed.
|
721 |
*/
|
722 |
|
723 |
static const struct dis386 dis386[] = { |
724 |
/* 00 */
|
725 |
{ "addB", { Eb, Gb } },
|
726 |
{ "addS", { Ev, Gv } },
|
727 |
{ "addB", { Gb, Eb } },
|
728 |
{ "addS", { Gv, Ev } },
|
729 |
{ "addB", { AL, Ib } },
|
730 |
{ "addS", { eAX, Iv } },
|
731 |
{ "push{T|}", { es } },
|
732 |
{ "pop{T|}", { es } },
|
733 |
/* 08 */
|
734 |
{ "orB", { Eb, Gb } },
|
735 |
{ "orS", { Ev, Gv } },
|
736 |
{ "orB", { Gb, Eb } },
|
737 |
{ "orS", { Gv, Ev } },
|
738 |
{ "orB", { AL, Ib } },
|
739 |
{ "orS", { eAX, Iv } },
|
740 |
{ "push{T|}", { cs } },
|
741 |
{ "(bad)", { XX } }, /* 0x0f extended opcode escape */ |
742 |
/* 10 */
|
743 |
{ "adcB", { Eb, Gb } },
|
744 |
{ "adcS", { Ev, Gv } },
|
745 |
{ "adcB", { Gb, Eb } },
|
746 |
{ "adcS", { Gv, Ev } },
|
747 |
{ "adcB", { AL, Ib } },
|
748 |
{ "adcS", { eAX, Iv } },
|
749 |
{ "push{T|}", { ss } },
|
750 |
{ "pop{T|}", { ss } },
|
751 |
/* 18 */
|
752 |
{ "sbbB", { Eb, Gb } },
|
753 |
{ "sbbS", { Ev, Gv } },
|
754 |
{ "sbbB", { Gb, Eb } },
|
755 |
{ "sbbS", { Gv, Ev } },
|
756 |
{ "sbbB", { AL, Ib } },
|
757 |
{ "sbbS", { eAX, Iv } },
|
758 |
{ "push{T|}", { ds } },
|
759 |
{ "pop{T|}", { ds } },
|
760 |
/* 20 */
|
761 |
{ "andB", { Eb, Gb } },
|
762 |
{ "andS", { Ev, Gv } },
|
763 |
{ "andB", { Gb, Eb } },
|
764 |
{ "andS", { Gv, Ev } },
|
765 |
{ "andB", { AL, Ib } },
|
766 |
{ "andS", { eAX, Iv } },
|
767 |
{ "(bad)", { XX } }, /* SEG ES prefix */ |
768 |
{ "daa{|}", { XX } },
|
769 |
/* 28 */
|
770 |
{ "subB", { Eb, Gb } },
|
771 |
{ "subS", { Ev, Gv } },
|
772 |
{ "subB", { Gb, Eb } },
|
773 |
{ "subS", { Gv, Ev } },
|
774 |
{ "subB", { AL, Ib } },
|
775 |
{ "subS", { eAX, Iv } },
|
776 |
{ "(bad)", { XX } }, /* SEG CS prefix */ |
777 |
{ "das{|}", { XX } },
|
778 |
/* 30 */
|
779 |
{ "xorB", { Eb, Gb } },
|
780 |
{ "xorS", { Ev, Gv } },
|
781 |
{ "xorB", { Gb, Eb } },
|
782 |
{ "xorS", { Gv, Ev } },
|
783 |
{ "xorB", { AL, Ib } },
|
784 |
{ "xorS", { eAX, Iv } },
|
785 |
{ "(bad)", { XX } }, /* SEG SS prefix */ |
786 |
{ "aaa{|}", { XX } },
|
787 |
/* 38 */
|
788 |
{ "cmpB", { Eb, Gb } },
|
789 |
{ "cmpS", { Ev, Gv } },
|
790 |
{ "cmpB", { Gb, Eb } },
|
791 |
{ "cmpS", { Gv, Ev } },
|
792 |
{ "cmpB", { AL, Ib } },
|
793 |
{ "cmpS", { eAX, Iv } },
|
794 |
{ "(bad)", { XX } }, /* SEG DS prefix */ |
795 |
{ "aas{|}", { XX } },
|
796 |
/* 40 */
|
797 |
{ "inc{S|}", { RMeAX } },
|
798 |
{ "inc{S|}", { RMeCX } },
|
799 |
{ "inc{S|}", { RMeDX } },
|
800 |
{ "inc{S|}", { RMeBX } },
|
801 |
{ "inc{S|}", { RMeSP } },
|
802 |
{ "inc{S|}", { RMeBP } },
|
803 |
{ "inc{S|}", { RMeSI } },
|
804 |
{ "inc{S|}", { RMeDI } },
|
805 |
/* 48 */
|
806 |
{ "dec{S|}", { RMeAX } },
|
807 |
{ "dec{S|}", { RMeCX } },
|
808 |
{ "dec{S|}", { RMeDX } },
|
809 |
{ "dec{S|}", { RMeBX } },
|
810 |
{ "dec{S|}", { RMeSP } },
|
811 |
{ "dec{S|}", { RMeBP } },
|
812 |
{ "dec{S|}", { RMeSI } },
|
813 |
{ "dec{S|}", { RMeDI } },
|
814 |
/* 50 */
|
815 |
{ "pushV", { RMrAX } },
|
816 |
{ "pushV", { RMrCX } },
|
817 |
{ "pushV", { RMrDX } },
|
818 |
{ "pushV", { RMrBX } },
|
819 |
{ "pushV", { RMrSP } },
|
820 |
{ "pushV", { RMrBP } },
|
821 |
{ "pushV", { RMrSI } },
|
822 |
{ "pushV", { RMrDI } },
|
823 |
/* 58 */
|
824 |
{ "popV", { RMrAX } },
|
825 |
{ "popV", { RMrCX } },
|
826 |
{ "popV", { RMrDX } },
|
827 |
{ "popV", { RMrBX } },
|
828 |
{ "popV", { RMrSP } },
|
829 |
{ "popV", { RMrBP } },
|
830 |
{ "popV", { RMrSI } },
|
831 |
{ "popV", { RMrDI } },
|
832 |
/* 60 */
|
833 |
{ X86_64_0 }, |
834 |
{ X86_64_1 }, |
835 |
{ X86_64_2 }, |
836 |
{ X86_64_3 }, |
837 |
{ "(bad)", { XX } }, /* seg fs */ |
838 |
{ "(bad)", { XX } }, /* seg gs */ |
839 |
{ "(bad)", { XX } }, /* op size prefix */ |
840 |
{ "(bad)", { XX } }, /* adr size prefix */ |
841 |
/* 68 */
|
842 |
{ "pushT", { Iq } },
|
843 |
{ "imulS", { Gv, Ev, Iv } },
|
844 |
{ "pushT", { sIb } },
|
845 |
{ "imulS", { Gv, Ev, sIb } },
|
846 |
{ "ins{b||b|}", { Ybr, indirDX } },
|
847 |
{ "ins{R||G|}", { Yzr, indirDX } },
|
848 |
{ "outs{b||b|}", { indirDXr, Xb } },
|
849 |
{ "outs{R||G|}", { indirDXr, Xz } },
|
850 |
/* 70 */
|
851 |
{ "joH", { Jb, XX, cond_jump_flag } },
|
852 |
{ "jnoH", { Jb, XX, cond_jump_flag } },
|
853 |
{ "jbH", { Jb, XX, cond_jump_flag } },
|
854 |
{ "jaeH", { Jb, XX, cond_jump_flag } },
|
855 |
{ "jeH", { Jb, XX, cond_jump_flag } },
|
856 |
{ "jneH", { Jb, XX, cond_jump_flag } },
|
857 |
{ "jbeH", { Jb, XX, cond_jump_flag } },
|
858 |
{ "jaH", { Jb, XX, cond_jump_flag } },
|
859 |
/* 78 */
|
860 |
{ "jsH", { Jb, XX, cond_jump_flag } },
|
861 |
{ "jnsH", { Jb, XX, cond_jump_flag } },
|
862 |
{ "jpH", { Jb, XX, cond_jump_flag } },
|
863 |
{ "jnpH", { Jb, XX, cond_jump_flag } },
|
864 |
{ "jlH", { Jb, XX, cond_jump_flag } },
|
865 |
{ "jgeH", { Jb, XX, cond_jump_flag } },
|
866 |
{ "jleH", { Jb, XX, cond_jump_flag } },
|
867 |
{ "jgH", { Jb, XX, cond_jump_flag } },
|
868 |
/* 80 */
|
869 |
{ GRP1b }, |
870 |
{ GRP1S }, |
871 |
{ "(bad)", { XX } },
|
872 |
{ GRP1Ss }, |
873 |
{ "testB", { Eb, Gb } },
|
874 |
{ "testS", { Ev, Gv } },
|
875 |
{ "xchgB", { Eb, Gb } },
|
876 |
{ "xchgS", { Ev, Gv } },
|
877 |
/* 88 */
|
878 |
{ "movB", { Eb, Gb } },
|
879 |
{ "movS", { Ev, Gv } },
|
880 |
{ "movB", { Gb, Eb } },
|
881 |
{ "movS", { Gv, Ev } },
|
882 |
{ "movD", { Sv, Sw } },
|
883 |
{ "leaS", { Gv, M } },
|
884 |
{ "movD", { Sw, Sv } },
|
885 |
{ GRP1a }, |
886 |
/* 90 */
|
887 |
{ PREGRP38 }, |
888 |
{ "xchgS", { RMeCX, eAX } },
|
889 |
{ "xchgS", { RMeDX, eAX } },
|
890 |
{ "xchgS", { RMeBX, eAX } },
|
891 |
{ "xchgS", { RMeSP, eAX } },
|
892 |
{ "xchgS", { RMeBP, eAX } },
|
893 |
{ "xchgS", { RMeSI, eAX } },
|
894 |
{ "xchgS", { RMeDI, eAX } },
|
895 |
/* 98 */
|
896 |
{ "cW{t||t|}R", { XX } },
|
897 |
{ "cR{t||t|}O", { XX } },
|
898 |
{ "Jcall{T|}", { Ap } },
|
899 |
{ "(bad)", { XX } }, /* fwait */ |
900 |
{ "pushfT", { XX } },
|
901 |
{ "popfT", { XX } },
|
902 |
{ "sahf{|}", { XX } },
|
903 |
{ "lahf{|}", { XX } },
|
904 |
/* a0 */
|
905 |
{ "movB", { AL, Ob } },
|
906 |
{ "movS", { eAX, Ov } },
|
907 |
{ "movB", { Ob, AL } },
|
908 |
{ "movS", { Ov, eAX } },
|
909 |
{ "movs{b||b|}", { Ybr, Xb } },
|
910 |
{ "movs{R||R|}", { Yvr, Xv } },
|
911 |
{ "cmps{b||b|}", { Xb, Yb } },
|
912 |
{ "cmps{R||R|}", { Xv, Yv } },
|
913 |
/* a8 */
|
914 |
{ "testB", { AL, Ib } },
|
915 |
{ "testS", { eAX, Iv } },
|
916 |
{ "stosB", { Ybr, AL } },
|
917 |
{ "stosS", { Yvr, eAX } },
|
918 |
{ "lodsB", { ALr, Xb } },
|
919 |
{ "lodsS", { eAXr, Xv } },
|
920 |
{ "scasB", { AL, Yb } },
|
921 |
{ "scasS", { eAX, Yv } },
|
922 |
/* b0 */
|
923 |
{ "movB", { RMAL, Ib } },
|
924 |
{ "movB", { RMCL, Ib } },
|
925 |
{ "movB", { RMDL, Ib } },
|
926 |
{ "movB", { RMBL, Ib } },
|
927 |
{ "movB", { RMAH, Ib } },
|
928 |
{ "movB", { RMCH, Ib } },
|
929 |
{ "movB", { RMDH, Ib } },
|
930 |
{ "movB", { RMBH, Ib } },
|
931 |
/* b8 */
|
932 |
{ "movS", { RMeAX, Iv64 } },
|
933 |
{ "movS", { RMeCX, Iv64 } },
|
934 |
{ "movS", { RMeDX, Iv64 } },
|
935 |
{ "movS", { RMeBX, Iv64 } },
|
936 |
{ "movS", { RMeSP, Iv64 } },
|
937 |
{ "movS", { RMeBP, Iv64 } },
|
938 |
{ "movS", { RMeSI, Iv64 } },
|
939 |
{ "movS", { RMeDI, Iv64 } },
|
940 |
/* c0 */
|
941 |
{ GRP2b }, |
942 |
{ GRP2S }, |
943 |
{ "retT", { Iw } },
|
944 |
{ "retT", { XX } },
|
945 |
{ "les{S|}", { Gv, Mp } },
|
946 |
{ "ldsS", { Gv, Mp } },
|
947 |
{ GRP11_C6 }, |
948 |
{ GRP11_C7 }, |
949 |
/* c8 */
|
950 |
{ "enterT", { Iw, Ib } },
|
951 |
{ "leaveT", { XX } },
|
952 |
{ "lretP", { Iw } },
|
953 |
{ "lretP", { XX } },
|
954 |
{ "int3", { XX } },
|
955 |
{ "int", { Ib } },
|
956 |
{ "into{|}", { XX } },
|
957 |
{ "iretP", { XX } },
|
958 |
/* d0 */
|
959 |
{ GRP2b_one }, |
960 |
{ GRP2S_one }, |
961 |
{ GRP2b_cl }, |
962 |
{ GRP2S_cl }, |
963 |
{ "aam{|}", { sIb } },
|
964 |
{ "aad{|}", { sIb } },
|
965 |
{ "(bad)", { XX } },
|
966 |
{ "xlat", { DSBX } },
|
967 |
/* d8 */
|
968 |
{ FLOAT }, |
969 |
{ FLOAT }, |
970 |
{ FLOAT }, |
971 |
{ FLOAT }, |
972 |
{ FLOAT }, |
973 |
{ FLOAT }, |
974 |
{ FLOAT }, |
975 |
{ FLOAT }, |
976 |
/* e0 */
|
977 |
{ "loopneFH", { Jb, XX, loop_jcxz_flag } },
|
978 |
{ "loopeFH", { Jb, XX, loop_jcxz_flag } },
|
979 |
{ "loopFH", { Jb, XX, loop_jcxz_flag } },
|
980 |
{ "jEcxzH", { Jb, XX, loop_jcxz_flag } },
|
981 |
{ "inB", { AL, Ib } },
|
982 |
{ "inG", { zAX, Ib } },
|
983 |
{ "outB", { Ib, AL } },
|
984 |
{ "outG", { Ib, zAX } },
|
985 |
/* e8 */
|
986 |
{ "callT", { Jv } },
|
987 |
{ "jmpT", { Jv } },
|
988 |
{ "Jjmp{T|}", { Ap } },
|
989 |
{ "jmp", { Jb } },
|
990 |
{ "inB", { AL, indirDX } },
|
991 |
{ "inG", { zAX, indirDX } },
|
992 |
{ "outB", { indirDX, AL } },
|
993 |
{ "outG", { indirDX, zAX } },
|
994 |
/* f0 */
|
995 |
{ "(bad)", { XX } }, /* lock prefix */ |
996 |
{ "icebp", { XX } },
|
997 |
{ "(bad)", { XX } }, /* repne */ |
998 |
{ "(bad)", { XX } }, /* repz */ |
999 |
{ "hlt", { XX } },
|
1000 |
{ "cmc", { XX } },
|
1001 |
{ GRP3b }, |
1002 |
{ GRP3S }, |
1003 |
/* f8 */
|
1004 |
{ "clc", { XX } },
|
1005 |
{ "stc", { XX } },
|
1006 |
{ "cli", { XX } },
|
1007 |
{ "sti", { XX } },
|
1008 |
{ "cld", { XX } },
|
1009 |
{ "std", { XX } },
|
1010 |
{ GRP4 }, |
1011 |
{ GRP5 }, |
1012 |
}; |
1013 |
|
1014 |
static const struct dis386 dis386_twobyte[] = { |
1015 |
/* 00 */
|
1016 |
{ GRP6 }, |
1017 |
{ GRP7 }, |
1018 |
{ "larS", { Gv, Ew } },
|
1019 |
{ "lslS", { Gv, Ew } },
|
1020 |
{ "(bad)", { XX } },
|
1021 |
{ "syscall", { XX } },
|
1022 |
{ "clts", { XX } },
|
1023 |
{ "sysretP", { XX } },
|
1024 |
/* 08 */
|
1025 |
{ "invd", { XX } },
|
1026 |
{ "wbinvd", { XX } },
|
1027 |
{ "(bad)", { XX } },
|
1028 |
{ "ud2a", { XX } },
|
1029 |
{ "(bad)", { XX } },
|
1030 |
{ GRPAMD }, |
1031 |
{ "femms", { XX } },
|
1032 |
{ "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */ |
1033 |
/* 10 */
|
1034 |
{ PREGRP8 }, |
1035 |
{ PREGRP9 }, |
1036 |
{ PREGRP30 }, |
1037 |
{ "movlpX", { EXq, XM, { SIMD_Fixup, 'h' } } }, |
1038 |
{ "unpcklpX", { XM, EXq } },
|
1039 |
{ "unpckhpX", { XM, EXq } },
|
1040 |
{ PREGRP31 }, |
1041 |
{ "movhpX", { EXq, XM, { SIMD_Fixup, 'l' } } }, |
1042 |
/* 18 */
|
1043 |
{ GRP16 }, |
1044 |
{ "(bad)", { XX } },
|
1045 |
{ "(bad)", { XX } },
|
1046 |
{ "(bad)", { XX } },
|
1047 |
{ "(bad)", { XX } },
|
1048 |
{ "(bad)", { XX } },
|
1049 |
{ "(bad)", { XX } },
|
1050 |
{ "nopQ", { Ev } },
|
1051 |
/* 20 */
|
1052 |
{ "movZ", { Rm, Cm } },
|
1053 |
{ "movZ", { Rm, Dm } },
|
1054 |
{ "movZ", { Cm, Rm } },
|
1055 |
{ "movZ", { Dm, Rm } },
|
1056 |
{ "movL", { Rd, Td } },
|
1057 |
{ "(bad)", { XX } },
|
1058 |
{ "movL", { Td, Rd } },
|
1059 |
{ "(bad)", { XX } },
|
1060 |
/* 28 */
|
1061 |
{ "movapX", { XM, EXx } },
|
1062 |
{ "movapX", { EXx, XM } },
|
1063 |
{ PREGRP2 }, |
1064 |
{ PREGRP33 }, |
1065 |
{ PREGRP4 }, |
1066 |
{ PREGRP3 }, |
1067 |
{ PREGRP93 }, |
1068 |
{ PREGRP94 }, |
1069 |
/* 30 */
|
1070 |
{ "wrmsr", { XX } },
|
1071 |
{ "rdtsc", { XX } },
|
1072 |
{ "rdmsr", { XX } },
|
1073 |
{ "rdpmc", { XX } },
|
1074 |
{ "sysenter", { XX } },
|
1075 |
{ "sysexit", { XX } },
|
1076 |
{ "(bad)", { XX } },
|
1077 |
{ "(bad)", { XX } },
|
1078 |
/* 38 */
|
1079 |
{ THREE_BYTE_0 }, |
1080 |
{ "(bad)", { XX } },
|
1081 |
{ THREE_BYTE_1 }, |
1082 |
{ "(bad)", { XX } },
|
1083 |
{ "(bad)", { XX } },
|
1084 |
{ "(bad)", { XX } },
|
1085 |
{ "(bad)", { XX } },
|
1086 |
{ "(bad)", { XX } },
|
1087 |
/* 40 */
|
1088 |
{ "cmovo", { Gv, Ev } },
|
1089 |
{ "cmovno", { Gv, Ev } },
|
1090 |
{ "cmovb", { Gv, Ev } },
|
1091 |
{ "cmovae", { Gv, Ev } },
|
1092 |
{ "cmove", { Gv, Ev } },
|
1093 |
{ "cmovne", { Gv, Ev } },
|
1094 |
{ "cmovbe", { Gv, Ev } },
|
1095 |
{ "cmova", { Gv, Ev } },
|
1096 |
/* 48 */
|
1097 |
{ "cmovs", { Gv, Ev } },
|
1098 |
{ "cmovns", { Gv, Ev } },
|
1099 |
{ "cmovp", { Gv, Ev } },
|
1100 |
{ "cmovnp", { Gv, Ev } },
|
1101 |
{ "cmovl", { Gv, Ev } },
|
1102 |
{ "cmovge", { Gv, Ev } },
|
1103 |
{ "cmovle", { Gv, Ev } },
|
1104 |
{ "cmovg", { Gv, Ev } },
|
1105 |
/* 50 */
|
1106 |
{ "movmskpX", { Gdq, XS } },
|
1107 |
{ PREGRP13 }, |
1108 |
{ PREGRP12 }, |
1109 |
{ PREGRP11 }, |
1110 |
{ "andpX", { XM, EXx } },
|
1111 |
{ "andnpX", { XM, EXx } },
|
1112 |
{ "orpX", { XM, EXx } },
|
1113 |
{ "xorpX", { XM, EXx } },
|
1114 |
/* 58 */
|
1115 |
{ PREGRP0 }, |
1116 |
{ PREGRP10 }, |
1117 |
{ PREGRP17 }, |
1118 |
{ PREGRP16 }, |
1119 |
{ PREGRP14 }, |
1120 |
{ PREGRP7 }, |
1121 |
{ PREGRP5 }, |
1122 |
{ PREGRP6 }, |
1123 |
/* 60 */
|
1124 |
{ PREGRP95 }, |
1125 |
{ PREGRP96 }, |
1126 |
{ PREGRP97 }, |
1127 |
{ "packsswb", { MX, EM } },
|
1128 |
{ "pcmpgtb", { MX, EM } },
|
1129 |
{ "pcmpgtw", { MX, EM } },
|
1130 |
{ "pcmpgtd", { MX, EM } },
|
1131 |
{ "packuswb", { MX, EM } },
|
1132 |
/* 68 */
|
1133 |
{ "punpckhbw", { MX, EM } },
|
1134 |
{ "punpckhwd", { MX, EM } },
|
1135 |
{ "punpckhdq", { MX, EM } },
|
1136 |
{ "packssdw", { MX, EM } },
|
1137 |
{ PREGRP26 }, |
1138 |
{ PREGRP24 }, |
1139 |
{ "movd", { MX, Edq } },
|
1140 |
{ PREGRP19 }, |
1141 |
/* 70 */
|
1142 |
{ PREGRP22 }, |
1143 |
{ GRP12 }, |
1144 |
{ GRP13 }, |
1145 |
{ GRP14 }, |
1146 |
{ "pcmpeqb", { MX, EM } },
|
1147 |
{ "pcmpeqw", { MX, EM } },
|
1148 |
{ "pcmpeqd", { MX, EM } },
|
1149 |
{ "emms", { XX } },
|
1150 |
/* 78 */
|
1151 |
{ PREGRP34 }, |
1152 |
{ PREGRP35 }, |
1153 |
{ "(bad)", { XX } },
|
1154 |
{ "(bad)", { XX } },
|
1155 |
{ PREGRP28 }, |
1156 |
{ PREGRP29 }, |
1157 |
{ PREGRP23 }, |
1158 |
{ PREGRP20 }, |
1159 |
/* 80 */
|
1160 |
{ "joH", { Jv, XX, cond_jump_flag } },
|
1161 |
{ "jnoH", { Jv, XX, cond_jump_flag } },
|
1162 |
{ "jbH", { Jv, XX, cond_jump_flag } },
|
1163 |
{ "jaeH", { Jv, XX, cond_jump_flag } },
|
1164 |
{ "jeH", { Jv, XX, cond_jump_flag } },
|
1165 |
{ "jneH", { Jv, XX, cond_jump_flag } },
|
1166 |
{ "jbeH", { Jv, XX, cond_jump_flag } },
|
1167 |
{ "jaH", { Jv, XX, cond_jump_flag } },
|
1168 |
/* 88 */
|
1169 |
{ "jsH", { Jv, XX, cond_jump_flag } },
|
1170 |
{ "jnsH", { Jv, XX, cond_jump_flag } },
|
1171 |
{ "jpH", { Jv, XX, cond_jump_flag } },
|
1172 |
{ "jnpH", { Jv, XX, cond_jump_flag } },
|
1173 |
{ "jlH", { Jv, XX, cond_jump_flag } },
|
1174 |
{ "jgeH", { Jv, XX, cond_jump_flag } },
|
1175 |
{ "jleH", { Jv, XX, cond_jump_flag } },
|
1176 |
{ "jgH", { Jv, XX, cond_jump_flag } },
|
1177 |
/* 90 */
|
1178 |
{ "seto", { Eb } },
|
1179 |
{ "setno", { Eb } },
|
1180 |
{ "setb", { Eb } },
|
1181 |
{ "setae", { Eb } },
|
1182 |
{ "sete", { Eb } },
|
1183 |
{ "setne", { Eb } },
|
1184 |
{ "setbe", { Eb } },
|
1185 |
{ "seta", { Eb } },
|
1186 |
/* 98 */
|
1187 |
{ "sets", { Eb } },
|
1188 |
{ "setns", { Eb } },
|
1189 |
{ "setp", { Eb } },
|
1190 |
{ "setnp", { Eb } },
|
1191 |
{ "setl", { Eb } },
|
1192 |
{ "setge", { Eb } },
|
1193 |
{ "setle", { Eb } },
|
1194 |
{ "setg", { Eb } },
|
1195 |
/* a0 */
|
1196 |
{ "pushT", { fs } },
|
1197 |
{ "popT", { fs } },
|
1198 |
{ "cpuid", { XX } },
|
1199 |
{ "btS", { Ev, Gv } },
|
1200 |
{ "shldS", { Ev, Gv, Ib } },
|
1201 |
{ "shldS", { Ev, Gv, CL } },
|
1202 |
{ GRPPADLCK2 }, |
1203 |
{ GRPPADLCK1 }, |
1204 |
/* a8 */
|
1205 |
{ "pushT", { gs } },
|
1206 |
{ "popT", { gs } },
|
1207 |
{ "rsm", { XX } },
|
1208 |
{ "btsS", { Ev, Gv } },
|
1209 |
{ "shrdS", { Ev, Gv, Ib } },
|
1210 |
{ "shrdS", { Ev, Gv, CL } },
|
1211 |
{ GRP15 }, |
1212 |
{ "imulS", { Gv, Ev } },
|
1213 |
/* b0 */
|
1214 |
{ "cmpxchgB", { Eb, Gb } },
|
1215 |
{ "cmpxchgS", { Ev, Gv } },
|
1216 |
{ "lssS", { Gv, Mp } },
|
1217 |
{ "btrS", { Ev, Gv } },
|
1218 |
{ "lfsS", { Gv, Mp } },
|
1219 |
{ "lgsS", { Gv, Mp } },
|
1220 |
{ "movz{bR|x|bR|x}", { Gv, Eb } },
|
1221 |
{ "movz{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */ |
1222 |
/* b8 */
|
1223 |
{ PREGRP37 }, |
1224 |
{ "ud2b", { XX } },
|
1225 |
{ GRP8 }, |
1226 |
{ "btcS", { Ev, Gv } },
|
1227 |
{ "bsfS", { Gv, Ev } },
|
1228 |
{ PREGRP36 }, |
1229 |
{ "movs{bR|x|bR|x}", { Gv, Eb } },
|
1230 |
{ "movs{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */ |
1231 |
/* c0 */
|
1232 |
{ "xaddB", { Eb, Gb } },
|
1233 |
{ "xaddS", { Ev, Gv } },
|
1234 |
{ PREGRP1 }, |
1235 |
{ "movntiS", { Ev, Gv } },
|
1236 |
{ "pinsrw", { MX, Edqw, Ib } },
|
1237 |
{ "pextrw", { Gdq, MS, Ib } },
|
1238 |
{ "shufpX", { XM, EXx, Ib } },
|
1239 |
{ GRP9 }, |
1240 |
/* c8 */
|
1241 |
{ "bswap", { RMeAX } },
|
1242 |
{ "bswap", { RMeCX } },
|
1243 |
{ "bswap", { RMeDX } },
|
1244 |
{ "bswap", { RMeBX } },
|
1245 |
{ "bswap", { RMeSP } },
|
1246 |
{ "bswap", { RMeBP } },
|
1247 |
{ "bswap", { RMeSI } },
|
1248 |
{ "bswap", { RMeDI } },
|
1249 |
/* d0 */
|
1250 |
{ PREGRP27 }, |
1251 |
{ "psrlw", { MX, EM } },
|
1252 |
{ "psrld", { MX, EM } },
|
1253 |
{ "psrlq", { MX, EM } },
|
1254 |
{ "paddq", { MX, EM } },
|
1255 |
{ "pmullw", { MX, EM } },
|
1256 |
{ PREGRP21 }, |
1257 |
{ "pmovmskb", { Gdq, MS } },
|
1258 |
/* d8 */
|
1259 |
{ "psubusb", { MX, EM } },
|
1260 |
{ "psubusw", { MX, EM } },
|
1261 |
{ "pminub", { MX, EM } },
|
1262 |
{ "pand", { MX, EM } },
|
1263 |
{ "paddusb", { MX, EM } },
|
1264 |
{ "paddusw", { MX, EM } },
|
1265 |
{ "pmaxub", { MX, EM } },
|
1266 |
{ "pandn", { MX, EM } },
|
1267 |
/* e0 */
|
1268 |
{ "pavgb", { MX, EM } },
|
1269 |
{ "psraw", { MX, EM } },
|
1270 |
{ "psrad", { MX, EM } },
|
1271 |
{ "pavgw", { MX, EM } },
|
1272 |
{ "pmulhuw", { MX, EM } },
|
1273 |
{ "pmulhw", { MX, EM } },
|
1274 |
{ PREGRP15 }, |
1275 |
{ PREGRP25 }, |
1276 |
/* e8 */
|
1277 |
{ "psubsb", { MX, EM } },
|
1278 |
{ "psubsw", { MX, EM } },
|
1279 |
{ "pminsw", { MX, EM } },
|
1280 |
{ "por", { MX, EM } },
|
1281 |
{ "paddsb", { MX, EM } },
|
1282 |
{ "paddsw", { MX, EM } },
|
1283 |
{ "pmaxsw", { MX, EM } },
|
1284 |
{ "pxor", { MX, EM } },
|
1285 |
/* f0 */
|
1286 |
{ PREGRP32 }, |
1287 |
{ "psllw", { MX, EM } },
|
1288 |
{ "pslld", { MX, EM } },
|
1289 |
{ "psllq", { MX, EM } },
|
1290 |
{ "pmuludq", { MX, EM } },
|
1291 |
{ "pmaddwd", { MX, EM } },
|
1292 |
{ "psadbw", { MX, EM } },
|
1293 |
{ PREGRP18 }, |
1294 |
/* f8 */
|
1295 |
{ "psubb", { MX, EM } },
|
1296 |
{ "psubw", { MX, EM } },
|
1297 |
{ "psubd", { MX, EM } },
|
1298 |
{ "psubq", { MX, EM } },
|
1299 |
{ "paddb", { MX, EM } },
|
1300 |
{ "paddw", { MX, EM } },
|
1301 |
{ "paddd", { MX, EM } },
|
1302 |
{ "(bad)", { XX } },
|
1303 |
}; |
1304 |
|
1305 |
static const unsigned char onebyte_has_modrm[256] = { |
1306 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1307 |
/* ------------------------------- */
|
1308 |
/* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */ |
1309 |
/* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */ |
1310 |
/* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */ |
1311 |
/* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */ |
1312 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */ |
1313 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */ |
1314 |
/* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */ |
1315 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */ |
1316 |
/* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */ |
1317 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */ |
1318 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */ |
1319 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */ |
1320 |
/* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */ |
1321 |
/* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */ |
1322 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */ |
1323 |
/* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */ |
1324 |
/* ------------------------------- */
|
1325 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1326 |
}; |
1327 |
|
1328 |
static const unsigned char twobyte_has_modrm[256] = { |
1329 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1330 |
/* ------------------------------- */
|
1331 |
/* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */ |
1332 |
/* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */ |
1333 |
/* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */ |
1334 |
/* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */ |
1335 |
/* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */ |
1336 |
/* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */ |
1337 |
/* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */ |
1338 |
/* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */ |
1339 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1340 |
/* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */ |
1341 |
/* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */ |
1342 |
/* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */ |
1343 |
/* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */ |
1344 |
/* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */ |
1345 |
/* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */ |
1346 |
/* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */ |
1347 |
/* ------------------------------- */
|
1348 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1349 |
}; |
1350 |
|
1351 |
static const unsigned char twobyte_uses_DATA_prefix[256] = { |
1352 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1353 |
/* ------------------------------- */
|
1354 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1355 |
/* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ |
1356 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ |
1357 |
/* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */ |
1358 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1359 |
/* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ |
1360 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */ |
1361 |
/* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1, /* 7f */ |
1362 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1363 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1364 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1365 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1366 |
/* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1367 |
/* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ |
1368 |
/* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ |
1369 |
/* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */ |
1370 |
/* ------------------------------- */
|
1371 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1372 |
}; |
1373 |
|
1374 |
static const unsigned char twobyte_uses_REPNZ_prefix[256] = { |
1375 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1376 |
/* ------------------------------- */
|
1377 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1378 |
/* 10 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ |
1379 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ |
1380 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1381 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1382 |
/* 50 */ 0,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1, /* 5f */ |
1383 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ |
1384 |
/* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0, /* 7f */ |
1385 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1386 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1387 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1388 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1389 |
/* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1390 |
/* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ |
1391 |
/* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ |
1392 |
/* f0 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1393 |
/* ------------------------------- */
|
1394 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1395 |
}; |
1396 |
|
1397 |
static const unsigned char twobyte_uses_REPZ_prefix[256] = { |
1398 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1399 |
/* ------------------------------- */
|
1400 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1401 |
/* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ |
1402 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ |
1403 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1404 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1405 |
/* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ |
1406 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* 6f */ |
1407 |
/* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */ |
1408 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1409 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1410 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1411 |
/* b0 */ 0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0, /* bf */ |
1412 |
/* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1413 |
/* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ |
1414 |
/* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ |
1415 |
/* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1416 |
/* ------------------------------- */
|
1417 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1418 |
}; |
1419 |
|
1420 |
/* This is used to determine if opcode 0f 38 XX uses DATA prefix. */
|
1421 |
static const unsigned char threebyte_0x38_uses_DATA_prefix[256] = { |
1422 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1423 |
/* ------------------------------- */
|
1424 |
/* 00 */ 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, /* 0f */ |
1425 |
/* 10 */ 1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0, /* 1f */ |
1426 |
/* 20 */ 1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0, /* 2f */ |
1427 |
/* 30 */ 1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, /* 3f */ |
1428 |
/* 40 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1429 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ |
1430 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ |
1431 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ |
1432 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1433 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1434 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1435 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1436 |
/* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1437 |
/* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ |
1438 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ |
1439 |
/* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1440 |
/* ------------------------------- */
|
1441 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1442 |
}; |
1443 |
|
1444 |
/* This is used to determine if opcode 0f 38 XX uses REPNZ prefix. */
|
1445 |
static const unsigned char threebyte_0x38_uses_REPNZ_prefix[256] = { |
1446 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1447 |
/* ------------------------------- */
|
1448 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1449 |
/* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ |
1450 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ |
1451 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1452 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1453 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ |
1454 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ |
1455 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ |
1456 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1457 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1458 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1459 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1460 |
/* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1461 |
/* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ |
1462 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ |
1463 |
/* f0 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1464 |
/* ------------------------------- */
|
1465 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1466 |
}; |
1467 |
|
1468 |
/* This is used to determine if opcode 0f 38 XX uses REPZ prefix. */
|
1469 |
static const unsigned char threebyte_0x38_uses_REPZ_prefix[256] = { |
1470 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1471 |
/* ------------------------------- */
|
1472 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1473 |
/* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ |
1474 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ |
1475 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1476 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1477 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ |
1478 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ |
1479 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ |
1480 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1481 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1482 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1483 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1484 |
/* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1485 |
/* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ |
1486 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ |
1487 |
/* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1488 |
/* ------------------------------- */
|
1489 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1490 |
}; |
1491 |
|
1492 |
/* This is used to determine if opcode 0f 3a XX uses DATA prefix. */
|
1493 |
static const unsigned char threebyte_0x3a_uses_DATA_prefix[256] = { |
1494 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1495 |
/* ------------------------------- */
|
1496 |
/* 00 */ 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, /* 0f */ |
1497 |
/* 10 */ 0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* 1f */ |
1498 |
/* 20 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ |
1499 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1500 |
/* 40 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1501 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ |
1502 |
/* 60 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ |
1503 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ |
1504 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1505 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1506 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1507 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1508 |
/* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1509 |
/* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ |
1510 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ |
1511 |
/* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1512 |
/* ------------------------------- */
|
1513 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1514 |
}; |
1515 |
|
1516 |
/* This is used to determine if opcode 0f 3a XX uses REPNZ prefix. */
|
1517 |
static const unsigned char threebyte_0x3a_uses_REPNZ_prefix[256] = { |
1518 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1519 |
/* ------------------------------- */
|
1520 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1521 |
/* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ |
1522 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ |
1523 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1524 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1525 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ |
1526 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ |
1527 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ |
1528 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1529 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1530 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1531 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1532 |
/* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1533 |
/* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ |
1534 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ |
1535 |
/* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1536 |
/* ------------------------------- */
|
1537 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1538 |
}; |
1539 |
|
1540 |
/* This is used to determine if opcode 0f 3a XX uses REPZ prefix. */
|
1541 |
static const unsigned char threebyte_0x3a_uses_REPZ_prefix[256] = { |
1542 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1543 |
/* ------------------------------- */
|
1544 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1545 |
/* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ |
1546 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ |
1547 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1548 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1549 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ |
1550 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ |
1551 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ |
1552 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1553 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1554 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1555 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1556 |
/* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1557 |
/* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ |
1558 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ |
1559 |
/* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ |
1560 |
/* ------------------------------- */
|
1561 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1562 |
}; |
1563 |
|
1564 |
static char obuf[100]; |
1565 |
static char *obufp; |
1566 |
static char scratchbuf[100]; |
1567 |
static unsigned char *start_codep; |
1568 |
static unsigned char *insn_codep; |
1569 |
static unsigned char *codep; |
1570 |
static disassemble_info *the_info;
|
1571 |
static struct |
1572 |
{ |
1573 |
int mod;
|
1574 |
int reg;
|
1575 |
int rm;
|
1576 |
} |
1577 |
modrm; |
1578 |
static unsigned char need_modrm; |
1579 |
|
1580 |
/* If we are accessing mod/rm/reg without need_modrm set, then the
|
1581 |
values are stale. Hitting this abort likely indicates that you
|
1582 |
need to update onebyte_has_modrm or twobyte_has_modrm. */
|
1583 |
#define MODRM_CHECK if (!need_modrm) abort () |
1584 |
|
1585 |
static const char * const *names64; |
1586 |
static const char * const *names32; |
1587 |
static const char * const *names16; |
1588 |
static const char * const *names8; |
1589 |
static const char * const *names8rex; |
1590 |
static const char * const *names_seg; |
1591 |
static const char * const *index16; |
1592 |
|
1593 |
static const char * const intel_names64[] = { |
1594 |
"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", |
1595 |
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" |
1596 |
}; |
1597 |
static const char * const intel_names32[] = { |
1598 |
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", |
1599 |
"r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" |
1600 |
}; |
1601 |
static const char * const intel_names16[] = { |
1602 |
"ax", "cx", "dx", "bx", "sp", "bp", "si", "di", |
1603 |
"r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" |
1604 |
}; |
1605 |
static const char * const intel_names8[] = { |
1606 |
"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh", |
1607 |
}; |
1608 |
static const char * const intel_names8rex[] = { |
1609 |
"al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", |
1610 |
"r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" |
1611 |
}; |
1612 |
static const char * const intel_names_seg[] = { |
1613 |
"es", "cs", "ss", "ds", "fs", "gs", "?", "?", |
1614 |
}; |
1615 |
static const char * const intel_index16[] = { |
1616 |
"bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx" |
1617 |
}; |
1618 |
|
1619 |
static const char * const att_names64[] = { |
1620 |
"%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi", |
1621 |
"%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" |
1622 |
}; |
1623 |
static const char * const att_names32[] = { |
1624 |
"%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi", |
1625 |
"%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" |
1626 |
}; |
1627 |
static const char * const att_names16[] = { |
1628 |
"%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", |
1629 |
"%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" |
1630 |
}; |
1631 |
static const char * const att_names8[] = { |
1632 |
"%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", |
1633 |
}; |
1634 |
static const char * const att_names8rex[] = { |
1635 |
"%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil", |
1636 |
"%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" |
1637 |
}; |
1638 |
static const char * const att_names_seg[] = { |
1639 |
"%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?", |
1640 |
}; |
1641 |
static const char * const att_index16[] = { |
1642 |
"%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx" |
1643 |
}; |
1644 |
|
1645 |
static const struct dis386 grps[][8] = { |
1646 |
/* GRP1a */
|
1647 |
{ |
1648 |
{ "popU", { stackEv } },
|
1649 |
{ "(bad)", { XX } },
|
1650 |
{ "(bad)", { XX } },
|
1651 |
{ "(bad)", { XX } },
|
1652 |
{ "(bad)", { XX } },
|
1653 |
{ "(bad)", { XX } },
|
1654 |
{ "(bad)", { XX } },
|
1655 |
{ "(bad)", { XX } },
|
1656 |
}, |
1657 |
/* GRP1b */
|
1658 |
{ |
1659 |
{ "addA", { Eb, Ib } },
|
1660 |
{ "orA", { Eb, Ib } },
|
1661 |
{ "adcA", { Eb, Ib } },
|
1662 |
{ "sbbA", { Eb, Ib } },
|
1663 |
{ "andA", { Eb, Ib } },
|
1664 |
{ "subA", { Eb, Ib } },
|
1665 |
{ "xorA", { Eb, Ib } },
|
1666 |
{ "cmpA", { Eb, Ib } },
|
1667 |
}, |
1668 |
/* GRP1S */
|
1669 |
{ |
1670 |
{ "addQ", { Ev, Iv } },
|
1671 |
{ "orQ", { Ev, Iv } },
|
1672 |
{ "adcQ", { Ev, Iv } },
|
1673 |
{ "sbbQ", { Ev, Iv } },
|
1674 |
{ "andQ", { Ev, Iv } },
|
1675 |
{ "subQ", { Ev, Iv } },
|
1676 |
{ "xorQ", { Ev, Iv } },
|
1677 |
{ "cmpQ", { Ev, Iv } },
|
1678 |
}, |
1679 |
/* GRP1Ss */
|
1680 |
{ |
1681 |
{ "addQ", { Ev, sIb } },
|
1682 |
{ "orQ", { Ev, sIb } },
|
1683 |
{ "adcQ", { Ev, sIb } },
|
1684 |
{ "sbbQ", { Ev, sIb } },
|
1685 |
{ "andQ", { Ev, sIb } },
|
1686 |
{ "subQ", { Ev, sIb } },
|
1687 |
{ "xorQ", { Ev, sIb } },
|
1688 |
{ "cmpQ", { Ev, sIb } },
|
1689 |
}, |
1690 |
/* GRP2b */
|
1691 |
{ |
1692 |
{ "rolA", { Eb, Ib } },
|
1693 |
{ "rorA", { Eb, Ib } },
|
1694 |
{ "rclA", { Eb, Ib } },
|
1695 |
{ "rcrA", { Eb, Ib } },
|
1696 |
{ "shlA", { Eb, Ib } },
|
1697 |
{ "shrA", { Eb, Ib } },
|
1698 |
{ "(bad)", { XX } },
|
1699 |
{ "sarA", { Eb, Ib } },
|
1700 |
}, |
1701 |
/* GRP2S */
|
1702 |
{ |
1703 |
{ "rolQ", { Ev, Ib } },
|
1704 |
{ "rorQ", { Ev, Ib } },
|
1705 |
{ "rclQ", { Ev, Ib } },
|
1706 |
{ "rcrQ", { Ev, Ib } },
|
1707 |
{ "shlQ", { Ev, Ib } },
|
1708 |
{ "shrQ", { Ev, Ib } },
|
1709 |
{ "(bad)", { XX } },
|
1710 |
{ "sarQ", { Ev, Ib } },
|
1711 |
}, |
1712 |
/* GRP2b_one */
|
1713 |
{ |
1714 |
{ "rolA", { Eb, I1 } },
|
1715 |
{ "rorA", { Eb, I1 } },
|
1716 |
{ "rclA", { Eb, I1 } },
|
1717 |
{ "rcrA", { Eb, I1 } },
|
1718 |
{ "shlA", { Eb, I1 } },
|
1719 |
{ "shrA", { Eb, I1 } },
|
1720 |
{ "(bad)", { XX } },
|
1721 |
{ "sarA", { Eb, I1 } },
|
1722 |
}, |
1723 |
/* GRP2S_one */
|
1724 |
{ |
1725 |
{ "rolQ", { Ev, I1 } },
|
1726 |
{ "rorQ", { Ev, I1 } },
|
1727 |
{ "rclQ", { Ev, I1 } },
|
1728 |
{ "rcrQ", { Ev, I1 } },
|
1729 |
{ "shlQ", { Ev, I1 } },
|
1730 |
{ "shrQ", { Ev, I1 } },
|
1731 |
{ "(bad)", { XX } },
|
1732 |
{ "sarQ", { Ev, I1 } },
|
1733 |
}, |
1734 |
/* GRP2b_cl */
|
1735 |
{ |
1736 |
{ "rolA", { Eb, CL } },
|
1737 |
{ "rorA", { Eb, CL } },
|
1738 |
{ "rclA", { Eb, CL } },
|
1739 |
{ "rcrA", { Eb, CL } },
|
1740 |
{ "shlA", { Eb, CL } },
|
1741 |
{ "shrA", { Eb, CL } },
|
1742 |
{ "(bad)", { XX } },
|
1743 |
{ "sarA", { Eb, CL } },
|
1744 |
}, |
1745 |
/* GRP2S_cl */
|
1746 |
{ |
1747 |
{ "rolQ", { Ev, CL } },
|
1748 |
{ "rorQ", { Ev, CL } },
|
1749 |
{ "rclQ", { Ev, CL } },
|
1750 |
{ "rcrQ", { Ev, CL } },
|
1751 |
{ "shlQ", { Ev, CL } },
|
1752 |
{ "shrQ", { Ev, CL } },
|
1753 |
{ "(bad)", { XX } },
|
1754 |
{ "sarQ", { Ev, CL } },
|
1755 |
}, |
1756 |
/* GRP3b */
|
1757 |
{ |
1758 |
{ "testA", { Eb, Ib } },
|
1759 |
{ "(bad)", { Eb } },
|
1760 |
{ "notA", { Eb } },
|
1761 |
{ "negA", { Eb } },
|
1762 |
{ "mulA", { Eb } }, /* Don't print the implicit %al register, */ |
1763 |
{ "imulA", { Eb } }, /* to distinguish these opcodes from other */ |
1764 |
{ "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */ |
1765 |
{ "idivA", { Eb } }, /* and idiv for consistency. */ |
1766 |
}, |
1767 |
/* GRP3S */
|
1768 |
{ |
1769 |
{ "testQ", { Ev, Iv } },
|
1770 |
{ "(bad)", { XX } },
|
1771 |
{ "notQ", { Ev } },
|
1772 |
{ "negQ", { Ev } },
|
1773 |
{ "mulQ", { Ev } }, /* Don't print the implicit register. */ |
1774 |
{ "imulQ", { Ev } },
|
1775 |
{ "divQ", { Ev } },
|
1776 |
{ "idivQ", { Ev } },
|
1777 |
}, |
1778 |
/* GRP4 */
|
1779 |
{ |
1780 |
{ "incA", { Eb } },
|
1781 |
{ "decA", { Eb } },
|
1782 |
{ "(bad)", { XX } },
|
1783 |
{ "(bad)", { XX } },
|
1784 |
{ "(bad)", { XX } },
|
1785 |
{ "(bad)", { XX } },
|
1786 |
{ "(bad)", { XX } },
|
1787 |
{ "(bad)", { XX } },
|
1788 |
}, |
1789 |
/* GRP5 */
|
1790 |
{ |
1791 |
{ "incQ", { Ev } },
|
1792 |
{ "decQ", { Ev } },
|
1793 |
{ "callT", { indirEv } },
|
1794 |
{ "JcallT", { indirEp } },
|
1795 |
{ "jmpT", { indirEv } },
|
1796 |
{ "JjmpT", { indirEp } },
|
1797 |
{ "pushU", { stackEv } },
|
1798 |
{ "(bad)", { XX } },
|
1799 |
}, |
1800 |
/* GRP6 */
|
1801 |
{ |
1802 |
{ "sldtD", { Sv } },
|
1803 |
{ "strD", { Sv } },
|
1804 |
{ "lldt", { Ew } },
|
1805 |
{ "ltr", { Ew } },
|
1806 |
{ "verr", { Ew } },
|
1807 |
{ "verw", { Ew } },
|
1808 |
{ "(bad)", { XX } },
|
1809 |
{ "(bad)", { XX } },
|
1810 |
}, |
1811 |
/* GRP7 */
|
1812 |
{ |
1813 |
{ "sgdt{Q|IQ||}", { { VMX_Fixup, 0 } } }, |
1814 |
{ "sidt{Q|IQ||}", { { PNI_Fixup, 0 } } }, |
1815 |
{ "lgdt{Q|Q||}", { M } },
|
1816 |
{ "lidt{Q|Q||}", { { SVME_Fixup, 0 } } }, |
1817 |
{ "smswD", { Sv } },
|
1818 |
{ "(bad)", { XX } },
|
1819 |
{ "lmsw", { Ew } },
|
1820 |
{ "invlpg", { { INVLPG_Fixup, w_mode } } },
|
1821 |
}, |
1822 |
/* GRP8 */
|
1823 |
{ |
1824 |
{ "(bad)", { XX } },
|
1825 |
{ "(bad)", { XX } },
|
1826 |
{ "(bad)", { XX } },
|
1827 |
{ "(bad)", { XX } },
|
1828 |
{ "btQ", { Ev, Ib } },
|
1829 |
{ "btsQ", { Ev, Ib } },
|
1830 |
{ "btrQ", { Ev, Ib } },
|
1831 |
{ "btcQ", { Ev, Ib } },
|
1832 |
}, |
1833 |
/* GRP9 */
|
1834 |
{ |
1835 |
{ "(bad)", { XX } },
|
1836 |
{ "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
|
1837 |
{ "(bad)", { XX } },
|
1838 |
{ "(bad)", { XX } },
|
1839 |
{ "(bad)", { XX } },
|
1840 |
{ "(bad)", { XX } },
|
1841 |
{ "", { VM } }, /* See OP_VMX. */ |
1842 |
{ "vmptrst", { Mq } },
|
1843 |
}, |
1844 |
/* GRP11_C6 */
|
1845 |
{ |
1846 |
{ "movA", { Eb, Ib } },
|
1847 |
{ "(bad)", { XX } },
|
1848 |
{ "(bad)", { XX } },
|
1849 |
{ "(bad)", { XX } },
|
1850 |
{ "(bad)", { XX } },
|
1851 |
{ "(bad)", { XX } },
|
1852 |
{ "(bad)", { XX } },
|
1853 |
{ "(bad)", { XX } },
|
1854 |
}, |
1855 |
/* GRP11_C7 */
|
1856 |
{ |
1857 |
{ "movQ", { Ev, Iv } },
|
1858 |
{ "(bad)", { XX } },
|
1859 |
{ "(bad)", { XX } },
|
1860 |
{ "(bad)", { XX } },
|
1861 |
{ "(bad)", { XX } },
|
1862 |
{ "(bad)", { XX } },
|
1863 |
{ "(bad)", { XX } },
|
1864 |
{ "(bad)", { XX } },
|
1865 |
}, |
1866 |
/* GRP12 */
|
1867 |
{ |
1868 |
{ "(bad)", { XX } },
|
1869 |
{ "(bad)", { XX } },
|
1870 |
{ "psrlw", { MS, Ib } },
|
1871 |
{ "(bad)", { XX } },
|
1872 |
{ "psraw", { MS, Ib } },
|
1873 |
{ "(bad)", { XX } },
|
1874 |
{ "psllw", { MS, Ib } },
|
1875 |
{ "(bad)", { XX } },
|
1876 |
}, |
1877 |
/* GRP13 */
|
1878 |
{ |
1879 |
{ "(bad)", { XX } },
|
1880 |
{ "(bad)", { XX } },
|
1881 |
{ "psrld", { MS, Ib } },
|
1882 |
{ "(bad)", { XX } },
|
1883 |
{ "psrad", { MS, Ib } },
|
1884 |
{ "(bad)", { XX } },
|
1885 |
{ "pslld", { MS, Ib } },
|
1886 |
{ "(bad)", { XX } },
|
1887 |
}, |
1888 |
/* GRP14 */
|
1889 |
{ |
1890 |
{ "(bad)", { XX } },
|
1891 |
{ "(bad)", { XX } },
|
1892 |
{ "psrlq", { MS, Ib } },
|
1893 |
{ "psrldq", { MS, Ib } },
|
1894 |
{ "(bad)", { XX } },
|
1895 |
{ "(bad)", { XX } },
|
1896 |
{ "psllq", { MS, Ib } },
|
1897 |
{ "pslldq", { MS, Ib } },
|
1898 |
}, |
1899 |
/* GRP15 */
|
1900 |
{ |
1901 |
{ "fxsave", { Ev } },
|
1902 |
{ "fxrstor", { Ev } },
|
1903 |
{ "ldmxcsr", { Ev } },
|
1904 |
{ "stmxcsr", { Ev } },
|
1905 |
{ "(bad)", { XX } },
|
1906 |
{ "lfence", { { OP_0fae, 0 } } }, |
1907 |
{ "mfence", { { OP_0fae, 0 } } }, |
1908 |
{ "clflush", { { OP_0fae, 0 } } }, |
1909 |
}, |
1910 |
/* GRP16 */
|
1911 |
{ |
1912 |
{ "prefetchnta", { Ev } },
|
1913 |
{ "prefetcht0", { Ev } },
|
1914 |
{ "prefetcht1", { Ev } },
|
1915 |
{ "prefetcht2", { Ev } },
|
1916 |
{ "(bad)", { XX } },
|
1917 |
{ "(bad)", { XX } },
|
1918 |
{ "(bad)", { XX } },
|
1919 |
{ "(bad)", { XX } },
|
1920 |
}, |
1921 |
/* GRPAMD */
|
1922 |
{ |
1923 |
{ "prefetch", { Eb } },
|
1924 |
{ "prefetchw", { Eb } },
|
1925 |
{ "(bad)", { XX } },
|
1926 |
{ "(bad)", { XX } },
|
1927 |
{ "(bad)", { XX } },
|
1928 |
{ "(bad)", { XX } },
|
1929 |
{ "(bad)", { XX } },
|
1930 |
{ "(bad)", { XX } },
|
1931 |
}, |
1932 |
/* GRPPADLCK1 */
|
1933 |
{ |
1934 |
{ "xstore-rng", { { OP_0f07, 0 } } }, |
1935 |
{ "xcrypt-ecb", { { OP_0f07, 0 } } }, |
1936 |
{ "xcrypt-cbc", { { OP_0f07, 0 } } }, |
1937 |
{ "xcrypt-ctr", { { OP_0f07, 0 } } }, |
1938 |
{ "xcrypt-cfb", { { OP_0f07, 0 } } }, |
1939 |
{ "xcrypt-ofb", { { OP_0f07, 0 } } }, |
1940 |
{ "(bad)", { { OP_0f07, 0 } } }, |
1941 |
{ "(bad)", { { OP_0f07, 0 } } }, |
1942 |
}, |
1943 |
/* GRPPADLCK2 */
|
1944 |
{ |
1945 |
{ "montmul", { { OP_0f07, 0 } } }, |
1946 |
{ "xsha1", { { OP_0f07, 0 } } }, |
1947 |
{ "xsha256", { { OP_0f07, 0 } } }, |
1948 |
{ "(bad)", { { OP_0f07, 0 } } }, |
1949 |
{ "(bad)", { { OP_0f07, 0 } } }, |
1950 |
{ "(bad)", { { OP_0f07, 0 } } }, |
1951 |
{ "(bad)", { { OP_0f07, 0 } } }, |
1952 |
{ "(bad)", { { OP_0f07, 0 } } }, |
1953 |
} |
1954 |
}; |
1955 |
|
1956 |
static const struct dis386 prefix_user_table[][4] = { |
1957 |
/* PREGRP0 */
|
1958 |
{ |
1959 |
{ "addps", { XM, EXx } },
|
1960 |
{ "addss", { XM, EXd } },
|
1961 |
{ "addpd", { XM, EXx } },
|
1962 |
{ "addsd", { XM, EXq } },
|
1963 |
}, |
1964 |
/* PREGRP1 */
|
1965 |
{ |
1966 |
{ "", { XM, EXx, OPSIMD } }, /* See OP_SIMD_SUFFIX. */ |
1967 |
{ "", { XM, EXx, OPSIMD } },
|
1968 |
{ "", { XM, EXx, OPSIMD } },
|
1969 |
{ "", { XM, EXx, OPSIMD } },
|
1970 |
}, |
1971 |
/* PREGRP2 */
|
1972 |
{ |
1973 |
{ "cvtpi2ps", { XM, EMC } },
|
1974 |
{ "cvtsi2ssY", { XM, Ev } },
|
1975 |
{ "cvtpi2pd", { XM, EMC } },
|
1976 |
{ "cvtsi2sdY", { XM, Ev } },
|
1977 |
}, |
1978 |
/* PREGRP3 */
|
1979 |
{ |
1980 |
{ "cvtps2pi", { MXC, EXx } },
|
1981 |
{ "cvtss2siY", { Gv, EXx } },
|
1982 |
{ "cvtpd2pi", { MXC, EXx } },
|
1983 |
{ "cvtsd2siY", { Gv, EXx } },
|
1984 |
}, |
1985 |
/* PREGRP4 */
|
1986 |
{ |
1987 |
{ "cvttps2pi", { MXC, EXx } },
|
1988 |
{ "cvttss2siY", { Gv, EXx } },
|
1989 |
{ "cvttpd2pi", { MXC, EXx } },
|
1990 |
{ "cvttsd2siY", { Gv, EXx } },
|
1991 |
}, |
1992 |
/* PREGRP5 */
|
1993 |
{ |
1994 |
{ "divps", { XM, EXx } },
|
1995 |
{ "divss", { XM, EXx } },
|
1996 |
{ "divpd", { XM, EXx } },
|
1997 |
{ "divsd", { XM, EXx } },
|
1998 |
}, |
1999 |
/* PREGRP6 */
|
2000 |
{ |
2001 |
{ "maxps", { XM, EXx } },
|
2002 |
{ "maxss", { XM, EXx } },
|
2003 |
{ "maxpd", { XM, EXx } },
|
2004 |
{ "maxsd", { XM, EXx } },
|
2005 |
}, |
2006 |
/* PREGRP7 */
|
2007 |
{ |
2008 |
{ "minps", { XM, EXx } },
|
2009 |
{ "minss", { XM, EXx } },
|
2010 |
{ "minpd", { XM, EXx } },
|
2011 |
{ "minsd", { XM, EXx } },
|
2012 |
}, |
2013 |
/* PREGRP8 */
|
2014 |
{ |
2015 |
{ "movups", { XM, EXx } },
|
2016 |
{ "movss", { XM, EXx } },
|
2017 |
{ "movupd", { XM, EXx } },
|
2018 |
{ "movsd", { XM, EXx } },
|
2019 |
}, |
2020 |
/* PREGRP9 */
|
2021 |
{ |
2022 |
{ "movups", { EXx, XM } },
|
2023 |
{ "movss", { EXx, XM } },
|
2024 |
{ "movupd", { EXx, XM } },
|
2025 |
{ "movsd", { EXx, XM } },
|
2026 |
}, |
2027 |
/* PREGRP10 */
|
2028 |
{ |
2029 |
{ "mulps", { XM, EXx } },
|
2030 |
{ "mulss", { XM, EXx } },
|
2031 |
{ "mulpd", { XM, EXx } },
|
2032 |
{ "mulsd", { XM, EXx } },
|
2033 |
}, |
2034 |
/* PREGRP11 */
|
2035 |
{ |
2036 |
{ "rcpps", { XM, EXx } },
|
2037 |
{ "rcpss", { XM, EXx } },
|
2038 |
{ "(bad)", { XM, EXx } },
|
2039 |
{ "(bad)", { XM, EXx } },
|
2040 |
}, |
2041 |
/* PREGRP12 */
|
2042 |
{ |
2043 |
{ "rsqrtps",{ XM, EXx } },
|
2044 |
{ "rsqrtss",{ XM, EXx } },
|
2045 |
{ "(bad)", { XM, EXx } },
|
2046 |
{ "(bad)", { XM, EXx } },
|
2047 |
}, |
2048 |
/* PREGRP13 */
|
2049 |
{ |
2050 |
{ "sqrtps", { XM, EXx } },
|
2051 |
{ "sqrtss", { XM, EXx } },
|
2052 |
{ "sqrtpd", { XM, EXx } },
|
2053 |
{ "sqrtsd", { XM, EXx } },
|
2054 |
}, |
2055 |
/* PREGRP14 */
|
2056 |
{ |
2057 |
{ "subps", { XM, EXx } },
|
2058 |
{ "subss", { XM, EXx } },
|
2059 |
{ "subpd", { XM, EXx } },
|
2060 |
{ "subsd", { XM, EXx } },
|
2061 |
}, |
2062 |
/* PREGRP15 */
|
2063 |
{ |
2064 |
{ "(bad)", { XM, EXx } },
|
2065 |
{ "cvtdq2pd", { XM, EXq } },
|
2066 |
{ "cvttpd2dq", { XM, EXx } },
|
2067 |
{ "cvtpd2dq", { XM, EXx } },
|
2068 |
}, |
2069 |
/* PREGRP16 */
|
2070 |
{ |
2071 |
{ "cvtdq2ps", { XM, EXx } },
|
2072 |
{ "cvttps2dq", { XM, EXx } },
|
2073 |
{ "cvtps2dq", { XM, EXx } },
|
2074 |
{ "(bad)", { XM, EXx } },
|
2075 |
}, |
2076 |
/* PREGRP17 */
|
2077 |
{ |
2078 |
{ "cvtps2pd", { XM, EXq } },
|
2079 |
{ "cvtss2sd", { XM, EXx } },
|
2080 |
{ "cvtpd2ps", { XM, EXx } },
|
2081 |
{ "cvtsd2ss", { XM, EXx } },
|
2082 |
}, |
2083 |
/* PREGRP18 */
|
2084 |
{ |
2085 |
{ "maskmovq", { MX, MS } },
|
2086 |
{ "(bad)", { XM, EXx } },
|
2087 |
{ "maskmovdqu", { XM, XS } },
|
2088 |
{ "(bad)", { XM, EXx } },
|
2089 |
}, |
2090 |
/* PREGRP19 */
|
2091 |
{ |
2092 |
{ "movq", { MX, EM } },
|
2093 |
{ "movdqu", { XM, EXx } },
|
2094 |
{ "movdqa", { XM, EXx } },
|
2095 |
{ "(bad)", { XM, EXx } },
|
2096 |
}, |
2097 |
/* PREGRP20 */
|
2098 |
{ |
2099 |
{ "movq", { EM, MX } },
|
2100 |
{ "movdqu", { EXx, XM } },
|
2101 |
{ "movdqa", { EXx, XM } },
|
2102 |
{ "(bad)", { EXx, XM } },
|
2103 |
}, |
2104 |
/* PREGRP21 */
|
2105 |
{ |
2106 |
{ "(bad)", { EXx, XM } },
|
2107 |
{ "movq2dq",{ XM, MS } },
|
2108 |
{ "movq", { EXx, XM } },
|
2109 |
{ "movdq2q",{ MX, XS } },
|
2110 |
}, |
2111 |
/* PREGRP22 */
|
2112 |
{ |
2113 |
{ "pshufw", { MX, EM, Ib } },
|
2114 |
{ "pshufhw",{ XM, EXx, Ib } },
|
2115 |
{ "pshufd", { XM, EXx, Ib } },
|
2116 |
{ "pshuflw",{ XM, EXx, Ib } },
|
2117 |
}, |
2118 |
/* PREGRP23 */
|
2119 |
{ |
2120 |
{ "movd", { Edq, MX } },
|
2121 |
{ "movq", { XM, EXx } },
|
2122 |
{ "movd", { Edq, XM } },
|
2123 |
{ "(bad)", { Ed, XM } },
|
2124 |
}, |
2125 |
/* PREGRP24 */
|
2126 |
{ |
2127 |
{ "(bad)", { MX, EXx } },
|
2128 |
{ "(bad)", { XM, EXx } },
|
2129 |
{ "punpckhqdq", { XM, EXx } },
|
2130 |
{ "(bad)", { XM, EXx } },
|
2131 |
}, |
2132 |
/* PREGRP25 */
|
2133 |
{ |
2134 |
{ "movntq", { EM, MX } },
|
2135 |
{ "(bad)", { EM, XM } },
|
2136 |
{ "movntdq",{ EM, XM } },
|
2137 |
{ "(bad)", { EM, XM } },
|
2138 |
}, |
2139 |
/* PREGRP26 */
|
2140 |
{ |
2141 |
{ "(bad)", { MX, EXx } },
|
2142 |
{ "(bad)", { XM, EXx } },
|
2143 |
{ "punpcklqdq", { XM, EXx } },
|
2144 |
{ "(bad)", { XM, EXx } },
|
2145 |
}, |
2146 |
/* PREGRP27 */
|
2147 |
{ |
2148 |
{ "(bad)", { MX, EXx } },
|
2149 |
{ "(bad)", { XM, EXx } },
|
2150 |
{ "addsubpd", { XM, EXx } },
|
2151 |
{ "addsubps", { XM, EXx } },
|
2152 |
}, |
2153 |
/* PREGRP28 */
|
2154 |
{ |
2155 |
{ "(bad)", { MX, EXx } },
|
2156 |
{ "(bad)", { XM, EXx } },
|
2157 |
{ "haddpd", { XM, EXx } },
|
2158 |
{ "haddps", { XM, EXx } },
|
2159 |
}, |
2160 |
/* PREGRP29 */
|
2161 |
{ |
2162 |
{ "(bad)", { MX, EXx } },
|
2163 |
{ "(bad)", { XM, EXx } },
|
2164 |
{ "hsubpd", { XM, EXx } },
|
2165 |
{ "hsubps", { XM, EXx } },
|
2166 |
}, |
2167 |
/* PREGRP30 */
|
2168 |
{ |
2169 |
{ "movlpX", { XM, EXq, { SIMD_Fixup, 'h' } } }, /* really only 2 operands */ |
2170 |
{ "movsldup", { XM, EXx } },
|
2171 |
{ "movlpd", { XM, EXq } },
|
2172 |
{ "movddup", { XM, EXq } },
|
2173 |
}, |
2174 |
/* PREGRP31 */
|
2175 |
{ |
2176 |
{ "movhpX", { XM, EXq, { SIMD_Fixup, 'l' } } }, |
2177 |
{ "movshdup", { XM, EXx } },
|
2178 |
{ "movhpd", { XM, EXq } },
|
2179 |
{ "(bad)", { XM, EXq } },
|
2180 |
}, |
2181 |
/* PREGRP32 */
|
2182 |
{ |
2183 |
{ "(bad)", { XM, EXx } },
|
2184 |
{ "(bad)", { XM, EXx } },
|
2185 |
{ "(bad)", { XM, EXx } },
|
2186 |
{ "lddqu", { XM, M } },
|
2187 |
}, |
2188 |
/* PREGRP33 */
|
2189 |
{ |
2190 |
{"movntps", { Ev, XM } },
|
2191 |
{"movntss", { Ev, XM } },
|
2192 |
{"movntpd", { Ev, XM } },
|
2193 |
{"movntsd", { Ev, XM } },
|
2194 |
}, |
2195 |
|
2196 |
/* PREGRP34 */
|
2197 |
{ |
2198 |
{"vmread", { Em, Gm } },
|
2199 |
{"(bad)", { XX } },
|
2200 |
{"extrq", { XS, Ib, Ib } },
|
2201 |
{"insertq", { XM, XS, Ib, Ib } },
|
2202 |
}, |
2203 |
|
2204 |
/* PREGRP35 */
|
2205 |
{ |
2206 |
{"vmwrite", { Gm, Em } },
|
2207 |
{"(bad)", { XX } },
|
2208 |
{"extrq", { XM, XS } },
|
2209 |
{"insertq", { XM, XS } },
|
2210 |
}, |
2211 |
|
2212 |
/* PREGRP36 */
|
2213 |
{ |
2214 |
{ "bsrS", { Gv, Ev } },
|
2215 |
{ "lzcntS", { Gv, Ev } },
|
2216 |
{ "bsrS", { Gv, Ev } },
|
2217 |
{ "(bad)", { XX } },
|
2218 |
}, |
2219 |
|
2220 |
/* PREGRP37 */
|
2221 |
{ |
2222 |
{ "(bad)", { XX } },
|
2223 |
{ "popcntS", { Gv, Ev } },
|
2224 |
{ "(bad)", { XX } },
|
2225 |
{ "(bad)", { XX } },
|
2226 |
}, |
2227 |
|
2228 |
/* PREGRP38 */
|
2229 |
{ |
2230 |
{ "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
|
2231 |
{ "pause", { XX } },
|
2232 |
{ "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
|
2233 |
{ "(bad)", { XX } },
|
2234 |
}, |
2235 |
|
2236 |
/* PREGRP39 */
|
2237 |
{ |
2238 |
{ "(bad)", { XX } },
|
2239 |
{ "(bad)", { XX } },
|
2240 |
{ "pblendvb", {XM, EXx, XMM0 } },
|
2241 |
{ "(bad)", { XX } },
|
2242 |
}, |
2243 |
|
2244 |
/* PREGRP40 */
|
2245 |
{ |
2246 |
{ "(bad)", { XX } },
|
2247 |
{ "(bad)", { XX } },
|
2248 |
{ "blendvps", {XM, EXx, XMM0 } },
|
2249 |
{ "(bad)", { XX } },
|
2250 |
}, |
2251 |
|
2252 |
/* PREGRP41 */
|
2253 |
{ |
2254 |
{ "(bad)", { XX } },
|
2255 |
{ "(bad)", { XX } },
|
2256 |
{ "blendvpd", { XM, EXx, XMM0 } },
|
2257 |
{ "(bad)", { XX } },
|
2258 |
}, |
2259 |
|
2260 |
/* PREGRP42 */
|
2261 |
{ |
2262 |
{ "(bad)", { XX } },
|
2263 |
{ "(bad)", { XX } },
|
2264 |
{ "ptest", { XM, EXx } },
|
2265 |
{ "(bad)", { XX } },
|
2266 |
}, |
2267 |
|
2268 |
/* PREGRP43 */
|
2269 |
{ |
2270 |
{ "(bad)", { XX } },
|
2271 |
{ "(bad)", { XX } },
|
2272 |
{ "pmovsxbw", { XM, EXx } },
|
2273 |
{ "(bad)", { XX } },
|
2274 |
}, |
2275 |
|
2276 |
/* PREGRP44 */
|
2277 |
{ |
2278 |
{ "(bad)", { XX } },
|
2279 |
{ "(bad)", { XX } },
|
2280 |
{ "pmovsxbd", { XM, EXx } },
|
2281 |
{ "(bad)", { XX } },
|
2282 |
}, |
2283 |
|
2284 |
/* PREGRP45 */
|
2285 |
{ |
2286 |
{ "(bad)", { XX } },
|
2287 |
{ "(bad)", { XX } },
|
2288 |
{ "pmovsxbq", { XM, EXx } },
|
2289 |
{ "(bad)", { XX } },
|
2290 |
}, |
2291 |
|
2292 |
/* PREGRP46 */
|
2293 |
{ |
2294 |
{ "(bad)", { XX } },
|
2295 |
{ "(bad)", { XX } },
|
2296 |
{ "pmovsxwd", { XM, EXx } },
|
2297 |
{ "(bad)", { XX } },
|
2298 |
}, |
2299 |
|
2300 |
/* PREGRP47 */
|
2301 |
{ |
2302 |
{ "(bad)", { XX } },
|
2303 |
{ "(bad)", { XX } },
|
2304 |
{ "pmovsxwq", { XM, EXx } },
|
2305 |
{ "(bad)", { XX } },
|
2306 |
}, |
2307 |
|
2308 |
/* PREGRP48 */
|
2309 |
{ |
2310 |
{ "(bad)", { XX } },
|
2311 |
{ "(bad)", { XX } },
|
2312 |
{ "pmovsxdq", { XM, EXx } },
|
2313 |
{ "(bad)", { XX } },
|
2314 |
}, |
2315 |
|
2316 |
/* PREGRP49 */
|
2317 |
{ |
2318 |
{ "(bad)", { XX } },
|
2319 |
{ "(bad)", { XX } },
|
2320 |
{ "pmuldq", { XM, EXx } },
|
2321 |
{ "(bad)", { XX } },
|
2322 |
}, |
2323 |
|
2324 |
/* PREGRP50 */
|
2325 |
{ |
2326 |
{ "(bad)", { XX } },
|
2327 |
{ "(bad)", { XX } },
|
2328 |
{ "pcmpeqq", { XM, EXx } },
|
2329 |
{ "(bad)", { XX } },
|
2330 |
}, |
2331 |
|
2332 |
/* PREGRP51 */
|
2333 |
{ |
2334 |
{ "(bad)", { XX } },
|
2335 |
{ "(bad)", { XX } },
|
2336 |
{ "movntdqa", { XM, EM } },
|
2337 |
{ "(bad)", { XX } },
|
2338 |
}, |
2339 |
|
2340 |
/* PREGRP52 */
|
2341 |
{ |
2342 |
{ "(bad)", { XX } },
|
2343 |
{ "(bad)", { XX } },
|
2344 |
{ "packusdw", { XM, EXx } },
|
2345 |
{ "(bad)", { XX } },
|
2346 |
}, |
2347 |
|
2348 |
/* PREGRP53 */
|
2349 |
{ |
2350 |
{ "(bad)", { XX } },
|
2351 |
{ "(bad)", { XX } },
|
2352 |
{ "pmovzxbw", { XM, EXx } },
|
2353 |
{ "(bad)", { XX } },
|
2354 |
}, |
2355 |
|
2356 |
/* PREGRP54 */
|
2357 |
{ |
2358 |
{ "(bad)", { XX } },
|
2359 |
{ "(bad)", { XX } },
|
2360 |
{ "pmovzxbd", { XM, EXx } },
|
2361 |
{ "(bad)", { XX } },
|
2362 |
}, |
2363 |
|
2364 |
/* PREGRP55 */
|
2365 |
{ |
2366 |
{ "(bad)", { XX } },
|
2367 |
{ "(bad)", { XX } },
|
2368 |
{ "pmovzxbq", { XM, EXx } },
|
2369 |
{ "(bad)", { XX } },
|
2370 |
}, |
2371 |
|
2372 |
/* PREGRP56 */
|
2373 |
{ |
2374 |
{ "(bad)", { XX } },
|
2375 |
{ "(bad)", { XX } },
|
2376 |
{ "pmovzxwd", { XM, EXx } },
|
2377 |
{ "(bad)", { XX } },
|
2378 |
}, |
2379 |
|
2380 |
/* PREGRP57 */
|
2381 |
{ |
2382 |
{ "(bad)", { XX } },
|
2383 |
{ "(bad)", { XX } },
|
2384 |
{ "pmovzxwq", { XM, EXx } },
|
2385 |
{ "(bad)", { XX } },
|
2386 |
}, |
2387 |
|
2388 |
/* PREGRP58 */
|
2389 |
{ |
2390 |
{ "(bad)", { XX } },
|
2391 |
{ "(bad)", { XX } },
|
2392 |
{ "pmovzxdq", { XM, EXx } },
|
2393 |
{ "(bad)", { XX } },
|
2394 |
}, |
2395 |
|
2396 |
/* PREGRP59 */
|
2397 |
{ |
2398 |
{ "(bad)", { XX } },
|
2399 |
{ "(bad)", { XX } },
|
2400 |
{ "pminsb", { XM, EXx } },
|
2401 |
{ "(bad)", { XX } },
|
2402 |
}, |
2403 |
|
2404 |
/* PREGRP60 */
|
2405 |
{ |
2406 |
{ "(bad)", { XX } },
|
2407 |
{ "(bad)", { XX } },
|
2408 |
{ "pminsd", { XM, EXx } },
|
2409 |
{ "(bad)", { XX } },
|
2410 |
}, |
2411 |
|
2412 |
/* PREGRP61 */
|
2413 |
{ |
2414 |
{ "(bad)", { XX } },
|
2415 |
{ "(bad)", { XX } },
|
2416 |
{ "pminuw", { XM, EXx } },
|
2417 |
{ "(bad)", { XX } },
|
2418 |
}, |
2419 |
|
2420 |
/* PREGRP62 */
|
2421 |
{ |
2422 |
{ "(bad)", { XX } },
|
2423 |
{ "(bad)", { XX } },
|
2424 |
{ "pminud", { XM, EXx } },
|
2425 |
{ "(bad)", { XX } },
|
2426 |
}, |
2427 |
|
2428 |
/* PREGRP63 */
|
2429 |
{ |
2430 |
{ "(bad)", { XX } },
|
2431 |
{ "(bad)", { XX } },
|
2432 |
{ "pmaxsb", { XM, EXx } },
|
2433 |
{ "(bad)", { XX } },
|
2434 |
}, |
2435 |
|
2436 |
/* PREGRP64 */
|
2437 |
{ |
2438 |
{ "(bad)", { XX } },
|
2439 |
{ "(bad)", { XX } },
|
2440 |
{ "pmaxsd", { XM, EXx } },
|
2441 |
{ "(bad)", { XX } },
|
2442 |
}, |
2443 |
|
2444 |
/* PREGRP65 */
|
2445 |
{ |
2446 |
{ "(bad)", { XX } },
|
2447 |
{ "(bad)", { XX } },
|
2448 |
{ "pmaxuw", { XM, EXx } },
|
2449 |
{ "(bad)", { XX } },
|
2450 |
}, |
2451 |
|
2452 |
/* PREGRP66 */
|
2453 |
{ |
2454 |
{ "(bad)", { XX } },
|
2455 |
{ "(bad)", { XX } },
|
2456 |
{ "pmaxud", { XM, EXx } },
|
2457 |
{ "(bad)", { XX } },
|
2458 |
}, |
2459 |
|
2460 |
/* PREGRP67 */
|
2461 |
{ |
2462 |
{ "(bad)", { XX } },
|
2463 |
{ "(bad)", { XX } },
|
2464 |
{ "pmulld", { XM, EXx } },
|
2465 |
{ "(bad)", { XX } },
|
2466 |
}, |
2467 |
|
2468 |
/* PREGRP68 */
|
2469 |
{ |
2470 |
{ "(bad)", { XX } },
|
2471 |
{ "(bad)", { XX } },
|
2472 |
{ "phminposuw", { XM, EXx } },
|
2473 |
{ "(bad)", { XX } },
|
2474 |
}, |
2475 |
|
2476 |
/* PREGRP69 */
|
2477 |
{ |
2478 |
{ "(bad)", { XX } },
|
2479 |
{ "(bad)", { XX } },
|
2480 |
{ "roundps", { XM, EXx, Ib } },
|
2481 |
{ "(bad)", { XX } },
|
2482 |
}, |
2483 |
|
2484 |
/* PREGRP70 */
|
2485 |
{ |
2486 |
{ "(bad)", { XX } },
|
2487 |
{ "(bad)", { XX } },
|
2488 |
{ "roundpd", { XM, EXx, Ib } },
|
2489 |
{ "(bad)", { XX } },
|
2490 |
}, |
2491 |
|
2492 |
/* PREGRP71 */
|
2493 |
{ |
2494 |
{ "(bad)", { XX } },
|
2495 |
{ "(bad)", { XX } },
|
2496 |
{ "roundss", { XM, EXx, Ib } },
|
2497 |
{ "(bad)", { XX } },
|
2498 |
}, |
2499 |
|
2500 |
/* PREGRP72 */
|
2501 |
{ |
2502 |
{ "(bad)", { XX } },
|
2503 |
{ "(bad)", { XX } },
|
2504 |
{ "roundsd", { XM, EXx, Ib } },
|
2505 |
{ "(bad)", { XX } },
|
2506 |
}, |
2507 |
|
2508 |
/* PREGRP73 */
|
2509 |
{ |
2510 |
{ "(bad)", { XX } },
|
2511 |
{ "(bad)", { XX } },
|
2512 |
{ "blendps", { XM, EXx, Ib } },
|
2513 |
{ "(bad)", { XX } },
|
2514 |
}, |
2515 |
|
2516 |
/* PREGRP74 */
|
2517 |
{ |
2518 |
{ "(bad)", { XX } },
|
2519 |
{ "(bad)", { XX } },
|
2520 |
{ "blendpd", { XM, EXx, Ib } },
|
2521 |
{ "(bad)", { XX } },
|
2522 |
}, |
2523 |
|
2524 |
/* PREGRP75 */
|
2525 |
{ |
2526 |
{ "(bad)", { XX } },
|
2527 |
{ "(bad)", { XX } },
|
2528 |
{ "pblendw", { XM, EXx, Ib } },
|
2529 |
{ "(bad)", { XX } },
|
2530 |
}, |
2531 |
|
2532 |
/* PREGRP76 */
|
2533 |
{ |
2534 |
{ "(bad)", { XX } },
|
2535 |
{ "(bad)", { XX } },
|
2536 |
{ "pextrb", { Edqb, XM, Ib } },
|
2537 |
{ "(bad)", { XX } },
|
2538 |
}, |
2539 |
|
2540 |
/* PREGRP77 */
|
2541 |
{ |
2542 |
{ "(bad)", { XX } },
|
2543 |
{ "(bad)", { XX } },
|
2544 |
{ "pextrw", { Edqw, XM, Ib } },
|
2545 |
{ "(bad)", { XX } },
|
2546 |
}, |
2547 |
|
2548 |
/* PREGRP78 */
|
2549 |
{ |
2550 |
{ "(bad)", { XX } },
|
2551 |
{ "(bad)", { XX } },
|
2552 |
{ "pextrK", { Edq, XM, Ib } },
|
2553 |
{ "(bad)", { XX } },
|
2554 |
}, |
2555 |
|
2556 |
/* PREGRP79 */
|
2557 |
{ |
2558 |
{ "(bad)", { XX } },
|
2559 |
{ "(bad)", { XX } },
|
2560 |
{ "extractps", { Edqd, XM, Ib } },
|
2561 |
{ "(bad)", { XX } },
|
2562 |
}, |
2563 |
|
2564 |
/* PREGRP80 */
|
2565 |
{ |
2566 |
{ "(bad)", { XX } },
|
2567 |
{ "(bad)", { XX } },
|
2568 |
{ "pinsrb", { XM, Edqb, Ib } },
|
2569 |
{ "(bad)", { XX } },
|
2570 |
}, |
2571 |
|
2572 |
/* PREGRP81 */
|
2573 |
{ |
2574 |
{ "(bad)", { XX } },
|
2575 |
{ "(bad)", { XX } },
|
2576 |
{ "insertps", { XM, EXx, Ib } },
|
2577 |
{ "(bad)", { XX } },
|
2578 |
}, |
2579 |
|
2580 |
/* PREGRP82 */
|
2581 |
{ |
2582 |
{ "(bad)", { XX } },
|
2583 |
{ "(bad)", { XX } },
|
2584 |
{ "pinsrK", { XM, Edq, Ib } },
|
2585 |
{ "(bad)", { XX } },
|
2586 |
}, |
2587 |
|
2588 |
/* PREGRP83 */
|
2589 |
{ |
2590 |
{ "(bad)", { XX } },
|
2591 |
{ "(bad)", { XX } },
|
2592 |
{ "dpps", { XM, EXx, Ib } },
|
2593 |
{ "(bad)", { XX } },
|
2594 |
}, |
2595 |
|
2596 |
/* PREGRP84 */
|
2597 |
{ |
2598 |
{ "(bad)", { XX } },
|
2599 |
{ "(bad)", { XX } },
|
2600 |
{ "dppd", { XM, EXx, Ib } },
|
2601 |
{ "(bad)", { XX } },
|
2602 |
}, |
2603 |
|
2604 |
/* PREGRP85 */
|
2605 |
{ |
2606 |
{ "(bad)", { XX } },
|
2607 |
{ "(bad)", { XX } },
|
2608 |
{ "mpsadbw", { XM, EXx, Ib } },
|
2609 |
{ "(bad)", { XX } },
|
2610 |
}, |
2611 |
|
2612 |
/* PREGRP86 */
|
2613 |
{ |
2614 |
{ "(bad)", { XX } },
|
2615 |
{ "(bad)", { XX } },
|
2616 |
{ "pcmpgtq", { XM, EXx } },
|
2617 |
{ "(bad)", { XX } },
|
2618 |
}, |
2619 |
|
2620 |
/* PREGRP87 */
|
2621 |
{ |
2622 |
{ "(bad)", { XX } },
|
2623 |
{ "(bad)", { XX } },
|
2624 |
{ "(bad)", { XX } },
|
2625 |
{ "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
|
2626 |
}, |
2627 |
|
2628 |
/* PREGRP88 */
|
2629 |
{ |
2630 |
{ "(bad)", { XX } },
|
2631 |
{ "(bad)", { XX } },
|
2632 |
{ "(bad)", { XX } },
|
2633 |
{ "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
|
2634 |
}, |
2635 |
|
2636 |
/* PREGRP89 */
|
2637 |
{ |
2638 |
{ "(bad)", { XX } },
|
2639 |
{ "(bad)", { XX } },
|
2640 |
{ "pcmpestrm", { XM, EXx, Ib } },
|
2641 |
{ "(bad)", { XX } },
|
2642 |
}, |
2643 |
|
2644 |
/* PREGRP90 */
|
2645 |
{ |
2646 |
{ "(bad)", { XX } },
|
2647 |
{ "(bad)", { XX } },
|
2648 |
{ "pcmpestri", { XM, EXx, Ib } },
|
2649 |
{ "(bad)", { XX } },
|
2650 |
}, |
2651 |
|
2652 |
/* PREGRP91 */
|
2653 |
{ |
2654 |
{ "(bad)", { XX } },
|
2655 |
{ "(bad)", { XX } },
|
2656 |
{ "pcmpistrm", { XM, EXx, Ib } },
|
2657 |
{ "(bad)", { XX } },
|
2658 |
}, |
2659 |
|
2660 |
/* PREGRP92 */
|
2661 |
{ |
2662 |
{ "(bad)", { XX } },
|
2663 |
{ "(bad)", { XX } },
|
2664 |
{ "pcmpistri", { XM, EXx, Ib } },
|
2665 |
{ "(bad)", { XX } },
|
2666 |
}, |
2667 |
|
2668 |
/* PREGRP93 */
|
2669 |
{ |
2670 |
{ "ucomiss",{ XM, EXd } },
|
2671 |
{ "(bad)", { XX } },
|
2672 |
{ "ucomisd",{ XM, EXq } },
|
2673 |
{ "(bad)", { XX } },
|
2674 |
}, |
2675 |
|
2676 |
/* PREGRP94 */
|
2677 |
{ |
2678 |
{ "comiss", { XM, EXd } },
|
2679 |
{ "(bad)", { XX } },
|
2680 |
{ "comisd", { XM, EXq } },
|
2681 |
{ "(bad)", { XX } },
|
2682 |
}, |
2683 |
|
2684 |
/* PREGRP95 */
|
2685 |
{ |
2686 |
{ "punpcklbw",{ MX, EMd } },
|
2687 |
{ "(bad)", { XX } },
|
2688 |
{ "punpcklbw",{ MX, EMq } },
|
2689 |
{ "(bad)", { XX } },
|
2690 |
}, |
2691 |
|
2692 |
/* PREGRP96 */
|
2693 |
{ |
2694 |
{ "punpcklwd",{ MX, EMd } },
|
2695 |
{ "(bad)", { XX } },
|
2696 |
{ "punpcklwd",{ MX, EMq } },
|
2697 |
{ "(bad)", { XX } },
|
2698 |
}, |
2699 |
|
2700 |
/* PREGRP97 */
|
2701 |
{ |
2702 |
{ "punpckldq",{ MX, EMd } },
|
2703 |
{ "(bad)", { XX } },
|
2704 |
{ "punpckldq",{ MX, EMq } },
|
2705 |
{ "(bad)", { XX } },
|
2706 |
}, |
2707 |
}; |
2708 |
|
2709 |
static const struct dis386 x86_64_table[][2] = { |
2710 |
{ |
2711 |
{ "pusha{P|}", { XX } },
|
2712 |
{ "(bad)", { XX } },
|
2713 |
}, |
2714 |
{ |
2715 |
{ "popa{P|}", { XX } },
|
2716 |
{ "(bad)", { XX } },
|
2717 |
}, |
2718 |
{ |
2719 |
{ "bound{S|}", { Gv, Ma } },
|
2720 |
{ "(bad)", { XX } },
|
2721 |
}, |
2722 |
{ |
2723 |
{ "arpl", { Ew, Gw } },
|
2724 |
{ "movs{||lq|xd}", { Gv, Ed } },
|
2725 |
}, |
2726 |
}; |
2727 |
|
2728 |
static const struct dis386 three_byte_table[][256] = { |
2729 |
/* THREE_BYTE_0 */
|
2730 |
{ |
2731 |
/* 00 */
|
2732 |
{ "pshufb", { MX, EM } },
|
2733 |
{ "phaddw", { MX, EM } },
|
2734 |
{ "phaddd", { MX, EM } },
|
2735 |
{ "phaddsw", { MX, EM } },
|
2736 |
{ "pmaddubsw", { MX, EM } },
|
2737 |
{ "phsubw", { MX, EM } },
|
2738 |
{ "phsubd", { MX, EM } },
|
2739 |
{ "phsubsw", { MX, EM } },
|
2740 |
/* 08 */
|
2741 |
{ "psignb", { MX, EM } },
|
2742 |
{ "psignw", { MX, EM } },
|
2743 |
{ "psignd", { MX, EM } },
|
2744 |
{ "pmulhrsw", { MX, EM } },
|
2745 |
{ "(bad)", { XX } },
|
2746 |
{ "(bad)", { XX } },
|
2747 |
{ "(bad)", { XX } },
|
2748 |
{ "(bad)", { XX } },
|
2749 |
/* 10 */
|
2750 |
{ PREGRP39 }, |
2751 |
{ "(bad)", { XX } },
|
2752 |
{ "(bad)", { XX } },
|
2753 |
{ "(bad)", { XX } },
|
2754 |
{ PREGRP40 }, |
2755 |
{ PREGRP41 }, |
2756 |
{ "(bad)", { XX } },
|
2757 |
{ PREGRP42 }, |
2758 |
/* 18 */
|
2759 |
{ "(bad)", { XX } },
|
2760 |
{ "(bad)", { XX } },
|
2761 |
{ "(bad)", { XX } },
|
2762 |
{ "(bad)", { XX } },
|
2763 |
{ "pabsb", { MX, EM } },
|
2764 |
{ "pabsw", { MX, EM } },
|
2765 |
{ "pabsd", { MX, EM } },
|
2766 |
{ "(bad)", { XX } },
|
2767 |
/* 20 */
|
2768 |
{ PREGRP43 }, |
2769 |
{ PREGRP44 }, |
2770 |
{ PREGRP45 }, |
2771 |
{ PREGRP46 }, |
2772 |
{ PREGRP47 }, |
2773 |
{ PREGRP48 }, |
2774 |
{ "(bad)", { XX } },
|
2775 |
{ "(bad)", { XX } },
|
2776 |
/* 28 */
|
2777 |
{ PREGRP49 }, |
2778 |
{ PREGRP50 }, |
2779 |
{ PREGRP51 }, |
2780 |
{ PREGRP52 }, |
2781 |
{ "(bad)", { XX } },
|
2782 |
{ "(bad)", { XX } },
|
2783 |
{ "(bad)", { XX } },
|
2784 |
{ "(bad)", { XX } },
|
2785 |
/* 30 */
|
2786 |
{ PREGRP53 }, |
2787 |
{ PREGRP54 }, |
2788 |
{ PREGRP55 }, |
2789 |
{ PREGRP56 }, |
2790 |
{ PREGRP57 }, |
2791 |
{ PREGRP58 }, |
2792 |
{ "(bad)", { XX } },
|
2793 |
{ PREGRP86 }, |
2794 |
/* 38 */
|
2795 |
{ PREGRP59 }, |
2796 |
{ PREGRP60 }, |
2797 |
{ PREGRP61 }, |
2798 |
{ PREGRP62 }, |
2799 |
{ PREGRP63 }, |
2800 |
{ PREGRP64 }, |
2801 |
{ PREGRP65 }, |
2802 |
{ PREGRP66 }, |
2803 |
/* 40 */
|
2804 |
{ PREGRP67 }, |
2805 |
{ PREGRP68 }, |
2806 |
{ "(bad)", { XX } },
|
2807 |
{ "(bad)", { XX } },
|
2808 |
{ "(bad)", { XX } },
|
2809 |
{ "(bad)", { XX } },
|
2810 |
{ "(bad)", { XX } },
|
2811 |
{ "(bad)", { XX } },
|
2812 |
/* 48 */
|
2813 |
{ "(bad)", { XX } },
|
2814 |
{ "(bad)", { XX } },
|
2815 |
{ "(bad)", { XX } },
|
2816 |
{ "(bad)", { XX } },
|
2817 |
{ "(bad)", { XX } },
|
2818 |
{ "(bad)", { XX } },
|
2819 |
{ "(bad)", { XX } },
|
2820 |
{ "(bad)", { XX } },
|
2821 |
/* 50 */
|
2822 |
{ "(bad)", { XX } },
|
2823 |
{ "(bad)", { XX } },
|
2824 |
{ "(bad)", { XX } },
|
2825 |
{ "(bad)", { XX } },
|
2826 |
{ "(bad)", { XX } },
|
2827 |
{ "(bad)", { XX } },
|
2828 |
{ "(bad)", { XX } },
|
2829 |
{ "(bad)", { XX } },
|
2830 |
/* 58 */
|
2831 |
{ "(bad)", { XX } },
|
2832 |
{ "(bad)", { XX } },
|
2833 |
{ "(bad)", { XX } },
|
2834 |
{ "(bad)", { XX } },
|
2835 |
{ "(bad)", { XX } },
|
2836 |
{ "(bad)", { XX } },
|
2837 |
{ "(bad)", { XX } },
|
2838 |
{ "(bad)", { XX } },
|
2839 |
/* 60 */
|
2840 |
{ "(bad)", { XX } },
|
2841 |
{ "(bad)", { XX } },
|
2842 |
{ "(bad)", { XX } },
|
2843 |
{ "(bad)", { XX } },
|
2844 |
{ "(bad)", { XX } },
|
2845 |
{ "(bad)", { XX } },
|
2846 |
{ "(bad)", { XX } },
|
2847 |
{ "(bad)", { XX } },
|
2848 |
/* 68 */
|
2849 |
{ "(bad)", { XX } },
|
2850 |
{ "(bad)", { XX } },
|
2851 |
{ "(bad)", { XX } },
|
2852 |
{ "(bad)", { XX } },
|
2853 |
{ "(bad)", { XX } },
|
2854 |
{ "(bad)", { XX } },
|
2855 |
{ "(bad)", { XX } },
|
2856 |
{ "(bad)", { XX } },
|
2857 |
/* 70 */
|
2858 |
{ "(bad)", { XX } },
|
2859 |
{ "(bad)", { XX } },
|
2860 |
{ "(bad)", { XX } },
|
2861 |
{ "(bad)", { XX } },
|
2862 |
{ "(bad)", { XX } },
|
2863 |
{ "(bad)", { XX } },
|
2864 |
{ "(bad)", { XX } },
|
2865 |
{ "(bad)", { XX } },
|
2866 |
/* 78 */
|
2867 |
{ "(bad)", { XX } },
|
2868 |
{ "(bad)", { XX } },
|
2869 |
{ "(bad)", { XX } },
|
2870 |
{ "(bad)", { XX } },
|
2871 |
{ "(bad)", { XX } },
|
2872 |
{ "(bad)", { XX } },
|
2873 |
{ "(bad)", { XX } },
|
2874 |
{ "(bad)", { XX } },
|
2875 |
/* 80 */
|
2876 |
{ "(bad)", { XX } },
|
2877 |
{ "(bad)", { XX } },
|
2878 |
{ "(bad)", { XX } },
|
2879 |
{ "(bad)", { XX } },
|
2880 |
{ "(bad)", { XX } },
|
2881 |
{ "(bad)", { XX } },
|
2882 |
{ "(bad)", { XX } },
|
2883 |
{ "(bad)", { XX } },
|
2884 |
/* 88 */
|
2885 |
{ "(bad)", { XX } },
|
2886 |
{ "(bad)", { XX } },
|
2887 |
{ "(bad)", { XX } },
|
2888 |
{ "(bad)", { XX } },
|
2889 |
{ "(bad)", { XX } },
|
2890 |
{ "(bad)", { XX } },
|
2891 |
{ "(bad)", { XX } },
|
2892 |
{ "(bad)", { XX } },
|
2893 |
/* 90 */
|
2894 |
{ "(bad)", { XX } },
|
2895 |
{ "(bad)", { XX } },
|
2896 |
{ "(bad)", { XX } },
|
2897 |
{ "(bad)", { XX } },
|
2898 |
{ "(bad)", { XX } },
|
2899 |
{ "(bad)", { XX } },
|
2900 |
{ "(bad)", { XX } },
|
2901 |
{ "(bad)", { XX } },
|
2902 |
/* 98 */
|
2903 |
{ "(bad)", { XX } },
|
2904 |
{ "(bad)", { XX } },
|
2905 |
{ "(bad)", { XX } },
|
2906 |
{ "(bad)", { XX } },
|
2907 |
{ "(bad)", { XX } },
|
2908 |
{ "(bad)", { XX } },
|
2909 |
{ "(bad)", { XX } },
|
2910 |
{ "(bad)", { XX } },
|
2911 |
/* a0 */
|
2912 |
{ "(bad)", { XX } },
|
2913 |
{ "(bad)", { XX } },
|
2914 |
{ "(bad)", { XX } },
|
2915 |
{ "(bad)", { XX } },
|
2916 |
{ "(bad)", { XX } },
|
2917 |
{ "(bad)", { XX } },
|
2918 |
{ "(bad)", { XX } },
|
2919 |
{ "(bad)", { XX } },
|
2920 |
/* a8 */
|
2921 |
{ "(bad)", { XX } },
|
2922 |
{ "(bad)", { XX } },
|
2923 |
{ "(bad)", { XX } },
|
2924 |
{ "(bad)", { XX } },
|
2925 |
{ "(bad)", { XX } },
|
2926 |
{ "(bad)", { XX } },
|
2927 |
{ "(bad)", { XX } },
|
2928 |
{ "(bad)", { XX } },
|
2929 |
/* b0 */
|
2930 |
{ "(bad)", { XX } },
|
2931 |
{ "(bad)", { XX } },
|
2932 |
{ "(bad)", { XX } },
|
2933 |
{ "(bad)", { XX } },
|
2934 |
{ "(bad)", { XX } },
|
2935 |
{ "(bad)", { XX } },
|
2936 |
{ "(bad)", { XX } },
|
2937 |
{ "(bad)", { XX } },
|
2938 |
/* b8 */
|
2939 |
{ "(bad)", { XX } },
|
2940 |
{ "(bad)", { XX } },
|
2941 |
{ "(bad)", { XX } },
|
2942 |
{ "(bad)", { XX } },
|
2943 |
{ "(bad)", { XX } },
|
2944 |
{ "(bad)", { XX } },
|
2945 |
{ "(bad)", { XX } },
|
2946 |
{ "(bad)", { XX } },
|
2947 |
/* c0 */
|
2948 |
{ "(bad)", { XX } },
|
2949 |
{ "(bad)", { XX } },
|
2950 |
{ "(bad)", { XX } },
|
2951 |
{ "(bad)", { XX } },
|
2952 |
{ "(bad)", { XX } },
|
2953 |
{ "(bad)", { XX } },
|
2954 |
{ "(bad)", { XX } },
|
2955 |
{ "(bad)", { XX } },
|
2956 |
/* c8 */
|
2957 |
{ "(bad)", { XX } },
|
2958 |
{ "(bad)", { XX } },
|
2959 |
{ "(bad)", { XX } },
|
2960 |
{ "(bad)", { XX } },
|
2961 |
{ "(bad)", { XX } },
|
2962 |
{ "(bad)", { XX } },
|
2963 |
{ "(bad)", { XX } },
|
2964 |
{ "(bad)", { XX } },
|
2965 |
/* d0 */
|
2966 |
{ "(bad)", { XX } },
|
2967 |
{ "(bad)", { XX } },
|
2968 |
{ "(bad)", { XX } },
|
2969 |
{ "(bad)", { XX } },
|
2970 |
{ "(bad)", { XX } },
|
2971 |
{ "(bad)", { XX } },
|
2972 |
{ "(bad)", { XX } },
|
2973 |
{ "(bad)", { XX } },
|
2974 |
/* d8 */
|
2975 |
{ "(bad)", { XX } },
|
2976 |
{ "(bad)", { XX } },
|
2977 |
{ "(bad)", { XX } },
|
2978 |
{ "(bad)", { XX } },
|
2979 |
{ "(bad)", { XX } },
|
2980 |
{ "(bad)", { XX } },
|
2981 |
{ "(bad)", { XX } },
|
2982 |
{ "(bad)", { XX } },
|
2983 |
/* e0 */
|
2984 |
{ "(bad)", { XX } },
|
2985 |
{ "(bad)", { XX } },
|
2986 |
{ "(bad)", { XX } },
|
2987 |
{ "(bad)", { XX } },
|
2988 |
{ "(bad)", { XX } },
|
2989 |
{ "(bad)", { XX } },
|
2990 |
{ "(bad)", { XX } },
|
2991 |
{ "(bad)", { XX } },
|
2992 |
/* e8 */
|
2993 |
{ "(bad)", { XX } },
|
2994 |
{ "(bad)", { XX } },
|
2995 |
{ "(bad)", { XX } },
|
2996 |
{ "(bad)", { XX } },
|
2997 |
{ "(bad)", { XX } },
|
2998 |
{ "(bad)", { XX } },
|
2999 |
{ "(bad)", { XX } },
|
3000 |
{ "(bad)", { XX } },
|
3001 |
/* f0 */
|
3002 |
{ PREGRP87 }, |
3003 |
{ PREGRP88 }, |
3004 |
{ "(bad)", { XX } },
|
3005 |
{ "(bad)", { XX } },
|
3006 |
{ "(bad)", { XX } },
|
3007 |
{ "(bad)", { XX } },
|
3008 |
{ "(bad)", { XX } },
|
3009 |
{ "(bad)", { XX } },
|
3010 |
/* f8 */
|
3011 |
{ "(bad)", { XX } },
|
3012 |
{ "(bad)", { XX } },
|
3013 |
{ "(bad)", { XX } },
|
3014 |
{ "(bad)", { XX } },
|
3015 |
{ "(bad)", { XX } },
|
3016 |
{ "(bad)", { XX } },
|
3017 |
{ "(bad)", { XX } },
|
3018 |
{ "(bad)", { XX } },
|
3019 |
}, |
3020 |
/* THREE_BYTE_1 */
|
3021 |
{ |
3022 |
/* 00 */
|
3023 |
{ "(bad)", { XX } },
|
3024 |
{ "(bad)", { XX } },
|
3025 |
{ "(bad)", { XX } },
|
3026 |
{ "(bad)", { XX } },
|
3027 |
{ "(bad)", { XX } },
|
3028 |
{ "(bad)", { XX } },
|
3029 |
{ "(bad)", { XX } },
|
3030 |
{ "(bad)", { XX } },
|
3031 |
/* 08 */
|
3032 |
{ PREGRP69 }, |
3033 |
{ PREGRP70 }, |
3034 |
{ PREGRP71 }, |
3035 |
{ PREGRP72 }, |
3036 |
{ PREGRP73 }, |
3037 |
{ PREGRP74 }, |
3038 |
{ PREGRP75 }, |
3039 |
{ "palignr", { MX, EM, Ib } },
|
3040 |
/* 10 */
|
3041 |
{ "(bad)", { XX } },
|
3042 |
{ "(bad)", { XX } },
|
3043 |
{ "(bad)", { XX } },
|
3044 |
{ "(bad)", { XX } },
|
3045 |
{ PREGRP76 }, |
3046 |
{ PREGRP77 }, |
3047 |
{ PREGRP78 }, |
3048 |
{ PREGRP79 }, |
3049 |
/* 18 */
|
3050 |
{ "(bad)", { XX } },
|
3051 |
{ "(bad)", { XX } },
|
3052 |
{ "(bad)", { XX } },
|
3053 |
{ "(bad)", { XX } },
|
3054 |
{ "(bad)", { XX } },
|
3055 |
{ "(bad)", { XX } },
|
3056 |
{ "(bad)", { XX } },
|
3057 |
{ "(bad)", { XX } },
|
3058 |
/* 20 */
|
3059 |
{ PREGRP80 }, |
3060 |
{ PREGRP81 }, |
3061 |
{ PREGRP82 }, |
3062 |
{ "(bad)", { XX } },
|
3063 |
{ "(bad)", { XX } },
|
3064 |
{ "(bad)", { XX } },
|
3065 |
{ "(bad)", { XX } },
|
3066 |
{ "(bad)", { XX } },
|
3067 |
/* 28 */
|
3068 |
{ "(bad)", { XX } },
|
3069 |
{ "(bad)", { XX } },
|
3070 |
{ "(bad)", { XX } },
|
3071 |
{ "(bad)", { XX } },
|
3072 |
{ "(bad)", { XX } },
|
3073 |
{ "(bad)", { XX } },
|
3074 |
{ "(bad)", { XX } },
|
3075 |
{ "(bad)", { XX } },
|
3076 |
/* 30 */
|
3077 |
{ "(bad)", { XX } },
|
3078 |
{ "(bad)", { XX } },
|
3079 |
{ "(bad)", { XX } },
|
3080 |
{ "(bad)", { XX } },
|
3081 |
{ "(bad)", { XX } },
|
3082 |
{ "(bad)", { XX } },
|
3083 |
{ "(bad)", { XX } },
|
3084 |
{ "(bad)", { XX } },
|
3085 |
/* 38 */
|
3086 |
{ "(bad)", { XX } },
|
3087 |
{ "(bad)", { XX } },
|
3088 |
{ "(bad)", { XX } },
|
3089 |
{ "(bad)", { XX } },
|
3090 |
{ "(bad)", { XX } },
|
3091 |
{ "(bad)", { XX } },
|
3092 |
{ "(bad)", { XX } },
|
3093 |
{ "(bad)", { XX } },
|
3094 |
/* 40 */
|
3095 |
{ PREGRP83 }, |
3096 |
{ PREGRP84 }, |
3097 |
{ PREGRP85 }, |
3098 |
{ "(bad)", { XX } },
|
3099 |
{ "(bad)", { XX } },
|
3100 |
{ "(bad)", { XX } },
|
3101 |
{ "(bad)", { XX } },
|
3102 |
{ "(bad)", { XX } },
|
3103 |
/* 48 */
|
3104 |
{ "(bad)", { XX } },
|
3105 |
{ "(bad)", { XX } },
|
3106 |
{ "(bad)", { XX } },
|
3107 |
{ "(bad)", { XX } },
|
3108 |
{ "(bad)", { XX } },
|
3109 |
{ "(bad)", { XX } },
|
3110 |
{ "(bad)", { XX } },
|
3111 |
{ "(bad)", { XX } },
|
3112 |
/* 50 */
|
3113 |
{ "(bad)", { XX } },
|
3114 |
{ "(bad)", { XX } },
|
3115 |
{ "(bad)", { XX } },
|
3116 |
{ "(bad)", { XX } },
|
3117 |
{ "(bad)", { XX } },
|
3118 |
{ "(bad)", { XX } },
|
3119 |
{ "(bad)", { XX } },
|
3120 |
{ "(bad)", { XX } },
|
3121 |
/* 58 */
|
3122 |
{ "(bad)", { XX } },
|
3123 |
{ "(bad)", { XX } },
|
3124 |
{ "(bad)", { XX } },
|
3125 |
{ "(bad)", { XX } },
|
3126 |
{ "(bad)", { XX } },
|
3127 |
{ "(bad)", { XX } },
|
3128 |
{ "(bad)", { XX } },
|
3129 |
{ "(bad)", { XX } },
|
3130 |
/* 60 */
|
3131 |
{ PREGRP89 }, |
3132 |
{ PREGRP90 }, |
3133 |
{ PREGRP91 }, |
3134 |
{ PREGRP92 }, |
3135 |
{ "(bad)", { XX } },
|
3136 |
{ "(bad)", { XX } },
|
3137 |
{ "(bad)", { XX } },
|
3138 |
{ "(bad)", { XX } },
|
3139 |
/* 68 */
|
3140 |
{ "(bad)", { XX } },
|
3141 |
{ "(bad)", { XX } },
|
3142 |
{ "(bad)", { XX } },
|
3143 |
{ "(bad)", { XX } },
|
3144 |
{ "(bad)", { XX } },
|
3145 |
{ "(bad)", { XX } },
|
3146 |
{ "(bad)", { XX } },
|
3147 |
{ "(bad)", { XX } },
|
3148 |
/* 70 */
|
3149 |
{ "(bad)", { XX } },
|
3150 |
{ "(bad)", { XX } },
|
3151 |
{ "(bad)", { XX } },
|
3152 |
{ "(bad)", { XX } },
|
3153 |
{ "(bad)", { XX } },
|
3154 |
{ "(bad)", { XX } },
|
3155 |
{ "(bad)", { XX } },
|
3156 |
{ "(bad)", { XX } },
|
3157 |
/* 78 */
|
3158 |
{ "(bad)", { XX } },
|
3159 |
{ "(bad)", { XX } },
|
3160 |
{ "(bad)", { XX } },
|
3161 |
{ "(bad)", { XX } },
|
3162 |
{ "(bad)", { XX } },
|
3163 |
{ "(bad)", { XX } },
|
3164 |
{ "(bad)", { XX } },
|
3165 |
{ "(bad)", { XX } },
|
3166 |
/* 80 */
|
3167 |
{ "(bad)", { XX } },
|
3168 |
{ "(bad)", { XX } },
|
3169 |
{ "(bad)", { XX } },
|
3170 |
{ "(bad)", { XX } },
|
3171 |
{ "(bad)", { XX } },
|
3172 |
{ "(bad)", { XX } },
|
3173 |
{ "(bad)", { XX } },
|
3174 |
{ "(bad)", { XX } },
|
3175 |
/* 88 */
|
3176 |
{ "(bad)", { XX } },
|
3177 |
{ "(bad)", { XX } },
|
3178 |
{ "(bad)", { XX } },
|
3179 |
{ "(bad)", { XX } },
|
3180 |
{ "(bad)", { XX } },
|
3181 |
{ "(bad)", { XX } },
|
3182 |
{ "(bad)", { XX } },
|
3183 |
{ "(bad)", { XX } },
|
3184 |
/* 90 */
|
3185 |
{ "(bad)", { XX } },
|
3186 |
{ "(bad)", { XX } },
|
3187 |
{ "(bad)", { XX } },
|
3188 |
{ "(bad)", { XX } },
|
3189 |
{ "(bad)", { XX } },
|
3190 |
{ "(bad)", { XX } },
|
3191 |
{ "(bad)", { XX } },
|
3192 |
{ "(bad)", { XX } },
|
3193 |
/* 98 */
|
3194 |
{ "(bad)", { XX } },
|
3195 |
{ "(bad)", { XX } },
|
3196 |
{ "(bad)", { XX } },
|
3197 |
{ "(bad)", { XX } },
|
3198 |
{ "(bad)", { XX } },
|
3199 |
{ "(bad)", { XX } },
|
3200 |
{ "(bad)", { XX } },
|
3201 |
{ "(bad)", { XX } },
|
3202 |
/* a0 */
|
3203 |
{ "(bad)", { XX } },
|
3204 |
{ "(bad)", { XX } },
|
3205 |
{ "(bad)", { XX } },
|
3206 |
{ "(bad)", { XX } },
|
3207 |
{ "(bad)", { XX } },
|
3208 |
{ "(bad)", { XX } },
|
3209 |
{ "(bad)", { XX } },
|
3210 |
{ "(bad)", { XX } },
|
3211 |
/* a8 */
|
3212 |
{ "(bad)", { XX } },
|
3213 |
{ "(bad)", { XX } },
|
3214 |
{ "(bad)", { XX } },
|
3215 |
{ "(bad)", { XX } },
|
3216 |
{ "(bad)", { XX } },
|
3217 |
{ "(bad)", { XX } },
|
3218 |
{ "(bad)", { XX } },
|
3219 |
{ "(bad)", { XX } },
|
3220 |
/* b0 */
|
3221 |
{ "(bad)", { XX } },
|
3222 |
{ "(bad)", { XX } },
|
3223 |
{ "(bad)", { XX } },
|
3224 |
{ "(bad)", { XX } },
|
3225 |
{ "(bad)", { XX } },
|
3226 |
{ "(bad)", { XX } },
|
3227 |
{ "(bad)", { XX } },
|
3228 |
{ "(bad)", { XX } },
|
3229 |
/* b8 */
|
3230 |
{ "(bad)", { XX } },
|
3231 |
{ "(bad)", { XX } },
|
3232 |
{ "(bad)", { XX } },
|
3233 |
{ "(bad)", { XX } },
|
3234 |
{ "(bad)", { XX } },
|
3235 |
{ "(bad)", { XX } },
|
3236 |
{ "(bad)", { XX } },
|
3237 |
{ "(bad)", { XX } },
|
3238 |
/* c0 */
|
3239 |
{ "(bad)", { XX } },
|
3240 |
{ "(bad)", { XX } },
|
3241 |
{ "(bad)", { XX } },
|
3242 |
{ "(bad)", { XX } },
|
3243 |
{ "(bad)", { XX } },
|
3244 |
{ "(bad)", { XX } },
|
3245 |
{ "(bad)", { XX } },
|
3246 |
{ "(bad)", { XX } },
|
3247 |
/* c8 */
|
3248 |
{ "(bad)", { XX } },
|
3249 |
{ "(bad)", { XX } },
|
3250 |
{ "(bad)", { XX } },
|
3251 |
{ "(bad)", { XX } },
|
3252 |
{ "(bad)", { XX } },
|
3253 |
{ "(bad)", { XX } },
|
3254 |
{ "(bad)", { XX } },
|
3255 |
{ "(bad)", { XX } },
|
3256 |
/* d0 */
|
3257 |
{ "(bad)", { XX } },
|
3258 |
{ "(bad)", { XX } },
|
3259 |
{ "(bad)", { XX } },
|
3260 |
{ "(bad)", { XX } },
|
3261 |
{ "(bad)", { XX } },
|
3262 |
{ "(bad)", { XX } },
|
3263 |
{ "(bad)", { XX } },
|
3264 |
{ "(bad)", { XX } },
|
3265 |
/* d8 */
|
3266 |
{ "(bad)", { XX } },
|
3267 |
{ "(bad)", { XX } },
|
3268 |
{ "(bad)", { XX } },
|
3269 |
{ "(bad)", { XX } },
|
3270 |
{ "(bad)", { XX } },
|
3271 |
{ "(bad)", { XX } },
|
3272 |
{ "(bad)", { XX } },
|
3273 |
{ "(bad)", { XX } },
|
3274 |
/* e0 */
|
3275 |
{ "(bad)", { XX } },
|
3276 |
{ "(bad)", { XX } },
|
3277 |
{ "(bad)", { XX } },
|
3278 |
{ "(bad)", { XX } },
|
3279 |
{ "(bad)", { XX } },
|
3280 |
{ "(bad)", { XX } },
|
3281 |
{ "(bad)", { XX } },
|
3282 |
{ "(bad)", { XX } },
|
3283 |
/* e8 */
|
3284 |
{ "(bad)", { XX } },
|
3285 |
{ "(bad)", { XX } },
|
3286 |
{ "(bad)", { XX } },
|
3287 |
{ "(bad)", { XX } },
|
3288 |
{ "(bad)", { XX } },
|
3289 |
{ "(bad)", { XX } },
|
3290 |
{ "(bad)", { XX } },
|
3291 |
{ "(bad)", { XX } },
|
3292 |
/* f0 */
|
3293 |
{ "(bad)", { XX } },
|
3294 |
{ "(bad)", { XX } },
|
3295 |
{ "(bad)", { XX } },
|
3296 |
{ "(bad)", { XX } },
|
3297 |
{ "(bad)", { XX } },
|
3298 |
{ "(bad)", { XX } },
|
3299 |
{ "(bad)", { XX } },
|
3300 |
{ "(bad)", { XX } },
|
3301 |
/* f8 */
|
3302 |
{ "(bad)", { XX } },
|
3303 |
{ "(bad)", { XX } },
|
3304 |
{ "(bad)", { XX } },
|
3305 |
{ "(bad)", { XX } },
|
3306 |
{ "(bad)", { XX } },
|
3307 |
{ "(bad)", { XX } },
|
3308 |
{ "(bad)", { XX } },
|
3309 |
{ "(bad)", { XX } },
|
3310 |
} |
3311 |
}; |
3312 |
|
3313 |
#define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>") |
3314 |
|
3315 |
static void |
3316 |
ckprefix (void)
|
3317 |
{ |
3318 |
int newrex;
|
3319 |
rex = 0;
|
3320 |
prefixes = 0;
|
3321 |
used_prefixes = 0;
|
3322 |
rex_used = 0;
|
3323 |
while (1) |
3324 |
{ |
3325 |
FETCH_DATA (the_info, codep + 1);
|
3326 |
newrex = 0;
|
3327 |
switch (*codep)
|
3328 |
{ |
3329 |
/* REX prefixes family. */
|
3330 |
case 0x40: |
3331 |
case 0x41: |
3332 |
case 0x42: |
3333 |
case 0x43: |
3334 |
case 0x44: |
3335 |
case 0x45: |
3336 |
case 0x46: |
3337 |
case 0x47: |
3338 |
case 0x48: |
3339 |
case 0x49: |
3340 |
case 0x4a: |
3341 |
case 0x4b: |
3342 |
case 0x4c: |
3343 |
case 0x4d: |
3344 |
case 0x4e: |
3345 |
case 0x4f: |
3346 |
if (address_mode == mode_64bit)
|
3347 |
newrex = *codep; |
3348 |
else
|
3349 |
return;
|
3350 |
break;
|
3351 |
case 0xf3: |
3352 |
prefixes |= PREFIX_REPZ; |
3353 |
break;
|
3354 |
case 0xf2: |
3355 |
prefixes |= PREFIX_REPNZ; |
3356 |
break;
|
3357 |
case 0xf0: |
3358 |
prefixes |= PREFIX_LOCK; |
3359 |
break;
|
3360 |
case 0x2e: |
3361 |
prefixes |= PREFIX_CS; |
3362 |
break;
|
3363 |
case 0x36: |
3364 |
prefixes |= PREFIX_SS; |
3365 |
break;
|
3366 |
case 0x3e: |
3367 |
prefixes |= PREFIX_DS; |
3368 |
break;
|
3369 |
case 0x26: |
3370 |
prefixes |= PREFIX_ES; |
3371 |
break;
|
3372 |
case 0x64: |
3373 |
prefixes |= PREFIX_FS; |
3374 |
break;
|
3375 |
case 0x65: |
3376 |
prefixes |= PREFIX_GS; |
3377 |
break;
|
3378 |
case 0x66: |
3379 |
prefixes |= PREFIX_DATA; |
3380 |
break;
|
3381 |
case 0x67: |
3382 |
prefixes |= PREFIX_ADDR; |
3383 |
break;
|
3384 |
case FWAIT_OPCODE:
|
3385 |
/* fwait is really an instruction. If there are prefixes
|
3386 |
before the fwait, they belong to the fwait, *not* to the
|
3387 |
following instruction. */
|
3388 |
if (prefixes || rex)
|
3389 |
{ |
3390 |
prefixes |= PREFIX_FWAIT; |
3391 |
codep++; |
3392 |
return;
|
3393 |
} |
3394 |
prefixes = PREFIX_FWAIT; |
3395 |
break;
|
3396 |
default:
|
3397 |
return;
|
3398 |
} |
3399 |
/* Rex is ignored when followed by another prefix. */
|
3400 |
if (rex)
|
3401 |
{ |
3402 |
rex_used = rex; |
3403 |
return;
|
3404 |
} |
3405 |
rex = newrex; |
3406 |
codep++; |
3407 |
} |
3408 |
} |
3409 |
|
3410 |
/* Return the name of the prefix byte PREF, or NULL if PREF is not a
|
3411 |
prefix byte. */
|
3412 |
|
3413 |
static const char * |
3414 |
prefix_name (int pref, int sizeflag) |
3415 |
{ |
3416 |
static const char * const rexes [16] = |
3417 |
{ |
3418 |
"rex", /* 0x40 */ |
3419 |
"rex.B", /* 0x41 */ |
3420 |
"rex.X", /* 0x42 */ |
3421 |
"rex.XB", /* 0x43 */ |
3422 |
"rex.R", /* 0x44 */ |
3423 |
"rex.RB", /* 0x45 */ |
3424 |
"rex.RX", /* 0x46 */ |
3425 |
"rex.RXB", /* 0x47 */ |
3426 |
"rex.W", /* 0x48 */ |
3427 |
"rex.WB", /* 0x49 */ |
3428 |
"rex.WX", /* 0x4a */ |
3429 |
"rex.WXB", /* 0x4b */ |
3430 |
"rex.WR", /* 0x4c */ |
3431 |
"rex.WRB", /* 0x4d */ |
3432 |
"rex.WRX", /* 0x4e */ |
3433 |
"rex.WRXB", /* 0x4f */ |
3434 |
}; |
3435 |
|
3436 |
switch (pref)
|
3437 |
{ |
3438 |
/* REX prefixes family. */
|
3439 |
case 0x40: |
3440 |
case 0x41: |
3441 |
case 0x42: |
3442 |
case 0x43: |
3443 |
case 0x44: |
3444 |
case 0x45: |
3445 |
case 0x46: |
3446 |
case 0x47: |
3447 |
case 0x48: |
3448 |
case 0x49: |
3449 |
case 0x4a: |
3450 |
case 0x4b: |
3451 |
case 0x4c: |
3452 |
case 0x4d: |
3453 |
case 0x4e: |
3454 |
case 0x4f: |
3455 |
return rexes [pref - 0x40]; |
3456 |
case 0xf3: |
3457 |
return "repz"; |
3458 |
case 0xf2: |
3459 |
return "repnz"; |
3460 |
case 0xf0: |
3461 |
return "lock"; |
3462 |
case 0x2e: |
3463 |
return "cs"; |
3464 |
case 0x36: |
3465 |
return "ss"; |
3466 |
case 0x3e: |
3467 |
return "ds"; |
3468 |
case 0x26: |
3469 |
return "es"; |
3470 |
case 0x64: |
3471 |
return "fs"; |
3472 |
case 0x65: |
3473 |
return "gs"; |
3474 |
case 0x66: |
3475 |
return (sizeflag & DFLAG) ? "data16" : "data32"; |
3476 |
case 0x67: |
3477 |
if (address_mode == mode_64bit)
|
3478 |
return (sizeflag & AFLAG) ? "addr32" : "addr64"; |
3479 |
else
|
3480 |
return (sizeflag & AFLAG) ? "addr16" : "addr32"; |
3481 |
case FWAIT_OPCODE:
|
3482 |
return "fwait"; |
3483 |
default:
|
3484 |
return NULL; |
3485 |
} |
3486 |
} |
3487 |
|
3488 |
static char op_out[MAX_OPERANDS][100]; |
3489 |
static int op_ad, op_index[MAX_OPERANDS]; |
3490 |
static int two_source_ops; |
3491 |
static bfd_vma op_address[MAX_OPERANDS];
|
3492 |
static bfd_vma op_riprel[MAX_OPERANDS];
|
3493 |
static bfd_vma start_pc;
|
3494 |
|
3495 |
/*
|
3496 |
* On the 386's of 1988, the maximum length of an instruction is 15 bytes.
|
3497 |
* (see topic "Redundant prefixes" in the "Differences from 8086"
|
3498 |
* section of the "Virtual 8086 Mode" chapter.)
|
3499 |
* 'pc' should be the address of this instruction, it will
|
3500 |
* be used to print the target address if this is a relative jump or call
|
3501 |
* The function returns the length of this instruction in bytes.
|
3502 |
*/
|
3503 |
|
3504 |
static char intel_syntax; |
3505 |
static char open_char; |
3506 |
static char close_char; |
3507 |
static char separator_char; |
3508 |
static char scale_char; |
3509 |
|
3510 |
int
|
3511 |
print_insn_i386 (bfd_vma pc, disassemble_info *info) |
3512 |
{ |
3513 |
intel_syntax = -1;
|
3514 |
|
3515 |
return print_insn (pc, info);
|
3516 |
} |
3517 |
|
3518 |
static int |
3519 |
print_insn (bfd_vma pc, disassemble_info *info) |
3520 |
{ |
3521 |
const struct dis386 *dp; |
3522 |
int i;
|
3523 |
char *op_txt[MAX_OPERANDS];
|
3524 |
int needcomma;
|
3525 |
unsigned char uses_DATA_prefix, uses_LOCK_prefix; |
3526 |
unsigned char uses_REPNZ_prefix, uses_REPZ_prefix; |
3527 |
int sizeflag;
|
3528 |
const char *p; |
3529 |
struct dis_private priv;
|
3530 |
unsigned char op; |
3531 |
|
3532 |
if (info->mach == bfd_mach_x86_64_intel_syntax
|
3533 |
|| info->mach == bfd_mach_x86_64) |
3534 |
address_mode = mode_64bit; |
3535 |
else
|
3536 |
address_mode = mode_32bit; |
3537 |
|
3538 |
if (intel_syntax == (char) -1) |
3539 |
intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax |
3540 |
|| info->mach == bfd_mach_x86_64_intel_syntax); |
3541 |
|
3542 |
if (info->mach == bfd_mach_i386_i386
|
3543 |
|| info->mach == bfd_mach_x86_64 |
3544 |
|| info->mach == bfd_mach_i386_i386_intel_syntax |
3545 |
|| info->mach == bfd_mach_x86_64_intel_syntax) |
3546 |
priv.orig_sizeflag = AFLAG | DFLAG; |
3547 |
else if (info->mach == bfd_mach_i386_i8086) |
3548 |
priv.orig_sizeflag = 0;
|
3549 |
else
|
3550 |
abort (); |
3551 |
|
3552 |
for (p = info->disassembler_options; p != NULL; ) |
3553 |
{ |
3554 |
if (strncmp (p, "x86-64", 6) == 0) |
3555 |
{ |
3556 |
address_mode = mode_64bit; |
3557 |
priv.orig_sizeflag = AFLAG | DFLAG; |
3558 |
} |
3559 |
else if (strncmp (p, "i386", 4) == 0) |
3560 |
{ |
3561 |
address_mode = mode_32bit; |
3562 |
priv.orig_sizeflag = AFLAG | DFLAG; |
3563 |
} |
3564 |
else if (strncmp (p, "i8086", 5) == 0) |
3565 |
{ |
3566 |
address_mode = mode_16bit; |
3567 |
priv.orig_sizeflag = 0;
|
3568 |
} |
3569 |
else if (strncmp (p, "intel", 5) == 0) |
3570 |
{ |
3571 |
intel_syntax = 1;
|
3572 |
} |
3573 |
else if (strncmp (p, "att", 3) == 0) |
3574 |
{ |
3575 |
intel_syntax = 0;
|
3576 |
} |
3577 |
else if (strncmp (p, "addr", 4) == 0) |
3578 |
{ |
3579 |
if (address_mode == mode_64bit)
|
3580 |
{ |
3581 |
if (p[4] == '3' && p[5] == '2') |
3582 |
priv.orig_sizeflag &= ~AFLAG; |
3583 |
else if (p[4] == '6' && p[5] == '4') |
3584 |
priv.orig_sizeflag |= AFLAG; |
3585 |
} |
3586 |
else
|
3587 |
{ |
3588 |
if (p[4] == '1' && p[5] == '6') |
3589 |
priv.orig_sizeflag &= ~AFLAG; |
3590 |
else if (p[4] == '3' && p[5] == '2') |
3591 |
priv.orig_sizeflag |= AFLAG; |
3592 |
} |
3593 |
} |
3594 |
else if (strncmp (p, "data", 4) == 0) |
3595 |
{ |
3596 |
if (p[4] == '1' && p[5] == '6') |
3597 |
priv.orig_sizeflag &= ~DFLAG; |
3598 |
else if (p[4] == '3' && p[5] == '2') |
3599 |
priv.orig_sizeflag |= DFLAG; |
3600 |
} |
3601 |
else if (strncmp (p, "suffix", 6) == 0) |
3602 |
priv.orig_sizeflag |= SUFFIX_ALWAYS; |
3603 |
|
3604 |
p = strchr (p, ',');
|
3605 |
if (p != NULL) |
3606 |
p++; |
3607 |
} |
3608 |
|
3609 |
if (intel_syntax)
|
3610 |
{ |
3611 |
names64 = intel_names64; |
3612 |
names32 = intel_names32; |
3613 |
names16 = intel_names16; |
3614 |
names8 = intel_names8; |
3615 |
names8rex = intel_names8rex; |
3616 |
names_seg = intel_names_seg; |
3617 |
index16 = intel_index16; |
3618 |
open_char = '[';
|
3619 |
close_char = ']';
|
3620 |
separator_char = '+';
|
3621 |
scale_char = '*';
|
3622 |
} |
3623 |
else
|
3624 |
{ |
3625 |
names64 = att_names64; |
3626 |
names32 = att_names32; |
3627 |
names16 = att_names16; |
3628 |
names8 = att_names8; |
3629 |
names8rex = att_names8rex; |
3630 |
names_seg = att_names_seg; |
3631 |
index16 = att_index16; |
3632 |
open_char = '(';
|
3633 |
close_char = ')';
|
3634 |
separator_char = ',';
|
3635 |
scale_char = ',';
|
3636 |
} |
3637 |
|
3638 |
/* The output looks better if we put 7 bytes on a line, since that
|
3639 |
puts most long word instructions on a single line. */
|
3640 |
info->bytes_per_line = 7;
|
3641 |
|
3642 |
info->private_data = &priv; |
3643 |
priv.max_fetched = priv.the_buffer; |
3644 |
priv.insn_start = pc; |
3645 |
|
3646 |
obuf[0] = 0; |
3647 |
for (i = 0; i < MAX_OPERANDS; ++i) |
3648 |
{ |
3649 |
op_out[i][0] = 0; |
3650 |
op_index[i] = -1;
|
3651 |
} |
3652 |
|
3653 |
the_info = info; |
3654 |
start_pc = pc; |
3655 |
start_codep = priv.the_buffer; |
3656 |
codep = priv.the_buffer; |
3657 |
|
3658 |
if (setjmp (priv.bailout) != 0) |
3659 |
{ |
3660 |
const char *name; |
3661 |
|
3662 |
/* Getting here means we tried for data but didn't get it. That
|
3663 |
means we have an incomplete instruction of some sort. Just
|
3664 |
print the first byte as a prefix or a .byte pseudo-op. */
|
3665 |
if (codep > priv.the_buffer)
|
3666 |
{ |
3667 |
name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
|
3668 |
if (name != NULL) |
3669 |
(*info->fprintf_func) (info->stream, "%s", name);
|
3670 |
else
|
3671 |
{ |
3672 |
/* Just print the first byte as a .byte instruction. */
|
3673 |
(*info->fprintf_func) (info->stream, ".byte 0x%x",
|
3674 |
(unsigned int) priv.the_buffer[0]); |
3675 |
} |
3676 |
|
3677 |
return 1; |
3678 |
} |
3679 |
|
3680 |
return -1; |
3681 |
} |
3682 |
|
3683 |
obufp = obuf; |
3684 |
ckprefix (); |
3685 |
|
3686 |
insn_codep = codep; |
3687 |
sizeflag = priv.orig_sizeflag; |
3688 |
|
3689 |
FETCH_DATA (info, codep + 1);
|
3690 |
two_source_ops = (*codep == 0x62) || (*codep == 0xc8); |
3691 |
|
3692 |
if (((prefixes & PREFIX_FWAIT)
|
3693 |
&& ((*codep < 0xd8) || (*codep > 0xdf))) |
3694 |
|| (rex && rex_used)) |
3695 |
{ |
3696 |
const char *name; |
3697 |
|
3698 |
/* fwait not followed by floating point instruction, or rex followed
|
3699 |
by other prefixes. Print the first prefix. */
|
3700 |
name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
|
3701 |
if (name == NULL) |
3702 |
name = INTERNAL_DISASSEMBLER_ERROR; |
3703 |
(*info->fprintf_func) (info->stream, "%s", name);
|
3704 |
return 1; |
3705 |
} |
3706 |
|
3707 |
op = 0;
|
3708 |
if (*codep == 0x0f) |
3709 |
{ |
3710 |
unsigned char threebyte; |
3711 |
FETCH_DATA (info, codep + 2);
|
3712 |
threebyte = *++codep; |
3713 |
dp = &dis386_twobyte[threebyte]; |
3714 |
need_modrm = twobyte_has_modrm[*codep]; |
3715 |
uses_DATA_prefix = twobyte_uses_DATA_prefix[*codep]; |
3716 |
uses_REPNZ_prefix = twobyte_uses_REPNZ_prefix[*codep]; |
3717 |
uses_REPZ_prefix = twobyte_uses_REPZ_prefix[*codep]; |
3718 |
uses_LOCK_prefix = (*codep & ~0x02) == 0x20; |
3719 |
codep++; |
3720 |
if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE) |
3721 |
{ |
3722 |
FETCH_DATA (info, codep + 2);
|
3723 |
op = *codep++; |
3724 |
switch (threebyte)
|
3725 |
{ |
3726 |
case 0x38: |
3727 |
uses_DATA_prefix = threebyte_0x38_uses_DATA_prefix[op]; |
3728 |
uses_REPNZ_prefix = threebyte_0x38_uses_REPNZ_prefix[op]; |
3729 |
uses_REPZ_prefix = threebyte_0x38_uses_REPZ_prefix[op]; |
3730 |
break;
|
3731 |
case 0x3a: |
3732 |
uses_DATA_prefix = threebyte_0x3a_uses_DATA_prefix[op]; |
3733 |
uses_REPNZ_prefix = threebyte_0x3a_uses_REPNZ_prefix[op]; |
3734 |
uses_REPZ_prefix = threebyte_0x3a_uses_REPZ_prefix[op]; |
3735 |
break;
|
3736 |
default:
|
3737 |
break;
|
3738 |
} |
3739 |
} |
3740 |
} |
3741 |
else
|
3742 |
{ |
3743 |
dp = &dis386[*codep]; |
3744 |
need_modrm = onebyte_has_modrm[*codep]; |
3745 |
uses_DATA_prefix = 0;
|
3746 |
uses_REPNZ_prefix = 0;
|
3747 |
/* pause is 0xf3 0x90. */
|
3748 |
uses_REPZ_prefix = *codep == 0x90;
|
3749 |
uses_LOCK_prefix = 0;
|
3750 |
codep++; |
3751 |
} |
3752 |
|
3753 |
if (!uses_REPZ_prefix && (prefixes & PREFIX_REPZ))
|
3754 |
{ |
3755 |
oappend ("repz ");
|
3756 |
used_prefixes |= PREFIX_REPZ; |
3757 |
} |
3758 |
if (!uses_REPNZ_prefix && (prefixes & PREFIX_REPNZ))
|
3759 |
{ |
3760 |
oappend ("repnz ");
|
3761 |
used_prefixes |= PREFIX_REPNZ; |
3762 |
} |
3763 |
|
3764 |
if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
|
3765 |
{ |
3766 |
oappend ("lock ");
|
3767 |
used_prefixes |= PREFIX_LOCK; |
3768 |
} |
3769 |
|
3770 |
if (prefixes & PREFIX_ADDR)
|
3771 |
{ |
3772 |
sizeflag ^= AFLAG; |
3773 |
if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax) |
3774 |
{ |
3775 |
if ((sizeflag & AFLAG) || address_mode == mode_64bit)
|
3776 |
oappend ("addr32 ");
|
3777 |
else
|
3778 |
oappend ("addr16 ");
|
3779 |
used_prefixes |= PREFIX_ADDR; |
3780 |
} |
3781 |
} |
3782 |
|
3783 |
if (!uses_DATA_prefix && (prefixes & PREFIX_DATA))
|
3784 |
{ |
3785 |
sizeflag ^= DFLAG; |
3786 |
if (dp->op[2].bytemode == cond_jump_mode |
3787 |
&& dp->op[0].bytemode == v_mode
|
3788 |
&& !intel_syntax) |
3789 |
{ |
3790 |
if (sizeflag & DFLAG)
|
3791 |
oappend ("data32 ");
|
3792 |
else
|
3793 |
oappend ("data16 ");
|
3794 |
used_prefixes |= PREFIX_DATA; |
3795 |
} |
3796 |
} |
3797 |
|
3798 |
if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE) |
3799 |
{ |
3800 |
dp = &three_byte_table[dp->op[1].bytemode][op];
|
3801 |
modrm.mod = (*codep >> 6) & 3; |
3802 |
modrm.reg = (*codep >> 3) & 7; |
3803 |
modrm.rm = *codep & 7;
|
3804 |
} |
3805 |
else if (need_modrm) |
3806 |
{ |
3807 |
FETCH_DATA (info, codep + 1);
|
3808 |
modrm.mod = (*codep >> 6) & 3; |
3809 |
modrm.reg = (*codep >> 3) & 7; |
3810 |
modrm.rm = *codep & 7;
|
3811 |
} |
3812 |
|
3813 |
if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE) |
3814 |
{ |
3815 |
dofloat (sizeflag); |
3816 |
} |
3817 |
else
|
3818 |
{ |
3819 |
int index;
|
3820 |
if (dp->name == NULL) |
3821 |
{ |
3822 |
switch (dp->op[0].bytemode) |
3823 |
{ |
3824 |
case USE_GROUPS:
|
3825 |
dp = &grps[dp->op[1].bytemode][modrm.reg];
|
3826 |
break;
|
3827 |
|
3828 |
case USE_PREFIX_USER_TABLE:
|
3829 |
index = 0;
|
3830 |
used_prefixes |= (prefixes & PREFIX_REPZ); |
3831 |
if (prefixes & PREFIX_REPZ)
|
3832 |
index = 1;
|
3833 |
else
|
3834 |
{ |
3835 |
/* We should check PREFIX_REPNZ and PREFIX_REPZ
|
3836 |
before PREFIX_DATA. */
|
3837 |
used_prefixes |= (prefixes & PREFIX_REPNZ); |
3838 |
if (prefixes & PREFIX_REPNZ)
|
3839 |
index = 3;
|
3840 |
else
|
3841 |
{ |
3842 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3843 |
if (prefixes & PREFIX_DATA)
|
3844 |
index = 2;
|
3845 |
} |
3846 |
} |
3847 |
dp = &prefix_user_table[dp->op[1].bytemode][index];
|
3848 |
break;
|
3849 |
|
3850 |
case X86_64_SPECIAL:
|
3851 |
index = address_mode == mode_64bit ? 1 : 0; |
3852 |
dp = &x86_64_table[dp->op[1].bytemode][index];
|
3853 |
break;
|
3854 |
|
3855 |
default:
|
3856 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
3857 |
break;
|
3858 |
} |
3859 |
} |
3860 |
|
3861 |
if (putop (dp->name, sizeflag) == 0) |
3862 |
{ |
3863 |
for (i = 0; i < MAX_OPERANDS; ++i) |
3864 |
{ |
3865 |
obufp = op_out[i]; |
3866 |
op_ad = MAX_OPERANDS - 1 - i;
|
3867 |
if (dp->op[i].rtn)
|
3868 |
(*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag); |
3869 |
} |
3870 |
} |
3871 |
} |
3872 |
|
3873 |
/* See if any prefixes were not used. If so, print the first one
|
3874 |
separately. If we don't do this, we'll wind up printing an
|
3875 |
instruction stream which does not precisely correspond to the
|
3876 |
bytes we are disassembling. */
|
3877 |
if ((prefixes & ~used_prefixes) != 0) |
3878 |
{ |
3879 |
const char *name; |
3880 |
|
3881 |
name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
|
3882 |
if (name == NULL) |
3883 |
name = INTERNAL_DISASSEMBLER_ERROR; |
3884 |
(*info->fprintf_func) (info->stream, "%s", name);
|
3885 |
return 1; |
3886 |
} |
3887 |
if (rex & ~rex_used)
|
3888 |
{ |
3889 |
const char *name; |
3890 |
name = prefix_name (rex | 0x40, priv.orig_sizeflag);
|
3891 |
if (name == NULL) |
3892 |
name = INTERNAL_DISASSEMBLER_ERROR; |
3893 |
(*info->fprintf_func) (info->stream, "%s ", name);
|
3894 |
} |
3895 |
|
3896 |
obufp = obuf + strlen (obuf); |
3897 |
for (i = strlen (obuf); i < 6; i++) |
3898 |
oappend (" ");
|
3899 |
oappend (" ");
|
3900 |
(*info->fprintf_func) (info->stream, "%s", obuf);
|
3901 |
|
3902 |
/* The enter and bound instructions are printed with operands in the same
|
3903 |
order as the intel book; everything else is printed in reverse order. */
|
3904 |
if (intel_syntax || two_source_ops)
|
3905 |
{ |
3906 |
bfd_vma riprel; |
3907 |
|
3908 |
for (i = 0; i < MAX_OPERANDS; ++i) |
3909 |
op_txt[i] = op_out[i]; |
3910 |
|
3911 |
for (i = 0; i < (MAX_OPERANDS >> 1); ++i) |
3912 |
{ |
3913 |
op_ad = op_index[i]; |
3914 |
op_index[i] = op_index[MAX_OPERANDS - 1 - i];
|
3915 |
op_index[MAX_OPERANDS - 1 - i] = op_ad;
|
3916 |
riprel = op_riprel[i]; |
3917 |
op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
|
3918 |
op_riprel[MAX_OPERANDS - 1 - i] = riprel;
|
3919 |
} |
3920 |
} |
3921 |
else
|
3922 |
{ |
3923 |
for (i = 0; i < MAX_OPERANDS; ++i) |
3924 |
op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
|
3925 |
} |
3926 |
|
3927 |
needcomma = 0;
|
3928 |
for (i = 0; i < MAX_OPERANDS; ++i) |
3929 |
if (*op_txt[i])
|
3930 |
{ |
3931 |
if (needcomma)
|
3932 |
(*info->fprintf_func) (info->stream, ",");
|
3933 |
if (op_index[i] != -1 && !op_riprel[i]) |
3934 |
(*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info); |
3935 |
else
|
3936 |
(*info->fprintf_func) (info->stream, "%s", op_txt[i]);
|
3937 |
needcomma = 1;
|
3938 |
} |
3939 |
|
3940 |
for (i = 0; i < MAX_OPERANDS; i++) |
3941 |
if (op_index[i] != -1 && op_riprel[i]) |
3942 |
{ |
3943 |
(*info->fprintf_func) (info->stream, " # ");
|
3944 |
(*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep |
3945 |
+ op_address[op_index[i]]), info); |
3946 |
break;
|
3947 |
} |
3948 |
return codep - priv.the_buffer;
|
3949 |
} |
3950 |
|
3951 |
static const char *float_mem[] = { |
3952 |
/* d8 */
|
3953 |
"fadd{s||s|}",
|
3954 |
"fmul{s||s|}",
|
3955 |
"fcom{s||s|}",
|
3956 |
"fcomp{s||s|}",
|
3957 |
"fsub{s||s|}",
|
3958 |
"fsubr{s||s|}",
|
3959 |
"fdiv{s||s|}",
|
3960 |
"fdivr{s||s|}",
|
3961 |
/* d9 */
|
3962 |
"fld{s||s|}",
|
3963 |
"(bad)",
|
3964 |
"fst{s||s|}",
|
3965 |
"fstp{s||s|}",
|
3966 |
"fldenvIC",
|
3967 |
"fldcw",
|
3968 |
"fNstenvIC",
|
3969 |
"fNstcw",
|
3970 |
/* da */
|
3971 |
"fiadd{l||l|}",
|
3972 |
"fimul{l||l|}",
|
3973 |
"ficom{l||l|}",
|
3974 |
"ficomp{l||l|}",
|
3975 |
"fisub{l||l|}",
|
3976 |
"fisubr{l||l|}",
|
3977 |
"fidiv{l||l|}",
|
3978 |
"fidivr{l||l|}",
|
3979 |
/* db */
|
3980 |
"fild{l||l|}",
|
3981 |
"fisttp{l||l|}",
|
3982 |
"fist{l||l|}",
|
3983 |
"fistp{l||l|}",
|
3984 |
"(bad)",
|
3985 |
"fld{t||t|}",
|
3986 |
"(bad)",
|
3987 |
"fstp{t||t|}",
|
3988 |
/* dc */
|
3989 |
"fadd{l||l|}",
|
3990 |
"fmul{l||l|}",
|
3991 |
"fcom{l||l|}",
|
3992 |
"fcomp{l||l|}",
|
3993 |
"fsub{l||l|}",
|
3994 |
"fsubr{l||l|}",
|
3995 |
"fdiv{l||l|}",
|
3996 |
"fdivr{l||l|}",
|
3997 |
/* dd */
|
3998 |
"fld{l||l|}",
|
3999 |
"fisttp{ll||ll|}",
|
4000 |
"fst{l||l|}",
|
4001 |
"fstp{l||l|}",
|
4002 |
"frstorIC",
|
4003 |
"(bad)",
|
4004 |
"fNsaveIC",
|
4005 |
"fNstsw",
|
4006 |
/* de */
|
4007 |
"fiadd",
|
4008 |
"fimul",
|
4009 |
"ficom",
|
4010 |
"ficomp",
|
4011 |
"fisub",
|
4012 |
"fisubr",
|
4013 |
"fidiv",
|
4014 |
"fidivr",
|
4015 |
/* df */
|
4016 |
"fild",
|
4017 |
"fisttp",
|
4018 |
"fist",
|
4019 |
"fistp",
|
4020 |
"fbld",
|
4021 |
"fild{ll||ll|}",
|
4022 |
"fbstp",
|
4023 |
"fistp{ll||ll|}",
|
4024 |
}; |
4025 |
|
4026 |
static const unsigned char float_mem_mode[] = { |
4027 |
/* d8 */
|
4028 |
d_mode, |
4029 |
d_mode, |
4030 |
d_mode, |
4031 |
d_mode, |
4032 |
d_mode, |
4033 |
d_mode, |
4034 |
d_mode, |
4035 |
d_mode, |
4036 |
/* d9 */
|
4037 |
d_mode, |
4038 |
0,
|
4039 |
d_mode, |
4040 |
d_mode, |
4041 |
0,
|
4042 |
w_mode, |
4043 |
0,
|
4044 |
w_mode, |
4045 |
/* da */
|
4046 |
d_mode, |
4047 |
d_mode, |
4048 |
d_mode, |
4049 |
d_mode, |
4050 |
d_mode, |
4051 |
d_mode, |
4052 |
d_mode, |
4053 |
d_mode, |
4054 |
/* db */
|
4055 |
d_mode, |
4056 |
d_mode, |
4057 |
d_mode, |
4058 |
d_mode, |
4059 |
0,
|
4060 |
t_mode, |
4061 |
0,
|
4062 |
t_mode, |
4063 |
/* dc */
|
4064 |
q_mode, |
4065 |
q_mode, |
4066 |
q_mode, |
4067 |
q_mode, |
4068 |
q_mode, |
4069 |
q_mode, |
4070 |
q_mode, |
4071 |
q_mode, |
4072 |
/* dd */
|
4073 |
q_mode, |
4074 |
q_mode, |
4075 |
q_mode, |
4076 |
q_mode, |
4077 |
0,
|
4078 |
0,
|
4079 |
0,
|
4080 |
w_mode, |
4081 |
/* de */
|
4082 |
w_mode, |
4083 |
w_mode, |
4084 |
w_mode, |
4085 |
w_mode, |
4086 |
w_mode, |
4087 |
w_mode, |
4088 |
w_mode, |
4089 |
w_mode, |
4090 |
/* df */
|
4091 |
w_mode, |
4092 |
w_mode, |
4093 |
w_mode, |
4094 |
w_mode, |
4095 |
t_mode, |
4096 |
q_mode, |
4097 |
t_mode, |
4098 |
q_mode |
4099 |
}; |
4100 |
|
4101 |
#define ST { OP_ST, 0 } |
4102 |
#define STi { OP_STi, 0 } |
4103 |
|
4104 |
#define FGRPd9_2 NULL, { { NULL, 0 } } |
4105 |
#define FGRPd9_4 NULL, { { NULL, 1 } } |
4106 |
#define FGRPd9_5 NULL, { { NULL, 2 } } |
4107 |
#define FGRPd9_6 NULL, { { NULL, 3 } } |
4108 |
#define FGRPd9_7 NULL, { { NULL, 4 } } |
4109 |
#define FGRPda_5 NULL, { { NULL, 5 } } |
4110 |
#define FGRPdb_4 NULL, { { NULL, 6 } } |
4111 |
#define FGRPde_3 NULL, { { NULL, 7 } } |
4112 |
#define FGRPdf_4 NULL, { { NULL, 8 } } |
4113 |
|
4114 |
static const struct dis386 float_reg[][8] = { |
4115 |
/* d8 */
|
4116 |
{ |
4117 |
{ "fadd", { ST, STi } },
|
4118 |
{ "fmul", { ST, STi } },
|
4119 |
{ "fcom", { STi } },
|
4120 |
{ "fcomp", { STi } },
|
4121 |
{ "fsub", { ST, STi } },
|
4122 |
{ "fsubr", { ST, STi } },
|
4123 |
{ "fdiv", { ST, STi } },
|
4124 |
{ "fdivr", { ST, STi } },
|
4125 |
}, |
4126 |
/* d9 */
|
4127 |
{ |
4128 |
{ "fld", { STi } },
|
4129 |
{ "fxch", { STi } },
|
4130 |
{ FGRPd9_2 }, |
4131 |
{ "(bad)", { XX } },
|
4132 |
{ FGRPd9_4 }, |
4133 |
{ FGRPd9_5 }, |
4134 |
{ FGRPd9_6 }, |
4135 |
{ FGRPd9_7 }, |
4136 |
}, |
4137 |
/* da */
|
4138 |
{ |
4139 |
{ "fcmovb", { ST, STi } },
|
4140 |
{ "fcmove", { ST, STi } },
|
4141 |
{ "fcmovbe",{ ST, STi } },
|
4142 |
{ "fcmovu", { ST, STi } },
|
4143 |
{ "(bad)", { XX } },
|
4144 |
{ FGRPda_5 }, |
4145 |
{ "(bad)", { XX } },
|
4146 |
{ "(bad)", { XX } },
|
4147 |
}, |
4148 |
/* db */
|
4149 |
{ |
4150 |
{ "fcmovnb",{ ST, STi } },
|
4151 |
{ "fcmovne",{ ST, STi } },
|
4152 |
{ "fcmovnbe",{ ST, STi } },
|
4153 |
{ "fcmovnu",{ ST, STi } },
|
4154 |
{ FGRPdb_4 }, |
4155 |
{ "fucomi", { ST, STi } },
|
4156 |
{ "fcomi", { ST, STi } },
|
4157 |
{ "(bad)", { XX } },
|
4158 |
}, |
4159 |
/* dc */
|
4160 |
{ |
4161 |
{ "fadd", { STi, ST } },
|
4162 |
{ "fmul", { STi, ST } },
|
4163 |
{ "(bad)", { XX } },
|
4164 |
{ "(bad)", { XX } },
|
4165 |
#if SYSV386_COMPAT
|
4166 |
{ "fsub", { STi, ST } },
|
4167 |
{ "fsubr", { STi, ST } },
|
4168 |
{ "fdiv", { STi, ST } },
|
4169 |
{ "fdivr", { STi, ST } },
|
4170 |
#else
|
4171 |
{ "fsubr", { STi, ST } },
|
4172 |
{ "fsub", { STi, ST } },
|
4173 |
{ "fdivr", { STi, ST } },
|
4174 |
{ "fdiv", { STi, ST } },
|
4175 |
#endif
|
4176 |
}, |
4177 |
/* dd */
|
4178 |
{ |
4179 |
{ "ffree", { STi } },
|
4180 |
{ "(bad)", { XX } },
|
4181 |
{ "fst", { STi } },
|
4182 |
{ "fstp", { STi } },
|
4183 |
{ "fucom", { STi } },
|
4184 |
{ "fucomp", { STi } },
|
4185 |
{ "(bad)", { XX } },
|
4186 |
{ "(bad)", { XX } },
|
4187 |
}, |
4188 |
/* de */
|
4189 |
{ |
4190 |
{ "faddp", { STi, ST } },
|
4191 |
{ "fmulp", { STi, ST } },
|
4192 |
{ "(bad)", { XX } },
|
4193 |
{ FGRPde_3 }, |
4194 |
#if SYSV386_COMPAT
|
4195 |
{ "fsubp", { STi, ST } },
|
4196 |
{ "fsubrp", { STi, ST } },
|
4197 |
{ "fdivp", { STi, ST } },
|
4198 |
{ "fdivrp", { STi, ST } },
|
4199 |
#else
|
4200 |
{ "fsubrp", { STi, ST } },
|
4201 |
{ "fsubp", { STi, ST } },
|
4202 |
{ "fdivrp", { STi, ST } },
|
4203 |
{ "fdivp", { STi, ST } },
|
4204 |
#endif
|
4205 |
}, |
4206 |
/* df */
|
4207 |
{ |
4208 |
{ "ffreep", { STi } },
|
4209 |
{ "(bad)", { XX } },
|
4210 |
{ "(bad)", { XX } },
|
4211 |
{ "(bad)", { XX } },
|
4212 |
{ FGRPdf_4 }, |
4213 |
{ "fucomip", { ST, STi } },
|
4214 |
{ "fcomip", { ST, STi } },
|
4215 |
{ "(bad)", { XX } },
|
4216 |
}, |
4217 |
}; |
4218 |
|
4219 |
static const char *fgrps[][8] = { |
4220 |
/* d9_2 0 */
|
4221 |
{ |
4222 |
"fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
4223 |
}, |
4224 |
|
4225 |
/* d9_4 1 */
|
4226 |
{ |
4227 |
"fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)", |
4228 |
}, |
4229 |
|
4230 |
/* d9_5 2 */
|
4231 |
{ |
4232 |
"fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)", |
4233 |
}, |
4234 |
|
4235 |
/* d9_6 3 */
|
4236 |
{ |
4237 |
"f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp", |
4238 |
}, |
4239 |
|
4240 |
/* d9_7 4 */
|
4241 |
{ |
4242 |
"fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos", |
4243 |
}, |
4244 |
|
4245 |
/* da_5 5 */
|
4246 |
{ |
4247 |
"(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
4248 |
}, |
4249 |
|
4250 |
/* db_4 6 */
|
4251 |
{ |
4252 |
"feni(287 only)","fdisi(287 only)","fNclex","fNinit", |
4253 |
"fNsetpm(287 only)","(bad)","(bad)","(bad)", |
4254 |
}, |
4255 |
|
4256 |
/* de_3 7 */
|
4257 |
{ |
4258 |
"(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
4259 |
}, |
4260 |
|
4261 |
/* df_4 8 */
|
4262 |
{ |
4263 |
"fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
4264 |
}, |
4265 |
}; |
4266 |
|
4267 |
static void |
4268 |
dofloat (int sizeflag)
|
4269 |
{ |
4270 |
const struct dis386 *dp; |
4271 |
unsigned char floatop; |
4272 |
|
4273 |
floatop = codep[-1];
|
4274 |
|
4275 |
if (modrm.mod != 3) |
4276 |
{ |
4277 |
int fp_indx = (floatop - 0xd8) * 8 + modrm.reg; |
4278 |
|
4279 |
putop (float_mem[fp_indx], sizeflag); |
4280 |
obufp = op_out[0];
|
4281 |
op_ad = 2;
|
4282 |
OP_E (float_mem_mode[fp_indx], sizeflag); |
4283 |
return;
|
4284 |
} |
4285 |
/* Skip mod/rm byte. */
|
4286 |
MODRM_CHECK; |
4287 |
codep++; |
4288 |
|
4289 |
dp = &float_reg[floatop - 0xd8][modrm.reg];
|
4290 |
if (dp->name == NULL) |
4291 |
{ |
4292 |
putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
|
4293 |
|
4294 |
/* Instruction fnstsw is only one with strange arg. */
|
4295 |
if (floatop == 0xdf && codep[-1] == 0xe0) |
4296 |
pstrcpy (op_out[0], sizeof(op_out[0]), names16[0]); |
4297 |
} |
4298 |
else
|
4299 |
{ |
4300 |
putop (dp->name, sizeflag); |
4301 |
|
4302 |
obufp = op_out[0];
|
4303 |
op_ad = 2;
|
4304 |
if (dp->op[0].rtn) |
4305 |
(*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag); |
4306 |
|
4307 |
obufp = op_out[1];
|
4308 |
op_ad = 1;
|
4309 |
if (dp->op[1].rtn) |
4310 |
(*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag); |
4311 |
} |
4312 |
} |
4313 |
|
4314 |
static void |
4315 |
OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
4316 |
{ |
4317 |
oappend ("%st" + intel_syntax);
|
4318 |
} |
4319 |
|
4320 |
static void |
4321 |
OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
4322 |
{ |
4323 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%st(%d)", modrm.rm); |
4324 |
oappend (scratchbuf + intel_syntax); |
4325 |
} |
4326 |
|
4327 |
/* Capital letters in template are macros. */
|
4328 |
static int |
4329 |
putop (const char *template, int sizeflag) |
4330 |
{ |
4331 |
const char *p; |
4332 |
int alt = 0; |
4333 |
|
4334 |
for (p = template; *p; p++)
|
4335 |
{ |
4336 |
switch (*p)
|
4337 |
{ |
4338 |
default:
|
4339 |
*obufp++ = *p; |
4340 |
break;
|
4341 |
case '{': |
4342 |
alt = 0;
|
4343 |
if (intel_syntax)
|
4344 |
alt += 1;
|
4345 |
if (address_mode == mode_64bit)
|
4346 |
alt += 2;
|
4347 |
while (alt != 0) |
4348 |
{ |
4349 |
while (*++p != '|') |
4350 |
{ |
4351 |
if (*p == '}') |
4352 |
{ |
4353 |
/* Alternative not valid. */
|
4354 |
pstrcpy (obuf, sizeof(obuf), "(bad)"); |
4355 |
obufp = obuf + 5;
|
4356 |
return 1; |
4357 |
} |
4358 |
else if (*p == '\0') |
4359 |
abort (); |
4360 |
} |
4361 |
alt--; |
4362 |
} |
4363 |
/* Fall through. */
|
4364 |
case 'I': |
4365 |
alt = 1;
|
4366 |
continue;
|
4367 |
case '|': |
4368 |
while (*++p != '}') |
4369 |
{ |
4370 |
if (*p == '\0') |
4371 |
abort (); |
4372 |
} |
4373 |
break;
|
4374 |
case '}': |
4375 |
break;
|
4376 |
case 'A': |
4377 |
if (intel_syntax)
|
4378 |
break;
|
4379 |
if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) |
4380 |
*obufp++ = 'b';
|
4381 |
break;
|
4382 |
case 'B': |
4383 |
if (intel_syntax)
|
4384 |
break;
|
4385 |
if (sizeflag & SUFFIX_ALWAYS)
|
4386 |
*obufp++ = 'b';
|
4387 |
break;
|
4388 |
case 'C': |
4389 |
if (intel_syntax && !alt)
|
4390 |
break;
|
4391 |
if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
|
4392 |
{ |
4393 |
if (sizeflag & DFLAG)
|
4394 |
*obufp++ = intel_syntax ? 'd' : 'l'; |
4395 |
else
|
4396 |
*obufp++ = intel_syntax ? 'w' : 's'; |
4397 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4398 |
} |
4399 |
break;
|
4400 |
case 'D': |
4401 |
if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
|
4402 |
break;
|
4403 |
USED_REX (REX_W); |
4404 |
if (modrm.mod == 3) |
4405 |
{ |
4406 |
if (rex & REX_W)
|
4407 |
*obufp++ = 'q';
|
4408 |
else if (sizeflag & DFLAG) |
4409 |
*obufp++ = intel_syntax ? 'd' : 'l'; |
4410 |
else
|
4411 |
*obufp++ = 'w';
|
4412 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4413 |
} |
4414 |
else
|
4415 |
*obufp++ = 'w';
|
4416 |
break;
|
4417 |
case 'E': /* For jcxz/jecxz */ |
4418 |
if (address_mode == mode_64bit)
|
4419 |
{ |
4420 |
if (sizeflag & AFLAG)
|
4421 |
*obufp++ = 'r';
|
4422 |
else
|
4423 |
*obufp++ = 'e';
|
4424 |
} |
4425 |
else
|
4426 |
if (sizeflag & AFLAG)
|
4427 |
*obufp++ = 'e';
|
4428 |
used_prefixes |= (prefixes & PREFIX_ADDR); |
4429 |
break;
|
4430 |
case 'F': |
4431 |
if (intel_syntax)
|
4432 |
break;
|
4433 |
if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
|
4434 |
{ |
4435 |
if (sizeflag & AFLAG)
|
4436 |
*obufp++ = address_mode == mode_64bit ? 'q' : 'l'; |
4437 |
else
|
4438 |
*obufp++ = address_mode == mode_64bit ? 'l' : 'w'; |
4439 |
used_prefixes |= (prefixes & PREFIX_ADDR); |
4440 |
} |
4441 |
break;
|
4442 |
case 'G': |
4443 |
if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS))) |
4444 |
break;
|
4445 |
if ((rex & REX_W) || (sizeflag & DFLAG))
|
4446 |
*obufp++ = 'l';
|
4447 |
else
|
4448 |
*obufp++ = 'w';
|
4449 |
if (!(rex & REX_W))
|
4450 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4451 |
break;
|
4452 |
case 'H': |
4453 |
if (intel_syntax)
|
4454 |
break;
|
4455 |
if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
|
4456 |
|| (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) |
4457 |
{ |
4458 |
used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS); |
4459 |
*obufp++ = ',';
|
4460 |
*obufp++ = 'p';
|
4461 |
if (prefixes & PREFIX_DS)
|
4462 |
*obufp++ = 't';
|
4463 |
else
|
4464 |
*obufp++ = 'n';
|
4465 |
} |
4466 |
break;
|
4467 |
case 'J': |
4468 |
if (intel_syntax)
|
4469 |
break;
|
4470 |
*obufp++ = 'l';
|
4471 |
break;
|
4472 |
case 'K': |
4473 |
USED_REX (REX_W); |
4474 |
if (rex & REX_W)
|
4475 |
*obufp++ = 'q';
|
4476 |
else
|
4477 |
*obufp++ = 'd';
|
4478 |
break;
|
4479 |
case 'Z': |
4480 |
if (intel_syntax)
|
4481 |
break;
|
4482 |
if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
|
4483 |
{ |
4484 |
*obufp++ = 'q';
|
4485 |
break;
|
4486 |
} |
4487 |
/* Fall through. */
|
4488 |
case 'L': |
4489 |
if (intel_syntax)
|
4490 |
break;
|
4491 |
if (sizeflag & SUFFIX_ALWAYS)
|
4492 |
*obufp++ = 'l';
|
4493 |
break;
|
4494 |
case 'N': |
4495 |
if ((prefixes & PREFIX_FWAIT) == 0) |
4496 |
*obufp++ = 'n';
|
4497 |
else
|
4498 |
used_prefixes |= PREFIX_FWAIT; |
4499 |
break;
|
4500 |
case 'O': |
4501 |
USED_REX (REX_W); |
4502 |
if (rex & REX_W)
|
4503 |
*obufp++ = 'o';
|
4504 |
else if (intel_syntax && (sizeflag & DFLAG)) |
4505 |
*obufp++ = 'q';
|
4506 |
else
|
4507 |
*obufp++ = 'd';
|
4508 |
if (!(rex & REX_W))
|
4509 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4510 |
break;
|
4511 |
case 'T': |
4512 |
if (intel_syntax)
|
4513 |
break;
|
4514 |
if (address_mode == mode_64bit && (sizeflag & DFLAG))
|
4515 |
{ |
4516 |
*obufp++ = 'q';
|
4517 |
break;
|
4518 |
} |
4519 |
/* Fall through. */
|
4520 |
case 'P': |
4521 |
if (intel_syntax)
|
4522 |
break;
|
4523 |
if ((prefixes & PREFIX_DATA)
|
4524 |
|| (rex & REX_W) |
4525 |
|| (sizeflag & SUFFIX_ALWAYS)) |
4526 |
{ |
4527 |
USED_REX (REX_W); |
4528 |
if (rex & REX_W)
|
4529 |
*obufp++ = 'q';
|
4530 |
else
|
4531 |
{ |
4532 |
if (sizeflag & DFLAG)
|
4533 |
*obufp++ = 'l';
|
4534 |
else
|
4535 |
*obufp++ = 'w';
|
4536 |
} |
4537 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4538 |
} |
4539 |
break;
|
4540 |
case 'U': |
4541 |
if (intel_syntax)
|
4542 |
break;
|
4543 |
if (address_mode == mode_64bit && (sizeflag & DFLAG))
|
4544 |
{ |
4545 |
if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) |
4546 |
*obufp++ = 'q';
|
4547 |
break;
|
4548 |
} |
4549 |
/* Fall through. */
|
4550 |
case 'Q': |
4551 |
if (intel_syntax && !alt)
|
4552 |
break;
|
4553 |
USED_REX (REX_W); |
4554 |
if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) |
4555 |
{ |
4556 |
if (rex & REX_W)
|
4557 |
*obufp++ = 'q';
|
4558 |
else
|
4559 |
{ |
4560 |
if (sizeflag & DFLAG)
|
4561 |
*obufp++ = intel_syntax ? 'd' : 'l'; |
4562 |
else
|
4563 |
*obufp++ = 'w';
|
4564 |
} |
4565 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4566 |
} |
4567 |
break;
|
4568 |
case 'R': |
4569 |
USED_REX (REX_W); |
4570 |
if (rex & REX_W)
|
4571 |
*obufp++ = 'q';
|
4572 |
else if (sizeflag & DFLAG) |
4573 |
{ |
4574 |
if (intel_syntax)
|
4575 |
*obufp++ = 'd';
|
4576 |
else
|
4577 |
*obufp++ = 'l';
|
4578 |
} |
4579 |
else
|
4580 |
*obufp++ = 'w';
|
4581 |
if (intel_syntax && !p[1] |
4582 |
&& ((rex & REX_W) || (sizeflag & DFLAG))) |
4583 |
*obufp++ = 'e';
|
4584 |
if (!(rex & REX_W))
|
4585 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4586 |
break;
|
4587 |
case 'V': |
4588 |
if (intel_syntax)
|
4589 |
break;
|
4590 |
if (address_mode == mode_64bit && (sizeflag & DFLAG))
|
4591 |
{ |
4592 |
if (sizeflag & SUFFIX_ALWAYS)
|
4593 |
*obufp++ = 'q';
|
4594 |
break;
|
4595 |
} |
4596 |
/* Fall through. */
|
4597 |
case 'S': |
4598 |
if (intel_syntax)
|
4599 |
break;
|
4600 |
if (sizeflag & SUFFIX_ALWAYS)
|
4601 |
{ |
4602 |
if (rex & REX_W)
|
4603 |
*obufp++ = 'q';
|
4604 |
else
|
4605 |
{ |
4606 |
if (sizeflag & DFLAG)
|
4607 |
*obufp++ = 'l';
|
4608 |
else
|
4609 |
*obufp++ = 'w';
|
4610 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4611 |
} |
4612 |
} |
4613 |
break;
|
4614 |
case 'X': |
4615 |
if (prefixes & PREFIX_DATA)
|
4616 |
*obufp++ = 'd';
|
4617 |
else
|
4618 |
*obufp++ = 's';
|
4619 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4620 |
break;
|
4621 |
case 'Y': |
4622 |
if (intel_syntax)
|
4623 |
break;
|
4624 |
if (rex & REX_W)
|
4625 |
{ |
4626 |
USED_REX (REX_W); |
4627 |
*obufp++ = 'q';
|
4628 |
} |
4629 |
break;
|
4630 |
/* implicit operand size 'l' for i386 or 'q' for x86-64 */
|
4631 |
case 'W': |
4632 |
/* operand size flag for cwtl, cbtw */
|
4633 |
USED_REX (REX_W); |
4634 |
if (rex & REX_W)
|
4635 |
{ |
4636 |
if (intel_syntax)
|
4637 |
*obufp++ = 'd';
|
4638 |
else
|
4639 |
*obufp++ = 'l';
|
4640 |
} |
4641 |
else if (sizeflag & DFLAG) |
4642 |
*obufp++ = 'w';
|
4643 |
else
|
4644 |
*obufp++ = 'b';
|
4645 |
if (!(rex & REX_W))
|
4646 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4647 |
break;
|
4648 |
} |
4649 |
alt = 0;
|
4650 |
} |
4651 |
*obufp = 0;
|
4652 |
return 0; |
4653 |
} |
4654 |
|
4655 |
static void |
4656 |
oappend (const char *s) |
4657 |
{ |
4658 |
strcpy (obufp, s); |
4659 |
obufp += strlen (s); |
4660 |
} |
4661 |
|
4662 |
static void |
4663 |
append_seg (void)
|
4664 |
{ |
4665 |
if (prefixes & PREFIX_CS)
|
4666 |
{ |
4667 |
used_prefixes |= PREFIX_CS; |
4668 |
oappend ("%cs:" + intel_syntax);
|
4669 |
} |
4670 |
if (prefixes & PREFIX_DS)
|
4671 |
{ |
4672 |
used_prefixes |= PREFIX_DS; |
4673 |
oappend ("%ds:" + intel_syntax);
|
4674 |
} |
4675 |
if (prefixes & PREFIX_SS)
|
4676 |
{ |
4677 |
used_prefixes |= PREFIX_SS; |
4678 |
oappend ("%ss:" + intel_syntax);
|
4679 |
} |
4680 |
if (prefixes & PREFIX_ES)
|
4681 |
{ |
4682 |
used_prefixes |= PREFIX_ES; |
4683 |
oappend ("%es:" + intel_syntax);
|
4684 |
} |
4685 |
if (prefixes & PREFIX_FS)
|
4686 |
{ |
4687 |
used_prefixes |= PREFIX_FS; |
4688 |
oappend ("%fs:" + intel_syntax);
|
4689 |
} |
4690 |
if (prefixes & PREFIX_GS)
|
4691 |
{ |
4692 |
used_prefixes |= PREFIX_GS; |
4693 |
oappend ("%gs:" + intel_syntax);
|
4694 |
} |
4695 |
} |
4696 |
|
4697 |
static void |
4698 |
OP_indirE (int bytemode, int sizeflag) |
4699 |
{ |
4700 |
if (!intel_syntax)
|
4701 |
oappend ("*");
|
4702 |
OP_E (bytemode, sizeflag); |
4703 |
} |
4704 |
|
4705 |
static void |
4706 |
print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp) |
4707 |
{ |
4708 |
if (address_mode == mode_64bit)
|
4709 |
{ |
4710 |
if (hex)
|
4711 |
{ |
4712 |
char tmp[30]; |
4713 |
int i;
|
4714 |
buf[0] = '0'; |
4715 |
buf[1] = 'x'; |
4716 |
snprintf_vma (tmp, sizeof(tmp), disp);
|
4717 |
for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++); |
4718 |
pstrcpy (buf + 2, bufsize - 2, tmp + i); |
4719 |
} |
4720 |
else
|
4721 |
{ |
4722 |
bfd_signed_vma v = disp; |
4723 |
char tmp[30]; |
4724 |
int i;
|
4725 |
if (v < 0) |
4726 |
{ |
4727 |
*(buf++) = '-';
|
4728 |
v = -disp; |
4729 |
/* Check for possible overflow on 0x8000000000000000. */
|
4730 |
if (v < 0) |
4731 |
{ |
4732 |
pstrcpy (buf, bufsize, "9223372036854775808");
|
4733 |
return;
|
4734 |
} |
4735 |
} |
4736 |
if (!v)
|
4737 |
{ |
4738 |
pstrcpy (buf, bufsize, "0");
|
4739 |
return;
|
4740 |
} |
4741 |
|
4742 |
i = 0;
|
4743 |
tmp[29] = 0; |
4744 |
while (v)
|
4745 |
{ |
4746 |
tmp[28 - i] = (v % 10) + '0'; |
4747 |
v /= 10;
|
4748 |
i++; |
4749 |
} |
4750 |
pstrcpy (buf, bufsize, tmp + 29 - i);
|
4751 |
} |
4752 |
} |
4753 |
else
|
4754 |
{ |
4755 |
if (hex)
|
4756 |
snprintf (buf, bufsize, "0x%x", (unsigned int) disp); |
4757 |
else
|
4758 |
snprintf (buf, bufsize, "%d", (int) disp); |
4759 |
} |
4760 |
} |
4761 |
|
4762 |
/* Put DISP in BUF as signed hex number. */
|
4763 |
|
4764 |
static void |
4765 |
print_displacement (char *buf, bfd_vma disp)
|
4766 |
{ |
4767 |
bfd_signed_vma val = disp; |
4768 |
char tmp[30]; |
4769 |
int i, j = 0; |
4770 |
|
4771 |
if (val < 0) |
4772 |
{ |
4773 |
buf[j++] = '-';
|
4774 |
val = -disp; |
4775 |
|
4776 |
/* Check for possible overflow. */
|
4777 |
if (val < 0) |
4778 |
{ |
4779 |
switch (address_mode)
|
4780 |
{ |
4781 |
case mode_64bit:
|
4782 |
strcpy (buf + j, "0x8000000000000000");
|
4783 |
break;
|
4784 |
case mode_32bit:
|
4785 |
strcpy (buf + j, "0x80000000");
|
4786 |
break;
|
4787 |
case mode_16bit:
|
4788 |
strcpy (buf + j, "0x8000");
|
4789 |
break;
|
4790 |
} |
4791 |
return;
|
4792 |
} |
4793 |
} |
4794 |
|
4795 |
buf[j++] = '0';
|
4796 |
buf[j++] = 'x';
|
4797 |
|
4798 |
snprintf_vma (tmp, sizeof(tmp), val);
|
4799 |
for (i = 0; tmp[i] == '0'; i++) |
4800 |
continue;
|
4801 |
if (tmp[i] == '\0') |
4802 |
i--; |
4803 |
strcpy (buf + j, tmp + i); |
4804 |
} |
4805 |
|
4806 |
static void |
4807 |
intel_operand_size (int bytemode, int sizeflag) |
4808 |
{ |
4809 |
switch (bytemode)
|
4810 |
{ |
4811 |
case b_mode:
|
4812 |
case dqb_mode:
|
4813 |
oappend ("BYTE PTR ");
|
4814 |
break;
|
4815 |
case w_mode:
|
4816 |
case dqw_mode:
|
4817 |
oappend ("WORD PTR ");
|
4818 |
break;
|
4819 |
case stack_v_mode:
|
4820 |
if (address_mode == mode_64bit && (sizeflag & DFLAG))
|
4821 |
{ |
4822 |
oappend ("QWORD PTR ");
|
4823 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4824 |
break;
|
4825 |
} |
4826 |
/* FALLTHRU */
|
4827 |
case v_mode:
|
4828 |
case dq_mode:
|
4829 |
USED_REX (REX_W); |
4830 |
if (rex & REX_W)
|
4831 |
oappend ("QWORD PTR ");
|
4832 |
else if ((sizeflag & DFLAG) || bytemode == dq_mode) |
4833 |
oappend ("DWORD PTR ");
|
4834 |
else
|
4835 |
oappend ("WORD PTR ");
|
4836 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4837 |
break;
|
4838 |
case z_mode:
|
4839 |
if ((rex & REX_W) || (sizeflag & DFLAG))
|
4840 |
*obufp++ = 'D';
|
4841 |
oappend ("WORD PTR ");
|
4842 |
if (!(rex & REX_W))
|
4843 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4844 |
break;
|
4845 |
case d_mode:
|
4846 |
case dqd_mode:
|
4847 |
oappend ("DWORD PTR ");
|
4848 |
break;
|
4849 |
case q_mode:
|
4850 |
oappend ("QWORD PTR ");
|
4851 |
break;
|
4852 |
case m_mode:
|
4853 |
if (address_mode == mode_64bit)
|
4854 |
oappend ("QWORD PTR ");
|
4855 |
else
|
4856 |
oappend ("DWORD PTR ");
|
4857 |
break;
|
4858 |
case f_mode:
|
4859 |
if (sizeflag & DFLAG)
|
4860 |
oappend ("FWORD PTR ");
|
4861 |
else
|
4862 |
oappend ("DWORD PTR ");
|
4863 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4864 |
break;
|
4865 |
case t_mode:
|
4866 |
oappend ("TBYTE PTR ");
|
4867 |
break;
|
4868 |
case x_mode:
|
4869 |
oappend ("XMMWORD PTR ");
|
4870 |
break;
|
4871 |
case o_mode:
|
4872 |
oappend ("OWORD PTR ");
|
4873 |
break;
|
4874 |
default:
|
4875 |
break;
|
4876 |
} |
4877 |
} |
4878 |
|
4879 |
static void |
4880 |
OP_E (int bytemode, int sizeflag) |
4881 |
{ |
4882 |
bfd_vma disp; |
4883 |
int add = 0; |
4884 |
int riprel = 0; |
4885 |
USED_REX (REX_B); |
4886 |
if (rex & REX_B)
|
4887 |
add += 8;
|
4888 |
|
4889 |
/* Skip mod/rm byte. */
|
4890 |
MODRM_CHECK; |
4891 |
codep++; |
4892 |
|
4893 |
if (modrm.mod == 3) |
4894 |
{ |
4895 |
switch (bytemode)
|
4896 |
{ |
4897 |
case b_mode:
|
4898 |
USED_REX (0);
|
4899 |
if (rex)
|
4900 |
oappend (names8rex[modrm.rm + add]); |
4901 |
else
|
4902 |
oappend (names8[modrm.rm + add]); |
4903 |
break;
|
4904 |
case w_mode:
|
4905 |
oappend (names16[modrm.rm + add]); |
4906 |
break;
|
4907 |
case d_mode:
|
4908 |
oappend (names32[modrm.rm + add]); |
4909 |
break;
|
4910 |
case q_mode:
|
4911 |
oappend (names64[modrm.rm + add]); |
4912 |
break;
|
4913 |
case m_mode:
|
4914 |
if (address_mode == mode_64bit)
|
4915 |
oappend (names64[modrm.rm + add]); |
4916 |
else
|
4917 |
oappend (names32[modrm.rm + add]); |
4918 |
break;
|
4919 |
case stack_v_mode:
|
4920 |
if (address_mode == mode_64bit && (sizeflag & DFLAG))
|
4921 |
{ |
4922 |
oappend (names64[modrm.rm + add]); |
4923 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4924 |
break;
|
4925 |
} |
4926 |
bytemode = v_mode; |
4927 |
/* FALLTHRU */
|
4928 |
case v_mode:
|
4929 |
case dq_mode:
|
4930 |
case dqb_mode:
|
4931 |
case dqd_mode:
|
4932 |
case dqw_mode:
|
4933 |
USED_REX (REX_W); |
4934 |
if (rex & REX_W)
|
4935 |
oappend (names64[modrm.rm + add]); |
4936 |
else if ((sizeflag & DFLAG) || bytemode != v_mode) |
4937 |
oappend (names32[modrm.rm + add]); |
4938 |
else
|
4939 |
oappend (names16[modrm.rm + add]); |
4940 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4941 |
break;
|
4942 |
case 0: |
4943 |
break;
|
4944 |
default:
|
4945 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
4946 |
break;
|
4947 |
} |
4948 |
return;
|
4949 |
} |
4950 |
|
4951 |
disp = 0;
|
4952 |
if (intel_syntax)
|
4953 |
intel_operand_size (bytemode, sizeflag); |
4954 |
append_seg (); |
4955 |
|
4956 |
if ((sizeflag & AFLAG) || address_mode == mode_64bit)
|
4957 |
{ |
4958 |
/* 32/64 bit address mode */
|
4959 |
int havedisp;
|
4960 |
int havesib;
|
4961 |
int havebase;
|
4962 |
int base;
|
4963 |
int index = 0; |
4964 |
int scale = 0; |
4965 |
|
4966 |
havesib = 0;
|
4967 |
havebase = 1;
|
4968 |
base = modrm.rm; |
4969 |
|
4970 |
if (base == 4) |
4971 |
{ |
4972 |
havesib = 1;
|
4973 |
FETCH_DATA (the_info, codep + 1);
|
4974 |
index = (*codep >> 3) & 7; |
4975 |
if (address_mode == mode_64bit || index != 0x4) |
4976 |
/* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */
|
4977 |
scale = (*codep >> 6) & 3; |
4978 |
base = *codep & 7;
|
4979 |
USED_REX (REX_X); |
4980 |
if (rex & REX_X)
|
4981 |
index += 8;
|
4982 |
codep++; |
4983 |
} |
4984 |
base += add; |
4985 |
|
4986 |
switch (modrm.mod)
|
4987 |
{ |
4988 |
case 0: |
4989 |
if ((base & 7) == 5) |
4990 |
{ |
4991 |
havebase = 0;
|
4992 |
if (address_mode == mode_64bit && !havesib)
|
4993 |
riprel = 1;
|
4994 |
disp = get32s (); |
4995 |
} |
4996 |
break;
|
4997 |
case 1: |
4998 |
FETCH_DATA (the_info, codep + 1);
|
4999 |
disp = *codep++; |
5000 |
if ((disp & 0x80) != 0) |
5001 |
disp -= 0x100;
|
5002 |
break;
|
5003 |
case 2: |
5004 |
disp = get32s (); |
5005 |
break;
|
5006 |
} |
5007 |
|
5008 |
havedisp = havebase || (havesib && (index != 4 || scale != 0)); |
5009 |
|
5010 |
if (!intel_syntax)
|
5011 |
if (modrm.mod != 0 || (base & 7) == 5) |
5012 |
{ |
5013 |
if (havedisp || riprel)
|
5014 |
print_displacement (scratchbuf, disp); |
5015 |
else
|
5016 |
print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp); |
5017 |
oappend (scratchbuf); |
5018 |
if (riprel)
|
5019 |
{ |
5020 |
set_op (disp, 1);
|
5021 |
oappend ("(%rip)");
|
5022 |
} |
5023 |
} |
5024 |
|
5025 |
if (havedisp || (intel_syntax && riprel))
|
5026 |
{ |
5027 |
*obufp++ = open_char; |
5028 |
if (intel_syntax && riprel)
|
5029 |
{ |
5030 |
set_op (disp, 1);
|
5031 |
oappend ("rip");
|
5032 |
} |
5033 |
*obufp = '\0';
|
5034 |
if (havebase)
|
5035 |
oappend (address_mode == mode_64bit && (sizeflag & AFLAG) |
5036 |
? names64[base] : names32[base]); |
5037 |
if (havesib)
|
5038 |
{ |
5039 |
if (index != 4) |
5040 |
{ |
5041 |
if (!intel_syntax || havebase)
|
5042 |
{ |
5043 |
*obufp++ = separator_char; |
5044 |
*obufp = '\0';
|
5045 |
} |
5046 |
oappend (address_mode == mode_64bit && (sizeflag & AFLAG) |
5047 |
? names64[index] : names32[index]); |
5048 |
} |
5049 |
if (scale != 0 || (!intel_syntax && index != 4)) |
5050 |
{ |
5051 |
*obufp++ = scale_char; |
5052 |
*obufp = '\0';
|
5053 |
snprintf (scratchbuf, sizeof(scratchbuf), "%d", 1 << scale); |
5054 |
oappend (scratchbuf); |
5055 |
} |
5056 |
} |
5057 |
if (intel_syntax
|
5058 |
&& (disp || modrm.mod != 0 || (base & 7) == 5)) |
5059 |
{ |
5060 |
if ((bfd_signed_vma) disp >= 0) |
5061 |
{ |
5062 |
*obufp++ = '+';
|
5063 |
*obufp = '\0';
|
5064 |
} |
5065 |
else if (modrm.mod != 1) |
5066 |
{ |
5067 |
*obufp++ = '-';
|
5068 |
*obufp = '\0';
|
5069 |
disp = - (bfd_signed_vma) disp; |
5070 |
} |
5071 |
|
5072 |
print_displacement (scratchbuf, disp); |
5073 |
oappend (scratchbuf); |
5074 |
} |
5075 |
|
5076 |
*obufp++ = close_char; |
5077 |
*obufp = '\0';
|
5078 |
} |
5079 |
else if (intel_syntax) |
5080 |
{ |
5081 |
if (modrm.mod != 0 || (base & 7) == 5) |
5082 |
{ |
5083 |
if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
|
5084 |
| PREFIX_ES | PREFIX_FS | PREFIX_GS)) |
5085 |
; |
5086 |
else
|
5087 |
{ |
5088 |
oappend (names_seg[ds_reg - es_reg]); |
5089 |
oappend (":");
|
5090 |
} |
5091 |
print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp); |
5092 |
oappend (scratchbuf); |
5093 |
} |
5094 |
} |
5095 |
} |
5096 |
else
|
5097 |
{ /* 16 bit address mode */
|
5098 |
switch (modrm.mod)
|
5099 |
{ |
5100 |
case 0: |
5101 |
if (modrm.rm == 6) |
5102 |
{ |
5103 |
disp = get16 (); |
5104 |
if ((disp & 0x8000) != 0) |
5105 |
disp -= 0x10000;
|
5106 |
} |
5107 |
break;
|
5108 |
case 1: |
5109 |
FETCH_DATA (the_info, codep + 1);
|
5110 |
disp = *codep++; |
5111 |
if ((disp & 0x80) != 0) |
5112 |
disp -= 0x100;
|
5113 |
break;
|
5114 |
case 2: |
5115 |
disp = get16 (); |
5116 |
if ((disp & 0x8000) != 0) |
5117 |
disp -= 0x10000;
|
5118 |
break;
|
5119 |
} |
5120 |
|
5121 |
if (!intel_syntax)
|
5122 |
if (modrm.mod != 0 || modrm.rm == 6) |
5123 |
{ |
5124 |
print_displacement (scratchbuf, disp); |
5125 |
oappend (scratchbuf); |
5126 |
} |
5127 |
|
5128 |
if (modrm.mod != 0 || modrm.rm != 6) |
5129 |
{ |
5130 |
*obufp++ = open_char; |
5131 |
*obufp = '\0';
|
5132 |
oappend (index16[modrm.rm]); |
5133 |
if (intel_syntax
|
5134 |
&& (disp || modrm.mod != 0 || modrm.rm == 6)) |
5135 |
{ |
5136 |
if ((bfd_signed_vma) disp >= 0) |
5137 |
{ |
5138 |
*obufp++ = '+';
|
5139 |
*obufp = '\0';
|
5140 |
} |
5141 |
else if (modrm.mod != 1) |
5142 |
{ |
5143 |
*obufp++ = '-';
|
5144 |
*obufp = '\0';
|
5145 |
disp = - (bfd_signed_vma) disp; |
5146 |
} |
5147 |
|
5148 |
print_displacement (scratchbuf, disp); |
5149 |
oappend (scratchbuf); |
5150 |
} |
5151 |
|
5152 |
*obufp++ = close_char; |
5153 |
*obufp = '\0';
|
5154 |
} |
5155 |
else if (intel_syntax) |
5156 |
{ |
5157 |
if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
|
5158 |
| PREFIX_ES | PREFIX_FS | PREFIX_GS)) |
5159 |
; |
5160 |
else
|
5161 |
{ |
5162 |
oappend (names_seg[ds_reg - es_reg]); |
5163 |
oappend (":");
|
5164 |
} |
5165 |
print_operand_value (scratchbuf, sizeof(scratchbuf), 1, |
5166 |
disp & 0xffff);
|
5167 |
oappend (scratchbuf); |
5168 |
} |
5169 |
} |
5170 |
} |
5171 |
|
5172 |
static void |
5173 |
OP_G (int bytemode, int sizeflag) |
5174 |
{ |
5175 |
int add = 0; |
5176 |
USED_REX (REX_R); |
5177 |
if (rex & REX_R)
|
5178 |
add += 8;
|
5179 |
switch (bytemode)
|
5180 |
{ |
5181 |
case b_mode:
|
5182 |
USED_REX (0);
|
5183 |
if (rex)
|
5184 |
oappend (names8rex[modrm.reg + add]); |
5185 |
else
|
5186 |
oappend (names8[modrm.reg + add]); |
5187 |
break;
|
5188 |
case w_mode:
|
5189 |
oappend (names16[modrm.reg + add]); |
5190 |
break;
|
5191 |
case d_mode:
|
5192 |
oappend (names32[modrm.reg + add]); |
5193 |
break;
|
5194 |
case q_mode:
|
5195 |
oappend (names64[modrm.reg + add]); |
5196 |
break;
|
5197 |
case v_mode:
|
5198 |
case dq_mode:
|
5199 |
case dqb_mode:
|
5200 |
case dqd_mode:
|
5201 |
case dqw_mode:
|
5202 |
USED_REX (REX_W); |
5203 |
if (rex & REX_W)
|
5204 |
oappend (names64[modrm.reg + add]); |
5205 |
else if ((sizeflag & DFLAG) || bytemode != v_mode) |
5206 |
oappend (names32[modrm.reg + add]); |
5207 |
else
|
5208 |
oappend (names16[modrm.reg + add]); |
5209 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5210 |
break;
|
5211 |
case m_mode:
|
5212 |
if (address_mode == mode_64bit)
|
5213 |
oappend (names64[modrm.reg + add]); |
5214 |
else
|
5215 |
oappend (names32[modrm.reg + add]); |
5216 |
break;
|
5217 |
default:
|
5218 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
5219 |
break;
|
5220 |
} |
5221 |
} |
5222 |
|
5223 |
static bfd_vma
|
5224 |
get64 (void)
|
5225 |
{ |
5226 |
bfd_vma x; |
5227 |
#ifdef BFD64
|
5228 |
unsigned int a; |
5229 |
unsigned int b; |
5230 |
|
5231 |
FETCH_DATA (the_info, codep + 8);
|
5232 |
a = *codep++ & 0xff;
|
5233 |
a |= (*codep++ & 0xff) << 8; |
5234 |
a |= (*codep++ & 0xff) << 16; |
5235 |
a |= (*codep++ & 0xff) << 24; |
5236 |
b = *codep++ & 0xff;
|
5237 |
b |= (*codep++ & 0xff) << 8; |
5238 |
b |= (*codep++ & 0xff) << 16; |
5239 |
b |= (*codep++ & 0xff) << 24; |
5240 |
x = a + ((bfd_vma) b << 32);
|
5241 |
#else
|
5242 |
abort (); |
5243 |
x = 0;
|
5244 |
#endif
|
5245 |
return x;
|
5246 |
} |
5247 |
|
5248 |
static bfd_signed_vma
|
5249 |
get32 (void)
|
5250 |
{ |
5251 |
bfd_signed_vma x = 0;
|
5252 |
|
5253 |
FETCH_DATA (the_info, codep + 4);
|
5254 |
x = *codep++ & (bfd_signed_vma) 0xff;
|
5255 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; |
5256 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; |
5257 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; |
5258 |
return x;
|
5259 |
} |
5260 |
|
5261 |
static bfd_signed_vma
|
5262 |
get32s (void)
|
5263 |
{ |
5264 |
bfd_signed_vma x = 0;
|
5265 |
|
5266 |
FETCH_DATA (the_info, codep + 4);
|
5267 |
x = *codep++ & (bfd_signed_vma) 0xff;
|
5268 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; |
5269 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; |
5270 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; |
5271 |
|
5272 |
x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31); |
5273 |
|
5274 |
return x;
|
5275 |
} |
5276 |
|
5277 |
static int |
5278 |
get16 (void)
|
5279 |
{ |
5280 |
int x = 0; |
5281 |
|
5282 |
FETCH_DATA (the_info, codep + 2);
|
5283 |
x = *codep++ & 0xff;
|
5284 |
x |= (*codep++ & 0xff) << 8; |
5285 |
return x;
|
5286 |
} |
5287 |
|
5288 |
static void |
5289 |
set_op (bfd_vma op, int riprel)
|
5290 |
{ |
5291 |
op_index[op_ad] = op_ad; |
5292 |
if (address_mode == mode_64bit)
|
5293 |
{ |
5294 |
op_address[op_ad] = op; |
5295 |
op_riprel[op_ad] = riprel; |
5296 |
} |
5297 |
else
|
5298 |
{ |
5299 |
/* Mask to get a 32-bit address. */
|
5300 |
op_address[op_ad] = op & 0xffffffff;
|
5301 |
op_riprel[op_ad] = riprel & 0xffffffff;
|
5302 |
} |
5303 |
} |
5304 |
|
5305 |
static void |
5306 |
OP_REG (int code, int sizeflag) |
5307 |
{ |
5308 |
const char *s; |
5309 |
int add = 0; |
5310 |
USED_REX (REX_B); |
5311 |
if (rex & REX_B)
|
5312 |
add = 8;
|
5313 |
|
5314 |
switch (code)
|
5315 |
{ |
5316 |
case ax_reg: case cx_reg: case dx_reg: case bx_reg: |
5317 |
case sp_reg: case bp_reg: case si_reg: case di_reg: |
5318 |
s = names16[code - ax_reg + add]; |
5319 |
break;
|
5320 |
case es_reg: case ss_reg: case cs_reg: |
5321 |
case ds_reg: case fs_reg: case gs_reg: |
5322 |
s = names_seg[code - es_reg + add]; |
5323 |
break;
|
5324 |
case al_reg: case ah_reg: case cl_reg: case ch_reg: |
5325 |
case dl_reg: case dh_reg: case bl_reg: case bh_reg: |
5326 |
USED_REX (0);
|
5327 |
if (rex)
|
5328 |
s = names8rex[code - al_reg + add]; |
5329 |
else
|
5330 |
s = names8[code - al_reg]; |
5331 |
break;
|
5332 |
case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: |
5333 |
case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: |
5334 |
if (address_mode == mode_64bit && (sizeflag & DFLAG))
|
5335 |
{ |
5336 |
s = names64[code - rAX_reg + add]; |
5337 |
break;
|
5338 |
} |
5339 |
code += eAX_reg - rAX_reg; |
5340 |
/* Fall through. */
|
5341 |
case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: |
5342 |
case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: |
5343 |
USED_REX (REX_W); |
5344 |
if (rex & REX_W)
|
5345 |
s = names64[code - eAX_reg + add]; |
5346 |
else if (sizeflag & DFLAG) |
5347 |
s = names32[code - eAX_reg + add]; |
5348 |
else
|
5349 |
s = names16[code - eAX_reg + add]; |
5350 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5351 |
break;
|
5352 |
default:
|
5353 |
s = INTERNAL_DISASSEMBLER_ERROR; |
5354 |
break;
|
5355 |
} |
5356 |
oappend (s); |
5357 |
} |
5358 |
|
5359 |
static void |
5360 |
OP_IMREG (int code, int sizeflag) |
5361 |
{ |
5362 |
const char *s; |
5363 |
|
5364 |
switch (code)
|
5365 |
{ |
5366 |
case indir_dx_reg:
|
5367 |
if (intel_syntax)
|
5368 |
s = "dx";
|
5369 |
else
|
5370 |
s = "(%dx)";
|
5371 |
break;
|
5372 |
case ax_reg: case cx_reg: case dx_reg: case bx_reg: |
5373 |
case sp_reg: case bp_reg: case si_reg: case di_reg: |
5374 |
s = names16[code - ax_reg]; |
5375 |
break;
|
5376 |
case es_reg: case ss_reg: case cs_reg: |
5377 |
case ds_reg: case fs_reg: case gs_reg: |
5378 |
s = names_seg[code - es_reg]; |
5379 |
break;
|
5380 |
case al_reg: case ah_reg: case cl_reg: case ch_reg: |
5381 |
case dl_reg: case dh_reg: case bl_reg: case bh_reg: |
5382 |
USED_REX (0);
|
5383 |
if (rex)
|
5384 |
s = names8rex[code - al_reg]; |
5385 |
else
|
5386 |
s = names8[code - al_reg]; |
5387 |
break;
|
5388 |
case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: |
5389 |
case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: |
5390 |
USED_REX (REX_W); |
5391 |
if (rex & REX_W)
|
5392 |
s = names64[code - eAX_reg]; |
5393 |
else if (sizeflag & DFLAG) |
5394 |
s = names32[code - eAX_reg]; |
5395 |
else
|
5396 |
s = names16[code - eAX_reg]; |
5397 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5398 |
break;
|
5399 |
case z_mode_ax_reg:
|
5400 |
if ((rex & REX_W) || (sizeflag & DFLAG))
|
5401 |
s = *names32; |
5402 |
else
|
5403 |
s = *names16; |
5404 |
if (!(rex & REX_W))
|
5405 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5406 |
break;
|
5407 |
default:
|
5408 |
s = INTERNAL_DISASSEMBLER_ERROR; |
5409 |
break;
|
5410 |
} |
5411 |
oappend (s); |
5412 |
} |
5413 |
|
5414 |
static void |
5415 |
OP_I (int bytemode, int sizeflag) |
5416 |
{ |
5417 |
bfd_signed_vma op; |
5418 |
bfd_signed_vma mask = -1;
|
5419 |
|
5420 |
switch (bytemode)
|
5421 |
{ |
5422 |
case b_mode:
|
5423 |
FETCH_DATA (the_info, codep + 1);
|
5424 |
op = *codep++; |
5425 |
mask = 0xff;
|
5426 |
break;
|
5427 |
case q_mode:
|
5428 |
if (address_mode == mode_64bit)
|
5429 |
{ |
5430 |
op = get32s (); |
5431 |
break;
|
5432 |
} |
5433 |
/* Fall through. */
|
5434 |
case v_mode:
|
5435 |
USED_REX (REX_W); |
5436 |
if (rex & REX_W)
|
5437 |
op = get32s (); |
5438 |
else if (sizeflag & DFLAG) |
5439 |
{ |
5440 |
op = get32 (); |
5441 |
mask = 0xffffffff;
|
5442 |
} |
5443 |
else
|
5444 |
{ |
5445 |
op = get16 (); |
5446 |
mask = 0xfffff;
|
5447 |
} |
5448 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5449 |
break;
|
5450 |
case w_mode:
|
5451 |
mask = 0xfffff;
|
5452 |
op = get16 (); |
5453 |
break;
|
5454 |
case const_1_mode:
|
5455 |
if (intel_syntax)
|
5456 |
oappend ("1");
|
5457 |
return;
|
5458 |
default:
|
5459 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
5460 |
return;
|
5461 |
} |
5462 |
|
5463 |
op &= mask; |
5464 |
scratchbuf[0] = '$'; |
5465 |
print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op); |
5466 |
oappend (scratchbuf + intel_syntax); |
5467 |
scratchbuf[0] = '\0'; |
5468 |
} |
5469 |
|
5470 |
static void |
5471 |
OP_I64 (int bytemode, int sizeflag) |
5472 |
{ |
5473 |
bfd_signed_vma op; |
5474 |
bfd_signed_vma mask = -1;
|
5475 |
|
5476 |
if (address_mode != mode_64bit)
|
5477 |
{ |
5478 |
OP_I (bytemode, sizeflag); |
5479 |
return;
|
5480 |
} |
5481 |
|
5482 |
switch (bytemode)
|
5483 |
{ |
5484 |
case b_mode:
|
5485 |
FETCH_DATA (the_info, codep + 1);
|
5486 |
op = *codep++; |
5487 |
mask = 0xff;
|
5488 |
break;
|
5489 |
case v_mode:
|
5490 |
USED_REX (REX_W); |
5491 |
if (rex & REX_W)
|
5492 |
op = get64 (); |
5493 |
else if (sizeflag & DFLAG) |
5494 |
{ |
5495 |
op = get32 (); |
5496 |
mask = 0xffffffff;
|
5497 |
} |
5498 |
else
|
5499 |
{ |
5500 |
op = get16 (); |
5501 |
mask = 0xfffff;
|
5502 |
} |
5503 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5504 |
break;
|
5505 |
case w_mode:
|
5506 |
mask = 0xfffff;
|
5507 |
op = get16 (); |
5508 |
break;
|
5509 |
default:
|
5510 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
5511 |
return;
|
5512 |
} |
5513 |
|
5514 |
op &= mask; |
5515 |
scratchbuf[0] = '$'; |
5516 |
print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op); |
5517 |
oappend (scratchbuf + intel_syntax); |
5518 |
scratchbuf[0] = '\0'; |
5519 |
} |
5520 |
|
5521 |
static void |
5522 |
OP_sI (int bytemode, int sizeflag) |
5523 |
{ |
5524 |
bfd_signed_vma op; |
5525 |
bfd_signed_vma mask = -1;
|
5526 |
|
5527 |
switch (bytemode)
|
5528 |
{ |
5529 |
case b_mode:
|
5530 |
FETCH_DATA (the_info, codep + 1);
|
5531 |
op = *codep++; |
5532 |
if ((op & 0x80) != 0) |
5533 |
op -= 0x100;
|
5534 |
mask = 0xffffffff;
|
5535 |
break;
|
5536 |
case v_mode:
|
5537 |
USED_REX (REX_W); |
5538 |
if (rex & REX_W)
|
5539 |
op = get32s (); |
5540 |
else if (sizeflag & DFLAG) |
5541 |
{ |
5542 |
op = get32s (); |
5543 |
mask = 0xffffffff;
|
5544 |
} |
5545 |
else
|
5546 |
{ |
5547 |
mask = 0xffffffff;
|
5548 |
op = get16 (); |
5549 |
if ((op & 0x8000) != 0) |
5550 |
op -= 0x10000;
|
5551 |
} |
5552 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5553 |
break;
|
5554 |
case w_mode:
|
5555 |
op = get16 (); |
5556 |
mask = 0xffffffff;
|
5557 |
if ((op & 0x8000) != 0) |
5558 |
op -= 0x10000;
|
5559 |
break;
|
5560 |
default:
|
5561 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
5562 |
return;
|
5563 |
} |
5564 |
|
5565 |
scratchbuf[0] = '$'; |
5566 |
print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op); |
5567 |
oappend (scratchbuf + intel_syntax); |
5568 |
} |
5569 |
|
5570 |
static void |
5571 |
OP_J (int bytemode, int sizeflag) |
5572 |
{ |
5573 |
bfd_vma disp; |
5574 |
bfd_vma mask = -1;
|
5575 |
bfd_vma segment = 0;
|
5576 |
|
5577 |
switch (bytemode)
|
5578 |
{ |
5579 |
case b_mode:
|
5580 |
FETCH_DATA (the_info, codep + 1);
|
5581 |
disp = *codep++; |
5582 |
if ((disp & 0x80) != 0) |
5583 |
disp -= 0x100;
|
5584 |
break;
|
5585 |
case v_mode:
|
5586 |
if ((sizeflag & DFLAG) || (rex & REX_W))
|
5587 |
disp = get32s (); |
5588 |
else
|
5589 |
{ |
5590 |
disp = get16 (); |
5591 |
if ((disp & 0x8000) != 0) |
5592 |
disp -= 0x10000;
|
5593 |
/* In 16bit mode, address is wrapped around at 64k within
|
5594 |
the same segment. Otherwise, a data16 prefix on a jump
|
5595 |
instruction means that the pc is masked to 16 bits after
|
5596 |
the displacement is added! */
|
5597 |
mask = 0xffff;
|
5598 |
if ((prefixes & PREFIX_DATA) == 0) |
5599 |
segment = ((start_pc + codep - start_codep) |
5600 |
& ~((bfd_vma) 0xffff));
|
5601 |
} |
5602 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5603 |
break;
|
5604 |
default:
|
5605 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
5606 |
return;
|
5607 |
} |
5608 |
disp = ((start_pc + codep - start_codep + disp) & mask) | segment; |
5609 |
set_op (disp, 0);
|
5610 |
print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp); |
5611 |
oappend (scratchbuf); |
5612 |
} |
5613 |
|
5614 |
static void |
5615 |
OP_SEG (int bytemode, int sizeflag) |
5616 |
{ |
5617 |
if (bytemode == w_mode)
|
5618 |
oappend (names_seg[modrm.reg]); |
5619 |
else
|
5620 |
OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
|
5621 |
} |
5622 |
|
5623 |
static void |
5624 |
OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag) |
5625 |
{ |
5626 |
int seg, offset;
|
5627 |
|
5628 |
if (sizeflag & DFLAG)
|
5629 |
{ |
5630 |
offset = get32 (); |
5631 |
seg = get16 (); |
5632 |
} |
5633 |
else
|
5634 |
{ |
5635 |
offset = get16 (); |
5636 |
seg = get16 (); |
5637 |
} |
5638 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5639 |
if (intel_syntax)
|
5640 |
snprintf (scratchbuf, sizeof(scratchbuf), "0x%x:0x%x", seg, offset); |
5641 |
else
|
5642 |
snprintf (scratchbuf, sizeof(scratchbuf), "$0x%x,$0x%x", seg, offset); |
5643 |
oappend (scratchbuf); |
5644 |
} |
5645 |
|
5646 |
static void |
5647 |
OP_OFF (int bytemode, int sizeflag) |
5648 |
{ |
5649 |
bfd_vma off; |
5650 |
|
5651 |
if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
|
5652 |
intel_operand_size (bytemode, sizeflag); |
5653 |
append_seg (); |
5654 |
|
5655 |
if ((sizeflag & AFLAG) || address_mode == mode_64bit)
|
5656 |
off = get32 (); |
5657 |
else
|
5658 |
off = get16 (); |
5659 |
|
5660 |
if (intel_syntax)
|
5661 |
{ |
5662 |
if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
|
5663 |
| PREFIX_ES | PREFIX_FS | PREFIX_GS))) |
5664 |
{ |
5665 |
oappend (names_seg[ds_reg - es_reg]); |
5666 |
oappend (":");
|
5667 |
} |
5668 |
} |
5669 |
print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off); |
5670 |
oappend (scratchbuf); |
5671 |
} |
5672 |
|
5673 |
static void |
5674 |
OP_OFF64 (int bytemode, int sizeflag) |
5675 |
{ |
5676 |
bfd_vma off; |
5677 |
|
5678 |
if (address_mode != mode_64bit
|
5679 |
|| (prefixes & PREFIX_ADDR)) |
5680 |
{ |
5681 |
OP_OFF (bytemode, sizeflag); |
5682 |
return;
|
5683 |
} |
5684 |
|
5685 |
if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
|
5686 |
intel_operand_size (bytemode, sizeflag); |
5687 |
append_seg (); |
5688 |
|
5689 |
off = get64 (); |
5690 |
|
5691 |
if (intel_syntax)
|
5692 |
{ |
5693 |
if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
|
5694 |
| PREFIX_ES | PREFIX_FS | PREFIX_GS))) |
5695 |
{ |
5696 |
oappend (names_seg[ds_reg - es_reg]); |
5697 |
oappend (":");
|
5698 |
} |
5699 |
} |
5700 |
print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off); |
5701 |
oappend (scratchbuf); |
5702 |
} |
5703 |
|
5704 |
static void |
5705 |
ptr_reg (int code, int sizeflag) |
5706 |
{ |
5707 |
const char *s; |
5708 |
|
5709 |
*obufp++ = open_char; |
5710 |
used_prefixes |= (prefixes & PREFIX_ADDR); |
5711 |
if (address_mode == mode_64bit)
|
5712 |
{ |
5713 |
if (!(sizeflag & AFLAG))
|
5714 |
s = names32[code - eAX_reg]; |
5715 |
else
|
5716 |
s = names64[code - eAX_reg]; |
5717 |
} |
5718 |
else if (sizeflag & AFLAG) |
5719 |
s = names32[code - eAX_reg]; |
5720 |
else
|
5721 |
s = names16[code - eAX_reg]; |
5722 |
oappend (s); |
5723 |
*obufp++ = close_char; |
5724 |
*obufp = 0;
|
5725 |
} |
5726 |
|
5727 |
static void |
5728 |
OP_ESreg (int code, int sizeflag) |
5729 |
{ |
5730 |
if (intel_syntax)
|
5731 |
{ |
5732 |
switch (codep[-1]) |
5733 |
{ |
5734 |
case 0x6d: /* insw/insl */ |
5735 |
intel_operand_size (z_mode, sizeflag); |
5736 |
break;
|
5737 |
case 0xa5: /* movsw/movsl/movsq */ |
5738 |
case 0xa7: /* cmpsw/cmpsl/cmpsq */ |
5739 |
case 0xab: /* stosw/stosl */ |
5740 |
case 0xaf: /* scasw/scasl */ |
5741 |
intel_operand_size (v_mode, sizeflag); |
5742 |
break;
|
5743 |
default:
|
5744 |
intel_operand_size (b_mode, sizeflag); |
5745 |
} |
5746 |
} |
5747 |
oappend ("%es:" + intel_syntax);
|
5748 |
ptr_reg (code, sizeflag); |
5749 |
} |
5750 |
|
5751 |
static void |
5752 |
OP_DSreg (int code, int sizeflag) |
5753 |
{ |
5754 |
if (intel_syntax)
|
5755 |
{ |
5756 |
switch (codep[-1]) |
5757 |
{ |
5758 |
case 0x6f: /* outsw/outsl */ |
5759 |
intel_operand_size (z_mode, sizeflag); |
5760 |
break;
|
5761 |
case 0xa5: /* movsw/movsl/movsq */ |
5762 |
case 0xa7: /* cmpsw/cmpsl/cmpsq */ |
5763 |
case 0xad: /* lodsw/lodsl/lodsq */ |
5764 |
intel_operand_size (v_mode, sizeflag); |
5765 |
break;
|
5766 |
default:
|
5767 |
intel_operand_size (b_mode, sizeflag); |
5768 |
} |
5769 |
} |
5770 |
if ((prefixes
|
5771 |
& (PREFIX_CS |
5772 |
| PREFIX_DS |
5773 |
| PREFIX_SS |
5774 |
| PREFIX_ES |
5775 |
| PREFIX_FS |
5776 |
| PREFIX_GS)) == 0)
|
5777 |
prefixes |= PREFIX_DS; |
5778 |
append_seg (); |
5779 |
ptr_reg (code, sizeflag); |
5780 |
} |
5781 |
|
5782 |
static void |
5783 |
OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
5784 |
{ |
5785 |
int add = 0; |
5786 |
if (rex & REX_R)
|
5787 |
{ |
5788 |
USED_REX (REX_R); |
5789 |
add = 8;
|
5790 |
} |
5791 |
else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK)) |
5792 |
{ |
5793 |
used_prefixes |= PREFIX_LOCK; |
5794 |
add = 8;
|
5795 |
} |
5796 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%cr%d", modrm.reg + add); |
5797 |
oappend (scratchbuf + intel_syntax); |
5798 |
} |
5799 |
|
5800 |
static void |
5801 |
OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
5802 |
{ |
5803 |
int add = 0; |
5804 |
USED_REX (REX_R); |
5805 |
if (rex & REX_R)
|
5806 |
add = 8;
|
5807 |
if (intel_syntax)
|
5808 |
snprintf (scratchbuf, sizeof(scratchbuf), "db%d", modrm.reg + add); |
5809 |
else
|
5810 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%db%d", modrm.reg + add); |
5811 |
oappend (scratchbuf); |
5812 |
} |
5813 |
|
5814 |
static void |
5815 |
OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
5816 |
{ |
5817 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%tr%d", modrm.reg); |
5818 |
oappend (scratchbuf + intel_syntax); |
5819 |
} |
5820 |
|
5821 |
static void |
5822 |
OP_R (int bytemode, int sizeflag) |
5823 |
{ |
5824 |
if (modrm.mod == 3) |
5825 |
OP_E (bytemode, sizeflag); |
5826 |
else
|
5827 |
BadOp (); |
5828 |
} |
5829 |
|
5830 |
static void |
5831 |
OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
5832 |
{ |
5833 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5834 |
if (prefixes & PREFIX_DATA)
|
5835 |
{ |
5836 |
int add = 0; |
5837 |
USED_REX (REX_R); |
5838 |
if (rex & REX_R)
|
5839 |
add = 8;
|
5840 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add); |
5841 |
} |
5842 |
else
|
5843 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg); |
5844 |
oappend (scratchbuf + intel_syntax); |
5845 |
} |
5846 |
|
5847 |
static void |
5848 |
OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
5849 |
{ |
5850 |
int add = 0; |
5851 |
USED_REX (REX_R); |
5852 |
if (rex & REX_R)
|
5853 |
add = 8;
|
5854 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add); |
5855 |
oappend (scratchbuf + intel_syntax); |
5856 |
} |
5857 |
|
5858 |
static void |
5859 |
OP_EM (int bytemode, int sizeflag) |
5860 |
{ |
5861 |
if (modrm.mod != 3) |
5862 |
{ |
5863 |
if (intel_syntax && bytemode == v_mode)
|
5864 |
{ |
5865 |
bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode; |
5866 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5867 |
} |
5868 |
OP_E (bytemode, sizeflag); |
5869 |
return;
|
5870 |
} |
5871 |
|
5872 |
/* Skip mod/rm byte. */
|
5873 |
MODRM_CHECK; |
5874 |
codep++; |
5875 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5876 |
if (prefixes & PREFIX_DATA)
|
5877 |
{ |
5878 |
int add = 0; |
5879 |
|
5880 |
USED_REX (REX_B); |
5881 |
if (rex & REX_B)
|
5882 |
add = 8;
|
5883 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add); |
5884 |
} |
5885 |
else
|
5886 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm); |
5887 |
oappend (scratchbuf + intel_syntax); |
5888 |
} |
5889 |
|
5890 |
/* cvt* are the only instructions in sse2 which have
|
5891 |
both SSE and MMX operands and also have 0x66 prefix
|
5892 |
in their opcode. 0x66 was originally used to differentiate
|
5893 |
between SSE and MMX instruction(operands). So we have to handle the
|
5894 |
cvt* separately using OP_EMC and OP_MXC */
|
5895 |
static void |
5896 |
OP_EMC (int bytemode, int sizeflag) |
5897 |
{ |
5898 |
if (modrm.mod != 3) |
5899 |
{ |
5900 |
if (intel_syntax && bytemode == v_mode)
|
5901 |
{ |
5902 |
bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode; |
5903 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5904 |
} |
5905 |
OP_E (bytemode, sizeflag); |
5906 |
return;
|
5907 |
} |
5908 |
|
5909 |
/* Skip mod/rm byte. */
|
5910 |
MODRM_CHECK; |
5911 |
codep++; |
5912 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5913 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm); |
5914 |
oappend (scratchbuf + intel_syntax); |
5915 |
} |
5916 |
|
5917 |
static void |
5918 |
OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
5919 |
{ |
5920 |
used_prefixes |= (prefixes & PREFIX_DATA); |
5921 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg); |
5922 |
oappend (scratchbuf + intel_syntax); |
5923 |
} |
5924 |
|
5925 |
static void |
5926 |
OP_EX (int bytemode, int sizeflag) |
5927 |
{ |
5928 |
int add = 0; |
5929 |
if (modrm.mod != 3) |
5930 |
{ |
5931 |
OP_E (bytemode, sizeflag); |
5932 |
return;
|
5933 |
} |
5934 |
USED_REX (REX_B); |
5935 |
if (rex & REX_B)
|
5936 |
add = 8;
|
5937 |
|
5938 |
/* Skip mod/rm byte. */
|
5939 |
MODRM_CHECK; |
5940 |
codep++; |
5941 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add); |
5942 |
oappend (scratchbuf + intel_syntax); |
5943 |
} |
5944 |
|
5945 |
static void |
5946 |
OP_MS (int bytemode, int sizeflag) |
5947 |
{ |
5948 |
if (modrm.mod == 3) |
5949 |
OP_EM (bytemode, sizeflag); |
5950 |
else
|
5951 |
BadOp (); |
5952 |
} |
5953 |
|
5954 |
static void |
5955 |
OP_XS (int bytemode, int sizeflag) |
5956 |
{ |
5957 |
if (modrm.mod == 3) |
5958 |
OP_EX (bytemode, sizeflag); |
5959 |
else
|
5960 |
BadOp (); |
5961 |
} |
5962 |
|
5963 |
static void |
5964 |
OP_M (int bytemode, int sizeflag) |
5965 |
{ |
5966 |
if (modrm.mod == 3) |
5967 |
/* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
|
5968 |
BadOp (); |
5969 |
else
|
5970 |
OP_E (bytemode, sizeflag); |
5971 |
} |
5972 |
|
5973 |
static void |
5974 |
OP_0f07 (int bytemode, int sizeflag) |
5975 |
{ |
5976 |
if (modrm.mod != 3 || modrm.rm != 0) |
5977 |
BadOp (); |
5978 |
else
|
5979 |
OP_E (bytemode, sizeflag); |
5980 |
} |
5981 |
|
5982 |
static void |
5983 |
OP_0fae (int bytemode, int sizeflag) |
5984 |
{ |
5985 |
if (modrm.mod == 3) |
5986 |
{ |
5987 |
if (modrm.reg == 7) |
5988 |
strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence"); |
5989 |
|
5990 |
if (modrm.reg < 5 || modrm.rm != 0) |
5991 |
{ |
5992 |
BadOp (); /* bad sfence, mfence, or lfence */
|
5993 |
return;
|
5994 |
} |
5995 |
} |
5996 |
else if (modrm.reg != 7) |
5997 |
{ |
5998 |
BadOp (); /* bad clflush */
|
5999 |
return;
|
6000 |
} |
6001 |
|
6002 |
OP_E (bytemode, sizeflag); |
6003 |
} |
6004 |
|
6005 |
/* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
|
6006 |
32bit mode and "xchg %rax,%rax" in 64bit mode. */
|
6007 |
|
6008 |
static void |
6009 |
NOP_Fixup1 (int bytemode, int sizeflag) |
6010 |
{ |
6011 |
if ((prefixes & PREFIX_DATA) != 0 |
6012 |
|| (rex != 0
|
6013 |
&& rex != 0x48
|
6014 |
&& address_mode == mode_64bit)) |
6015 |
OP_REG (bytemode, sizeflag); |
6016 |
else
|
6017 |
strcpy (obuf, "nop");
|
6018 |
} |
6019 |
|
6020 |
static void |
6021 |
NOP_Fixup2 (int bytemode, int sizeflag) |
6022 |
{ |
6023 |
if ((prefixes & PREFIX_DATA) != 0 |
6024 |
|| (rex != 0
|
6025 |
&& rex != 0x48
|
6026 |
&& address_mode == mode_64bit)) |
6027 |
OP_IMREG (bytemode, sizeflag); |
6028 |
} |
6029 |
|
6030 |
static const char *Suffix3DNow[] = { |
6031 |
/* 00 */ NULL, NULL, NULL, NULL, |
6032 |
/* 04 */ NULL, NULL, NULL, NULL, |
6033 |
/* 08 */ NULL, NULL, NULL, NULL, |
6034 |
/* 0C */ "pi2fw", "pi2fd", NULL, NULL, |
6035 |
/* 10 */ NULL, NULL, NULL, NULL, |
6036 |
/* 14 */ NULL, NULL, NULL, NULL, |
6037 |
/* 18 */ NULL, NULL, NULL, NULL, |
6038 |
/* 1C */ "pf2iw", "pf2id", NULL, NULL, |
6039 |
/* 20 */ NULL, NULL, NULL, NULL, |
6040 |
/* 24 */ NULL, NULL, NULL, NULL, |
6041 |
/* 28 */ NULL, NULL, NULL, NULL, |
6042 |
/* 2C */ NULL, NULL, NULL, NULL, |
6043 |
/* 30 */ NULL, NULL, NULL, NULL, |
6044 |
/* 34 */ NULL, NULL, NULL, NULL, |
6045 |
/* 38 */ NULL, NULL, NULL, NULL, |
6046 |
/* 3C */ NULL, NULL, NULL, NULL, |
6047 |
/* 40 */ NULL, NULL, NULL, NULL, |
6048 |
/* 44 */ NULL, NULL, NULL, NULL, |
6049 |
/* 48 */ NULL, NULL, NULL, NULL, |
6050 |
/* 4C */ NULL, NULL, NULL, NULL, |
6051 |
/* 50 */ NULL, NULL, NULL, NULL, |
6052 |
/* 54 */ NULL, NULL, NULL, NULL, |
6053 |
/* 58 */ NULL, NULL, NULL, NULL, |
6054 |
/* 5C */ NULL, NULL, NULL, NULL, |
6055 |
/* 60 */ NULL, NULL, NULL, NULL, |
6056 |
/* 64 */ NULL, NULL, NULL, NULL, |
6057 |
/* 68 */ NULL, NULL, NULL, NULL, |
6058 |
/* 6C */ NULL, NULL, NULL, NULL, |
6059 |
/* 70 */ NULL, NULL, NULL, NULL, |
6060 |
/* 74 */ NULL, NULL, NULL, NULL, |
6061 |
/* 78 */ NULL, NULL, NULL, NULL, |
6062 |
/* 7C */ NULL, NULL, NULL, NULL, |
6063 |
/* 80 */ NULL, NULL, NULL, NULL, |
6064 |
/* 84 */ NULL, NULL, NULL, NULL, |
6065 |
/* 88 */ NULL, NULL, "pfnacc", NULL, |
6066 |
/* 8C */ NULL, NULL, "pfpnacc", NULL, |
6067 |
/* 90 */ "pfcmpge", NULL, NULL, NULL, |
6068 |
/* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt", |
6069 |
/* 98 */ NULL, NULL, "pfsub", NULL, |
6070 |
/* 9C */ NULL, NULL, "pfadd", NULL, |
6071 |
/* A0 */ "pfcmpgt", NULL, NULL, NULL, |
6072 |
/* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1", |
6073 |
/* A8 */ NULL, NULL, "pfsubr", NULL, |
6074 |
/* AC */ NULL, NULL, "pfacc", NULL, |
6075 |
/* B0 */ "pfcmpeq", NULL, NULL, NULL, |
6076 |
/* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw", |
6077 |
/* B8 */ NULL, NULL, NULL, "pswapd", |
6078 |
/* BC */ NULL, NULL, NULL, "pavgusb", |
6079 |
/* C0 */ NULL, NULL, NULL, NULL, |
6080 |
/* C4 */ NULL, NULL, NULL, NULL, |
6081 |
/* C8 */ NULL, NULL, NULL, NULL, |
6082 |
/* CC */ NULL, NULL, NULL, NULL, |
6083 |
/* D0 */ NULL, NULL, NULL, NULL, |
6084 |
/* D4 */ NULL, NULL, NULL, NULL, |
6085 |
/* D8 */ NULL, NULL, NULL, NULL, |
6086 |
/* DC */ NULL, NULL, NULL, NULL, |
6087 |
/* E0 */ NULL, NULL, NULL, NULL, |
6088 |
/* E4 */ NULL, NULL, NULL, NULL, |
6089 |
/* E8 */ NULL, NULL, NULL, NULL, |
6090 |
/* EC */ NULL, NULL, NULL, NULL, |
6091 |
/* F0 */ NULL, NULL, NULL, NULL, |
6092 |
/* F4 */ NULL, NULL, NULL, NULL, |
6093 |
/* F8 */ NULL, NULL, NULL, NULL, |
6094 |
/* FC */ NULL, NULL, NULL, NULL, |
6095 |
}; |
6096 |
|
6097 |
static void |
6098 |
OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
6099 |
{ |
6100 |
const char *mnemonic; |
6101 |
|
6102 |
FETCH_DATA (the_info, codep + 1);
|
6103 |
/* AMD 3DNow! instructions are specified by an opcode suffix in the
|
6104 |
place where an 8-bit immediate would normally go. ie. the last
|
6105 |
byte of the instruction. */
|
6106 |
obufp = obuf + strlen (obuf); |
6107 |
mnemonic = Suffix3DNow[*codep++ & 0xff];
|
6108 |
if (mnemonic)
|
6109 |
oappend (mnemonic); |
6110 |
else
|
6111 |
{ |
6112 |
/* Since a variable sized modrm/sib chunk is between the start
|
6113 |
of the opcode (0x0f0f) and the opcode suffix, we need to do
|
6114 |
all the modrm processing first, and don't know until now that
|
6115 |
we have a bad opcode. This necessitates some cleaning up. */
|
6116 |
op_out[0][0] = '\0'; |
6117 |
op_out[1][0] = '\0'; |
6118 |
BadOp (); |
6119 |
} |
6120 |
} |
6121 |
|
6122 |
static const char *simd_cmp_op[] = { |
6123 |
"eq",
|
6124 |
"lt",
|
6125 |
"le",
|
6126 |
"unord",
|
6127 |
"neq",
|
6128 |
"nlt",
|
6129 |
"nle",
|
6130 |
"ord"
|
6131 |
}; |
6132 |
|
6133 |
static void |
6134 |
OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) |
6135 |
{ |
6136 |
unsigned int cmp_type; |
6137 |
|
6138 |
FETCH_DATA (the_info, codep + 1);
|
6139 |
obufp = obuf + strlen (obuf); |
6140 |
cmp_type = *codep++ & 0xff;
|
6141 |
if (cmp_type < 8) |
6142 |
{ |
6143 |
char suffix1 = 'p', suffix2 = 's'; |
6144 |
used_prefixes |= (prefixes & PREFIX_REPZ); |
6145 |
if (prefixes & PREFIX_REPZ)
|
6146 |
suffix1 = 's';
|
6147 |
else
|
6148 |
{ |
6149 |
used_prefixes |= (prefixes & PREFIX_DATA); |
6150 |
if (prefixes & PREFIX_DATA)
|
6151 |
suffix2 = 'd';
|
6152 |
else
|
6153 |
{ |
6154 |
used_prefixes |= (prefixes & PREFIX_REPNZ); |
6155 |
if (prefixes & PREFIX_REPNZ)
|
6156 |
suffix1 = 's', suffix2 = 'd'; |
6157 |
} |
6158 |
} |
6159 |
snprintf (scratchbuf, sizeof(scratchbuf), "cmp%s%c%c", |
6160 |
simd_cmp_op[cmp_type], suffix1, suffix2); |
6161 |
used_prefixes |= (prefixes & PREFIX_REPZ); |
6162 |
oappend (scratchbuf); |
6163 |
} |
6164 |
else
|
6165 |
{ |
6166 |
/* We have a bad extension byte. Clean up. */
|
6167 |
op_out[0][0] = '\0'; |
6168 |
op_out[1][0] = '\0'; |
6169 |
BadOp (); |
6170 |
} |
6171 |
} |
6172 |
|
6173 |
static void |
6174 |
SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED) |
6175 |
{ |
6176 |
/* Change movlps/movhps to movhlps/movlhps for 2 register operand
|
6177 |
forms of these instructions. */
|
6178 |
if (modrm.mod == 3) |
6179 |
{ |
6180 |
char *p = obuf + strlen (obuf);
|
6181 |
*(p + 1) = '\0'; |
6182 |
*p = *(p - 1);
|
6183 |
*(p - 1) = *(p - 2); |
6184 |
*(p - 2) = *(p - 3); |
6185 |
*(p - 3) = extrachar;
|
6186 |
} |
6187 |
} |
6188 |
|
6189 |
static void |
6190 |
PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) |
6191 |
{ |
6192 |
if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 1) |
6193 |
{ |
6194 |
/* Override "sidt". */
|
6195 |
size_t olen = strlen (obuf); |
6196 |
char *p = obuf + olen - 4; |
6197 |
const char * const *names = (address_mode == mode_64bit |
6198 |
? names64 : names32); |
6199 |
|
6200 |
/* We might have a suffix when disassembling with -Msuffix. */
|
6201 |
if (*p == 'i') |
6202 |
--p; |
6203 |
|
6204 |
/* Remove "addr16/addr32" if we aren't in Intel mode. */
|
6205 |
if (!intel_syntax
|
6206 |
&& (prefixes & PREFIX_ADDR) |
6207 |
&& olen >= (4 + 7) |
6208 |
&& *(p - 1) == ' ' |
6209 |
&& strncmp (p - 7, "addr", 4) == 0 |
6210 |
&& (strncmp (p - 3, "16", 2) == 0 |
6211 |
|| strncmp (p - 3, "32", 2) == 0)) |
6212 |
p -= 7;
|
6213 |
|
6214 |
if (modrm.rm)
|
6215 |
{ |
6216 |
/* mwait %eax,%ecx */
|
6217 |
strcpy (p, "mwait");
|
6218 |
if (!intel_syntax)
|
6219 |
strcpy (op_out[0], names[0]); |
6220 |
} |
6221 |
else
|
6222 |
{ |
6223 |
/* monitor %eax,%ecx,%edx" */
|
6224 |
strcpy (p, "monitor");
|
6225 |
if (!intel_syntax)
|
6226 |
{ |
6227 |
const char * const *op1_names; |
6228 |
if (!(prefixes & PREFIX_ADDR))
|
6229 |
op1_names = (address_mode == mode_16bit |
6230 |
? names16 : names); |
6231 |
else
|
6232 |
{ |
6233 |
op1_names = (address_mode != mode_32bit |
6234 |
? names32 : names16); |
6235 |
used_prefixes |= PREFIX_ADDR; |
6236 |
} |
6237 |
strcpy (op_out[0], op1_names[0]); |
6238 |
strcpy (op_out[2], names[2]); |
6239 |
} |
6240 |
} |
6241 |
if (!intel_syntax)
|
6242 |
{ |
6243 |
strcpy (op_out[1], names[1]); |
6244 |
two_source_ops = 1;
|
6245 |
} |
6246 |
|
6247 |
codep++; |
6248 |
} |
6249 |
else
|
6250 |
OP_M (0, sizeflag);
|
6251 |
} |
6252 |
|
6253 |
static void |
6254 |
SVME_Fixup (int bytemode, int sizeflag) |
6255 |
{ |
6256 |
const char *alt; |
6257 |
char *p;
|
6258 |
|
6259 |
switch (*codep)
|
6260 |
{ |
6261 |
case 0xd8: |
6262 |
alt = "vmrun";
|
6263 |
break;
|
6264 |
case 0xd9: |
6265 |
alt = "vmmcall";
|
6266 |
break;
|
6267 |
case 0xda: |
6268 |
alt = "vmload";
|
6269 |
break;
|
6270 |
case 0xdb: |
6271 |
alt = "vmsave";
|
6272 |
break;
|
6273 |
case 0xdc: |
6274 |
alt = "stgi";
|
6275 |
break;
|
6276 |
case 0xdd: |
6277 |
alt = "clgi";
|
6278 |
break;
|
6279 |
case 0xde: |
6280 |
alt = "skinit";
|
6281 |
break;
|
6282 |
case 0xdf: |
6283 |
alt = "invlpga";
|
6284 |
break;
|
6285 |
default:
|
6286 |
OP_M (bytemode, sizeflag); |
6287 |
return;
|
6288 |
} |
6289 |
/* Override "lidt". */
|
6290 |
p = obuf + strlen (obuf) - 4;
|
6291 |
/* We might have a suffix. */
|
6292 |
if (*p == 'i') |
6293 |
--p; |
6294 |
strcpy (p, alt); |
6295 |
if (!(prefixes & PREFIX_ADDR))
|
6296 |
{ |
6297 |
++codep; |
6298 |
return;
|
6299 |
} |
6300 |
used_prefixes |= PREFIX_ADDR; |
6301 |
switch (*codep++)
|
6302 |
{ |
6303 |
case 0xdf: |
6304 |
strcpy (op_out[1], names32[1]); |
6305 |
two_source_ops = 1;
|
6306 |
/* Fall through. */
|
6307 |
case 0xd8: |
6308 |
case 0xda: |
6309 |
case 0xdb: |
6310 |
*obufp++ = open_char; |
6311 |
if (address_mode == mode_64bit || (sizeflag & AFLAG))
|
6312 |
alt = names32[0];
|
6313 |
else
|
6314 |
alt = names16[0];
|
6315 |
strcpy (obufp, alt); |
6316 |
obufp += strlen (alt); |
6317 |
*obufp++ = close_char; |
6318 |
*obufp = '\0';
|
6319 |
break;
|
6320 |
} |
6321 |
} |
6322 |
|
6323 |
static void |
6324 |
INVLPG_Fixup (int bytemode, int sizeflag) |
6325 |
{ |
6326 |
const char *alt; |
6327 |
|
6328 |
switch (*codep)
|
6329 |
{ |
6330 |
case 0xf8: |
6331 |
alt = "swapgs";
|
6332 |
break;
|
6333 |
case 0xf9: |
6334 |
alt = "rdtscp";
|
6335 |
break;
|
6336 |
default:
|
6337 |
OP_M (bytemode, sizeflag); |
6338 |
return;
|
6339 |
} |
6340 |
/* Override "invlpg". */
|
6341 |
strcpy (obuf + strlen (obuf) - 6, alt);
|
6342 |
codep++; |
6343 |
} |
6344 |
|
6345 |
static void |
6346 |
BadOp (void)
|
6347 |
{ |
6348 |
/* Throw away prefixes and 1st. opcode byte. */
|
6349 |
codep = insn_codep + 1;
|
6350 |
oappend ("(bad)");
|
6351 |
} |
6352 |
|
6353 |
static void |
6354 |
VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) |
6355 |
{ |
6356 |
if (modrm.mod == 3 |
6357 |
&& modrm.reg == 0
|
6358 |
&& modrm.rm >=1
|
6359 |
&& modrm.rm <= 4)
|
6360 |
{ |
6361 |
/* Override "sgdt". */
|
6362 |
char *p = obuf + strlen (obuf) - 4; |
6363 |
|
6364 |
/* We might have a suffix when disassembling with -Msuffix. */
|
6365 |
if (*p == 'g') |
6366 |
--p; |
6367 |
|
6368 |
switch (modrm.rm)
|
6369 |
{ |
6370 |
case 1: |
6371 |
strcpy (p, "vmcall");
|
6372 |
break;
|
6373 |
case 2: |
6374 |
strcpy (p, "vmlaunch");
|
6375 |
break;
|
6376 |
case 3: |
6377 |
strcpy (p, "vmresume");
|
6378 |
break;
|
6379 |
case 4: |
6380 |
strcpy (p, "vmxoff");
|
6381 |
break;
|
6382 |
} |
6383 |
|
6384 |
codep++; |
6385 |
} |
6386 |
else
|
6387 |
OP_E (0, sizeflag);
|
6388 |
} |
6389 |
|
6390 |
static void |
6391 |
OP_VMX (int bytemode, int sizeflag) |
6392 |
{ |
6393 |
used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ)); |
6394 |
if (prefixes & PREFIX_DATA)
|
6395 |
strcpy (obuf, "vmclear");
|
6396 |
else if (prefixes & PREFIX_REPZ) |
6397 |
strcpy (obuf, "vmxon");
|
6398 |
else
|
6399 |
strcpy (obuf, "vmptrld");
|
6400 |
OP_E (bytemode, sizeflag); |
6401 |
} |
6402 |
|
6403 |
static void |
6404 |
REP_Fixup (int bytemode, int sizeflag) |
6405 |
{ |
6406 |
/* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
|
6407 |
lods and stos. */
|
6408 |
size_t ilen = 0;
|
6409 |
|
6410 |
if (prefixes & PREFIX_REPZ)
|
6411 |
switch (*insn_codep)
|
6412 |
{ |
6413 |
case 0x6e: /* outsb */ |
6414 |
case 0x6f: /* outsw/outsl */ |
6415 |
case 0xa4: /* movsb */ |
6416 |
case 0xa5: /* movsw/movsl/movsq */ |
6417 |
if (!intel_syntax)
|
6418 |
ilen = 5;
|
6419 |
else
|
6420 |
ilen = 4;
|
6421 |
break;
|
6422 |
case 0xaa: /* stosb */ |
6423 |
case 0xab: /* stosw/stosl/stosq */ |
6424 |
case 0xac: /* lodsb */ |
6425 |
case 0xad: /* lodsw/lodsl/lodsq */ |
6426 |
if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
|
6427 |
ilen = 5;
|
6428 |
else
|
6429 |
ilen = 4;
|
6430 |
break;
|
6431 |
case 0x6c: /* insb */ |
6432 |
case 0x6d: /* insl/insw */ |
6433 |
if (!intel_syntax)
|
6434 |
ilen = 4;
|
6435 |
else
|
6436 |
ilen = 3;
|
6437 |
break;
|
6438 |
default:
|
6439 |
abort (); |
6440 |
break;
|
6441 |
} |
6442 |
|
6443 |
if (ilen != 0) |
6444 |
{ |
6445 |
size_t olen; |
6446 |
char *p;
|
6447 |
|
6448 |
olen = strlen (obuf); |
6449 |
p = obuf + olen - ilen - 1 - 4; |
6450 |
/* Handle "repz [addr16|addr32]". */
|
6451 |
if ((prefixes & PREFIX_ADDR))
|
6452 |
p -= 1 + 6; |
6453 |
|
6454 |
memmove (p + 3, p + 4, olen - (p + 3 - obuf)); |
6455 |
} |
6456 |
|
6457 |
switch (bytemode)
|
6458 |
{ |
6459 |
case al_reg:
|
6460 |
case eAX_reg:
|
6461 |
case indir_dx_reg:
|
6462 |
OP_IMREG (bytemode, sizeflag); |
6463 |
break;
|
6464 |
case eDI_reg:
|
6465 |
OP_ESreg (bytemode, sizeflag); |
6466 |
break;
|
6467 |
case eSI_reg:
|
6468 |
OP_DSreg (bytemode, sizeflag); |
6469 |
break;
|
6470 |
default:
|
6471 |
abort (); |
6472 |
break;
|
6473 |
} |
6474 |
} |
6475 |
|
6476 |
static void |
6477 |
CMPXCHG8B_Fixup (int bytemode, int sizeflag) |
6478 |
{ |
6479 |
USED_REX (REX_W); |
6480 |
if (rex & REX_W)
|
6481 |
{ |
6482 |
/* Change cmpxchg8b to cmpxchg16b. */
|
6483 |
char *p = obuf + strlen (obuf) - 2; |
6484 |
strcpy (p, "16b");
|
6485 |
bytemode = o_mode; |
6486 |
} |
6487 |
OP_M (bytemode, sizeflag); |
6488 |
} |
6489 |
|
6490 |
static void |
6491 |
XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED) |
6492 |
{ |
6493 |
snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", reg); |
6494 |
oappend (scratchbuf + intel_syntax); |
6495 |
} |
6496 |
|
6497 |
static void |
6498 |
CRC32_Fixup (int bytemode, int sizeflag) |
6499 |
{ |
6500 |
/* Add proper suffix to "crc32". */
|
6501 |
char *p = obuf + strlen (obuf);
|
6502 |
|
6503 |
switch (bytemode)
|
6504 |
{ |
6505 |
case b_mode:
|
6506 |
if (intel_syntax)
|
6507 |
break;
|
6508 |
|
6509 |
*p++ = 'b';
|
6510 |
break;
|
6511 |
case v_mode:
|
6512 |
if (intel_syntax)
|
6513 |
break;
|
6514 |
|
6515 |
USED_REX (REX_W); |
6516 |
if (rex & REX_W)
|
6517 |
*p++ = 'q';
|
6518 |
else if (sizeflag & DFLAG) |
6519 |
*p++ = 'l';
|
6520 |
else
|
6521 |
*p++ = 'w';
|
6522 |
used_prefixes |= (prefixes & PREFIX_DATA); |
6523 |
break;
|
6524 |
default:
|
6525 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
6526 |
break;
|
6527 |
} |
6528 |
*p = '\0';
|
6529 |
|
6530 |
if (modrm.mod == 3) |
6531 |
{ |
6532 |
int add;
|
6533 |
|
6534 |
/* Skip mod/rm byte. */
|
6535 |
MODRM_CHECK; |
6536 |
codep++; |
6537 |
|
6538 |
USED_REX (REX_B); |
6539 |
add = (rex & REX_B) ? 8 : 0; |
6540 |
if (bytemode == b_mode)
|
6541 |
{ |
6542 |
USED_REX (0);
|
6543 |
if (rex)
|
6544 |
oappend (names8rex[modrm.rm + add]); |
6545 |
else
|
6546 |
oappend (names8[modrm.rm + add]); |
6547 |
} |
6548 |
else
|
6549 |
{ |
6550 |
USED_REX (REX_W); |
6551 |
if (rex & REX_W)
|
6552 |
oappend (names64[modrm.rm + add]); |
6553 |
else if ((prefixes & PREFIX_DATA)) |
6554 |
oappend (names16[modrm.rm + add]); |
6555 |
else
|
6556 |
oappend (names32[modrm.rm + add]); |
6557 |
} |
6558 |
} |
6559 |
else
|
6560 |
OP_E (bytemode, sizeflag); |
6561 |
} |