root / i386-dis.c @ 5439779e
History | View | Annotate | Download (96.6 kB)
1 |
/* Print i386 instructions for GDB, the GNU debugger.
|
---|---|
2 |
Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
3 |
2001
|
4 |
Free Software Foundation, Inc.
|
5 |
|
6 |
This file is part of GDB.
|
7 |
|
8 |
This program is free software; you can redistribute it and/or modify
|
9 |
it under the terms of the GNU General Public License as published by
|
10 |
the Free Software Foundation; either version 2 of the License, or
|
11 |
(at your option) any later version.
|
12 |
|
13 |
This program is distributed in the hope that it will be useful,
|
14 |
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
16 |
GNU General Public License for more details.
|
17 |
|
18 |
You should have received a copy of the GNU General Public License
|
19 |
along with this program; if not, write to the Free Software
|
20 |
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 |
*/
|
28 |
|
29 |
/*
|
30 |
* The main tables describing the instructions is essentially a copy
|
31 |
* of the "Opcode Map" chapter (Appendix A) of the Intel 80386
|
32 |
* Programmers Manual. Usually, there is a capital letter, followed
|
33 |
* by a small letter. The capital letter tell the addressing mode,
|
34 |
* and the small letter tells about the operand size. Refer to
|
35 |
* the Intel manual for details.
|
36 |
*/
|
37 |
|
38 |
#include <stdlib.h> |
39 |
#include "dis-asm.h" |
40 |
|
41 |
#define MAXLEN 20 |
42 |
|
43 |
#include <setjmp.h> |
44 |
|
45 |
#ifndef UNIXWARE_COMPAT
|
46 |
/* Set non-zero for broken, compatible instructions. Set to zero for
|
47 |
non-broken opcodes. */
|
48 |
#define UNIXWARE_COMPAT 1 |
49 |
#endif
|
50 |
|
51 |
static int fetch_data PARAMS ((struct disassemble_info *, bfd_byte *)); |
52 |
static void ckprefix PARAMS ((void)); |
53 |
static const char *prefix_name PARAMS ((int, int)); |
54 |
static int print_insn PARAMS ((bfd_vma, disassemble_info *)); |
55 |
static void dofloat PARAMS ((int)); |
56 |
static void OP_ST PARAMS ((int, int)); |
57 |
static void OP_STi PARAMS ((int, int)); |
58 |
static int putop PARAMS ((const char *, int)); |
59 |
static void oappend PARAMS ((const char *)); |
60 |
static void append_seg PARAMS ((void)); |
61 |
static void OP_indirE PARAMS ((int, int)); |
62 |
static void print_operand_value PARAMS ((char *, int, bfd_vma)); |
63 |
static void OP_E PARAMS ((int, int)); |
64 |
static void OP_G PARAMS ((int, int)); |
65 |
static bfd_vma get64 PARAMS ((void)); |
66 |
static bfd_signed_vma get32 PARAMS ((void)); |
67 |
static bfd_signed_vma get32s PARAMS ((void)); |
68 |
static int get16 PARAMS ((void)); |
69 |
static void set_op PARAMS ((bfd_vma, int)); |
70 |
static void OP_REG PARAMS ((int, int)); |
71 |
static void OP_IMREG PARAMS ((int, int)); |
72 |
static void OP_I PARAMS ((int, int)); |
73 |
static void OP_I64 PARAMS ((int, int)); |
74 |
static void OP_sI PARAMS ((int, int)); |
75 |
static void OP_J PARAMS ((int, int)); |
76 |
static void OP_SEG PARAMS ((int, int)); |
77 |
static void OP_DIR PARAMS ((int, int)); |
78 |
static void OP_OFF PARAMS ((int, int)); |
79 |
static void OP_OFF64 PARAMS ((int, int)); |
80 |
static void ptr_reg PARAMS ((int, int)); |
81 |
static void OP_ESreg PARAMS ((int, int)); |
82 |
static void OP_DSreg PARAMS ((int, int)); |
83 |
static void OP_C PARAMS ((int, int)); |
84 |
static void OP_D PARAMS ((int, int)); |
85 |
static void OP_T PARAMS ((int, int)); |
86 |
static void OP_Rd PARAMS ((int, int)); |
87 |
static void OP_MMX PARAMS ((int, int)); |
88 |
static void OP_XMM PARAMS ((int, int)); |
89 |
static void OP_EM PARAMS ((int, int)); |
90 |
static void OP_EX PARAMS ((int, int)); |
91 |
static void OP_MS PARAMS ((int, int)); |
92 |
static void OP_XS PARAMS ((int, int)); |
93 |
static void OP_3DNowSuffix PARAMS ((int, int)); |
94 |
static void OP_SIMD_Suffix PARAMS ((int, int)); |
95 |
static void SIMD_Fixup PARAMS ((int, int)); |
96 |
static void BadOp PARAMS ((void)); |
97 |
|
98 |
struct dis_private {
|
99 |
/* Points to first byte not fetched. */
|
100 |
bfd_byte *max_fetched; |
101 |
bfd_byte the_buffer[MAXLEN]; |
102 |
bfd_vma insn_start; |
103 |
int orig_sizeflag;
|
104 |
jmp_buf bailout; |
105 |
}; |
106 |
|
107 |
/* The opcode for the fwait instruction, which we treat as a prefix
|
108 |
when we can. */
|
109 |
#define FWAIT_OPCODE (0x9b) |
110 |
|
111 |
/* Set to 1 for 64bit mode disassembly. */
|
112 |
static int mode_64bit; |
113 |
|
114 |
/* Flags for the prefixes for the current instruction. See below. */
|
115 |
static int prefixes; |
116 |
|
117 |
/* REX prefix the current instruction. See below. */
|
118 |
static int rex; |
119 |
/* Bits of REX we've already used. */
|
120 |
static int rex_used; |
121 |
#define REX_MODE64 8 |
122 |
#define REX_EXTX 4 |
123 |
#define REX_EXTY 2 |
124 |
#define REX_EXTZ 1 |
125 |
/* Mark parts used in the REX prefix. When we are testing for
|
126 |
empty prefix (for 8bit register REX extension), just mask it
|
127 |
out. Otherwise test for REX bit is excuse for existence of REX
|
128 |
only in case value is nonzero. */
|
129 |
#define USED_REX(value) \
|
130 |
{ \ |
131 |
if (value) \
|
132 |
rex_used |= (rex & value) ? (value) | 0x40 : 0; \ |
133 |
else \
|
134 |
rex_used |= 0x40; \
|
135 |
} |
136 |
|
137 |
/* Flags for prefixes which we somehow handled when printing the
|
138 |
current instruction. */
|
139 |
static int used_prefixes; |
140 |
|
141 |
/* Flags stored in PREFIXES. */
|
142 |
#define PREFIX_REPZ 1 |
143 |
#define PREFIX_REPNZ 2 |
144 |
#define PREFIX_LOCK 4 |
145 |
#define PREFIX_CS 8 |
146 |
#define PREFIX_SS 0x10 |
147 |
#define PREFIX_DS 0x20 |
148 |
#define PREFIX_ES 0x40 |
149 |
#define PREFIX_FS 0x80 |
150 |
#define PREFIX_GS 0x100 |
151 |
#define PREFIX_DATA 0x200 |
152 |
#define PREFIX_ADDR 0x400 |
153 |
#define PREFIX_FWAIT 0x800 |
154 |
|
155 |
/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
|
156 |
to ADDR (exclusive) are valid. Returns 1 for success, longjmps
|
157 |
on error. */
|
158 |
#define FETCH_DATA(info, addr) \
|
159 |
((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
|
160 |
? 1 : fetch_data ((info), (addr)))
|
161 |
|
162 |
static int |
163 |
fetch_data (info, addr) |
164 |
struct disassemble_info *info;
|
165 |
bfd_byte *addr; |
166 |
{ |
167 |
int status;
|
168 |
struct dis_private *priv = (struct dis_private *) info->private_data; |
169 |
bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); |
170 |
|
171 |
status = (*info->read_memory_func) (start, |
172 |
priv->max_fetched, |
173 |
addr - priv->max_fetched, |
174 |
info); |
175 |
if (status != 0) |
176 |
{ |
177 |
/* If we did manage to read at least one byte, then
|
178 |
print_insn_i386 will do something sensible. Otherwise, print
|
179 |
an error. We do that here because this is where we know
|
180 |
STATUS. */
|
181 |
if (priv->max_fetched == priv->the_buffer)
|
182 |
(*info->memory_error_func) (status, start, info); |
183 |
longjmp (priv->bailout, 1);
|
184 |
} |
185 |
else
|
186 |
priv->max_fetched = addr; |
187 |
return 1; |
188 |
} |
189 |
|
190 |
#define XX NULL, 0 |
191 |
|
192 |
#define Eb OP_E, b_mode
|
193 |
#define Ev OP_E, v_mode
|
194 |
#define Ed OP_E, d_mode
|
195 |
#define indirEb OP_indirE, b_mode
|
196 |
#define indirEv OP_indirE, v_mode
|
197 |
#define Ew OP_E, w_mode
|
198 |
#define Ma OP_E, v_mode
|
199 |
#define M OP_E, 0 /* lea, lgdt, etc. */ |
200 |
#define Mp OP_E, 0 /* 32 or 48 bit memory operand for LDS, LES etc */ |
201 |
#define Gb OP_G, b_mode
|
202 |
#define Gv OP_G, v_mode
|
203 |
#define Gd OP_G, d_mode
|
204 |
#define Gw OP_G, w_mode
|
205 |
#define Rd OP_Rd, d_mode
|
206 |
#define Rm OP_Rd, m_mode
|
207 |
#define Ib OP_I, b_mode
|
208 |
#define sIb OP_sI, b_mode /* sign extened byte */ |
209 |
#define Iv OP_I, v_mode
|
210 |
#define Iq OP_I, q_mode
|
211 |
#define Iv64 OP_I64, v_mode
|
212 |
#define Iw OP_I, w_mode
|
213 |
#define Jb OP_J, b_mode
|
214 |
#define Jv OP_J, v_mode
|
215 |
#define Cm OP_C, m_mode
|
216 |
#define Dm OP_D, m_mode
|
217 |
#define Td OP_T, d_mode
|
218 |
|
219 |
#define RMeAX OP_REG, eAX_reg
|
220 |
#define RMeBX OP_REG, eBX_reg
|
221 |
#define RMeCX OP_REG, eCX_reg
|
222 |
#define RMeDX OP_REG, eDX_reg
|
223 |
#define RMeSP OP_REG, eSP_reg
|
224 |
#define RMeBP OP_REG, eBP_reg
|
225 |
#define RMeSI OP_REG, eSI_reg
|
226 |
#define RMeDI OP_REG, eDI_reg
|
227 |
#define RMrAX OP_REG, rAX_reg
|
228 |
#define RMrBX OP_REG, rBX_reg
|
229 |
#define RMrCX OP_REG, rCX_reg
|
230 |
#define RMrDX OP_REG, rDX_reg
|
231 |
#define RMrSP OP_REG, rSP_reg
|
232 |
#define RMrBP OP_REG, rBP_reg
|
233 |
#define RMrSI OP_REG, rSI_reg
|
234 |
#define RMrDI OP_REG, rDI_reg
|
235 |
#define RMAL OP_REG, al_reg
|
236 |
#define RMAL OP_REG, al_reg
|
237 |
#define RMCL OP_REG, cl_reg
|
238 |
#define RMDL OP_REG, dl_reg
|
239 |
#define RMBL OP_REG, bl_reg
|
240 |
#define RMAH OP_REG, ah_reg
|
241 |
#define RMCH OP_REG, ch_reg
|
242 |
#define RMDH OP_REG, dh_reg
|
243 |
#define RMBH OP_REG, bh_reg
|
244 |
#define RMAX OP_REG, ax_reg
|
245 |
#define RMDX OP_REG, dx_reg
|
246 |
|
247 |
#define eAX OP_IMREG, eAX_reg
|
248 |
#define eBX OP_IMREG, eBX_reg
|
249 |
#define eCX OP_IMREG, eCX_reg
|
250 |
#define eDX OP_IMREG, eDX_reg
|
251 |
#define eSP OP_IMREG, eSP_reg
|
252 |
#define eBP OP_IMREG, eBP_reg
|
253 |
#define eSI OP_IMREG, eSI_reg
|
254 |
#define eDI OP_IMREG, eDI_reg
|
255 |
#define AL OP_IMREG, al_reg
|
256 |
#define AL OP_IMREG, al_reg
|
257 |
#define CL OP_IMREG, cl_reg
|
258 |
#define DL OP_IMREG, dl_reg
|
259 |
#define BL OP_IMREG, bl_reg
|
260 |
#define AH OP_IMREG, ah_reg
|
261 |
#define CH OP_IMREG, ch_reg
|
262 |
#define DH OP_IMREG, dh_reg
|
263 |
#define BH OP_IMREG, bh_reg
|
264 |
#define AX OP_IMREG, ax_reg
|
265 |
#define DX OP_IMREG, dx_reg
|
266 |
#define indirDX OP_IMREG, indir_dx_reg
|
267 |
|
268 |
#define Sw OP_SEG, w_mode
|
269 |
#define Ap OP_DIR, 0 |
270 |
#define Ob OP_OFF, b_mode
|
271 |
#define Ob64 OP_OFF64, b_mode
|
272 |
#define Ov OP_OFF, v_mode
|
273 |
#define Ov64 OP_OFF64, v_mode
|
274 |
#define Xb OP_DSreg, eSI_reg
|
275 |
#define Xv OP_DSreg, eSI_reg
|
276 |
#define Yb OP_ESreg, eDI_reg
|
277 |
#define Yv OP_ESreg, eDI_reg
|
278 |
#define DSBX OP_DSreg, eBX_reg
|
279 |
|
280 |
#define es OP_REG, es_reg
|
281 |
#define ss OP_REG, ss_reg
|
282 |
#define cs OP_REG, cs_reg
|
283 |
#define ds OP_REG, ds_reg
|
284 |
#define fs OP_REG, fs_reg
|
285 |
#define gs OP_REG, gs_reg
|
286 |
|
287 |
#define MX OP_MMX, 0 |
288 |
#define XM OP_XMM, 0 |
289 |
#define EM OP_EM, v_mode
|
290 |
#define EX OP_EX, v_mode
|
291 |
#define MS OP_MS, v_mode
|
292 |
#define XS OP_XS, v_mode
|
293 |
#define None OP_E, 0 |
294 |
#define OPSUF OP_3DNowSuffix, 0 |
295 |
#define OPSIMD OP_SIMD_Suffix, 0 |
296 |
|
297 |
#define cond_jump_flag NULL, cond_jump_mode |
298 |
#define loop_jcxz_flag NULL, loop_jcxz_mode |
299 |
|
300 |
/* bits in sizeflag */
|
301 |
#define SUFFIX_ALWAYS 4 |
302 |
#define AFLAG 2 |
303 |
#define DFLAG 1 |
304 |
|
305 |
#define b_mode 1 /* byte operand */ |
306 |
#define v_mode 2 /* operand size depends on prefixes */ |
307 |
#define w_mode 3 /* word operand */ |
308 |
#define d_mode 4 /* double word operand */ |
309 |
#define q_mode 5 /* quad word operand */ |
310 |
#define x_mode 6 |
311 |
#define m_mode 7 /* d_mode in 32bit, q_mode in 64bit mode. */ |
312 |
#define cond_jump_mode 8 |
313 |
#define loop_jcxz_mode 9 |
314 |
|
315 |
#define es_reg 100 |
316 |
#define cs_reg 101 |
317 |
#define ss_reg 102 |
318 |
#define ds_reg 103 |
319 |
#define fs_reg 104 |
320 |
#define gs_reg 105 |
321 |
|
322 |
#define eAX_reg 108 |
323 |
#define eCX_reg 109 |
324 |
#define eDX_reg 110 |
325 |
#define eBX_reg 111 |
326 |
#define eSP_reg 112 |
327 |
#define eBP_reg 113 |
328 |
#define eSI_reg 114 |
329 |
#define eDI_reg 115 |
330 |
|
331 |
#define al_reg 116 |
332 |
#define cl_reg 117 |
333 |
#define dl_reg 118 |
334 |
#define bl_reg 119 |
335 |
#define ah_reg 120 |
336 |
#define ch_reg 121 |
337 |
#define dh_reg 122 |
338 |
#define bh_reg 123 |
339 |
|
340 |
#define ax_reg 124 |
341 |
#define cx_reg 125 |
342 |
#define dx_reg 126 |
343 |
#define bx_reg 127 |
344 |
#define sp_reg 128 |
345 |
#define bp_reg 129 |
346 |
#define si_reg 130 |
347 |
#define di_reg 131 |
348 |
|
349 |
#define rAX_reg 132 |
350 |
#define rCX_reg 133 |
351 |
#define rDX_reg 134 |
352 |
#define rBX_reg 135 |
353 |
#define rSP_reg 136 |
354 |
#define rBP_reg 137 |
355 |
#define rSI_reg 138 |
356 |
#define rDI_reg 139 |
357 |
|
358 |
#define indir_dx_reg 150 |
359 |
|
360 |
#define FLOATCODE 1 |
361 |
#define USE_GROUPS 2 |
362 |
#define USE_PREFIX_USER_TABLE 3 |
363 |
#define X86_64_SPECIAL 4 |
364 |
|
365 |
#define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0 |
366 |
|
367 |
#define GRP1b NULL, NULL, USE_GROUPS, NULL, 0, NULL, 0 |
368 |
#define GRP1S NULL, NULL, USE_GROUPS, NULL, 1, NULL, 0 |
369 |
#define GRP1Ss NULL, NULL, USE_GROUPS, NULL, 2, NULL, 0 |
370 |
#define GRP2b NULL, NULL, USE_GROUPS, NULL, 3, NULL, 0 |
371 |
#define GRP2S NULL, NULL, USE_GROUPS, NULL, 4, NULL, 0 |
372 |
#define GRP2b_one NULL, NULL, USE_GROUPS, NULL, 5, NULL, 0 |
373 |
#define GRP2S_one NULL, NULL, USE_GROUPS, NULL, 6, NULL, 0 |
374 |
#define GRP2b_cl NULL, NULL, USE_GROUPS, NULL, 7, NULL, 0 |
375 |
#define GRP2S_cl NULL, NULL, USE_GROUPS, NULL, 8, NULL, 0 |
376 |
#define GRP3b NULL, NULL, USE_GROUPS, NULL, 9, NULL, 0 |
377 |
#define GRP3S NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0 |
378 |
#define GRP4 NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0 |
379 |
#define GRP5 NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0 |
380 |
#define GRP6 NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0 |
381 |
#define GRP7 NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0 |
382 |
#define GRP8 NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0 |
383 |
#define GRP9 NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0 |
384 |
#define GRP10 NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0 |
385 |
#define GRP11 NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0 |
386 |
#define GRP12 NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0 |
387 |
#define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0 |
388 |
#define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0 |
389 |
#define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0 |
390 |
|
391 |
#define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0 |
392 |
#define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0 |
393 |
#define PREGRP2 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 2, NULL, 0 |
394 |
#define PREGRP3 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 3, NULL, 0 |
395 |
#define PREGRP4 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 4, NULL, 0 |
396 |
#define PREGRP5 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 5, NULL, 0 |
397 |
#define PREGRP6 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 6, NULL, 0 |
398 |
#define PREGRP7 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 7, NULL, 0 |
399 |
#define PREGRP8 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 8, NULL, 0 |
400 |
#define PREGRP9 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 9, NULL, 0 |
401 |
#define PREGRP10 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0 |
402 |
#define PREGRP11 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0 |
403 |
#define PREGRP12 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0 |
404 |
#define PREGRP13 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0 |
405 |
#define PREGRP14 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0 |
406 |
#define PREGRP15 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0 |
407 |
#define PREGRP16 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0 |
408 |
#define PREGRP17 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0 |
409 |
#define PREGRP18 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0 |
410 |
#define PREGRP19 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0 |
411 |
#define PREGRP20 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0 |
412 |
#define PREGRP21 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0 |
413 |
#define PREGRP22 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0 |
414 |
#define PREGRP23 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0 |
415 |
#define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0 |
416 |
#define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0 |
417 |
#define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0 |
418 |
|
419 |
#define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0 |
420 |
|
421 |
typedef void (*op_rtn) PARAMS ((int bytemode, int sizeflag)); |
422 |
|
423 |
struct dis386 {
|
424 |
const char *name; |
425 |
op_rtn op1; |
426 |
int bytemode1;
|
427 |
op_rtn op2; |
428 |
int bytemode2;
|
429 |
op_rtn op3; |
430 |
int bytemode3;
|
431 |
}; |
432 |
|
433 |
/* Upper case letters in the instruction names here are macros.
|
434 |
'A' => print 'b' if no register operands or suffix_always is true
|
435 |
'B' => print 'b' if suffix_always is true
|
436 |
'E' => print 'e' if 32-bit form of jcxz
|
437 |
'F' => print 'w' or 'l' depending on address size prefix (loop insns)
|
438 |
'H' => print ",pt" or ",pn" branch hint
|
439 |
'L' => print 'l' if suffix_always is true
|
440 |
'N' => print 'n' if instruction has no wait "prefix"
|
441 |
'O' => print 'd', or 'o'
|
442 |
'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
|
443 |
. or suffix_always is true. print 'q' if rex prefix is present.
|
444 |
'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
|
445 |
. is true
|
446 |
'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
|
447 |
'S' => print 'w', 'l' or 'q' if suffix_always is true
|
448 |
'T' => print 'q' in 64bit mode and behave as 'P' otherwise
|
449 |
'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
|
450 |
'X' => print 's', 'd' depending on data16 prefix (for XMM)
|
451 |
'W' => print 'b' or 'w' ("w" or "de" in intel mode)
|
452 |
'Y' => 'q' if instruction has an REX 64bit overwrite prefix
|
453 |
|
454 |
Many of the above letters print nothing in Intel mode. See "putop"
|
455 |
for the details.
|
456 |
|
457 |
Braces '{' and '}', and vertical bars '|', indicate alternative
|
458 |
mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
|
459 |
modes. In cases where there are only two alternatives, the X86_64
|
460 |
instruction is reserved, and "(bad)" is printed.
|
461 |
*/
|
462 |
|
463 |
static const struct dis386 dis386[] = { |
464 |
/* 00 */
|
465 |
{ "addB", Eb, Gb, XX },
|
466 |
{ "addS", Ev, Gv, XX },
|
467 |
{ "addB", Gb, Eb, XX },
|
468 |
{ "addS", Gv, Ev, XX },
|
469 |
{ "addB", AL, Ib, XX },
|
470 |
{ "addS", eAX, Iv, XX },
|
471 |
{ "push{T|}", es, XX, XX },
|
472 |
{ "pop{T|}", es, XX, XX },
|
473 |
/* 08 */
|
474 |
{ "orB", Eb, Gb, XX },
|
475 |
{ "orS", Ev, Gv, XX },
|
476 |
{ "orB", Gb, Eb, XX },
|
477 |
{ "orS", Gv, Ev, XX },
|
478 |
{ "orB", AL, Ib, XX },
|
479 |
{ "orS", eAX, Iv, XX },
|
480 |
{ "push{T|}", cs, XX, XX },
|
481 |
{ "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */ |
482 |
/* 10 */
|
483 |
{ "adcB", Eb, Gb, XX },
|
484 |
{ "adcS", Ev, Gv, XX },
|
485 |
{ "adcB", Gb, Eb, XX },
|
486 |
{ "adcS", Gv, Ev, XX },
|
487 |
{ "adcB", AL, Ib, XX },
|
488 |
{ "adcS", eAX, Iv, XX },
|
489 |
{ "push{T|}", ss, XX, XX },
|
490 |
{ "popT|}", ss, XX, XX },
|
491 |
/* 18 */
|
492 |
{ "sbbB", Eb, Gb, XX },
|
493 |
{ "sbbS", Ev, Gv, XX },
|
494 |
{ "sbbB", Gb, Eb, XX },
|
495 |
{ "sbbS", Gv, Ev, XX },
|
496 |
{ "sbbB", AL, Ib, XX },
|
497 |
{ "sbbS", eAX, Iv, XX },
|
498 |
{ "push{T|}", ds, XX, XX },
|
499 |
{ "pop{T|}", ds, XX, XX },
|
500 |
/* 20 */
|
501 |
{ "andB", Eb, Gb, XX },
|
502 |
{ "andS", Ev, Gv, XX },
|
503 |
{ "andB", Gb, Eb, XX },
|
504 |
{ "andS", Gv, Ev, XX },
|
505 |
{ "andB", AL, Ib, XX },
|
506 |
{ "andS", eAX, Iv, XX },
|
507 |
{ "(bad)", XX, XX, XX }, /* SEG ES prefix */ |
508 |
{ "daa{|}", XX, XX, XX },
|
509 |
/* 28 */
|
510 |
{ "subB", Eb, Gb, XX },
|
511 |
{ "subS", Ev, Gv, XX },
|
512 |
{ "subB", Gb, Eb, XX },
|
513 |
{ "subS", Gv, Ev, XX },
|
514 |
{ "subB", AL, Ib, XX },
|
515 |
{ "subS", eAX, Iv, XX },
|
516 |
{ "(bad)", XX, XX, XX }, /* SEG CS prefix */ |
517 |
{ "das{|}", XX, XX, XX },
|
518 |
/* 30 */
|
519 |
{ "xorB", Eb, Gb, XX },
|
520 |
{ "xorS", Ev, Gv, XX },
|
521 |
{ "xorB", Gb, Eb, XX },
|
522 |
{ "xorS", Gv, Ev, XX },
|
523 |
{ "xorB", AL, Ib, XX },
|
524 |
{ "xorS", eAX, Iv, XX },
|
525 |
{ "(bad)", XX, XX, XX }, /* SEG SS prefix */ |
526 |
{ "aaa{|}", XX, XX, XX },
|
527 |
/* 38 */
|
528 |
{ "cmpB", Eb, Gb, XX },
|
529 |
{ "cmpS", Ev, Gv, XX },
|
530 |
{ "cmpB", Gb, Eb, XX },
|
531 |
{ "cmpS", Gv, Ev, XX },
|
532 |
{ "cmpB", AL, Ib, XX },
|
533 |
{ "cmpS", eAX, Iv, XX },
|
534 |
{ "(bad)", XX, XX, XX }, /* SEG DS prefix */ |
535 |
{ "aas{|}", XX, XX, XX },
|
536 |
/* 40 */
|
537 |
{ "inc{S|}", RMeAX, XX, XX },
|
538 |
{ "inc{S|}", RMeCX, XX, XX },
|
539 |
{ "inc{S|}", RMeDX, XX, XX },
|
540 |
{ "inc{S|}", RMeBX, XX, XX },
|
541 |
{ "inc{S|}", RMeSP, XX, XX },
|
542 |
{ "inc{S|}", RMeBP, XX, XX },
|
543 |
{ "inc{S|}", RMeSI, XX, XX },
|
544 |
{ "inc{S|}", RMeDI, XX, XX },
|
545 |
/* 48 */
|
546 |
{ "dec{S|}", RMeAX, XX, XX },
|
547 |
{ "dec{S|}", RMeCX, XX, XX },
|
548 |
{ "dec{S|}", RMeDX, XX, XX },
|
549 |
{ "dec{S|}", RMeBX, XX, XX },
|
550 |
{ "dec{S|}", RMeSP, XX, XX },
|
551 |
{ "dec{S|}", RMeBP, XX, XX },
|
552 |
{ "dec{S|}", RMeSI, XX, XX },
|
553 |
{ "dec{S|}", RMeDI, XX, XX },
|
554 |
/* 50 */
|
555 |
{ "pushS", RMrAX, XX, XX },
|
556 |
{ "pushS", RMrCX, XX, XX },
|
557 |
{ "pushS", RMrDX, XX, XX },
|
558 |
{ "pushS", RMrBX, XX, XX },
|
559 |
{ "pushS", RMrSP, XX, XX },
|
560 |
{ "pushS", RMrBP, XX, XX },
|
561 |
{ "pushS", RMrSI, XX, XX },
|
562 |
{ "pushS", RMrDI, XX, XX },
|
563 |
/* 58 */
|
564 |
{ "popS", RMrAX, XX, XX },
|
565 |
{ "popS", RMrCX, XX, XX },
|
566 |
{ "popS", RMrDX, XX, XX },
|
567 |
{ "popS", RMrBX, XX, XX },
|
568 |
{ "popS", RMrSP, XX, XX },
|
569 |
{ "popS", RMrBP, XX, XX },
|
570 |
{ "popS", RMrSI, XX, XX },
|
571 |
{ "popS", RMrDI, XX, XX },
|
572 |
/* 60 */
|
573 |
{ "pusha{P|}", XX, XX, XX },
|
574 |
{ "popa{P|}", XX, XX, XX },
|
575 |
{ "bound{S|}", Gv, Ma, XX },
|
576 |
{ X86_64_0 }, |
577 |
{ "(bad)", XX, XX, XX }, /* seg fs */ |
578 |
{ "(bad)", XX, XX, XX }, /* seg gs */ |
579 |
{ "(bad)", XX, XX, XX }, /* op size prefix */ |
580 |
{ "(bad)", XX, XX, XX }, /* adr size prefix */ |
581 |
/* 68 */
|
582 |
{ "pushT", Iq, XX, XX },
|
583 |
{ "imulS", Gv, Ev, Iv },
|
584 |
{ "pushT", sIb, XX, XX },
|
585 |
{ "imulS", Gv, Ev, sIb },
|
586 |
{ "ins{b||b|}", Yb, indirDX, XX },
|
587 |
{ "ins{R||R|}", Yv, indirDX, XX },
|
588 |
{ "outs{b||b|}", indirDX, Xb, XX },
|
589 |
{ "outs{R||R|}", indirDX, Xv, XX },
|
590 |
/* 70 */
|
591 |
{ "joH", Jb, XX, cond_jump_flag },
|
592 |
{ "jnoH", Jb, XX, cond_jump_flag },
|
593 |
{ "jbH", Jb, XX, cond_jump_flag },
|
594 |
{ "jaeH", Jb, XX, cond_jump_flag },
|
595 |
{ "jeH", Jb, XX, cond_jump_flag },
|
596 |
{ "jneH", Jb, XX, cond_jump_flag },
|
597 |
{ "jbeH", Jb, XX, cond_jump_flag },
|
598 |
{ "jaH", Jb, XX, cond_jump_flag },
|
599 |
/* 78 */
|
600 |
{ "jsH", Jb, XX, cond_jump_flag },
|
601 |
{ "jnsH", Jb, XX, cond_jump_flag },
|
602 |
{ "jpH", Jb, XX, cond_jump_flag },
|
603 |
{ "jnpH", Jb, XX, cond_jump_flag },
|
604 |
{ "jlH", Jb, XX, cond_jump_flag },
|
605 |
{ "jgeH", Jb, XX, cond_jump_flag },
|
606 |
{ "jleH", Jb, XX, cond_jump_flag },
|
607 |
{ "jgH", Jb, XX, cond_jump_flag },
|
608 |
/* 80 */
|
609 |
{ GRP1b }, |
610 |
{ GRP1S }, |
611 |
{ "(bad)", XX, XX, XX },
|
612 |
{ GRP1Ss }, |
613 |
{ "testB", Eb, Gb, XX },
|
614 |
{ "testS", Ev, Gv, XX },
|
615 |
{ "xchgB", Eb, Gb, XX },
|
616 |
{ "xchgS", Ev, Gv, XX },
|
617 |
/* 88 */
|
618 |
{ "movB", Eb, Gb, XX },
|
619 |
{ "movS", Ev, Gv, XX },
|
620 |
{ "movB", Gb, Eb, XX },
|
621 |
{ "movS", Gv, Ev, XX },
|
622 |
{ "movQ", Ev, Sw, XX },
|
623 |
{ "leaS", Gv, M, XX },
|
624 |
{ "movQ", Sw, Ev, XX },
|
625 |
{ "popU", Ev, XX, XX },
|
626 |
/* 90 */
|
627 |
{ "nop", XX, XX, XX },
|
628 |
/* FIXME: NOP with REPz prefix is called PAUSE. */
|
629 |
{ "xchgS", RMeCX, eAX, XX },
|
630 |
{ "xchgS", RMeDX, eAX, XX },
|
631 |
{ "xchgS", RMeBX, eAX, XX },
|
632 |
{ "xchgS", RMeSP, eAX, XX },
|
633 |
{ "xchgS", RMeBP, eAX, XX },
|
634 |
{ "xchgS", RMeSI, eAX, XX },
|
635 |
{ "xchgS", RMeDI, eAX, XX },
|
636 |
/* 98 */
|
637 |
{ "cW{tR||tR|}", XX, XX, XX },
|
638 |
{ "cR{tO||tO|}", XX, XX, XX },
|
639 |
{ "lcall{T|}", Ap, XX, XX },
|
640 |
{ "(bad)", XX, XX, XX }, /* fwait */ |
641 |
{ "pushfT", XX, XX, XX },
|
642 |
{ "popfT", XX, XX, XX },
|
643 |
{ "sahf{|}", XX, XX, XX },
|
644 |
{ "lahf{|}", XX, XX, XX },
|
645 |
/* a0 */
|
646 |
{ "movB", AL, Ob64, XX },
|
647 |
{ "movS", eAX, Ov64, XX },
|
648 |
{ "movB", Ob64, AL, XX },
|
649 |
{ "movS", Ov64, eAX, XX },
|
650 |
{ "movs{b||b|}", Yb, Xb, XX },
|
651 |
{ "movs{R||R|}", Yv, Xv, XX },
|
652 |
{ "cmps{b||b|}", Xb, Yb, XX },
|
653 |
{ "cmps{R||R|}", Xv, Yv, XX },
|
654 |
/* a8 */
|
655 |
{ "testB", AL, Ib, XX },
|
656 |
{ "testS", eAX, Iv, XX },
|
657 |
{ "stosB", Yb, AL, XX },
|
658 |
{ "stosS", Yv, eAX, XX },
|
659 |
{ "lodsB", AL, Xb, XX },
|
660 |
{ "lodsS", eAX, Xv, XX },
|
661 |
{ "scasB", AL, Yb, XX },
|
662 |
{ "scasS", eAX, Yv, XX },
|
663 |
/* b0 */
|
664 |
{ "movB", RMAL, Ib, XX },
|
665 |
{ "movB", RMCL, Ib, XX },
|
666 |
{ "movB", RMDL, Ib, XX },
|
667 |
{ "movB", RMBL, Ib, XX },
|
668 |
{ "movB", RMAH, Ib, XX },
|
669 |
{ "movB", RMCH, Ib, XX },
|
670 |
{ "movB", RMDH, Ib, XX },
|
671 |
{ "movB", RMBH, Ib, XX },
|
672 |
/* b8 */
|
673 |
{ "movS", RMeAX, Iv64, XX },
|
674 |
{ "movS", RMeCX, Iv64, XX },
|
675 |
{ "movS", RMeDX, Iv64, XX },
|
676 |
{ "movS", RMeBX, Iv64, XX },
|
677 |
{ "movS", RMeSP, Iv64, XX },
|
678 |
{ "movS", RMeBP, Iv64, XX },
|
679 |
{ "movS", RMeSI, Iv64, XX },
|
680 |
{ "movS", RMeDI, Iv64, XX },
|
681 |
/* c0 */
|
682 |
{ GRP2b }, |
683 |
{ GRP2S }, |
684 |
{ "retT", Iw, XX, XX },
|
685 |
{ "retT", XX, XX, XX },
|
686 |
{ "les{S|}", Gv, Mp, XX },
|
687 |
{ "ldsS", Gv, Mp, XX },
|
688 |
{ "movA", Eb, Ib, XX },
|
689 |
{ "movQ", Ev, Iv, XX },
|
690 |
/* c8 */
|
691 |
{ "enterT", Iw, Ib, XX },
|
692 |
{ "leaveT", XX, XX, XX },
|
693 |
{ "lretP", Iw, XX, XX },
|
694 |
{ "lretP", XX, XX, XX },
|
695 |
{ "int3", XX, XX, XX },
|
696 |
{ "int", Ib, XX, XX },
|
697 |
{ "into{|}", XX, XX, XX },
|
698 |
{ "iretP", XX, XX, XX },
|
699 |
/* d0 */
|
700 |
{ GRP2b_one }, |
701 |
{ GRP2S_one }, |
702 |
{ GRP2b_cl }, |
703 |
{ GRP2S_cl }, |
704 |
{ "aam{|}", sIb, XX, XX },
|
705 |
{ "aad{|}", sIb, XX, XX },
|
706 |
{ "(bad)", XX, XX, XX },
|
707 |
{ "xlat", DSBX, XX, XX },
|
708 |
/* d8 */
|
709 |
{ FLOAT }, |
710 |
{ FLOAT }, |
711 |
{ FLOAT }, |
712 |
{ FLOAT }, |
713 |
{ FLOAT }, |
714 |
{ FLOAT }, |
715 |
{ FLOAT }, |
716 |
{ FLOAT }, |
717 |
/* e0 */
|
718 |
{ "loopneFH", Jb, XX, loop_jcxz_flag },
|
719 |
{ "loopeFH", Jb, XX, loop_jcxz_flag },
|
720 |
{ "loopFH", Jb, XX, loop_jcxz_flag },
|
721 |
{ "jEcxzH", Jb, XX, loop_jcxz_flag },
|
722 |
{ "inB", AL, Ib, XX },
|
723 |
{ "inS", eAX, Ib, XX },
|
724 |
{ "outB", Ib, AL, XX },
|
725 |
{ "outS", Ib, eAX, XX },
|
726 |
/* e8 */
|
727 |
{ "callT", Jv, XX, XX },
|
728 |
{ "jmpT", Jv, XX, XX },
|
729 |
{ "ljmp{T|}", Ap, XX, XX },
|
730 |
{ "jmp", Jb, XX, XX },
|
731 |
{ "inB", AL, indirDX, XX },
|
732 |
{ "inS", eAX, indirDX, XX },
|
733 |
{ "outB", indirDX, AL, XX },
|
734 |
{ "outS", indirDX, eAX, XX },
|
735 |
/* f0 */
|
736 |
{ "(bad)", XX, XX, XX }, /* lock prefix */ |
737 |
{ "(bad)", XX, XX, XX },
|
738 |
{ "(bad)", XX, XX, XX }, /* repne */ |
739 |
{ "(bad)", XX, XX, XX }, /* repz */ |
740 |
{ "hlt", XX, XX, XX },
|
741 |
{ "cmc", XX, XX, XX },
|
742 |
{ GRP3b }, |
743 |
{ GRP3S }, |
744 |
/* f8 */
|
745 |
{ "clc", XX, XX, XX },
|
746 |
{ "stc", XX, XX, XX },
|
747 |
{ "cli", XX, XX, XX },
|
748 |
{ "sti", XX, XX, XX },
|
749 |
{ "cld", XX, XX, XX },
|
750 |
{ "std", XX, XX, XX },
|
751 |
{ GRP4 }, |
752 |
{ GRP5 }, |
753 |
}; |
754 |
|
755 |
static const struct dis386 dis386_twobyte[] = { |
756 |
/* 00 */
|
757 |
{ GRP6 }, |
758 |
{ GRP7 }, |
759 |
{ "larS", Gv, Ew, XX },
|
760 |
{ "lslS", Gv, Ew, XX },
|
761 |
{ "(bad)", XX, XX, XX },
|
762 |
{ "syscall", XX, XX, XX },
|
763 |
{ "clts", XX, XX, XX },
|
764 |
{ "sysretP", XX, XX, XX },
|
765 |
/* 08 */
|
766 |
{ "invd", XX, XX, XX },
|
767 |
{ "wbinvd", XX, XX, XX },
|
768 |
{ "(bad)", XX, XX, XX },
|
769 |
{ "ud2a", XX, XX, XX },
|
770 |
{ "(bad)", XX, XX, XX },
|
771 |
{ GRPAMD }, |
772 |
{ "femms", XX, XX, XX },
|
773 |
{ "", MX, EM, OPSUF }, /* See OP_3DNowSuffix. */ |
774 |
/* 10 */
|
775 |
{ PREGRP8 }, |
776 |
{ PREGRP9 }, |
777 |
{ "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */ |
778 |
{ "movlpX", EX, XM, SIMD_Fixup, 'h' }, |
779 |
{ "unpcklpX", XM, EX, XX },
|
780 |
{ "unpckhpX", XM, EX, XX },
|
781 |
{ "movhpX", XM, EX, SIMD_Fixup, 'l' }, |
782 |
{ "movhpX", EX, XM, SIMD_Fixup, 'l' }, |
783 |
/* 18 */
|
784 |
{ GRP14 }, |
785 |
{ "(bad)", XX, XX, XX },
|
786 |
{ "(bad)", XX, XX, XX },
|
787 |
{ "(bad)", XX, XX, XX },
|
788 |
{ "(bad)", XX, XX, XX },
|
789 |
{ "(bad)", XX, XX, XX },
|
790 |
{ "(bad)", XX, XX, XX },
|
791 |
{ "(bad)", XX, XX, XX },
|
792 |
/* 20 */
|
793 |
{ "movL", Rm, Cm, XX },
|
794 |
{ "movL", Rm, Dm, XX },
|
795 |
{ "movL", Cm, Rm, XX },
|
796 |
{ "movL", Dm, Rm, XX },
|
797 |
{ "movL", Rd, Td, XX },
|
798 |
{ "(bad)", XX, XX, XX },
|
799 |
{ "movL", Td, Rd, XX },
|
800 |
{ "(bad)", XX, XX, XX },
|
801 |
/* 28 */
|
802 |
{ "movapX", XM, EX, XX },
|
803 |
{ "movapX", EX, XM, XX },
|
804 |
{ PREGRP2 }, |
805 |
{ "movntpX", Ev, XM, XX },
|
806 |
{ PREGRP4 }, |
807 |
{ PREGRP3 }, |
808 |
{ "ucomisX", XM,EX, XX },
|
809 |
{ "comisX", XM,EX, XX },
|
810 |
/* 30 */
|
811 |
{ "wrmsr", XX, XX, XX },
|
812 |
{ "rdtsc", XX, XX, XX },
|
813 |
{ "rdmsr", XX, XX, XX },
|
814 |
{ "rdpmc", XX, XX, XX },
|
815 |
{ "sysenter", XX, XX, XX },
|
816 |
{ "sysexit", XX, XX, XX },
|
817 |
{ "(bad)", XX, XX, XX },
|
818 |
{ "(bad)", XX, XX, XX },
|
819 |
/* 38 */
|
820 |
{ "(bad)", XX, XX, XX },
|
821 |
{ "(bad)", XX, XX, XX },
|
822 |
{ "(bad)", XX, XX, XX },
|
823 |
{ "(bad)", XX, XX, XX },
|
824 |
{ "(bad)", XX, XX, XX },
|
825 |
{ "(bad)", XX, XX, XX },
|
826 |
{ "(bad)", XX, XX, XX },
|
827 |
{ "(bad)", XX, XX, XX },
|
828 |
/* 40 */
|
829 |
{ "cmovo", Gv, Ev, XX },
|
830 |
{ "cmovno", Gv, Ev, XX },
|
831 |
{ "cmovb", Gv, Ev, XX },
|
832 |
{ "cmovae", Gv, Ev, XX },
|
833 |
{ "cmove", Gv, Ev, XX },
|
834 |
{ "cmovne", Gv, Ev, XX },
|
835 |
{ "cmovbe", Gv, Ev, XX },
|
836 |
{ "cmova", Gv, Ev, XX },
|
837 |
/* 48 */
|
838 |
{ "cmovs", Gv, Ev, XX },
|
839 |
{ "cmovns", Gv, Ev, XX },
|
840 |
{ "cmovp", Gv, Ev, XX },
|
841 |
{ "cmovnp", Gv, Ev, XX },
|
842 |
{ "cmovl", Gv, Ev, XX },
|
843 |
{ "cmovge", Gv, Ev, XX },
|
844 |
{ "cmovle", Gv, Ev, XX },
|
845 |
{ "cmovg", Gv, Ev, XX },
|
846 |
/* 50 */
|
847 |
{ "movmskpX", Gd, XS, XX },
|
848 |
{ PREGRP13 }, |
849 |
{ PREGRP12 }, |
850 |
{ PREGRP11 }, |
851 |
{ "andpX", XM, EX, XX },
|
852 |
{ "andnpX", XM, EX, XX },
|
853 |
{ "orpX", XM, EX, XX },
|
854 |
{ "xorpX", XM, EX, XX },
|
855 |
/* 58 */
|
856 |
{ PREGRP0 }, |
857 |
{ PREGRP10 }, |
858 |
{ PREGRP17 }, |
859 |
{ PREGRP16 }, |
860 |
{ PREGRP14 }, |
861 |
{ PREGRP7 }, |
862 |
{ PREGRP5 }, |
863 |
{ PREGRP6 }, |
864 |
/* 60 */
|
865 |
{ "punpcklbw", MX, EM, XX },
|
866 |
{ "punpcklwd", MX, EM, XX },
|
867 |
{ "punpckldq", MX, EM, XX },
|
868 |
{ "packsswb", MX, EM, XX },
|
869 |
{ "pcmpgtb", MX, EM, XX },
|
870 |
{ "pcmpgtw", MX, EM, XX },
|
871 |
{ "pcmpgtd", MX, EM, XX },
|
872 |
{ "packuswb", MX, EM, XX },
|
873 |
/* 68 */
|
874 |
{ "punpckhbw", MX, EM, XX },
|
875 |
{ "punpckhwd", MX, EM, XX },
|
876 |
{ "punpckhdq", MX, EM, XX },
|
877 |
{ "packssdw", MX, EM, XX },
|
878 |
{ PREGRP26 }, |
879 |
{ PREGRP24 }, |
880 |
{ "movd", MX, Ed, XX },
|
881 |
{ PREGRP19 }, |
882 |
/* 70 */
|
883 |
{ PREGRP22 }, |
884 |
{ GRP10 }, |
885 |
{ GRP11 }, |
886 |
{ GRP12 }, |
887 |
{ "pcmpeqb", MX, EM, XX },
|
888 |
{ "pcmpeqw", MX, EM, XX },
|
889 |
{ "pcmpeqd", MX, EM, XX },
|
890 |
{ "emms", XX, XX, XX },
|
891 |
/* 78 */
|
892 |
{ "(bad)", XX, XX, XX },
|
893 |
{ "(bad)", XX, XX, XX },
|
894 |
{ "(bad)", XX, XX, XX },
|
895 |
{ "(bad)", XX, XX, XX },
|
896 |
{ "(bad)", XX, XX, XX },
|
897 |
{ "(bad)", XX, XX, XX },
|
898 |
{ PREGRP23 }, |
899 |
{ PREGRP20 }, |
900 |
/* 80 */
|
901 |
{ "joH", Jv, XX, cond_jump_flag },
|
902 |
{ "jnoH", Jv, XX, cond_jump_flag },
|
903 |
{ "jbH", Jv, XX, cond_jump_flag },
|
904 |
{ "jaeH", Jv, XX, cond_jump_flag },
|
905 |
{ "jeH", Jv, XX, cond_jump_flag },
|
906 |
{ "jneH", Jv, XX, cond_jump_flag },
|
907 |
{ "jbeH", Jv, XX, cond_jump_flag },
|
908 |
{ "jaH", Jv, XX, cond_jump_flag },
|
909 |
/* 88 */
|
910 |
{ "jsH", Jv, XX, cond_jump_flag },
|
911 |
{ "jnsH", Jv, XX, cond_jump_flag },
|
912 |
{ "jpH", Jv, XX, cond_jump_flag },
|
913 |
{ "jnpH", Jv, XX, cond_jump_flag },
|
914 |
{ "jlH", Jv, XX, cond_jump_flag },
|
915 |
{ "jgeH", Jv, XX, cond_jump_flag },
|
916 |
{ "jleH", Jv, XX, cond_jump_flag },
|
917 |
{ "jgH", Jv, XX, cond_jump_flag },
|
918 |
/* 90 */
|
919 |
{ "seto", Eb, XX, XX },
|
920 |
{ "setno", Eb, XX, XX },
|
921 |
{ "setb", Eb, XX, XX },
|
922 |
{ "setae", Eb, XX, XX },
|
923 |
{ "sete", Eb, XX, XX },
|
924 |
{ "setne", Eb, XX, XX },
|
925 |
{ "setbe", Eb, XX, XX },
|
926 |
{ "seta", Eb, XX, XX },
|
927 |
/* 98 */
|
928 |
{ "sets", Eb, XX, XX },
|
929 |
{ "setns", Eb, XX, XX },
|
930 |
{ "setp", Eb, XX, XX },
|
931 |
{ "setnp", Eb, XX, XX },
|
932 |
{ "setl", Eb, XX, XX },
|
933 |
{ "setge", Eb, XX, XX },
|
934 |
{ "setle", Eb, XX, XX },
|
935 |
{ "setg", Eb, XX, XX },
|
936 |
/* a0 */
|
937 |
{ "pushT", fs, XX, XX },
|
938 |
{ "popT", fs, XX, XX },
|
939 |
{ "cpuid", XX, XX, XX },
|
940 |
{ "btS", Ev, Gv, XX },
|
941 |
{ "shldS", Ev, Gv, Ib },
|
942 |
{ "shldS", Ev, Gv, CL },
|
943 |
{ "(bad)", XX, XX, XX },
|
944 |
{ "(bad)", XX, XX, XX },
|
945 |
/* a8 */
|
946 |
{ "pushT", gs, XX, XX },
|
947 |
{ "popT", gs, XX, XX },
|
948 |
{ "rsm", XX, XX, XX },
|
949 |
{ "btsS", Ev, Gv, XX },
|
950 |
{ "shrdS", Ev, Gv, Ib },
|
951 |
{ "shrdS", Ev, Gv, CL },
|
952 |
{ GRP13 }, |
953 |
{ "imulS", Gv, Ev, XX },
|
954 |
/* b0 */
|
955 |
{ "cmpxchgB", Eb, Gb, XX },
|
956 |
{ "cmpxchgS", Ev, Gv, XX },
|
957 |
{ "lssS", Gv, Mp, XX },
|
958 |
{ "btrS", Ev, Gv, XX },
|
959 |
{ "lfsS", Gv, Mp, XX },
|
960 |
{ "lgsS", Gv, Mp, XX },
|
961 |
{ "movz{bR|x|bR|x}", Gv, Eb, XX },
|
962 |
{ "movz{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movzww ! */ |
963 |
/* b8 */
|
964 |
{ "(bad)", XX, XX, XX },
|
965 |
{ "ud2b", XX, XX, XX },
|
966 |
{ GRP8 }, |
967 |
{ "btcS", Ev, Gv, XX },
|
968 |
{ "bsfS", Gv, Ev, XX },
|
969 |
{ "bsrS", Gv, Ev, XX },
|
970 |
{ "movs{bR|x|bR|x}", Gv, Eb, XX },
|
971 |
{ "movs{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movsww ! */ |
972 |
/* c0 */
|
973 |
{ "xaddB", Eb, Gb, XX },
|
974 |
{ "xaddS", Ev, Gv, XX },
|
975 |
{ PREGRP1 }, |
976 |
{ "movntiS", Ev, Gv, XX },
|
977 |
{ "pinsrw", MX, Ed, Ib },
|
978 |
{ "pextrw", Gd, MS, Ib },
|
979 |
{ "shufpX", XM, EX, Ib },
|
980 |
{ GRP9 }, |
981 |
/* c8 */
|
982 |
{ "bswap", RMeAX, XX, XX },
|
983 |
{ "bswap", RMeCX, XX, XX },
|
984 |
{ "bswap", RMeDX, XX, XX },
|
985 |
{ "bswap", RMeBX, XX, XX },
|
986 |
{ "bswap", RMeSP, XX, XX },
|
987 |
{ "bswap", RMeBP, XX, XX },
|
988 |
{ "bswap", RMeSI, XX, XX },
|
989 |
{ "bswap", RMeDI, XX, XX },
|
990 |
/* d0 */
|
991 |
{ "(bad)", XX, XX, XX },
|
992 |
{ "psrlw", MX, EM, XX },
|
993 |
{ "psrld", MX, EM, XX },
|
994 |
{ "psrlq", MX, EM, XX },
|
995 |
{ "paddq", MX, EM, XX },
|
996 |
{ "pmullw", MX, EM, XX },
|
997 |
{ PREGRP21 }, |
998 |
{ "pmovmskb", Gd, MS, XX },
|
999 |
/* d8 */
|
1000 |
{ "psubusb", MX, EM, XX },
|
1001 |
{ "psubusw", MX, EM, XX },
|
1002 |
{ "pminub", MX, EM, XX },
|
1003 |
{ "pand", MX, EM, XX },
|
1004 |
{ "paddusb", MX, EM, XX },
|
1005 |
{ "paddusw", MX, EM, XX },
|
1006 |
{ "pmaxub", MX, EM, XX },
|
1007 |
{ "pandn", MX, EM, XX },
|
1008 |
/* e0 */
|
1009 |
{ "pavgb", MX, EM, XX },
|
1010 |
{ "psraw", MX, EM, XX },
|
1011 |
{ "psrad", MX, EM, XX },
|
1012 |
{ "pavgw", MX, EM, XX },
|
1013 |
{ "pmulhuw", MX, EM, XX },
|
1014 |
{ "pmulhw", MX, EM, XX },
|
1015 |
{ PREGRP15 }, |
1016 |
{ PREGRP25 }, |
1017 |
/* e8 */
|
1018 |
{ "psubsb", MX, EM, XX },
|
1019 |
{ "psubsw", MX, EM, XX },
|
1020 |
{ "pminsw", MX, EM, XX },
|
1021 |
{ "por", MX, EM, XX },
|
1022 |
{ "paddsb", MX, EM, XX },
|
1023 |
{ "paddsw", MX, EM, XX },
|
1024 |
{ "pmaxsw", MX, EM, XX },
|
1025 |
{ "pxor", MX, EM, XX },
|
1026 |
/* f0 */
|
1027 |
{ "(bad)", XX, XX, XX },
|
1028 |
{ "psllw", MX, EM, XX },
|
1029 |
{ "pslld", MX, EM, XX },
|
1030 |
{ "psllq", MX, EM, XX },
|
1031 |
{ "pmuludq", MX, EM, XX },
|
1032 |
{ "pmaddwd", MX, EM, XX },
|
1033 |
{ "psadbw", MX, EM, XX },
|
1034 |
{ PREGRP18 }, |
1035 |
/* f8 */
|
1036 |
{ "psubb", MX, EM, XX },
|
1037 |
{ "psubw", MX, EM, XX },
|
1038 |
{ "psubd", MX, EM, XX },
|
1039 |
{ "psubq", MX, EM, XX },
|
1040 |
{ "paddb", MX, EM, XX },
|
1041 |
{ "paddw", MX, EM, XX },
|
1042 |
{ "paddd", MX, EM, XX },
|
1043 |
{ "(bad)", XX, XX, XX }
|
1044 |
}; |
1045 |
|
1046 |
static const unsigned char onebyte_has_modrm[256] = { |
1047 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1048 |
/* ------------------------------- */
|
1049 |
/* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */ |
1050 |
/* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */ |
1051 |
/* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */ |
1052 |
/* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */ |
1053 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */ |
1054 |
/* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */ |
1055 |
/* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */ |
1056 |
/* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */ |
1057 |
/* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */ |
1058 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */ |
1059 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */ |
1060 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */ |
1061 |
/* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */ |
1062 |
/* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */ |
1063 |
/* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */ |
1064 |
/* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */ |
1065 |
/* ------------------------------- */
|
1066 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1067 |
}; |
1068 |
|
1069 |
static const unsigned char twobyte_has_modrm[256] = { |
1070 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1071 |
/* ------------------------------- */
|
1072 |
/* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */ |
1073 |
/* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */ |
1074 |
/* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */ |
1075 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1076 |
/* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */ |
1077 |
/* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */ |
1078 |
/* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */ |
1079 |
/* 70 */ 1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1, /* 7f */ |
1080 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1081 |
/* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */ |
1082 |
/* a0 */ 0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1, /* af */ |
1083 |
/* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */ |
1084 |
/* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */ |
1085 |
/* d0 */ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */ |
1086 |
/* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */ |
1087 |
/* f0 */ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */ |
1088 |
/* ------------------------------- */
|
1089 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1090 |
}; |
1091 |
|
1092 |
static const unsigned char twobyte_uses_SSE_prefix[256] = { |
1093 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1094 |
/* ------------------------------- */
|
1095 |
/* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ |
1096 |
/* 10 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ |
1097 |
/* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */ |
1098 |
/* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ |
1099 |
/* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ |
1100 |
/* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ |
1101 |
/* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */ |
1102 |
/* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */ |
1103 |
/* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ |
1104 |
/* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ |
1105 |
/* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ |
1106 |
/* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ |
1107 |
/* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ |
1108 |
/* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ |
1109 |
/* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ |
1110 |
/* f0 */ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */ |
1111 |
/* ------------------------------- */
|
1112 |
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
|
1113 |
}; |
1114 |
|
1115 |
static char obuf[100]; |
1116 |
static char *obufp; |
1117 |
static char scratchbuf[100]; |
1118 |
static unsigned char *start_codep; |
1119 |
static unsigned char *insn_codep; |
1120 |
static unsigned char *codep; |
1121 |
static disassemble_info *the_info;
|
1122 |
static int mod; |
1123 |
static int rm; |
1124 |
static int reg; |
1125 |
static unsigned char need_modrm; |
1126 |
|
1127 |
/* If we are accessing mod/rm/reg without need_modrm set, then the
|
1128 |
values are stale. Hitting this abort likely indicates that you
|
1129 |
need to update onebyte_has_modrm or twobyte_has_modrm. */
|
1130 |
#define MODRM_CHECK if (!need_modrm) abort () |
1131 |
|
1132 |
static const char **names64; |
1133 |
static const char **names32; |
1134 |
static const char **names16; |
1135 |
static const char **names8; |
1136 |
static const char **names8rex; |
1137 |
static const char **names_seg; |
1138 |
static const char **index16; |
1139 |
|
1140 |
static const char *intel_names64[] = { |
1141 |
"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", |
1142 |
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" |
1143 |
}; |
1144 |
static const char *intel_names32[] = { |
1145 |
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", |
1146 |
"r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" |
1147 |
}; |
1148 |
static const char *intel_names16[] = { |
1149 |
"ax", "cx", "dx", "bx", "sp", "bp", "si", "di", |
1150 |
"r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" |
1151 |
}; |
1152 |
static const char *intel_names8[] = { |
1153 |
"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh", |
1154 |
}; |
1155 |
static const char *intel_names8rex[] = { |
1156 |
"al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", |
1157 |
"r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" |
1158 |
}; |
1159 |
static const char *intel_names_seg[] = { |
1160 |
"es", "cs", "ss", "ds", "fs", "gs", "?", "?", |
1161 |
}; |
1162 |
static const char *intel_index16[] = { |
1163 |
"bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx" |
1164 |
}; |
1165 |
|
1166 |
static const char *att_names64[] = { |
1167 |
"%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi", |
1168 |
"%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" |
1169 |
}; |
1170 |
static const char *att_names32[] = { |
1171 |
"%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi", |
1172 |
"%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" |
1173 |
}; |
1174 |
static const char *att_names16[] = { |
1175 |
"%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", |
1176 |
"%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" |
1177 |
}; |
1178 |
static const char *att_names8[] = { |
1179 |
"%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", |
1180 |
}; |
1181 |
static const char *att_names8rex[] = { |
1182 |
"%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil", |
1183 |
"%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" |
1184 |
}; |
1185 |
static const char *att_names_seg[] = { |
1186 |
"%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?", |
1187 |
}; |
1188 |
static const char *att_index16[] = { |
1189 |
"%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx" |
1190 |
}; |
1191 |
|
1192 |
static const struct dis386 grps[][8] = { |
1193 |
/* GRP1b */
|
1194 |
{ |
1195 |
{ "addA", Eb, Ib, XX },
|
1196 |
{ "orA", Eb, Ib, XX },
|
1197 |
{ "adcA", Eb, Ib, XX },
|
1198 |
{ "sbbA", Eb, Ib, XX },
|
1199 |
{ "andA", Eb, Ib, XX },
|
1200 |
{ "subA", Eb, Ib, XX },
|
1201 |
{ "xorA", Eb, Ib, XX },
|
1202 |
{ "cmpA", Eb, Ib, XX }
|
1203 |
}, |
1204 |
/* GRP1S */
|
1205 |
{ |
1206 |
{ "addQ", Ev, Iv, XX },
|
1207 |
{ "orQ", Ev, Iv, XX },
|
1208 |
{ "adcQ", Ev, Iv, XX },
|
1209 |
{ "sbbQ", Ev, Iv, XX },
|
1210 |
{ "andQ", Ev, Iv, XX },
|
1211 |
{ "subQ", Ev, Iv, XX },
|
1212 |
{ "xorQ", Ev, Iv, XX },
|
1213 |
{ "cmpQ", Ev, Iv, XX }
|
1214 |
}, |
1215 |
/* GRP1Ss */
|
1216 |
{ |
1217 |
{ "addQ", Ev, sIb, XX },
|
1218 |
{ "orQ", Ev, sIb, XX },
|
1219 |
{ "adcQ", Ev, sIb, XX },
|
1220 |
{ "sbbQ", Ev, sIb, XX },
|
1221 |
{ "andQ", Ev, sIb, XX },
|
1222 |
{ "subQ", Ev, sIb, XX },
|
1223 |
{ "xorQ", Ev, sIb, XX },
|
1224 |
{ "cmpQ", Ev, sIb, XX }
|
1225 |
}, |
1226 |
/* GRP2b */
|
1227 |
{ |
1228 |
{ "rolA", Eb, Ib, XX },
|
1229 |
{ "rorA", Eb, Ib, XX },
|
1230 |
{ "rclA", Eb, Ib, XX },
|
1231 |
{ "rcrA", Eb, Ib, XX },
|
1232 |
{ "shlA", Eb, Ib, XX },
|
1233 |
{ "shrA", Eb, Ib, XX },
|
1234 |
{ "(bad)", XX, XX, XX },
|
1235 |
{ "sarA", Eb, Ib, XX },
|
1236 |
}, |
1237 |
/* GRP2S */
|
1238 |
{ |
1239 |
{ "rolQ", Ev, Ib, XX },
|
1240 |
{ "rorQ", Ev, Ib, XX },
|
1241 |
{ "rclQ", Ev, Ib, XX },
|
1242 |
{ "rcrQ", Ev, Ib, XX },
|
1243 |
{ "shlQ", Ev, Ib, XX },
|
1244 |
{ "shrQ", Ev, Ib, XX },
|
1245 |
{ "(bad)", XX, XX, XX },
|
1246 |
{ "sarQ", Ev, Ib, XX },
|
1247 |
}, |
1248 |
/* GRP2b_one */
|
1249 |
{ |
1250 |
{ "rolA", Eb, XX, XX },
|
1251 |
{ "rorA", Eb, XX, XX },
|
1252 |
{ "rclA", Eb, XX, XX },
|
1253 |
{ "rcrA", Eb, XX, XX },
|
1254 |
{ "shlA", Eb, XX, XX },
|
1255 |
{ "shrA", Eb, XX, XX },
|
1256 |
{ "(bad)", XX, XX, XX },
|
1257 |
{ "sarA", Eb, XX, XX },
|
1258 |
}, |
1259 |
/* GRP2S_one */
|
1260 |
{ |
1261 |
{ "rolQ", Ev, XX, XX },
|
1262 |
{ "rorQ", Ev, XX, XX },
|
1263 |
{ "rclQ", Ev, XX, XX },
|
1264 |
{ "rcrQ", Ev, XX, XX },
|
1265 |
{ "shlQ", Ev, XX, XX },
|
1266 |
{ "shrQ", Ev, XX, XX },
|
1267 |
{ "(bad)", XX, XX, XX},
|
1268 |
{ "sarQ", Ev, XX, XX },
|
1269 |
}, |
1270 |
/* GRP2b_cl */
|
1271 |
{ |
1272 |
{ "rolA", Eb, CL, XX },
|
1273 |
{ "rorA", Eb, CL, XX },
|
1274 |
{ "rclA", Eb, CL, XX },
|
1275 |
{ "rcrA", Eb, CL, XX },
|
1276 |
{ "shlA", Eb, CL, XX },
|
1277 |
{ "shrA", Eb, CL, XX },
|
1278 |
{ "(bad)", XX, XX, XX },
|
1279 |
{ "sarA", Eb, CL, XX },
|
1280 |
}, |
1281 |
/* GRP2S_cl */
|
1282 |
{ |
1283 |
{ "rolQ", Ev, CL, XX },
|
1284 |
{ "rorQ", Ev, CL, XX },
|
1285 |
{ "rclQ", Ev, CL, XX },
|
1286 |
{ "rcrQ", Ev, CL, XX },
|
1287 |
{ "shlQ", Ev, CL, XX },
|
1288 |
{ "shrQ", Ev, CL, XX },
|
1289 |
{ "(bad)", XX, XX, XX },
|
1290 |
{ "sarQ", Ev, CL, XX }
|
1291 |
}, |
1292 |
/* GRP3b */
|
1293 |
{ |
1294 |
{ "testA", Eb, Ib, XX },
|
1295 |
{ "(bad)", Eb, XX, XX },
|
1296 |
{ "notA", Eb, XX, XX },
|
1297 |
{ "negA", Eb, XX, XX },
|
1298 |
{ "mulA", Eb, XX, XX }, /* Don't print the implicit %al register, */ |
1299 |
{ "imulA", Eb, XX, XX }, /* to distinguish these opcodes from other */ |
1300 |
{ "divA", Eb, XX, XX }, /* mul/imul opcodes. Do the same for div */ |
1301 |
{ "idivA", Eb, XX, XX } /* and idiv for consistency. */ |
1302 |
}, |
1303 |
/* GRP3S */
|
1304 |
{ |
1305 |
{ "testQ", Ev, Iv, XX },
|
1306 |
{ "(bad)", XX, XX, XX },
|
1307 |
{ "notQ", Ev, XX, XX },
|
1308 |
{ "negQ", Ev, XX, XX },
|
1309 |
{ "mulQ", Ev, XX, XX }, /* Don't print the implicit register. */ |
1310 |
{ "imulQ", Ev, XX, XX },
|
1311 |
{ "divQ", Ev, XX, XX },
|
1312 |
{ "idivQ", Ev, XX, XX },
|
1313 |
}, |
1314 |
/* GRP4 */
|
1315 |
{ |
1316 |
{ "incA", Eb, XX, XX },
|
1317 |
{ "decA", Eb, XX, XX },
|
1318 |
{ "(bad)", XX, XX, XX },
|
1319 |
{ "(bad)", XX, XX, XX },
|
1320 |
{ "(bad)", XX, XX, XX },
|
1321 |
{ "(bad)", XX, XX, XX },
|
1322 |
{ "(bad)", XX, XX, XX },
|
1323 |
{ "(bad)", XX, XX, XX },
|
1324 |
}, |
1325 |
/* GRP5 */
|
1326 |
{ |
1327 |
{ "incQ", Ev, XX, XX },
|
1328 |
{ "decQ", Ev, XX, XX },
|
1329 |
{ "callT", indirEv, XX, XX },
|
1330 |
{ "lcallT", indirEv, XX, XX },
|
1331 |
{ "jmpT", indirEv, XX, XX },
|
1332 |
{ "ljmpT", indirEv, XX, XX },
|
1333 |
{ "pushU", Ev, XX, XX },
|
1334 |
{ "(bad)", XX, XX, XX },
|
1335 |
}, |
1336 |
/* GRP6 */
|
1337 |
{ |
1338 |
{ "sldtQ", Ev, XX, XX },
|
1339 |
{ "strQ", Ev, XX, XX },
|
1340 |
{ "lldt", Ew, XX, XX },
|
1341 |
{ "ltr", Ew, XX, XX },
|
1342 |
{ "verr", Ew, XX, XX },
|
1343 |
{ "verw", Ew, XX, XX },
|
1344 |
{ "(bad)", XX, XX, XX },
|
1345 |
{ "(bad)", XX, XX, XX }
|
1346 |
}, |
1347 |
/* GRP7 */
|
1348 |
{ |
1349 |
{ "sgdtQ", M, XX, XX },
|
1350 |
{ "sidtQ", M, XX, XX },
|
1351 |
{ "lgdtQ", M, XX, XX },
|
1352 |
{ "lidtQ", M, XX, XX },
|
1353 |
{ "smswQ", Ev, XX, XX },
|
1354 |
{ "(bad)", XX, XX, XX },
|
1355 |
{ "lmsw", Ew, XX, XX },
|
1356 |
{ "invlpg", Ew, XX, XX },
|
1357 |
}, |
1358 |
/* GRP8 */
|
1359 |
{ |
1360 |
{ "(bad)", XX, XX, XX },
|
1361 |
{ "(bad)", XX, XX, XX },
|
1362 |
{ "(bad)", XX, XX, XX },
|
1363 |
{ "(bad)", XX, XX, XX },
|
1364 |
{ "btQ", Ev, Ib, XX },
|
1365 |
{ "btsQ", Ev, Ib, XX },
|
1366 |
{ "btrQ", Ev, Ib, XX },
|
1367 |
{ "btcQ", Ev, Ib, XX },
|
1368 |
}, |
1369 |
/* GRP9 */
|
1370 |
{ |
1371 |
{ "(bad)", XX, XX, XX },
|
1372 |
{ "cmpxchg8b", Ev, XX, XX },
|
1373 |
{ "(bad)", XX, XX, XX },
|
1374 |
{ "(bad)", XX, XX, XX },
|
1375 |
{ "(bad)", XX, XX, XX },
|
1376 |
{ "(bad)", XX, XX, XX },
|
1377 |
{ "(bad)", XX, XX, XX },
|
1378 |
{ "(bad)", XX, XX, XX },
|
1379 |
}, |
1380 |
/* GRP10 */
|
1381 |
{ |
1382 |
{ "(bad)", XX, XX, XX },
|
1383 |
{ "(bad)", XX, XX, XX },
|
1384 |
{ "psrlw", MS, Ib, XX },
|
1385 |
{ "(bad)", XX, XX, XX },
|
1386 |
{ "psraw", MS, Ib, XX },
|
1387 |
{ "(bad)", XX, XX, XX },
|
1388 |
{ "psllw", MS, Ib, XX },
|
1389 |
{ "(bad)", XX, XX, XX },
|
1390 |
}, |
1391 |
/* GRP11 */
|
1392 |
{ |
1393 |
{ "(bad)", XX, XX, XX },
|
1394 |
{ "(bad)", XX, XX, XX },
|
1395 |
{ "psrld", MS, Ib, XX },
|
1396 |
{ "(bad)", XX, XX, XX },
|
1397 |
{ "psrad", MS, Ib, XX },
|
1398 |
{ "(bad)", XX, XX, XX },
|
1399 |
{ "pslld", MS, Ib, XX },
|
1400 |
{ "(bad)", XX, XX, XX },
|
1401 |
}, |
1402 |
/* GRP12 */
|
1403 |
{ |
1404 |
{ "(bad)", XX, XX, XX },
|
1405 |
{ "(bad)", XX, XX, XX },
|
1406 |
{ "psrlq", MS, Ib, XX },
|
1407 |
{ "psrldq", MS, Ib, XX },
|
1408 |
{ "(bad)", XX, XX, XX },
|
1409 |
{ "(bad)", XX, XX, XX },
|
1410 |
{ "psllq", MS, Ib, XX },
|
1411 |
{ "pslldq", MS, Ib, XX },
|
1412 |
}, |
1413 |
/* GRP13 */
|
1414 |
{ |
1415 |
{ "fxsave", Ev, XX, XX },
|
1416 |
{ "fxrstor", Ev, XX, XX },
|
1417 |
{ "ldmxcsr", Ev, XX, XX },
|
1418 |
{ "stmxcsr", Ev, XX, XX },
|
1419 |
{ "(bad)", XX, XX, XX },
|
1420 |
{ "lfence", None, XX, XX },
|
1421 |
{ "mfence", None, XX, XX },
|
1422 |
{ "sfence", None, XX, XX },
|
1423 |
/* FIXME: the sfence with memory operand is clflush! */
|
1424 |
}, |
1425 |
/* GRP14 */
|
1426 |
{ |
1427 |
{ "prefetchnta", Ev, XX, XX },
|
1428 |
{ "prefetcht0", Ev, XX, XX },
|
1429 |
{ "prefetcht1", Ev, XX, XX },
|
1430 |
{ "prefetcht2", Ev, XX, XX },
|
1431 |
{ "(bad)", XX, XX, XX },
|
1432 |
{ "(bad)", XX, XX, XX },
|
1433 |
{ "(bad)", XX, XX, XX },
|
1434 |
{ "(bad)", XX, XX, XX },
|
1435 |
}, |
1436 |
/* GRPAMD */
|
1437 |
{ |
1438 |
{ "prefetch", Eb, XX, XX },
|
1439 |
{ "prefetchw", Eb, XX, XX },
|
1440 |
{ "(bad)", XX, XX, XX },
|
1441 |
{ "(bad)", XX, XX, XX },
|
1442 |
{ "(bad)", XX, XX, XX },
|
1443 |
{ "(bad)", XX, XX, XX },
|
1444 |
{ "(bad)", XX, XX, XX },
|
1445 |
{ "(bad)", XX, XX, XX },
|
1446 |
} |
1447 |
}; |
1448 |
|
1449 |
static const struct dis386 prefix_user_table[][4] = { |
1450 |
/* PREGRP0 */
|
1451 |
{ |
1452 |
{ "addps", XM, EX, XX },
|
1453 |
{ "addss", XM, EX, XX },
|
1454 |
{ "addpd", XM, EX, XX },
|
1455 |
{ "addsd", XM, EX, XX },
|
1456 |
}, |
1457 |
/* PREGRP1 */
|
1458 |
{ |
1459 |
{ "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX. */ |
1460 |
{ "", XM, EX, OPSIMD },
|
1461 |
{ "", XM, EX, OPSIMD },
|
1462 |
{ "", XM, EX, OPSIMD },
|
1463 |
}, |
1464 |
/* PREGRP2 */
|
1465 |
{ |
1466 |
{ "cvtpi2ps", XM, EM, XX },
|
1467 |
{ "cvtsi2ssY", XM, Ev, XX },
|
1468 |
{ "cvtpi2pd", XM, EM, XX },
|
1469 |
{ "cvtsi2sdY", XM, Ev, XX },
|
1470 |
}, |
1471 |
/* PREGRP3 */
|
1472 |
{ |
1473 |
{ "cvtps2pi", MX, EX, XX },
|
1474 |
{ "cvtss2siY", Gv, EX, XX },
|
1475 |
{ "cvtpd2pi", MX, EX, XX },
|
1476 |
{ "cvtsd2siY", Gv, EX, XX },
|
1477 |
}, |
1478 |
/* PREGRP4 */
|
1479 |
{ |
1480 |
{ "cvttps2pi", MX, EX, XX },
|
1481 |
{ "cvttss2siY", Gv, EX, XX },
|
1482 |
{ "cvttpd2pi", MX, EX, XX },
|
1483 |
{ "cvttsd2siY", Gv, EX, XX },
|
1484 |
}, |
1485 |
/* PREGRP5 */
|
1486 |
{ |
1487 |
{ "divps", XM, EX, XX },
|
1488 |
{ "divss", XM, EX, XX },
|
1489 |
{ "divpd", XM, EX, XX },
|
1490 |
{ "divsd", XM, EX, XX },
|
1491 |
}, |
1492 |
/* PREGRP6 */
|
1493 |
{ |
1494 |
{ "maxps", XM, EX, XX },
|
1495 |
{ "maxss", XM, EX, XX },
|
1496 |
{ "maxpd", XM, EX, XX },
|
1497 |
{ "maxsd", XM, EX, XX },
|
1498 |
}, |
1499 |
/* PREGRP7 */
|
1500 |
{ |
1501 |
{ "minps", XM, EX, XX },
|
1502 |
{ "minss", XM, EX, XX },
|
1503 |
{ "minpd", XM, EX, XX },
|
1504 |
{ "minsd", XM, EX, XX },
|
1505 |
}, |
1506 |
/* PREGRP8 */
|
1507 |
{ |
1508 |
{ "movups", XM, EX, XX },
|
1509 |
{ "movss", XM, EX, XX },
|
1510 |
{ "movupd", XM, EX, XX },
|
1511 |
{ "movsd", XM, EX, XX },
|
1512 |
}, |
1513 |
/* PREGRP9 */
|
1514 |
{ |
1515 |
{ "movups", EX, XM, XX },
|
1516 |
{ "movss", EX, XM, XX },
|
1517 |
{ "movupd", EX, XM, XX },
|
1518 |
{ "movsd", EX, XM, XX },
|
1519 |
}, |
1520 |
/* PREGRP10 */
|
1521 |
{ |
1522 |
{ "mulps", XM, EX, XX },
|
1523 |
{ "mulss", XM, EX, XX },
|
1524 |
{ "mulpd", XM, EX, XX },
|
1525 |
{ "mulsd", XM, EX, XX },
|
1526 |
}, |
1527 |
/* PREGRP11 */
|
1528 |
{ |
1529 |
{ "rcpps", XM, EX, XX },
|
1530 |
{ "rcpss", XM, EX, XX },
|
1531 |
{ "(bad)", XM, EX, XX },
|
1532 |
{ "(bad)", XM, EX, XX },
|
1533 |
}, |
1534 |
/* PREGRP12 */
|
1535 |
{ |
1536 |
{ "rsqrtps", XM, EX, XX },
|
1537 |
{ "rsqrtss", XM, EX, XX },
|
1538 |
{ "(bad)", XM, EX, XX },
|
1539 |
{ "(bad)", XM, EX, XX },
|
1540 |
}, |
1541 |
/* PREGRP13 */
|
1542 |
{ |
1543 |
{ "sqrtps", XM, EX, XX },
|
1544 |
{ "sqrtss", XM, EX, XX },
|
1545 |
{ "sqrtpd", XM, EX, XX },
|
1546 |
{ "sqrtsd", XM, EX, XX },
|
1547 |
}, |
1548 |
/* PREGRP14 */
|
1549 |
{ |
1550 |
{ "subps", XM, EX, XX },
|
1551 |
{ "subss", XM, EX, XX },
|
1552 |
{ "subpd", XM, EX, XX },
|
1553 |
{ "subsd", XM, EX, XX },
|
1554 |
}, |
1555 |
/* PREGRP15 */
|
1556 |
{ |
1557 |
{ "(bad)", XM, EX, XX },
|
1558 |
{ "cvtdq2pd", XM, EX, XX },
|
1559 |
{ "cvttpd2dq", XM, EX, XX },
|
1560 |
{ "cvtpd2dq", XM, EX, XX },
|
1561 |
}, |
1562 |
/* PREGRP16 */
|
1563 |
{ |
1564 |
{ "cvtdq2ps", XM, EX, XX },
|
1565 |
{ "cvttps2dq",XM, EX, XX },
|
1566 |
{ "cvtps2dq",XM, EX, XX },
|
1567 |
{ "(bad)", XM, EX, XX },
|
1568 |
}, |
1569 |
/* PREGRP17 */
|
1570 |
{ |
1571 |
{ "cvtps2pd", XM, EX, XX },
|
1572 |
{ "cvtss2sd", XM, EX, XX },
|
1573 |
{ "cvtpd2ps", XM, EX, XX },
|
1574 |
{ "cvtsd2ss", XM, EX, XX },
|
1575 |
}, |
1576 |
/* PREGRP18 */
|
1577 |
{ |
1578 |
{ "maskmovq", MX, MS, XX },
|
1579 |
{ "(bad)", XM, EX, XX },
|
1580 |
{ "maskmovdqu", XM, EX, XX },
|
1581 |
{ "(bad)", XM, EX, XX },
|
1582 |
}, |
1583 |
/* PREGRP19 */
|
1584 |
{ |
1585 |
{ "movq", MX, EM, XX },
|
1586 |
{ "movdqu", XM, EX, XX },
|
1587 |
{ "movdqa", XM, EX, XX },
|
1588 |
{ "(bad)", XM, EX, XX },
|
1589 |
}, |
1590 |
/* PREGRP20 */
|
1591 |
{ |
1592 |
{ "movq", EM, MX, XX },
|
1593 |
{ "movdqu", EX, XM, XX },
|
1594 |
{ "movdqa", EX, XM, XX },
|
1595 |
{ "(bad)", EX, XM, XX },
|
1596 |
}, |
1597 |
/* PREGRP21 */
|
1598 |
{ |
1599 |
{ "(bad)", EX, XM, XX },
|
1600 |
{ "movq2dq", XM, MS, XX },
|
1601 |
{ "movq", EX, XM, XX },
|
1602 |
{ "movdq2q", MX, XS, XX },
|
1603 |
}, |
1604 |
/* PREGRP22 */
|
1605 |
{ |
1606 |
{ "pshufw", MX, EM, Ib },
|
1607 |
{ "pshufhw", XM, EX, Ib },
|
1608 |
{ "pshufd", XM, EX, Ib },
|
1609 |
{ "pshuflw", XM, EX, Ib },
|
1610 |
}, |
1611 |
/* PREGRP23 */
|
1612 |
{ |
1613 |
{ "movd", Ed, MX, XX },
|
1614 |
{ "movq", XM, EX, XX },
|
1615 |
{ "movd", Ed, XM, XX },
|
1616 |
{ "(bad)", Ed, XM, XX },
|
1617 |
}, |
1618 |
/* PREGRP24 */
|
1619 |
{ |
1620 |
{ "(bad)", MX, EX, XX },
|
1621 |
{ "(bad)", XM, EX, XX },
|
1622 |
{ "punpckhqdq", XM, EX, XX },
|
1623 |
{ "(bad)", XM, EX, XX },
|
1624 |
}, |
1625 |
/* PREGRP25 */
|
1626 |
{ |
1627 |
{ "movntq", Ev, MX, XX },
|
1628 |
{ "(bad)", Ev, XM, XX },
|
1629 |
{ "movntdq", Ev, XM, XX },
|
1630 |
{ "(bad)", Ev, XM, XX },
|
1631 |
}, |
1632 |
/* PREGRP26 */
|
1633 |
{ |
1634 |
{ "(bad)", MX, EX, XX },
|
1635 |
{ "(bad)", XM, EX, XX },
|
1636 |
{ "punpcklqdq", XM, EX, XX },
|
1637 |
{ "(bad)", XM, EX, XX },
|
1638 |
}, |
1639 |
}; |
1640 |
|
1641 |
static const struct dis386 x86_64_table[][2] = { |
1642 |
{ |
1643 |
{ "arpl", Ew, Gw, XX },
|
1644 |
{ "movs{||lq|xd}", Gv, Ed, XX },
|
1645 |
}, |
1646 |
}; |
1647 |
|
1648 |
#define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>") |
1649 |
|
1650 |
static void |
1651 |
ckprefix () |
1652 |
{ |
1653 |
int newrex;
|
1654 |
rex = 0;
|
1655 |
prefixes = 0;
|
1656 |
used_prefixes = 0;
|
1657 |
rex_used = 0;
|
1658 |
while (1) |
1659 |
{ |
1660 |
FETCH_DATA (the_info, codep + 1);
|
1661 |
newrex = 0;
|
1662 |
switch (*codep)
|
1663 |
{ |
1664 |
/* REX prefixes family. */
|
1665 |
case 0x40: |
1666 |
case 0x41: |
1667 |
case 0x42: |
1668 |
case 0x43: |
1669 |
case 0x44: |
1670 |
case 0x45: |
1671 |
case 0x46: |
1672 |
case 0x47: |
1673 |
case 0x48: |
1674 |
case 0x49: |
1675 |
case 0x4a: |
1676 |
case 0x4b: |
1677 |
case 0x4c: |
1678 |
case 0x4d: |
1679 |
case 0x4e: |
1680 |
case 0x4f: |
1681 |
if (mode_64bit)
|
1682 |
newrex = *codep; |
1683 |
else
|
1684 |
return;
|
1685 |
break;
|
1686 |
case 0xf3: |
1687 |
prefixes |= PREFIX_REPZ; |
1688 |
break;
|
1689 |
case 0xf2: |
1690 |
prefixes |= PREFIX_REPNZ; |
1691 |
break;
|
1692 |
case 0xf0: |
1693 |
prefixes |= PREFIX_LOCK; |
1694 |
break;
|
1695 |
case 0x2e: |
1696 |
prefixes |= PREFIX_CS; |
1697 |
break;
|
1698 |
case 0x36: |
1699 |
prefixes |= PREFIX_SS; |
1700 |
break;
|
1701 |
case 0x3e: |
1702 |
prefixes |= PREFIX_DS; |
1703 |
break;
|
1704 |
case 0x26: |
1705 |
prefixes |= PREFIX_ES; |
1706 |
break;
|
1707 |
case 0x64: |
1708 |
prefixes |= PREFIX_FS; |
1709 |
break;
|
1710 |
case 0x65: |
1711 |
prefixes |= PREFIX_GS; |
1712 |
break;
|
1713 |
case 0x66: |
1714 |
prefixes |= PREFIX_DATA; |
1715 |
break;
|
1716 |
case 0x67: |
1717 |
prefixes |= PREFIX_ADDR; |
1718 |
break;
|
1719 |
case FWAIT_OPCODE:
|
1720 |
/* fwait is really an instruction. If there are prefixes
|
1721 |
before the fwait, they belong to the fwait, *not* to the
|
1722 |
following instruction. */
|
1723 |
if (prefixes)
|
1724 |
{ |
1725 |
prefixes |= PREFIX_FWAIT; |
1726 |
codep++; |
1727 |
return;
|
1728 |
} |
1729 |
prefixes = PREFIX_FWAIT; |
1730 |
break;
|
1731 |
default:
|
1732 |
return;
|
1733 |
} |
1734 |
/* Rex is ignored when followed by another prefix. */
|
1735 |
if (rex)
|
1736 |
{ |
1737 |
oappend (prefix_name (rex, 0));
|
1738 |
oappend (" ");
|
1739 |
} |
1740 |
rex = newrex; |
1741 |
codep++; |
1742 |
} |
1743 |
} |
1744 |
|
1745 |
/* Return the name of the prefix byte PREF, or NULL if PREF is not a
|
1746 |
prefix byte. */
|
1747 |
|
1748 |
static const char * |
1749 |
prefix_name (pref, sizeflag) |
1750 |
int pref;
|
1751 |
int sizeflag;
|
1752 |
{ |
1753 |
switch (pref)
|
1754 |
{ |
1755 |
/* REX prefixes family. */
|
1756 |
case 0x40: |
1757 |
return "rex"; |
1758 |
case 0x41: |
1759 |
return "rexZ"; |
1760 |
case 0x42: |
1761 |
return "rexY"; |
1762 |
case 0x43: |
1763 |
return "rexYZ"; |
1764 |
case 0x44: |
1765 |
return "rexX"; |
1766 |
case 0x45: |
1767 |
return "rexXZ"; |
1768 |
case 0x46: |
1769 |
return "rexXY"; |
1770 |
case 0x47: |
1771 |
return "rexXYZ"; |
1772 |
case 0x48: |
1773 |
return "rex64"; |
1774 |
case 0x49: |
1775 |
return "rex64Z"; |
1776 |
case 0x4a: |
1777 |
return "rex64Y"; |
1778 |
case 0x4b: |
1779 |
return "rex64YZ"; |
1780 |
case 0x4c: |
1781 |
return "rex64X"; |
1782 |
case 0x4d: |
1783 |
return "rex64XZ"; |
1784 |
case 0x4e: |
1785 |
return "rex64XY"; |
1786 |
case 0x4f: |
1787 |
return "rex64XYZ"; |
1788 |
case 0xf3: |
1789 |
return "repz"; |
1790 |
case 0xf2: |
1791 |
return "repnz"; |
1792 |
case 0xf0: |
1793 |
return "lock"; |
1794 |
case 0x2e: |
1795 |
return "cs"; |
1796 |
case 0x36: |
1797 |
return "ss"; |
1798 |
case 0x3e: |
1799 |
return "ds"; |
1800 |
case 0x26: |
1801 |
return "es"; |
1802 |
case 0x64: |
1803 |
return "fs"; |
1804 |
case 0x65: |
1805 |
return "gs"; |
1806 |
case 0x66: |
1807 |
return (sizeflag & DFLAG) ? "data16" : "data32"; |
1808 |
case 0x67: |
1809 |
if (mode_64bit)
|
1810 |
return (sizeflag & AFLAG) ? "addr32" : "addr64"; |
1811 |
else
|
1812 |
return ((sizeflag & AFLAG) && !mode_64bit) ? "addr16" : "addr32"; |
1813 |
case FWAIT_OPCODE:
|
1814 |
return "fwait"; |
1815 |
default:
|
1816 |
return NULL; |
1817 |
} |
1818 |
} |
1819 |
|
1820 |
static char op1out[100], op2out[100], op3out[100]; |
1821 |
static int op_ad, op_index[3]; |
1822 |
static bfd_vma op_address[3]; |
1823 |
static bfd_vma op_riprel[3]; |
1824 |
static bfd_vma start_pc;
|
1825 |
|
1826 |
/*
|
1827 |
* On the 386's of 1988, the maximum length of an instruction is 15 bytes.
|
1828 |
* (see topic "Redundant prefixes" in the "Differences from 8086"
|
1829 |
* section of the "Virtual 8086 Mode" chapter.)
|
1830 |
* 'pc' should be the address of this instruction, it will
|
1831 |
* be used to print the target address if this is a relative jump or call
|
1832 |
* The function returns the length of this instruction in bytes.
|
1833 |
*/
|
1834 |
|
1835 |
static int8_t intel_syntax;
|
1836 |
static char open_char; |
1837 |
static char close_char; |
1838 |
static char separator_char; |
1839 |
static char scale_char; |
1840 |
|
1841 |
int
|
1842 |
print_insn_i386 (pc, info) |
1843 |
bfd_vma pc; |
1844 |
disassemble_info *info; |
1845 |
{ |
1846 |
intel_syntax = -1;
|
1847 |
|
1848 |
return print_insn (pc, info);
|
1849 |
} |
1850 |
|
1851 |
static int |
1852 |
print_insn (pc, info) |
1853 |
bfd_vma pc; |
1854 |
disassemble_info *info; |
1855 |
{ |
1856 |
const struct dis386 *dp; |
1857 |
int i;
|
1858 |
int two_source_ops;
|
1859 |
char *first, *second, *third;
|
1860 |
int needcomma;
|
1861 |
unsigned char uses_SSE_prefix; |
1862 |
int sizeflag;
|
1863 |
const char *p; |
1864 |
struct dis_private priv;
|
1865 |
|
1866 |
mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax |
1867 |
|| info->mach == bfd_mach_x86_64); |
1868 |
|
1869 |
if (intel_syntax == -1) |
1870 |
intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax |
1871 |
|| info->mach == bfd_mach_x86_64_intel_syntax); |
1872 |
|
1873 |
if (info->mach == bfd_mach_i386_i386
|
1874 |
|| info->mach == bfd_mach_x86_64 |
1875 |
|| info->mach == bfd_mach_i386_i386_intel_syntax |
1876 |
|| info->mach == bfd_mach_x86_64_intel_syntax) |
1877 |
priv.orig_sizeflag = AFLAG | DFLAG; |
1878 |
else if (info->mach == bfd_mach_i386_i8086) |
1879 |
priv.orig_sizeflag = 0;
|
1880 |
else
|
1881 |
abort (); |
1882 |
|
1883 |
for (p = info->disassembler_options; p != NULL; ) |
1884 |
{ |
1885 |
if (strncmp (p, "x86-64", 6) == 0) |
1886 |
{ |
1887 |
mode_64bit = 1;
|
1888 |
priv.orig_sizeflag = AFLAG | DFLAG; |
1889 |
} |
1890 |
else if (strncmp (p, "i386", 4) == 0) |
1891 |
{ |
1892 |
mode_64bit = 0;
|
1893 |
priv.orig_sizeflag = AFLAG | DFLAG; |
1894 |
} |
1895 |
else if (strncmp (p, "i8086", 5) == 0) |
1896 |
{ |
1897 |
mode_64bit = 0;
|
1898 |
priv.orig_sizeflag = 0;
|
1899 |
} |
1900 |
else if (strncmp (p, "intel", 5) == 0) |
1901 |
{ |
1902 |
intel_syntax = 1;
|
1903 |
} |
1904 |
else if (strncmp (p, "att", 3) == 0) |
1905 |
{ |
1906 |
intel_syntax = 0;
|
1907 |
} |
1908 |
else if (strncmp (p, "addr", 4) == 0) |
1909 |
{ |
1910 |
if (p[4] == '1' && p[5] == '6') |
1911 |
priv.orig_sizeflag &= ~AFLAG; |
1912 |
else if (p[4] == '3' && p[5] == '2') |
1913 |
priv.orig_sizeflag |= AFLAG; |
1914 |
} |
1915 |
else if (strncmp (p, "data", 4) == 0) |
1916 |
{ |
1917 |
if (p[4] == '1' && p[5] == '6') |
1918 |
priv.orig_sizeflag &= ~DFLAG; |
1919 |
else if (p[4] == '3' && p[5] == '2') |
1920 |
priv.orig_sizeflag |= DFLAG; |
1921 |
} |
1922 |
else if (strncmp (p, "suffix", 6) == 0) |
1923 |
priv.orig_sizeflag |= SUFFIX_ALWAYS; |
1924 |
|
1925 |
p = strchr (p, ',');
|
1926 |
if (p != NULL) |
1927 |
p++; |
1928 |
} |
1929 |
|
1930 |
if (intel_syntax)
|
1931 |
{ |
1932 |
names64 = intel_names64; |
1933 |
names32 = intel_names32; |
1934 |
names16 = intel_names16; |
1935 |
names8 = intel_names8; |
1936 |
names8rex = intel_names8rex; |
1937 |
names_seg = intel_names_seg; |
1938 |
index16 = intel_index16; |
1939 |
open_char = '[';
|
1940 |
close_char = ']';
|
1941 |
separator_char = '+';
|
1942 |
scale_char = '*';
|
1943 |
} |
1944 |
else
|
1945 |
{ |
1946 |
names64 = att_names64; |
1947 |
names32 = att_names32; |
1948 |
names16 = att_names16; |
1949 |
names8 = att_names8; |
1950 |
names8rex = att_names8rex; |
1951 |
names_seg = att_names_seg; |
1952 |
index16 = att_index16; |
1953 |
open_char = '(';
|
1954 |
close_char = ')';
|
1955 |
separator_char = ',';
|
1956 |
scale_char = ',';
|
1957 |
} |
1958 |
|
1959 |
/* The output looks better if we put 7 bytes on a line, since that
|
1960 |
puts most long word instructions on a single line. */
|
1961 |
info->bytes_per_line = 7;
|
1962 |
|
1963 |
info->private_data = (PTR) &priv; |
1964 |
priv.max_fetched = priv.the_buffer; |
1965 |
priv.insn_start = pc; |
1966 |
|
1967 |
obuf[0] = 0; |
1968 |
op1out[0] = 0; |
1969 |
op2out[0] = 0; |
1970 |
op3out[0] = 0; |
1971 |
|
1972 |
op_index[0] = op_index[1] = op_index[2] = -1; |
1973 |
|
1974 |
the_info = info; |
1975 |
start_pc = pc; |
1976 |
start_codep = priv.the_buffer; |
1977 |
codep = priv.the_buffer; |
1978 |
|
1979 |
if (setjmp (priv.bailout) != 0) |
1980 |
{ |
1981 |
const char *name; |
1982 |
|
1983 |
/* Getting here means we tried for data but didn't get it. That
|
1984 |
means we have an incomplete instruction of some sort. Just
|
1985 |
print the first byte as a prefix or a .byte pseudo-op. */
|
1986 |
if (codep > priv.the_buffer)
|
1987 |
{ |
1988 |
name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
|
1989 |
if (name != NULL) |
1990 |
(*info->fprintf_func) (info->stream, "%s", name);
|
1991 |
else
|
1992 |
{ |
1993 |
/* Just print the first byte as a .byte instruction. */
|
1994 |
(*info->fprintf_func) (info->stream, ".byte 0x%x",
|
1995 |
(unsigned int) priv.the_buffer[0]); |
1996 |
} |
1997 |
|
1998 |
return 1; |
1999 |
} |
2000 |
|
2001 |
return -1; |
2002 |
} |
2003 |
|
2004 |
obufp = obuf; |
2005 |
ckprefix (); |
2006 |
|
2007 |
insn_codep = codep; |
2008 |
sizeflag = priv.orig_sizeflag; |
2009 |
|
2010 |
FETCH_DATA (info, codep + 1);
|
2011 |
two_source_ops = (*codep == 0x62) || (*codep == 0xc8); |
2012 |
|
2013 |
if ((prefixes & PREFIX_FWAIT)
|
2014 |
&& ((*codep < 0xd8) || (*codep > 0xdf))) |
2015 |
{ |
2016 |
const char *name; |
2017 |
|
2018 |
/* fwait not followed by floating point instruction. Print the
|
2019 |
first prefix, which is probably fwait itself. */
|
2020 |
name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
|
2021 |
if (name == NULL) |
2022 |
name = INTERNAL_DISASSEMBLER_ERROR; |
2023 |
(*info->fprintf_func) (info->stream, "%s", name);
|
2024 |
return 1; |
2025 |
} |
2026 |
|
2027 |
if (*codep == 0x0f) |
2028 |
{ |
2029 |
FETCH_DATA (info, codep + 2);
|
2030 |
dp = &dis386_twobyte[*++codep]; |
2031 |
need_modrm = twobyte_has_modrm[*codep]; |
2032 |
uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep]; |
2033 |
} |
2034 |
else
|
2035 |
{ |
2036 |
dp = &dis386[*codep]; |
2037 |
need_modrm = onebyte_has_modrm[*codep]; |
2038 |
uses_SSE_prefix = 0;
|
2039 |
} |
2040 |
codep++; |
2041 |
|
2042 |
if (!uses_SSE_prefix && (prefixes & PREFIX_REPZ))
|
2043 |
{ |
2044 |
oappend ("repz ");
|
2045 |
used_prefixes |= PREFIX_REPZ; |
2046 |
} |
2047 |
if (!uses_SSE_prefix && (prefixes & PREFIX_REPNZ))
|
2048 |
{ |
2049 |
oappend ("repnz ");
|
2050 |
used_prefixes |= PREFIX_REPNZ; |
2051 |
} |
2052 |
if (prefixes & PREFIX_LOCK)
|
2053 |
{ |
2054 |
oappend ("lock ");
|
2055 |
used_prefixes |= PREFIX_LOCK; |
2056 |
} |
2057 |
|
2058 |
if (prefixes & PREFIX_ADDR)
|
2059 |
{ |
2060 |
sizeflag ^= AFLAG; |
2061 |
if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
|
2062 |
{ |
2063 |
if ((sizeflag & AFLAG) || mode_64bit)
|
2064 |
oappend ("addr32 ");
|
2065 |
else
|
2066 |
oappend ("addr16 ");
|
2067 |
used_prefixes |= PREFIX_ADDR; |
2068 |
} |
2069 |
} |
2070 |
|
2071 |
if (!uses_SSE_prefix && (prefixes & PREFIX_DATA))
|
2072 |
{ |
2073 |
sizeflag ^= DFLAG; |
2074 |
if (dp->bytemode3 == cond_jump_mode
|
2075 |
&& dp->bytemode1 == v_mode |
2076 |
&& !intel_syntax) |
2077 |
{ |
2078 |
if (sizeflag & DFLAG)
|
2079 |
oappend ("data32 ");
|
2080 |
else
|
2081 |
oappend ("data16 ");
|
2082 |
used_prefixes |= PREFIX_DATA; |
2083 |
} |
2084 |
} |
2085 |
|
2086 |
if (need_modrm)
|
2087 |
{ |
2088 |
FETCH_DATA (info, codep + 1);
|
2089 |
mod = (*codep >> 6) & 3; |
2090 |
reg = (*codep >> 3) & 7; |
2091 |
rm = *codep & 7;
|
2092 |
} |
2093 |
|
2094 |
if (dp->name == NULL && dp->bytemode1 == FLOATCODE) |
2095 |
{ |
2096 |
dofloat (sizeflag); |
2097 |
} |
2098 |
else
|
2099 |
{ |
2100 |
int index;
|
2101 |
if (dp->name == NULL) |
2102 |
{ |
2103 |
switch (dp->bytemode1)
|
2104 |
{ |
2105 |
case USE_GROUPS:
|
2106 |
dp = &grps[dp->bytemode2][reg]; |
2107 |
break;
|
2108 |
|
2109 |
case USE_PREFIX_USER_TABLE:
|
2110 |
index = 0;
|
2111 |
used_prefixes |= (prefixes & PREFIX_REPZ); |
2112 |
if (prefixes & PREFIX_REPZ)
|
2113 |
index = 1;
|
2114 |
else
|
2115 |
{ |
2116 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2117 |
if (prefixes & PREFIX_DATA)
|
2118 |
index = 2;
|
2119 |
else
|
2120 |
{ |
2121 |
used_prefixes |= (prefixes & PREFIX_REPNZ); |
2122 |
if (prefixes & PREFIX_REPNZ)
|
2123 |
index = 3;
|
2124 |
} |
2125 |
} |
2126 |
dp = &prefix_user_table[dp->bytemode2][index]; |
2127 |
break;
|
2128 |
|
2129 |
case X86_64_SPECIAL:
|
2130 |
dp = &x86_64_table[dp->bytemode2][mode_64bit]; |
2131 |
break;
|
2132 |
|
2133 |
default:
|
2134 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
2135 |
break;
|
2136 |
} |
2137 |
} |
2138 |
|
2139 |
if (putop (dp->name, sizeflag) == 0) |
2140 |
{ |
2141 |
obufp = op1out; |
2142 |
op_ad = 2;
|
2143 |
if (dp->op1)
|
2144 |
(*dp->op1) (dp->bytemode1, sizeflag); |
2145 |
|
2146 |
obufp = op2out; |
2147 |
op_ad = 1;
|
2148 |
if (dp->op2)
|
2149 |
(*dp->op2) (dp->bytemode2, sizeflag); |
2150 |
|
2151 |
obufp = op3out; |
2152 |
op_ad = 0;
|
2153 |
if (dp->op3)
|
2154 |
(*dp->op3) (dp->bytemode3, sizeflag); |
2155 |
} |
2156 |
} |
2157 |
|
2158 |
/* See if any prefixes were not used. If so, print the first one
|
2159 |
separately. If we don't do this, we'll wind up printing an
|
2160 |
instruction stream which does not precisely correspond to the
|
2161 |
bytes we are disassembling. */
|
2162 |
if ((prefixes & ~used_prefixes) != 0) |
2163 |
{ |
2164 |
const char *name; |
2165 |
|
2166 |
name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
|
2167 |
if (name == NULL) |
2168 |
name = INTERNAL_DISASSEMBLER_ERROR; |
2169 |
(*info->fprintf_func) (info->stream, "%s", name);
|
2170 |
return 1; |
2171 |
} |
2172 |
if (rex & ~rex_used)
|
2173 |
{ |
2174 |
const char *name; |
2175 |
name = prefix_name (rex | 0x40, priv.orig_sizeflag);
|
2176 |
if (name == NULL) |
2177 |
name = INTERNAL_DISASSEMBLER_ERROR; |
2178 |
(*info->fprintf_func) (info->stream, "%s ", name);
|
2179 |
} |
2180 |
|
2181 |
obufp = obuf + strlen (obuf); |
2182 |
for (i = strlen (obuf); i < 6; i++) |
2183 |
oappend (" ");
|
2184 |
oappend (" ");
|
2185 |
(*info->fprintf_func) (info->stream, "%s", obuf);
|
2186 |
|
2187 |
/* The enter and bound instructions are printed with operands in the same
|
2188 |
order as the intel book; everything else is printed in reverse order. */
|
2189 |
if (intel_syntax || two_source_ops)
|
2190 |
{ |
2191 |
first = op1out; |
2192 |
second = op2out; |
2193 |
third = op3out; |
2194 |
op_ad = op_index[0];
|
2195 |
op_index[0] = op_index[2]; |
2196 |
op_index[2] = op_ad;
|
2197 |
} |
2198 |
else
|
2199 |
{ |
2200 |
first = op3out; |
2201 |
second = op2out; |
2202 |
third = op1out; |
2203 |
} |
2204 |
needcomma = 0;
|
2205 |
if (*first)
|
2206 |
{ |
2207 |
if (op_index[0] != -1 && !op_riprel[0]) |
2208 |
(*info->print_address_func) ((bfd_vma) op_address[op_index[0]], info);
|
2209 |
else
|
2210 |
(*info->fprintf_func) (info->stream, "%s", first);
|
2211 |
needcomma = 1;
|
2212 |
} |
2213 |
if (*second)
|
2214 |
{ |
2215 |
if (needcomma)
|
2216 |
(*info->fprintf_func) (info->stream, ",");
|
2217 |
if (op_index[1] != -1 && !op_riprel[1]) |
2218 |
(*info->print_address_func) ((bfd_vma) op_address[op_index[1]], info);
|
2219 |
else
|
2220 |
(*info->fprintf_func) (info->stream, "%s", second);
|
2221 |
needcomma = 1;
|
2222 |
} |
2223 |
if (*third)
|
2224 |
{ |
2225 |
if (needcomma)
|
2226 |
(*info->fprintf_func) (info->stream, ",");
|
2227 |
if (op_index[2] != -1 && !op_riprel[2]) |
2228 |
(*info->print_address_func) ((bfd_vma) op_address[op_index[2]], info);
|
2229 |
else
|
2230 |
(*info->fprintf_func) (info->stream, "%s", third);
|
2231 |
} |
2232 |
for (i = 0; i < 3; i++) |
2233 |
if (op_index[i] != -1 && op_riprel[i]) |
2234 |
{ |
2235 |
(*info->fprintf_func) (info->stream, " # ");
|
2236 |
(*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep |
2237 |
+ op_address[op_index[i]]), info); |
2238 |
} |
2239 |
return codep - priv.the_buffer;
|
2240 |
} |
2241 |
|
2242 |
static const char *float_mem[] = { |
2243 |
/* d8 */
|
2244 |
"fadd{s||s|}",
|
2245 |
"fmul{s||s|}",
|
2246 |
"fcom{s||s|}",
|
2247 |
"fcomp{s||s|}",
|
2248 |
"fsub{s||s|}",
|
2249 |
"fsubr{s||s|}",
|
2250 |
"fdiv{s||s|}",
|
2251 |
"fdivr{s||s|}",
|
2252 |
/* d9 */
|
2253 |
"fld{s||s|}",
|
2254 |
"(bad)",
|
2255 |
"fst{s||s|}",
|
2256 |
"fstp{s||s|}",
|
2257 |
"fldenv",
|
2258 |
"fldcw",
|
2259 |
"fNstenv",
|
2260 |
"fNstcw",
|
2261 |
/* da */
|
2262 |
"fiadd{l||l|}",
|
2263 |
"fimul{l||l|}",
|
2264 |
"ficom{l||l|}",
|
2265 |
"ficomp{l||l|}",
|
2266 |
"fisub{l||l|}",
|
2267 |
"fisubr{l||l|}",
|
2268 |
"fidiv{l||l|}",
|
2269 |
"fidivr{l||l|}",
|
2270 |
/* db */
|
2271 |
"fild{l||l|}",
|
2272 |
"(bad)",
|
2273 |
"fist{l||l|}",
|
2274 |
"fistp{l||l|}",
|
2275 |
"(bad)",
|
2276 |
"fld{t||t|}",
|
2277 |
"(bad)",
|
2278 |
"fstp{t||t|}",
|
2279 |
/* dc */
|
2280 |
"fadd{l||l|}",
|
2281 |
"fmul{l||l|}",
|
2282 |
"fcom{l||l|}",
|
2283 |
"fcomp{l||l|}",
|
2284 |
"fsub{l||l|}",
|
2285 |
"fsubr{l||l|}",
|
2286 |
"fdiv{l||l|}",
|
2287 |
"fdivr{l||l|}",
|
2288 |
/* dd */
|
2289 |
"fld{l||l|}",
|
2290 |
"(bad)",
|
2291 |
"fst{l||l|}",
|
2292 |
"fstp{l||l|}",
|
2293 |
"frstor",
|
2294 |
"(bad)",
|
2295 |
"fNsave",
|
2296 |
"fNstsw",
|
2297 |
/* de */
|
2298 |
"fiadd",
|
2299 |
"fimul",
|
2300 |
"ficom",
|
2301 |
"ficomp",
|
2302 |
"fisub",
|
2303 |
"fisubr",
|
2304 |
"fidiv",
|
2305 |
"fidivr",
|
2306 |
/* df */
|
2307 |
"fild",
|
2308 |
"(bad)",
|
2309 |
"fist",
|
2310 |
"fistp",
|
2311 |
"fbld",
|
2312 |
"fild{ll||ll|}",
|
2313 |
"fbstp",
|
2314 |
"fistpll",
|
2315 |
}; |
2316 |
|
2317 |
#define ST OP_ST, 0 |
2318 |
#define STi OP_STi, 0 |
2319 |
|
2320 |
#define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0 |
2321 |
#define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0 |
2322 |
#define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0 |
2323 |
#define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0 |
2324 |
#define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0 |
2325 |
#define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0 |
2326 |
#define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0 |
2327 |
#define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0 |
2328 |
#define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0 |
2329 |
|
2330 |
static const struct dis386 float_reg[][8] = { |
2331 |
/* d8 */
|
2332 |
{ |
2333 |
{ "fadd", ST, STi, XX },
|
2334 |
{ "fmul", ST, STi, XX },
|
2335 |
{ "fcom", STi, XX, XX },
|
2336 |
{ "fcomp", STi, XX, XX },
|
2337 |
{ "fsub", ST, STi, XX },
|
2338 |
{ "fsubr", ST, STi, XX },
|
2339 |
{ "fdiv", ST, STi, XX },
|
2340 |
{ "fdivr", ST, STi, XX },
|
2341 |
}, |
2342 |
/* d9 */
|
2343 |
{ |
2344 |
{ "fld", STi, XX, XX },
|
2345 |
{ "fxch", STi, XX, XX },
|
2346 |
{ FGRPd9_2 }, |
2347 |
{ "(bad)", XX, XX, XX },
|
2348 |
{ FGRPd9_4 }, |
2349 |
{ FGRPd9_5 }, |
2350 |
{ FGRPd9_6 }, |
2351 |
{ FGRPd9_7 }, |
2352 |
}, |
2353 |
/* da */
|
2354 |
{ |
2355 |
{ "fcmovb", ST, STi, XX },
|
2356 |
{ "fcmove", ST, STi, XX },
|
2357 |
{ "fcmovbe",ST, STi, XX },
|
2358 |
{ "fcmovu", ST, STi, XX },
|
2359 |
{ "(bad)", XX, XX, XX },
|
2360 |
{ FGRPda_5 }, |
2361 |
{ "(bad)", XX, XX, XX },
|
2362 |
{ "(bad)", XX, XX, XX },
|
2363 |
}, |
2364 |
/* db */
|
2365 |
{ |
2366 |
{ "fcmovnb",ST, STi, XX },
|
2367 |
{ "fcmovne",ST, STi, XX },
|
2368 |
{ "fcmovnbe",ST, STi, XX },
|
2369 |
{ "fcmovnu",ST, STi, XX },
|
2370 |
{ FGRPdb_4 }, |
2371 |
{ "fucomi", ST, STi, XX },
|
2372 |
{ "fcomi", ST, STi, XX },
|
2373 |
{ "(bad)", XX, XX, XX },
|
2374 |
}, |
2375 |
/* dc */
|
2376 |
{ |
2377 |
{ "fadd", STi, ST, XX },
|
2378 |
{ "fmul", STi, ST, XX },
|
2379 |
{ "(bad)", XX, XX, XX },
|
2380 |
{ "(bad)", XX, XX, XX },
|
2381 |
#if UNIXWARE_COMPAT
|
2382 |
{ "fsub", STi, ST, XX },
|
2383 |
{ "fsubr", STi, ST, XX },
|
2384 |
{ "fdiv", STi, ST, XX },
|
2385 |
{ "fdivr", STi, ST, XX },
|
2386 |
#else
|
2387 |
{ "fsubr", STi, ST, XX },
|
2388 |
{ "fsub", STi, ST, XX },
|
2389 |
{ "fdivr", STi, ST, XX },
|
2390 |
{ "fdiv", STi, ST, XX },
|
2391 |
#endif
|
2392 |
}, |
2393 |
/* dd */
|
2394 |
{ |
2395 |
{ "ffree", STi, XX, XX },
|
2396 |
{ "(bad)", XX, XX, XX },
|
2397 |
{ "fst", STi, XX, XX },
|
2398 |
{ "fstp", STi, XX, XX },
|
2399 |
{ "fucom", STi, XX, XX },
|
2400 |
{ "fucomp", STi, XX, XX },
|
2401 |
{ "(bad)", XX, XX, XX },
|
2402 |
{ "(bad)", XX, XX, XX },
|
2403 |
}, |
2404 |
/* de */
|
2405 |
{ |
2406 |
{ "faddp", STi, ST, XX },
|
2407 |
{ "fmulp", STi, ST, XX },
|
2408 |
{ "(bad)", XX, XX, XX },
|
2409 |
{ FGRPde_3 }, |
2410 |
#if UNIXWARE_COMPAT
|
2411 |
{ "fsubp", STi, ST, XX },
|
2412 |
{ "fsubrp", STi, ST, XX },
|
2413 |
{ "fdivp", STi, ST, XX },
|
2414 |
{ "fdivrp", STi, ST, XX },
|
2415 |
#else
|
2416 |
{ "fsubrp", STi, ST, XX },
|
2417 |
{ "fsubp", STi, ST, XX },
|
2418 |
{ "fdivrp", STi, ST, XX },
|
2419 |
{ "fdivp", STi, ST, XX },
|
2420 |
#endif
|
2421 |
}, |
2422 |
/* df */
|
2423 |
{ |
2424 |
{ "ffreep", STi, XX, XX },
|
2425 |
{ "(bad)", XX, XX, XX },
|
2426 |
{ "(bad)", XX, XX, XX },
|
2427 |
{ "(bad)", XX, XX, XX },
|
2428 |
{ FGRPdf_4 }, |
2429 |
{ "fucomip",ST, STi, XX },
|
2430 |
{ "fcomip", ST, STi, XX },
|
2431 |
{ "(bad)", XX, XX, XX },
|
2432 |
}, |
2433 |
}; |
2434 |
|
2435 |
static char *fgrps[][8] = { |
2436 |
/* d9_2 0 */
|
2437 |
{ |
2438 |
"fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
2439 |
}, |
2440 |
|
2441 |
/* d9_4 1 */
|
2442 |
{ |
2443 |
"fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)", |
2444 |
}, |
2445 |
|
2446 |
/* d9_5 2 */
|
2447 |
{ |
2448 |
"fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)", |
2449 |
}, |
2450 |
|
2451 |
/* d9_6 3 */
|
2452 |
{ |
2453 |
"f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp", |
2454 |
}, |
2455 |
|
2456 |
/* d9_7 4 */
|
2457 |
{ |
2458 |
"fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos", |
2459 |
}, |
2460 |
|
2461 |
/* da_5 5 */
|
2462 |
{ |
2463 |
"(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
2464 |
}, |
2465 |
|
2466 |
/* db_4 6 */
|
2467 |
{ |
2468 |
"feni(287 only)","fdisi(287 only)","fNclex","fNinit", |
2469 |
"fNsetpm(287 only)","(bad)","(bad)","(bad)", |
2470 |
}, |
2471 |
|
2472 |
/* de_3 7 */
|
2473 |
{ |
2474 |
"(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
2475 |
}, |
2476 |
|
2477 |
/* df_4 8 */
|
2478 |
{ |
2479 |
"fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", |
2480 |
}, |
2481 |
}; |
2482 |
|
2483 |
static void |
2484 |
dofloat (sizeflag) |
2485 |
int sizeflag;
|
2486 |
{ |
2487 |
const struct dis386 *dp; |
2488 |
unsigned char floatop; |
2489 |
|
2490 |
floatop = codep[-1];
|
2491 |
|
2492 |
if (mod != 3) |
2493 |
{ |
2494 |
putop (float_mem[(floatop - 0xd8) * 8 + reg], sizeflag); |
2495 |
obufp = op1out; |
2496 |
if (floatop == 0xdb) |
2497 |
OP_E (x_mode, sizeflag); |
2498 |
else if (floatop == 0xdd) |
2499 |
OP_E (d_mode, sizeflag); |
2500 |
else
|
2501 |
OP_E (v_mode, sizeflag); |
2502 |
return;
|
2503 |
} |
2504 |
/* Skip mod/rm byte. */
|
2505 |
MODRM_CHECK; |
2506 |
codep++; |
2507 |
|
2508 |
dp = &float_reg[floatop - 0xd8][reg];
|
2509 |
if (dp->name == NULL) |
2510 |
{ |
2511 |
putop (fgrps[dp->bytemode1][rm], sizeflag); |
2512 |
|
2513 |
/* Instruction fnstsw is only one with strange arg. */
|
2514 |
if (floatop == 0xdf && codep[-1] == 0xe0) |
2515 |
strcpy (op1out, names16[0]);
|
2516 |
} |
2517 |
else
|
2518 |
{ |
2519 |
putop (dp->name, sizeflag); |
2520 |
|
2521 |
obufp = op1out; |
2522 |
if (dp->op1)
|
2523 |
(*dp->op1) (dp->bytemode1, sizeflag); |
2524 |
obufp = op2out; |
2525 |
if (dp->op2)
|
2526 |
(*dp->op2) (dp->bytemode2, sizeflag); |
2527 |
} |
2528 |
} |
2529 |
|
2530 |
static void |
2531 |
OP_ST (bytemode, sizeflag) |
2532 |
int bytemode;
|
2533 |
int sizeflag;
|
2534 |
{ |
2535 |
oappend ("%st");
|
2536 |
} |
2537 |
|
2538 |
static void |
2539 |
OP_STi (bytemode, sizeflag) |
2540 |
int bytemode;
|
2541 |
int sizeflag;
|
2542 |
{ |
2543 |
sprintf (scratchbuf, "%%st(%d)", rm);
|
2544 |
oappend (scratchbuf + intel_syntax); |
2545 |
} |
2546 |
|
2547 |
/* Capital letters in template are macros. */
|
2548 |
static int |
2549 |
putop (template, sizeflag) |
2550 |
const char *template; |
2551 |
int sizeflag;
|
2552 |
{ |
2553 |
const char *p; |
2554 |
int alt;
|
2555 |
|
2556 |
for (p = template; *p; p++)
|
2557 |
{ |
2558 |
switch (*p)
|
2559 |
{ |
2560 |
default:
|
2561 |
*obufp++ = *p; |
2562 |
break;
|
2563 |
case '{': |
2564 |
alt = 0;
|
2565 |
if (intel_syntax)
|
2566 |
alt += 1;
|
2567 |
if (mode_64bit)
|
2568 |
alt += 2;
|
2569 |
while (alt != 0) |
2570 |
{ |
2571 |
while (*++p != '|') |
2572 |
{ |
2573 |
if (*p == '}') |
2574 |
{ |
2575 |
/* Alternative not valid. */
|
2576 |
strcpy (obuf, "(bad)");
|
2577 |
obufp = obuf + 5;
|
2578 |
return 1; |
2579 |
} |
2580 |
else if (*p == '\0') |
2581 |
abort (); |
2582 |
} |
2583 |
alt--; |
2584 |
} |
2585 |
break;
|
2586 |
case '|': |
2587 |
while (*++p != '}') |
2588 |
{ |
2589 |
if (*p == '\0') |
2590 |
abort (); |
2591 |
} |
2592 |
break;
|
2593 |
case '}': |
2594 |
break;
|
2595 |
case 'A': |
2596 |
if (intel_syntax)
|
2597 |
break;
|
2598 |
if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) |
2599 |
*obufp++ = 'b';
|
2600 |
break;
|
2601 |
case 'B': |
2602 |
if (intel_syntax)
|
2603 |
break;
|
2604 |
if (sizeflag & SUFFIX_ALWAYS)
|
2605 |
*obufp++ = 'b';
|
2606 |
break;
|
2607 |
case 'E': /* For jcxz/jecxz */ |
2608 |
if (mode_64bit)
|
2609 |
{ |
2610 |
if (sizeflag & AFLAG)
|
2611 |
*obufp++ = 'r';
|
2612 |
else
|
2613 |
*obufp++ = 'e';
|
2614 |
} |
2615 |
else
|
2616 |
if (sizeflag & AFLAG)
|
2617 |
*obufp++ = 'e';
|
2618 |
used_prefixes |= (prefixes & PREFIX_ADDR); |
2619 |
break;
|
2620 |
case 'F': |
2621 |
if (intel_syntax)
|
2622 |
break;
|
2623 |
if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
|
2624 |
{ |
2625 |
if (sizeflag & AFLAG)
|
2626 |
*obufp++ = mode_64bit ? 'q' : 'l'; |
2627 |
else
|
2628 |
*obufp++ = mode_64bit ? 'l' : 'w'; |
2629 |
used_prefixes |= (prefixes & PREFIX_ADDR); |
2630 |
} |
2631 |
break;
|
2632 |
case 'H': |
2633 |
if (intel_syntax)
|
2634 |
break;
|
2635 |
if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
|
2636 |
|| (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) |
2637 |
{ |
2638 |
used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS); |
2639 |
*obufp++ = ',';
|
2640 |
*obufp++ = 'p';
|
2641 |
if (prefixes & PREFIX_DS)
|
2642 |
*obufp++ = 't';
|
2643 |
else
|
2644 |
*obufp++ = 'n';
|
2645 |
} |
2646 |
break;
|
2647 |
case 'L': |
2648 |
if (intel_syntax)
|
2649 |
break;
|
2650 |
if (sizeflag & SUFFIX_ALWAYS)
|
2651 |
*obufp++ = 'l';
|
2652 |
break;
|
2653 |
case 'N': |
2654 |
if ((prefixes & PREFIX_FWAIT) == 0) |
2655 |
*obufp++ = 'n';
|
2656 |
else
|
2657 |
used_prefixes |= PREFIX_FWAIT; |
2658 |
break;
|
2659 |
case 'O': |
2660 |
USED_REX (REX_MODE64); |
2661 |
if (rex & REX_MODE64)
|
2662 |
*obufp++ = 'o';
|
2663 |
else
|
2664 |
*obufp++ = 'd';
|
2665 |
break;
|
2666 |
case 'T': |
2667 |
if (intel_syntax)
|
2668 |
break;
|
2669 |
if (mode_64bit)
|
2670 |
{ |
2671 |
*obufp++ = 'q';
|
2672 |
break;
|
2673 |
} |
2674 |
/* Fall through. */
|
2675 |
case 'P': |
2676 |
if (intel_syntax)
|
2677 |
break;
|
2678 |
if ((prefixes & PREFIX_DATA)
|
2679 |
|| (rex & REX_MODE64) |
2680 |
|| (sizeflag & SUFFIX_ALWAYS)) |
2681 |
{ |
2682 |
USED_REX (REX_MODE64); |
2683 |
if (rex & REX_MODE64)
|
2684 |
*obufp++ = 'q';
|
2685 |
else
|
2686 |
{ |
2687 |
if (sizeflag & DFLAG)
|
2688 |
*obufp++ = 'l';
|
2689 |
else
|
2690 |
*obufp++ = 'w';
|
2691 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2692 |
} |
2693 |
} |
2694 |
break;
|
2695 |
case 'U': |
2696 |
if (intel_syntax)
|
2697 |
break;
|
2698 |
if (mode_64bit)
|
2699 |
{ |
2700 |
*obufp++ = 'q';
|
2701 |
break;
|
2702 |
} |
2703 |
/* Fall through. */
|
2704 |
case 'Q': |
2705 |
if (intel_syntax)
|
2706 |
break;
|
2707 |
USED_REX (REX_MODE64); |
2708 |
if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) |
2709 |
{ |
2710 |
if (rex & REX_MODE64)
|
2711 |
*obufp++ = 'q';
|
2712 |
else
|
2713 |
{ |
2714 |
if (sizeflag & DFLAG)
|
2715 |
*obufp++ = 'l';
|
2716 |
else
|
2717 |
*obufp++ = 'w';
|
2718 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2719 |
} |
2720 |
} |
2721 |
break;
|
2722 |
case 'R': |
2723 |
USED_REX (REX_MODE64); |
2724 |
if (intel_syntax)
|
2725 |
{ |
2726 |
if (rex & REX_MODE64)
|
2727 |
{ |
2728 |
*obufp++ = 'q';
|
2729 |
*obufp++ = 't';
|
2730 |
} |
2731 |
else if (sizeflag & DFLAG) |
2732 |
{ |
2733 |
*obufp++ = 'd';
|
2734 |
*obufp++ = 'q';
|
2735 |
} |
2736 |
else
|
2737 |
{ |
2738 |
*obufp++ = 'w';
|
2739 |
*obufp++ = 'd';
|
2740 |
} |
2741 |
} |
2742 |
else
|
2743 |
{ |
2744 |
if (rex & REX_MODE64)
|
2745 |
*obufp++ = 'q';
|
2746 |
else if (sizeflag & DFLAG) |
2747 |
*obufp++ = 'l';
|
2748 |
else
|
2749 |
*obufp++ = 'w';
|
2750 |
} |
2751 |
if (!(rex & REX_MODE64))
|
2752 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2753 |
break;
|
2754 |
case 'S': |
2755 |
if (intel_syntax)
|
2756 |
break;
|
2757 |
if (sizeflag & SUFFIX_ALWAYS)
|
2758 |
{ |
2759 |
if (rex & REX_MODE64)
|
2760 |
*obufp++ = 'q';
|
2761 |
else
|
2762 |
{ |
2763 |
if (sizeflag & DFLAG)
|
2764 |
*obufp++ = 'l';
|
2765 |
else
|
2766 |
*obufp++ = 'w';
|
2767 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2768 |
} |
2769 |
} |
2770 |
break;
|
2771 |
case 'X': |
2772 |
if (prefixes & PREFIX_DATA)
|
2773 |
*obufp++ = 'd';
|
2774 |
else
|
2775 |
*obufp++ = 's';
|
2776 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2777 |
break;
|
2778 |
case 'Y': |
2779 |
if (intel_syntax)
|
2780 |
break;
|
2781 |
if (rex & REX_MODE64)
|
2782 |
{ |
2783 |
USED_REX (REX_MODE64); |
2784 |
*obufp++ = 'q';
|
2785 |
} |
2786 |
break;
|
2787 |
/* implicit operand size 'l' for i386 or 'q' for x86-64 */
|
2788 |
case 'W': |
2789 |
/* operand size flag for cwtl, cbtw */
|
2790 |
USED_REX (0);
|
2791 |
if (rex)
|
2792 |
*obufp++ = 'l';
|
2793 |
else if (sizeflag & DFLAG) |
2794 |
*obufp++ = 'w';
|
2795 |
else
|
2796 |
*obufp++ = 'b';
|
2797 |
if (intel_syntax)
|
2798 |
{ |
2799 |
if (rex)
|
2800 |
{ |
2801 |
*obufp++ = 'q';
|
2802 |
*obufp++ = 'e';
|
2803 |
} |
2804 |
if (sizeflag & DFLAG)
|
2805 |
{ |
2806 |
*obufp++ = 'd';
|
2807 |
*obufp++ = 'e';
|
2808 |
} |
2809 |
else
|
2810 |
{ |
2811 |
*obufp++ = 'w';
|
2812 |
} |
2813 |
} |
2814 |
if (!rex)
|
2815 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2816 |
break;
|
2817 |
} |
2818 |
} |
2819 |
*obufp = 0;
|
2820 |
return 0; |
2821 |
} |
2822 |
|
2823 |
static void |
2824 |
oappend (s) |
2825 |
const char *s; |
2826 |
{ |
2827 |
strcpy (obufp, s); |
2828 |
obufp += strlen (s); |
2829 |
} |
2830 |
|
2831 |
static void |
2832 |
append_seg () |
2833 |
{ |
2834 |
if (prefixes & PREFIX_CS)
|
2835 |
{ |
2836 |
used_prefixes |= PREFIX_CS; |
2837 |
oappend ("%cs:" + intel_syntax);
|
2838 |
} |
2839 |
if (prefixes & PREFIX_DS)
|
2840 |
{ |
2841 |
used_prefixes |= PREFIX_DS; |
2842 |
oappend ("%ds:" + intel_syntax);
|
2843 |
} |
2844 |
if (prefixes & PREFIX_SS)
|
2845 |
{ |
2846 |
used_prefixes |= PREFIX_SS; |
2847 |
oappend ("%ss:" + intel_syntax);
|
2848 |
} |
2849 |
if (prefixes & PREFIX_ES)
|
2850 |
{ |
2851 |
used_prefixes |= PREFIX_ES; |
2852 |
oappend ("%es:" + intel_syntax);
|
2853 |
} |
2854 |
if (prefixes & PREFIX_FS)
|
2855 |
{ |
2856 |
used_prefixes |= PREFIX_FS; |
2857 |
oappend ("%fs:" + intel_syntax);
|
2858 |
} |
2859 |
if (prefixes & PREFIX_GS)
|
2860 |
{ |
2861 |
used_prefixes |= PREFIX_GS; |
2862 |
oappend ("%gs:" + intel_syntax);
|
2863 |
} |
2864 |
} |
2865 |
|
2866 |
static void |
2867 |
OP_indirE (bytemode, sizeflag) |
2868 |
int bytemode;
|
2869 |
int sizeflag;
|
2870 |
{ |
2871 |
if (!intel_syntax)
|
2872 |
oappend ("*");
|
2873 |
OP_E (bytemode, sizeflag); |
2874 |
} |
2875 |
|
2876 |
static void |
2877 |
print_operand_value (buf, hex, disp) |
2878 |
char *buf;
|
2879 |
int hex;
|
2880 |
bfd_vma disp; |
2881 |
{ |
2882 |
if (mode_64bit)
|
2883 |
{ |
2884 |
if (hex)
|
2885 |
{ |
2886 |
char tmp[30]; |
2887 |
int i;
|
2888 |
buf[0] = '0'; |
2889 |
buf[1] = 'x'; |
2890 |
sprintf_vma (tmp, disp); |
2891 |
for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++); |
2892 |
strcpy (buf + 2, tmp + i);
|
2893 |
} |
2894 |
else
|
2895 |
{ |
2896 |
bfd_signed_vma v = disp; |
2897 |
char tmp[30]; |
2898 |
int i;
|
2899 |
if (v < 0) |
2900 |
{ |
2901 |
*(buf++) = '-';
|
2902 |
v = -disp; |
2903 |
/* Check for possible overflow on 0x8000000000000000. */
|
2904 |
if (v < 0) |
2905 |
{ |
2906 |
strcpy (buf, "9223372036854775808");
|
2907 |
return;
|
2908 |
} |
2909 |
} |
2910 |
if (!v)
|
2911 |
{ |
2912 |
strcpy (buf, "0");
|
2913 |
return;
|
2914 |
} |
2915 |
|
2916 |
i = 0;
|
2917 |
tmp[29] = 0; |
2918 |
while (v)
|
2919 |
{ |
2920 |
tmp[28 - i] = (v % 10) + '0'; |
2921 |
v /= 10;
|
2922 |
i++; |
2923 |
} |
2924 |
strcpy (buf, tmp + 29 - i);
|
2925 |
} |
2926 |
} |
2927 |
else
|
2928 |
{ |
2929 |
if (hex)
|
2930 |
sprintf (buf, "0x%x", (unsigned int) disp); |
2931 |
else
|
2932 |
sprintf (buf, "%d", (int) disp); |
2933 |
} |
2934 |
} |
2935 |
|
2936 |
static void |
2937 |
OP_E (bytemode, sizeflag) |
2938 |
int bytemode;
|
2939 |
int sizeflag;
|
2940 |
{ |
2941 |
bfd_vma disp; |
2942 |
int add = 0; |
2943 |
int riprel = 0; |
2944 |
USED_REX (REX_EXTZ); |
2945 |
if (rex & REX_EXTZ)
|
2946 |
add += 8;
|
2947 |
|
2948 |
/* Skip mod/rm byte. */
|
2949 |
MODRM_CHECK; |
2950 |
codep++; |
2951 |
|
2952 |
if (mod == 3) |
2953 |
{ |
2954 |
switch (bytemode)
|
2955 |
{ |
2956 |
case b_mode:
|
2957 |
USED_REX (0);
|
2958 |
if (rex)
|
2959 |
oappend (names8rex[rm + add]); |
2960 |
else
|
2961 |
oappend (names8[rm + add]); |
2962 |
break;
|
2963 |
case w_mode:
|
2964 |
oappend (names16[rm + add]); |
2965 |
break;
|
2966 |
case d_mode:
|
2967 |
oappend (names32[rm + add]); |
2968 |
break;
|
2969 |
case q_mode:
|
2970 |
oappend (names64[rm + add]); |
2971 |
break;
|
2972 |
case m_mode:
|
2973 |
if (mode_64bit)
|
2974 |
oappend (names64[rm + add]); |
2975 |
else
|
2976 |
oappend (names32[rm + add]); |
2977 |
break;
|
2978 |
case v_mode:
|
2979 |
USED_REX (REX_MODE64); |
2980 |
if (rex & REX_MODE64)
|
2981 |
oappend (names64[rm + add]); |
2982 |
else if (sizeflag & DFLAG) |
2983 |
oappend (names32[rm + add]); |
2984 |
else
|
2985 |
oappend (names16[rm + add]); |
2986 |
used_prefixes |= (prefixes & PREFIX_DATA); |
2987 |
break;
|
2988 |
case 0: |
2989 |
if (!(codep[-2] == 0xAE && codep[-1] == 0xF8 /* sfence */) |
2990 |
&& !(codep[-2] == 0xAE && codep[-1] == 0xF0 /* mfence */) |
2991 |
&& !(codep[-2] == 0xAE && codep[-1] == 0xe8 /* lfence */)) |
2992 |
BadOp (); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */
|
2993 |
break;
|
2994 |
default:
|
2995 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
2996 |
break;
|
2997 |
} |
2998 |
return;
|
2999 |
} |
3000 |
|
3001 |
disp = 0;
|
3002 |
append_seg (); |
3003 |
|
3004 |
if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */ |
3005 |
{ |
3006 |
int havesib;
|
3007 |
int havebase;
|
3008 |
int base;
|
3009 |
int index = 0; |
3010 |
int scale = 0; |
3011 |
|
3012 |
havesib = 0;
|
3013 |
havebase = 1;
|
3014 |
base = rm; |
3015 |
|
3016 |
if (base == 4) |
3017 |
{ |
3018 |
havesib = 1;
|
3019 |
FETCH_DATA (the_info, codep + 1);
|
3020 |
scale = (*codep >> 6) & 3; |
3021 |
index = (*codep >> 3) & 7; |
3022 |
base = *codep & 7;
|
3023 |
USED_REX (REX_EXTY); |
3024 |
USED_REX (REX_EXTZ); |
3025 |
if (rex & REX_EXTY)
|
3026 |
index += 8;
|
3027 |
if (rex & REX_EXTZ)
|
3028 |
base += 8;
|
3029 |
codep++; |
3030 |
} |
3031 |
|
3032 |
switch (mod)
|
3033 |
{ |
3034 |
case 0: |
3035 |
if ((base & 7) == 5) |
3036 |
{ |
3037 |
havebase = 0;
|
3038 |
if (mode_64bit && !havesib && (sizeflag & AFLAG))
|
3039 |
riprel = 1;
|
3040 |
disp = get32s (); |
3041 |
} |
3042 |
break;
|
3043 |
case 1: |
3044 |
FETCH_DATA (the_info, codep + 1);
|
3045 |
disp = *codep++; |
3046 |
if ((disp & 0x80) != 0) |
3047 |
disp -= 0x100;
|
3048 |
break;
|
3049 |
case 2: |
3050 |
disp = get32s (); |
3051 |
break;
|
3052 |
} |
3053 |
|
3054 |
if (!intel_syntax)
|
3055 |
if (mod != 0 || (base & 7) == 5) |
3056 |
{ |
3057 |
print_operand_value (scratchbuf, !riprel, disp); |
3058 |
oappend (scratchbuf); |
3059 |
if (riprel)
|
3060 |
{ |
3061 |
set_op (disp, 1);
|
3062 |
oappend ("(%rip)");
|
3063 |
} |
3064 |
} |
3065 |
|
3066 |
if (havebase || (havesib && (index != 4 || scale != 0))) |
3067 |
{ |
3068 |
if (intel_syntax)
|
3069 |
{ |
3070 |
switch (bytemode)
|
3071 |
{ |
3072 |
case b_mode:
|
3073 |
oappend ("BYTE PTR ");
|
3074 |
break;
|
3075 |
case w_mode:
|
3076 |
oappend ("WORD PTR ");
|
3077 |
break;
|
3078 |
case v_mode:
|
3079 |
oappend ("DWORD PTR ");
|
3080 |
break;
|
3081 |
case d_mode:
|
3082 |
oappend ("QWORD PTR ");
|
3083 |
break;
|
3084 |
case m_mode:
|
3085 |
if (mode_64bit)
|
3086 |
oappend ("DWORD PTR ");
|
3087 |
else
|
3088 |
oappend ("QWORD PTR ");
|
3089 |
break;
|
3090 |
case x_mode:
|
3091 |
oappend ("XWORD PTR ");
|
3092 |
break;
|
3093 |
default:
|
3094 |
break;
|
3095 |
} |
3096 |
} |
3097 |
*obufp++ = open_char; |
3098 |
if (intel_syntax && riprel)
|
3099 |
oappend ("rip + ");
|
3100 |
*obufp = '\0';
|
3101 |
USED_REX (REX_EXTZ); |
3102 |
if (!havesib && (rex & REX_EXTZ))
|
3103 |
base += 8;
|
3104 |
if (havebase)
|
3105 |
oappend (mode_64bit && (sizeflag & AFLAG) |
3106 |
? names64[base] : names32[base]); |
3107 |
if (havesib)
|
3108 |
{ |
3109 |
if (index != 4) |
3110 |
{ |
3111 |
if (intel_syntax)
|
3112 |
{ |
3113 |
if (havebase)
|
3114 |
{ |
3115 |
*obufp++ = separator_char; |
3116 |
*obufp = '\0';
|
3117 |
} |
3118 |
sprintf (scratchbuf, "%s",
|
3119 |
mode_64bit && (sizeflag & AFLAG) |
3120 |
? names64[index] : names32[index]); |
3121 |
} |
3122 |
else
|
3123 |
sprintf (scratchbuf, ",%s",
|
3124 |
mode_64bit && (sizeflag & AFLAG) |
3125 |
? names64[index] : names32[index]); |
3126 |
oappend (scratchbuf); |
3127 |
} |
3128 |
if (!intel_syntax
|
3129 |
|| (intel_syntax |
3130 |
&& bytemode != b_mode |
3131 |
&& bytemode != w_mode |
3132 |
&& bytemode != v_mode)) |
3133 |
{ |
3134 |
*obufp++ = scale_char; |
3135 |
*obufp = '\0';
|
3136 |
sprintf (scratchbuf, "%d", 1 << scale); |
3137 |
oappend (scratchbuf); |
3138 |
} |
3139 |
} |
3140 |
if (intel_syntax)
|
3141 |
if (mod != 0 || (base & 7) == 5) |
3142 |
{ |
3143 |
/* Don't print zero displacements. */
|
3144 |
if (disp != 0) |
3145 |
{ |
3146 |
if ((bfd_signed_vma) disp > 0) |
3147 |
{ |
3148 |
*obufp++ = '+';
|
3149 |
*obufp = '\0';
|
3150 |
} |
3151 |
|
3152 |
print_operand_value (scratchbuf, 0, disp);
|
3153 |
oappend (scratchbuf); |
3154 |
} |
3155 |
} |
3156 |
|
3157 |
*obufp++ = close_char; |
3158 |
*obufp = '\0';
|
3159 |
} |
3160 |
else if (intel_syntax) |
3161 |
{ |
3162 |
if (mod != 0 || (base & 7) == 5) |
3163 |
{ |
3164 |
if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
|
3165 |
| PREFIX_ES | PREFIX_FS | PREFIX_GS)) |
3166 |
; |
3167 |
else
|
3168 |
{ |
3169 |
oappend (names_seg[ds_reg - es_reg]); |
3170 |
oappend (":");
|
3171 |
} |
3172 |
print_operand_value (scratchbuf, 1, disp);
|
3173 |
oappend (scratchbuf); |
3174 |
} |
3175 |
} |
3176 |
} |
3177 |
else
|
3178 |
{ /* 16 bit address mode */
|
3179 |
switch (mod)
|
3180 |
{ |
3181 |
case 0: |
3182 |
if ((rm & 7) == 6) |
3183 |
{ |
3184 |
disp = get16 (); |
3185 |
if ((disp & 0x8000) != 0) |
3186 |
disp -= 0x10000;
|
3187 |
} |
3188 |
break;
|
3189 |
case 1: |
3190 |
FETCH_DATA (the_info, codep + 1);
|
3191 |
disp = *codep++; |
3192 |
if ((disp & 0x80) != 0) |
3193 |
disp -= 0x100;
|
3194 |
break;
|
3195 |
case 2: |
3196 |
disp = get16 (); |
3197 |
if ((disp & 0x8000) != 0) |
3198 |
disp -= 0x10000;
|
3199 |
break;
|
3200 |
} |
3201 |
|
3202 |
if (!intel_syntax)
|
3203 |
if (mod != 0 || (rm & 7) == 6) |
3204 |
{ |
3205 |
print_operand_value (scratchbuf, 0, disp);
|
3206 |
oappend (scratchbuf); |
3207 |
} |
3208 |
|
3209 |
if (mod != 0 || (rm & 7) != 6) |
3210 |
{ |
3211 |
*obufp++ = open_char; |
3212 |
*obufp = '\0';
|
3213 |
oappend (index16[rm + add]); |
3214 |
*obufp++ = close_char; |
3215 |
*obufp = '\0';
|
3216 |
} |
3217 |
} |
3218 |
} |
3219 |
|
3220 |
static void |
3221 |
OP_G (bytemode, sizeflag) |
3222 |
int bytemode;
|
3223 |
int sizeflag;
|
3224 |
{ |
3225 |
int add = 0; |
3226 |
USED_REX (REX_EXTX); |
3227 |
if (rex & REX_EXTX)
|
3228 |
add += 8;
|
3229 |
switch (bytemode)
|
3230 |
{ |
3231 |
case b_mode:
|
3232 |
USED_REX (0);
|
3233 |
if (rex)
|
3234 |
oappend (names8rex[reg + add]); |
3235 |
else
|
3236 |
oappend (names8[reg + add]); |
3237 |
break;
|
3238 |
case w_mode:
|
3239 |
oappend (names16[reg + add]); |
3240 |
break;
|
3241 |
case d_mode:
|
3242 |
oappend (names32[reg + add]); |
3243 |
break;
|
3244 |
case q_mode:
|
3245 |
oappend (names64[reg + add]); |
3246 |
break;
|
3247 |
case v_mode:
|
3248 |
USED_REX (REX_MODE64); |
3249 |
if (rex & REX_MODE64)
|
3250 |
oappend (names64[reg + add]); |
3251 |
else if (sizeflag & DFLAG) |
3252 |
oappend (names32[reg + add]); |
3253 |
else
|
3254 |
oappend (names16[reg + add]); |
3255 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3256 |
break;
|
3257 |
default:
|
3258 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
3259 |
break;
|
3260 |
} |
3261 |
} |
3262 |
|
3263 |
static bfd_vma
|
3264 |
get64 () |
3265 |
{ |
3266 |
bfd_vma x; |
3267 |
#ifdef BFD64
|
3268 |
unsigned int a; |
3269 |
unsigned int b; |
3270 |
|
3271 |
FETCH_DATA (the_info, codep + 8);
|
3272 |
a = *codep++ & 0xff;
|
3273 |
a |= (*codep++ & 0xff) << 8; |
3274 |
a |= (*codep++ & 0xff) << 16; |
3275 |
a |= (*codep++ & 0xff) << 24; |
3276 |
b = *codep++ & 0xff;
|
3277 |
b |= (*codep++ & 0xff) << 8; |
3278 |
b |= (*codep++ & 0xff) << 16; |
3279 |
b |= (*codep++ & 0xff) << 24; |
3280 |
x = a + ((bfd_vma) b << 32);
|
3281 |
#else
|
3282 |
abort (); |
3283 |
x = 0;
|
3284 |
#endif
|
3285 |
return x;
|
3286 |
} |
3287 |
|
3288 |
static bfd_signed_vma
|
3289 |
get32 () |
3290 |
{ |
3291 |
bfd_signed_vma x = 0;
|
3292 |
|
3293 |
FETCH_DATA (the_info, codep + 4);
|
3294 |
x = *codep++ & (bfd_signed_vma) 0xff;
|
3295 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; |
3296 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; |
3297 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; |
3298 |
return x;
|
3299 |
} |
3300 |
|
3301 |
static bfd_signed_vma
|
3302 |
get32s () |
3303 |
{ |
3304 |
bfd_signed_vma x = 0;
|
3305 |
|
3306 |
FETCH_DATA (the_info, codep + 4);
|
3307 |
x = *codep++ & (bfd_signed_vma) 0xff;
|
3308 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; |
3309 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; |
3310 |
x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; |
3311 |
|
3312 |
x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31); |
3313 |
|
3314 |
return x;
|
3315 |
} |
3316 |
|
3317 |
static int |
3318 |
get16 () |
3319 |
{ |
3320 |
int x = 0; |
3321 |
|
3322 |
FETCH_DATA (the_info, codep + 2);
|
3323 |
x = *codep++ & 0xff;
|
3324 |
x |= (*codep++ & 0xff) << 8; |
3325 |
return x;
|
3326 |
} |
3327 |
|
3328 |
static void |
3329 |
set_op (op, riprel) |
3330 |
bfd_vma op; |
3331 |
int riprel;
|
3332 |
{ |
3333 |
op_index[op_ad] = op_ad; |
3334 |
if (mode_64bit)
|
3335 |
{ |
3336 |
op_address[op_ad] = op; |
3337 |
op_riprel[op_ad] = riprel; |
3338 |
} |
3339 |
else
|
3340 |
{ |
3341 |
/* Mask to get a 32-bit address. */
|
3342 |
op_address[op_ad] = op & 0xffffffff;
|
3343 |
op_riprel[op_ad] = riprel & 0xffffffff;
|
3344 |
} |
3345 |
} |
3346 |
|
3347 |
static void |
3348 |
OP_REG (code, sizeflag) |
3349 |
int code;
|
3350 |
int sizeflag;
|
3351 |
{ |
3352 |
const char *s; |
3353 |
int add = 0; |
3354 |
USED_REX (REX_EXTZ); |
3355 |
if (rex & REX_EXTZ)
|
3356 |
add = 8;
|
3357 |
|
3358 |
switch (code)
|
3359 |
{ |
3360 |
case indir_dx_reg:
|
3361 |
if (intel_syntax)
|
3362 |
s = "[dx]";
|
3363 |
else
|
3364 |
s = "(%dx)";
|
3365 |
break;
|
3366 |
case ax_reg: case cx_reg: case dx_reg: case bx_reg: |
3367 |
case sp_reg: case bp_reg: case si_reg: case di_reg: |
3368 |
s = names16[code - ax_reg + add]; |
3369 |
break;
|
3370 |
case es_reg: case ss_reg: case cs_reg: |
3371 |
case ds_reg: case fs_reg: case gs_reg: |
3372 |
s = names_seg[code - es_reg + add]; |
3373 |
break;
|
3374 |
case al_reg: case ah_reg: case cl_reg: case ch_reg: |
3375 |
case dl_reg: case dh_reg: case bl_reg: case bh_reg: |
3376 |
USED_REX (0);
|
3377 |
if (rex)
|
3378 |
s = names8rex[code - al_reg + add]; |
3379 |
else
|
3380 |
s = names8[code - al_reg]; |
3381 |
break;
|
3382 |
case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: |
3383 |
case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: |
3384 |
if (mode_64bit)
|
3385 |
{ |
3386 |
s = names64[code - rAX_reg + add]; |
3387 |
break;
|
3388 |
} |
3389 |
code += eAX_reg - rAX_reg; |
3390 |
/* Fall through. */
|
3391 |
case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: |
3392 |
case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: |
3393 |
USED_REX (REX_MODE64); |
3394 |
if (rex & REX_MODE64)
|
3395 |
s = names64[code - eAX_reg + add]; |
3396 |
else if (sizeflag & DFLAG) |
3397 |
s = names32[code - eAX_reg + add]; |
3398 |
else
|
3399 |
s = names16[code - eAX_reg + add]; |
3400 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3401 |
break;
|
3402 |
default:
|
3403 |
s = INTERNAL_DISASSEMBLER_ERROR; |
3404 |
break;
|
3405 |
} |
3406 |
oappend (s); |
3407 |
} |
3408 |
|
3409 |
static void |
3410 |
OP_IMREG (code, sizeflag) |
3411 |
int code;
|
3412 |
int sizeflag;
|
3413 |
{ |
3414 |
const char *s; |
3415 |
|
3416 |
switch (code)
|
3417 |
{ |
3418 |
case indir_dx_reg:
|
3419 |
if (intel_syntax)
|
3420 |
s = "[dx]";
|
3421 |
else
|
3422 |
s = "(%dx)";
|
3423 |
break;
|
3424 |
case ax_reg: case cx_reg: case dx_reg: case bx_reg: |
3425 |
case sp_reg: case bp_reg: case si_reg: case di_reg: |
3426 |
s = names16[code - ax_reg]; |
3427 |
break;
|
3428 |
case es_reg: case ss_reg: case cs_reg: |
3429 |
case ds_reg: case fs_reg: case gs_reg: |
3430 |
s = names_seg[code - es_reg]; |
3431 |
break;
|
3432 |
case al_reg: case ah_reg: case cl_reg: case ch_reg: |
3433 |
case dl_reg: case dh_reg: case bl_reg: case bh_reg: |
3434 |
USED_REX (0);
|
3435 |
if (rex)
|
3436 |
s = names8rex[code - al_reg]; |
3437 |
else
|
3438 |
s = names8[code - al_reg]; |
3439 |
break;
|
3440 |
case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: |
3441 |
case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: |
3442 |
USED_REX (REX_MODE64); |
3443 |
if (rex & REX_MODE64)
|
3444 |
s = names64[code - eAX_reg]; |
3445 |
else if (sizeflag & DFLAG) |
3446 |
s = names32[code - eAX_reg]; |
3447 |
else
|
3448 |
s = names16[code - eAX_reg]; |
3449 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3450 |
break;
|
3451 |
default:
|
3452 |
s = INTERNAL_DISASSEMBLER_ERROR; |
3453 |
break;
|
3454 |
} |
3455 |
oappend (s); |
3456 |
} |
3457 |
|
3458 |
static void |
3459 |
OP_I (bytemode, sizeflag) |
3460 |
int bytemode;
|
3461 |
int sizeflag;
|
3462 |
{ |
3463 |
bfd_signed_vma op; |
3464 |
bfd_signed_vma mask = -1;
|
3465 |
|
3466 |
switch (bytemode)
|
3467 |
{ |
3468 |
case b_mode:
|
3469 |
FETCH_DATA (the_info, codep + 1);
|
3470 |
op = *codep++; |
3471 |
mask = 0xff;
|
3472 |
break;
|
3473 |
case q_mode:
|
3474 |
if (mode_64bit)
|
3475 |
{ |
3476 |
op = get32s (); |
3477 |
break;
|
3478 |
} |
3479 |
/* Fall through. */
|
3480 |
case v_mode:
|
3481 |
USED_REX (REX_MODE64); |
3482 |
if (rex & REX_MODE64)
|
3483 |
op = get32s (); |
3484 |
else if (sizeflag & DFLAG) |
3485 |
{ |
3486 |
op = get32 (); |
3487 |
mask = 0xffffffff;
|
3488 |
} |
3489 |
else
|
3490 |
{ |
3491 |
op = get16 (); |
3492 |
mask = 0xfffff;
|
3493 |
} |
3494 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3495 |
break;
|
3496 |
case w_mode:
|
3497 |
mask = 0xfffff;
|
3498 |
op = get16 (); |
3499 |
break;
|
3500 |
default:
|
3501 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
3502 |
return;
|
3503 |
} |
3504 |
|
3505 |
op &= mask; |
3506 |
scratchbuf[0] = '$'; |
3507 |
print_operand_value (scratchbuf + 1, 1, op); |
3508 |
oappend (scratchbuf + intel_syntax); |
3509 |
scratchbuf[0] = '\0'; |
3510 |
} |
3511 |
|
3512 |
static void |
3513 |
OP_I64 (bytemode, sizeflag) |
3514 |
int bytemode;
|
3515 |
int sizeflag;
|
3516 |
{ |
3517 |
bfd_signed_vma op; |
3518 |
bfd_signed_vma mask = -1;
|
3519 |
|
3520 |
if (!mode_64bit)
|
3521 |
{ |
3522 |
OP_I (bytemode, sizeflag); |
3523 |
return;
|
3524 |
} |
3525 |
|
3526 |
switch (bytemode)
|
3527 |
{ |
3528 |
case b_mode:
|
3529 |
FETCH_DATA (the_info, codep + 1);
|
3530 |
op = *codep++; |
3531 |
mask = 0xff;
|
3532 |
break;
|
3533 |
case v_mode:
|
3534 |
USED_REX (REX_MODE64); |
3535 |
if (rex & REX_MODE64)
|
3536 |
op = get64 (); |
3537 |
else if (sizeflag & DFLAG) |
3538 |
{ |
3539 |
op = get32 (); |
3540 |
mask = 0xffffffff;
|
3541 |
} |
3542 |
else
|
3543 |
{ |
3544 |
op = get16 (); |
3545 |
mask = 0xfffff;
|
3546 |
} |
3547 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3548 |
break;
|
3549 |
case w_mode:
|
3550 |
mask = 0xfffff;
|
3551 |
op = get16 (); |
3552 |
break;
|
3553 |
default:
|
3554 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
3555 |
return;
|
3556 |
} |
3557 |
|
3558 |
op &= mask; |
3559 |
scratchbuf[0] = '$'; |
3560 |
print_operand_value (scratchbuf + 1, 1, op); |
3561 |
oappend (scratchbuf + intel_syntax); |
3562 |
scratchbuf[0] = '\0'; |
3563 |
} |
3564 |
|
3565 |
static void |
3566 |
OP_sI (bytemode, sizeflag) |
3567 |
int bytemode;
|
3568 |
int sizeflag;
|
3569 |
{ |
3570 |
bfd_signed_vma op; |
3571 |
bfd_signed_vma mask = -1;
|
3572 |
|
3573 |
switch (bytemode)
|
3574 |
{ |
3575 |
case b_mode:
|
3576 |
FETCH_DATA (the_info, codep + 1);
|
3577 |
op = *codep++; |
3578 |
if ((op & 0x80) != 0) |
3579 |
op -= 0x100;
|
3580 |
mask = 0xffffffff;
|
3581 |
break;
|
3582 |
case v_mode:
|
3583 |
USED_REX (REX_MODE64); |
3584 |
if (rex & REX_MODE64)
|
3585 |
op = get32s (); |
3586 |
else if (sizeflag & DFLAG) |
3587 |
{ |
3588 |
op = get32s (); |
3589 |
mask = 0xffffffff;
|
3590 |
} |
3591 |
else
|
3592 |
{ |
3593 |
mask = 0xffffffff;
|
3594 |
op = get16 (); |
3595 |
if ((op & 0x8000) != 0) |
3596 |
op -= 0x10000;
|
3597 |
} |
3598 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3599 |
break;
|
3600 |
case w_mode:
|
3601 |
op = get16 (); |
3602 |
mask = 0xffffffff;
|
3603 |
if ((op & 0x8000) != 0) |
3604 |
op -= 0x10000;
|
3605 |
break;
|
3606 |
default:
|
3607 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
3608 |
return;
|
3609 |
} |
3610 |
|
3611 |
scratchbuf[0] = '$'; |
3612 |
print_operand_value (scratchbuf + 1, 1, op); |
3613 |
oappend (scratchbuf + intel_syntax); |
3614 |
} |
3615 |
|
3616 |
static void |
3617 |
OP_J (bytemode, sizeflag) |
3618 |
int bytemode;
|
3619 |
int sizeflag;
|
3620 |
{ |
3621 |
bfd_vma disp; |
3622 |
bfd_vma mask = -1;
|
3623 |
|
3624 |
switch (bytemode)
|
3625 |
{ |
3626 |
case b_mode:
|
3627 |
FETCH_DATA (the_info, codep + 1);
|
3628 |
disp = *codep++; |
3629 |
if ((disp & 0x80) != 0) |
3630 |
disp -= 0x100;
|
3631 |
break;
|
3632 |
case v_mode:
|
3633 |
if (sizeflag & DFLAG)
|
3634 |
disp = get32s (); |
3635 |
else
|
3636 |
{ |
3637 |
disp = get16 (); |
3638 |
/* For some reason, a data16 prefix on a jump instruction
|
3639 |
means that the pc is masked to 16 bits after the
|
3640 |
displacement is added! */
|
3641 |
mask = 0xffff;
|
3642 |
} |
3643 |
break;
|
3644 |
default:
|
3645 |
oappend (INTERNAL_DISASSEMBLER_ERROR); |
3646 |
return;
|
3647 |
} |
3648 |
disp = (start_pc + codep - start_codep + disp) & mask; |
3649 |
set_op (disp, 0);
|
3650 |
print_operand_value (scratchbuf, 1, disp);
|
3651 |
oappend (scratchbuf); |
3652 |
} |
3653 |
|
3654 |
static void |
3655 |
OP_SEG (dummy, sizeflag) |
3656 |
int dummy;
|
3657 |
int sizeflag;
|
3658 |
{ |
3659 |
oappend (names_seg[reg]); |
3660 |
} |
3661 |
|
3662 |
static void |
3663 |
OP_DIR (dummy, sizeflag) |
3664 |
int dummy;
|
3665 |
int sizeflag;
|
3666 |
{ |
3667 |
int seg, offset;
|
3668 |
|
3669 |
if (sizeflag & DFLAG)
|
3670 |
{ |
3671 |
offset = get32 (); |
3672 |
seg = get16 (); |
3673 |
} |
3674 |
else
|
3675 |
{ |
3676 |
offset = get16 (); |
3677 |
seg = get16 (); |
3678 |
} |
3679 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3680 |
if (intel_syntax)
|
3681 |
sprintf (scratchbuf, "0x%x,0x%x", seg, offset);
|
3682 |
else
|
3683 |
sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
|
3684 |
oappend (scratchbuf); |
3685 |
} |
3686 |
|
3687 |
static void |
3688 |
OP_OFF (bytemode, sizeflag) |
3689 |
int bytemode;
|
3690 |
int sizeflag;
|
3691 |
{ |
3692 |
bfd_vma off; |
3693 |
|
3694 |
append_seg (); |
3695 |
|
3696 |
if ((sizeflag & AFLAG) || mode_64bit)
|
3697 |
off = get32 (); |
3698 |
else
|
3699 |
off = get16 (); |
3700 |
|
3701 |
if (intel_syntax)
|
3702 |
{ |
3703 |
if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
|
3704 |
| PREFIX_ES | PREFIX_FS | PREFIX_GS))) |
3705 |
{ |
3706 |
oappend (names_seg[ds_reg - es_reg]); |
3707 |
oappend (":");
|
3708 |
} |
3709 |
} |
3710 |
print_operand_value (scratchbuf, 1, off);
|
3711 |
oappend (scratchbuf); |
3712 |
} |
3713 |
|
3714 |
static void |
3715 |
OP_OFF64 (bytemode, sizeflag) |
3716 |
int bytemode;
|
3717 |
int sizeflag;
|
3718 |
{ |
3719 |
bfd_vma off; |
3720 |
|
3721 |
if (!mode_64bit)
|
3722 |
{ |
3723 |
OP_OFF (bytemode, sizeflag); |
3724 |
return;
|
3725 |
} |
3726 |
|
3727 |
append_seg (); |
3728 |
|
3729 |
off = get64 (); |
3730 |
|
3731 |
if (intel_syntax)
|
3732 |
{ |
3733 |
if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
|
3734 |
| PREFIX_ES | PREFIX_FS | PREFIX_GS))) |
3735 |
{ |
3736 |
oappend (names_seg[ds_reg - es_reg]); |
3737 |
oappend (":");
|
3738 |
} |
3739 |
} |
3740 |
print_operand_value (scratchbuf, 1, off);
|
3741 |
oappend (scratchbuf); |
3742 |
} |
3743 |
|
3744 |
static void |
3745 |
ptr_reg (code, sizeflag) |
3746 |
int code;
|
3747 |
int sizeflag;
|
3748 |
{ |
3749 |
const char *s; |
3750 |
if (intel_syntax)
|
3751 |
oappend ("[");
|
3752 |
else
|
3753 |
oappend ("(");
|
3754 |
|
3755 |
USED_REX (REX_MODE64); |
3756 |
if (rex & REX_MODE64)
|
3757 |
{ |
3758 |
if (!(sizeflag & AFLAG))
|
3759 |
s = names32[code - eAX_reg]; |
3760 |
else
|
3761 |
s = names64[code - eAX_reg]; |
3762 |
} |
3763 |
else if (sizeflag & AFLAG) |
3764 |
s = names32[code - eAX_reg]; |
3765 |
else
|
3766 |
s = names16[code - eAX_reg]; |
3767 |
oappend (s); |
3768 |
if (intel_syntax)
|
3769 |
oappend ("]");
|
3770 |
else
|
3771 |
oappend (")");
|
3772 |
} |
3773 |
|
3774 |
static void |
3775 |
OP_ESreg (code, sizeflag) |
3776 |
int code;
|
3777 |
int sizeflag;
|
3778 |
{ |
3779 |
oappend ("%es:" + intel_syntax);
|
3780 |
ptr_reg (code, sizeflag); |
3781 |
} |
3782 |
|
3783 |
static void |
3784 |
OP_DSreg (code, sizeflag) |
3785 |
int code;
|
3786 |
int sizeflag;
|
3787 |
{ |
3788 |
if ((prefixes
|
3789 |
& (PREFIX_CS |
3790 |
| PREFIX_DS |
3791 |
| PREFIX_SS |
3792 |
| PREFIX_ES |
3793 |
| PREFIX_FS |
3794 |
| PREFIX_GS)) == 0)
|
3795 |
prefixes |= PREFIX_DS; |
3796 |
append_seg (); |
3797 |
ptr_reg (code, sizeflag); |
3798 |
} |
3799 |
|
3800 |
static void |
3801 |
OP_C (dummy, sizeflag) |
3802 |
int dummy;
|
3803 |
int sizeflag;
|
3804 |
{ |
3805 |
int add = 0; |
3806 |
USED_REX (REX_EXTX); |
3807 |
if (rex & REX_EXTX)
|
3808 |
add = 8;
|
3809 |
sprintf (scratchbuf, "%%cr%d", reg + add);
|
3810 |
oappend (scratchbuf + intel_syntax); |
3811 |
} |
3812 |
|
3813 |
static void |
3814 |
OP_D (dummy, sizeflag) |
3815 |
int dummy;
|
3816 |
int sizeflag;
|
3817 |
{ |
3818 |
int add = 0; |
3819 |
USED_REX (REX_EXTX); |
3820 |
if (rex & REX_EXTX)
|
3821 |
add = 8;
|
3822 |
if (intel_syntax)
|
3823 |
sprintf (scratchbuf, "db%d", reg + add);
|
3824 |
else
|
3825 |
sprintf (scratchbuf, "%%db%d", reg + add);
|
3826 |
oappend (scratchbuf); |
3827 |
} |
3828 |
|
3829 |
static void |
3830 |
OP_T (dummy, sizeflag) |
3831 |
int dummy;
|
3832 |
int sizeflag;
|
3833 |
{ |
3834 |
sprintf (scratchbuf, "%%tr%d", reg);
|
3835 |
oappend (scratchbuf + intel_syntax); |
3836 |
} |
3837 |
|
3838 |
static void |
3839 |
OP_Rd (bytemode, sizeflag) |
3840 |
int bytemode;
|
3841 |
int sizeflag;
|
3842 |
{ |
3843 |
if (mod == 3) |
3844 |
OP_E (bytemode, sizeflag); |
3845 |
else
|
3846 |
BadOp (); |
3847 |
} |
3848 |
|
3849 |
static void |
3850 |
OP_MMX (bytemode, sizeflag) |
3851 |
int bytemode;
|
3852 |
int sizeflag;
|
3853 |
{ |
3854 |
int add = 0; |
3855 |
USED_REX (REX_EXTX); |
3856 |
if (rex & REX_EXTX)
|
3857 |
add = 8;
|
3858 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3859 |
if (prefixes & PREFIX_DATA)
|
3860 |
sprintf (scratchbuf, "%%xmm%d", reg + add);
|
3861 |
else
|
3862 |
sprintf (scratchbuf, "%%mm%d", reg + add);
|
3863 |
oappend (scratchbuf + intel_syntax); |
3864 |
} |
3865 |
|
3866 |
static void |
3867 |
OP_XMM (bytemode, sizeflag) |
3868 |
int bytemode;
|
3869 |
int sizeflag;
|
3870 |
{ |
3871 |
int add = 0; |
3872 |
USED_REX (REX_EXTX); |
3873 |
if (rex & REX_EXTX)
|
3874 |
add = 8;
|
3875 |
sprintf (scratchbuf, "%%xmm%d", reg + add);
|
3876 |
oappend (scratchbuf + intel_syntax); |
3877 |
} |
3878 |
|
3879 |
static void |
3880 |
OP_EM (bytemode, sizeflag) |
3881 |
int bytemode;
|
3882 |
int sizeflag;
|
3883 |
{ |
3884 |
int add = 0; |
3885 |
if (mod != 3) |
3886 |
{ |
3887 |
OP_E (bytemode, sizeflag); |
3888 |
return;
|
3889 |
} |
3890 |
USED_REX (REX_EXTZ); |
3891 |
if (rex & REX_EXTZ)
|
3892 |
add = 8;
|
3893 |
|
3894 |
/* Skip mod/rm byte. */
|
3895 |
MODRM_CHECK; |
3896 |
codep++; |
3897 |
used_prefixes |= (prefixes & PREFIX_DATA); |
3898 |
if (prefixes & PREFIX_DATA)
|
3899 |
sprintf (scratchbuf, "%%xmm%d", rm + add);
|
3900 |
else
|
3901 |
sprintf (scratchbuf, "%%mm%d", rm + add);
|
3902 |
oappend (scratchbuf + intel_syntax); |
3903 |
} |
3904 |
|
3905 |
static void |
3906 |
OP_EX (bytemode, sizeflag) |
3907 |
int bytemode;
|
3908 |
int sizeflag;
|
3909 |
{ |
3910 |
int add = 0; |
3911 |
if (mod != 3) |
3912 |
{ |
3913 |
OP_E (bytemode, sizeflag); |
3914 |
return;
|
3915 |
} |
3916 |
USED_REX (REX_EXTZ); |
3917 |
if (rex & REX_EXTZ)
|
3918 |
add = 8;
|
3919 |
|
3920 |
/* Skip mod/rm byte. */
|
3921 |
MODRM_CHECK; |
3922 |
codep++; |
3923 |
sprintf (scratchbuf, "%%xmm%d", rm + add);
|
3924 |
oappend (scratchbuf + intel_syntax); |
3925 |
} |
3926 |
|
3927 |
static void |
3928 |
OP_MS (bytemode, sizeflag) |
3929 |
int bytemode;
|
3930 |
int sizeflag;
|
3931 |
{ |
3932 |
if (mod == 3) |
3933 |
OP_EM (bytemode, sizeflag); |
3934 |
else
|
3935 |
BadOp (); |
3936 |
} |
3937 |
|
3938 |
static void |
3939 |
OP_XS (bytemode, sizeflag) |
3940 |
int bytemode;
|
3941 |
int sizeflag;
|
3942 |
{ |
3943 |
if (mod == 3) |
3944 |
OP_EX (bytemode, sizeflag); |
3945 |
else
|
3946 |
BadOp (); |
3947 |
} |
3948 |
|
3949 |
static const char *Suffix3DNow[] = { |
3950 |
/* 00 */ NULL, NULL, NULL, NULL, |
3951 |
/* 04 */ NULL, NULL, NULL, NULL, |
3952 |
/* 08 */ NULL, NULL, NULL, NULL, |
3953 |
/* 0C */ "pi2fw", "pi2fd", NULL, NULL, |
3954 |
/* 10 */ NULL, NULL, NULL, NULL, |
3955 |
/* 14 */ NULL, NULL, NULL, NULL, |
3956 |
/* 18 */ NULL, NULL, NULL, NULL, |
3957 |
/* 1C */ "pf2iw", "pf2id", NULL, NULL, |
3958 |
/* 20 */ NULL, NULL, NULL, NULL, |
3959 |
/* 24 */ NULL, NULL, NULL, NULL, |
3960 |
/* 28 */ NULL, NULL, NULL, NULL, |
3961 |
/* 2C */ NULL, NULL, NULL, NULL, |
3962 |
/* 30 */ NULL, NULL, NULL, NULL, |
3963 |
/* 34 */ NULL, NULL, NULL, NULL, |
3964 |
/* 38 */ NULL, NULL, NULL, NULL, |
3965 |
/* 3C */ NULL, NULL, NULL, NULL, |
3966 |
/* 40 */ NULL, NULL, NULL, NULL, |
3967 |
/* 44 */ NULL, NULL, NULL, NULL, |
3968 |
/* 48 */ NULL, NULL, NULL, NULL, |
3969 |
/* 4C */ NULL, NULL, NULL, NULL, |
3970 |
/* 50 */ NULL, NULL, NULL, NULL, |
3971 |
/* 54 */ NULL, NULL, NULL, NULL, |
3972 |
/* 58 */ NULL, NULL, NULL, NULL, |
3973 |
/* 5C */ NULL, NULL, NULL, NULL, |
3974 |
/* 60 */ NULL, NULL, NULL, NULL, |
3975 |
/* 64 */ NULL, NULL, NULL, NULL, |
3976 |
/* 68 */ NULL, NULL, NULL, NULL, |
3977 |
/* 6C */ NULL, NULL, NULL, NULL, |
3978 |
/* 70 */ NULL, NULL, NULL, NULL, |
3979 |
/* 74 */ NULL, NULL, NULL, NULL, |
3980 |
/* 78 */ NULL, NULL, NULL, NULL, |
3981 |
/* 7C */ NULL, NULL, NULL, NULL, |
3982 |
/* 80 */ NULL, NULL, NULL, NULL, |
3983 |
/* 84 */ NULL, NULL, NULL, NULL, |
3984 |
/* 88 */ NULL, NULL, "pfnacc", NULL, |
3985 |
/* 8C */ NULL, NULL, "pfpnacc", NULL, |
3986 |
/* 90 */ "pfcmpge", NULL, NULL, NULL, |
3987 |
/* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt", |
3988 |
/* 98 */ NULL, NULL, "pfsub", NULL, |
3989 |
/* 9C */ NULL, NULL, "pfadd", NULL, |
3990 |
/* A0 */ "pfcmpgt", NULL, NULL, NULL, |
3991 |
/* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1", |
3992 |
/* A8 */ NULL, NULL, "pfsubr", NULL, |
3993 |
/* AC */ NULL, NULL, "pfacc", NULL, |
3994 |
/* B0 */ "pfcmpeq", NULL, NULL, NULL, |
3995 |
/* B4 */ "pfmul", NULL, "pfrcpit2", "pfmulhrw", |
3996 |
/* B8 */ NULL, NULL, NULL, "pswapd", |
3997 |
/* BC */ NULL, NULL, NULL, "pavgusb", |
3998 |
/* C0 */ NULL, NULL, NULL, NULL, |
3999 |
/* C4 */ NULL, NULL, NULL, NULL, |
4000 |
/* C8 */ NULL, NULL, NULL, NULL, |
4001 |
/* CC */ NULL, NULL, NULL, NULL, |
4002 |
/* D0 */ NULL, NULL, NULL, NULL, |
4003 |
/* D4 */ NULL, NULL, NULL, NULL, |
4004 |
/* D8 */ NULL, NULL, NULL, NULL, |
4005 |
/* DC */ NULL, NULL, NULL, NULL, |
4006 |
/* E0 */ NULL, NULL, NULL, NULL, |
4007 |
/* E4 */ NULL, NULL, NULL, NULL, |
4008 |
/* E8 */ NULL, NULL, NULL, NULL, |
4009 |
/* EC */ NULL, NULL, NULL, NULL, |
4010 |
/* F0 */ NULL, NULL, NULL, NULL, |
4011 |
/* F4 */ NULL, NULL, NULL, NULL, |
4012 |
/* F8 */ NULL, NULL, NULL, NULL, |
4013 |
/* FC */ NULL, NULL, NULL, NULL, |
4014 |
}; |
4015 |
|
4016 |
static void |
4017 |
OP_3DNowSuffix (bytemode, sizeflag) |
4018 |
int bytemode;
|
4019 |
int sizeflag;
|
4020 |
{ |
4021 |
const char *mnemonic; |
4022 |
|
4023 |
FETCH_DATA (the_info, codep + 1);
|
4024 |
/* AMD 3DNow! instructions are specified by an opcode suffix in the
|
4025 |
place where an 8-bit immediate would normally go. ie. the last
|
4026 |
byte of the instruction. */
|
4027 |
obufp = obuf + strlen (obuf); |
4028 |
mnemonic = Suffix3DNow[*codep++ & 0xff];
|
4029 |
if (mnemonic)
|
4030 |
oappend (mnemonic); |
4031 |
else
|
4032 |
{ |
4033 |
/* Since a variable sized modrm/sib chunk is between the start
|
4034 |
of the opcode (0x0f0f) and the opcode suffix, we need to do
|
4035 |
all the modrm processing first, and don't know until now that
|
4036 |
we have a bad opcode. This necessitates some cleaning up. */
|
4037 |
op1out[0] = '\0'; |
4038 |
op2out[0] = '\0'; |
4039 |
BadOp (); |
4040 |
} |
4041 |
} |
4042 |
|
4043 |
static const char *simd_cmp_op[] = { |
4044 |
"eq",
|
4045 |
"lt",
|
4046 |
"le",
|
4047 |
"unord",
|
4048 |
"neq",
|
4049 |
"nlt",
|
4050 |
"nle",
|
4051 |
"ord"
|
4052 |
}; |
4053 |
|
4054 |
static void |
4055 |
OP_SIMD_Suffix (bytemode, sizeflag) |
4056 |
int bytemode;
|
4057 |
int sizeflag;
|
4058 |
{ |
4059 |
unsigned int cmp_type; |
4060 |
|
4061 |
FETCH_DATA (the_info, codep + 1);
|
4062 |
obufp = obuf + strlen (obuf); |
4063 |
cmp_type = *codep++ & 0xff;
|
4064 |
if (cmp_type < 8) |
4065 |
{ |
4066 |
char suffix1 = 'p', suffix2 = 's'; |
4067 |
used_prefixes |= (prefixes & PREFIX_REPZ); |
4068 |
if (prefixes & PREFIX_REPZ)
|
4069 |
suffix1 = 's';
|
4070 |
else
|
4071 |
{ |
4072 |
used_prefixes |= (prefixes & PREFIX_DATA); |
4073 |
if (prefixes & PREFIX_DATA)
|
4074 |
suffix2 = 'd';
|
4075 |
else
|
4076 |
{ |
4077 |
used_prefixes |= (prefixes & PREFIX_REPNZ); |
4078 |
if (prefixes & PREFIX_REPNZ)
|
4079 |
suffix1 = 's', suffix2 = 'd'; |
4080 |
} |
4081 |
} |
4082 |
sprintf (scratchbuf, "cmp%s%c%c",
|
4083 |
simd_cmp_op[cmp_type], suffix1, suffix2); |
4084 |
used_prefixes |= (prefixes & PREFIX_REPZ); |
4085 |
oappend (scratchbuf); |
4086 |
} |
4087 |
else
|
4088 |
{ |
4089 |
/* We have a bad extension byte. Clean up. */
|
4090 |
op1out[0] = '\0'; |
4091 |
op2out[0] = '\0'; |
4092 |
BadOp (); |
4093 |
} |
4094 |
} |
4095 |
|
4096 |
static void |
4097 |
SIMD_Fixup (extrachar, sizeflag) |
4098 |
int extrachar;
|
4099 |
int sizeflag;
|
4100 |
{ |
4101 |
/* Change movlps/movhps to movhlps/movlhps for 2 register operand
|
4102 |
forms of these instructions. */
|
4103 |
if (mod == 3) |
4104 |
{ |
4105 |
char *p = obuf + strlen (obuf);
|
4106 |
*(p + 1) = '\0'; |
4107 |
*p = *(p - 1);
|
4108 |
*(p - 1) = *(p - 2); |
4109 |
*(p - 2) = *(p - 3); |
4110 |
*(p - 3) = extrachar;
|
4111 |
} |
4112 |
} |
4113 |
|
4114 |
static void |
4115 |
BadOp (void)
|
4116 |
{ |
4117 |
/* Throw away prefixes and 1st. opcode byte. */
|
4118 |
codep = insn_codep + 1;
|
4119 |
oappend ("(bad)");
|
4120 |
} |