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