projects / deliverable / binutils-gdb.git / blob
? search:


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