gdb/i386-tdep.c

   1 /* Intel 386 target-dependent stuff.
   2
   3    Copyright (C) 1988-2015 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "opcode/i386.h"
  22 #include "arch-utils.h"
  23 #include "command.h"
  24 #include "dummy-frame.h"
  25 #include "dwarf2-frame.h"
  26 #include "doublest.h"
  27 #include "frame.h"
  28 #include "frame-base.h"
  29 #include "frame-unwind.h"
  30 #include "inferior.h"
  31 #include "infrun.h"
  32 #include "gdbcmd.h"
  33 #include "gdbcore.h"
  34 #include "gdbtypes.h"
  35 #include "objfiles.h"
  36 #include "osabi.h"
  37 #include "regcache.h"
  38 #include "reggroups.h"
  39 #include "regset.h"
  40 #include "symfile.h"
  41 #include "symtab.h"
  42 #include "target.h"
  43 #include "value.h"
  44 #include "dis-asm.h"
  45 #include "disasm.h"
  46 #include "remote.h"
  47 #include "i386-tdep.h"
  48 #include "i387-tdep.h"
  49 #include "x86-xstate.h"
  50
  51 #include "record.h"
  52 #include "record-full.h"
  53 #include "features/i386/i386.c"
  54 #include "features/i386/i386-avx.c"
  55 #include "features/i386/i386-mpx.c"
  56 #include "features/i386/i386-avx512.c"
  57 #include "features/i386/i386-mmx.c"
  58
  59 #include "ax.h"
  60 #include "ax-gdb.h"
  61
  62 #include "stap-probe.h"
  63 #include "user-regs.h"
  64 #include "cli/cli-utils.h"
  65 #include "expression.h"
  66 #include "parser-defs.h"
  67 #include <ctype.h>
  68
  69 /* Register names.  */
  70
  71 static const char *i386_register_names[] =
  72 {
  73   "eax",   "ecx",    "edx",   "ebx",
  74   "esp",   "ebp",    "esi",   "edi",
  75   "eip",   "eflags", "cs",    "ss",
  76   "ds",    "es",     "fs",    "gs",
  77   "st0",   "st1",    "st2",   "st3",
  78   "st4",   "st5",    "st6",   "st7",
  79   "fctrl", "fstat",  "ftag",  "fiseg",
  80   "fioff", "foseg",  "fooff", "fop",
  81   "xmm0",  "xmm1",   "xmm2",  "xmm3",
  82   "xmm4",  "xmm5",   "xmm6",  "xmm7",
  83   "mxcsr"
  84 };
  85
  86 static const char *i386_zmm_names[] =
  87 {
  88   "zmm0",  "zmm1",   "zmm2",  "zmm3",
  89   "zmm4",  "zmm5",   "zmm6",  "zmm7"
  90 };
  91
  92 static const char *i386_zmmh_names[] =
  93 {
  94   "zmm0h",  "zmm1h",   "zmm2h",  "zmm3h",
  95   "zmm4h",  "zmm5h",   "zmm6h",  "zmm7h"
  96 };
  97
  98 static const char *i386_k_names[] =
  99 {
 100   "k0",  "k1",   "k2",  "k3",
 101   "k4",  "k5",   "k6",  "k7"
 102 };
 103
 104 static const char *i386_ymm_names[] =
 105 {
 106   "ymm0",  "ymm1",   "ymm2",  "ymm3",
 107   "ymm4",  "ymm5",   "ymm6",  "ymm7",
 108 };
 109
 110 static const char *i386_ymmh_names[] =
 111 {
 112   "ymm0h",  "ymm1h",   "ymm2h",  "ymm3h",
 113   "ymm4h",  "ymm5h",   "ymm6h",  "ymm7h",
 114 };
 115
 116 static const char *i386_mpx_names[] =
 117 {
 118   "bnd0raw", "bnd1raw", "bnd2raw", "bnd3raw", "bndcfgu", "bndstatus"
 119 };
 120
 121 /* Register names for MPX pseudo-registers.  */
 122
 123 static const char *i386_bnd_names[] =
 124 {
 125   "bnd0", "bnd1", "bnd2", "bnd3"
 126 };
 127
 128 /* Register names for MMX pseudo-registers.  */
 129
 130 static const char *i386_mmx_names[] =
 131 {
 132   "mm0", "mm1", "mm2", "mm3",
 133   "mm4", "mm5", "mm6", "mm7"
 134 };
 135
 136 /* Register names for byte pseudo-registers.  */
 137
 138 static const char *i386_byte_names[] =
 139 {
 140   "al", "cl", "dl", "bl",
 141   "ah", "ch", "dh", "bh"
 142 };
 143
 144 /* Register names for word pseudo-registers.  */
 145
 146 static const char *i386_word_names[] =
 147 {
 148   "ax", "cx", "dx", "bx",
 149   "", "bp", "si", "di"
 150 };
 151
 152 /* Constant used for reading/writing pseudo registers.  In 64-bit mode, we have
 153    16 lower ZMM regs that extend corresponding xmm/ymm registers.  In addition,
 154    we have 16 upper ZMM regs that have to be handled differently.  */
 155
 156 const int num_lower_zmm_regs = 16;
 157
 158 /* MMX register?  */
 159
 160 static int
 161 i386_mmx_regnum_p (struct gdbarch *gdbarch, int regnum)
 162 {
 163   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 164   int mm0_regnum = tdep->mm0_regnum;
 165
 166   if (mm0_regnum < 0)
 167     return 0;
 168
 169   regnum -= mm0_regnum;
 170   return regnum >= 0 && regnum < tdep->num_mmx_regs;
 171 }
 172
 173 /* Byte register?  */
 174
 175 int
 176 i386_byte_regnum_p (struct gdbarch *gdbarch, int regnum)
 177 {
 178   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 179
 180   regnum -= tdep->al_regnum;
 181   return regnum >= 0 && regnum < tdep->num_byte_regs;
 182 }
 183
 184 /* Word register?  */
 185
 186 int
 187 i386_word_regnum_p (struct gdbarch *gdbarch, int regnum)
 188 {
 189   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 190
 191   regnum -= tdep->ax_regnum;
 192   return regnum >= 0 && regnum < tdep->num_word_regs;
 193 }
 194
 195 /* Dword register?  */
 196
 197 int
 198 i386_dword_regnum_p (struct gdbarch *gdbarch, int regnum)
 199 {
 200   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 201   int eax_regnum = tdep->eax_regnum;
 202
 203   if (eax_regnum < 0)
 204     return 0;
 205
 206   regnum -= eax_regnum;
 207   return regnum >= 0 && regnum < tdep->num_dword_regs;
 208 }
 209
 210 /* AVX512 register?  */
 211
 212 int
 213 i386_zmmh_regnum_p (struct gdbarch *gdbarch, int regnum)
 214 {
 215   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 216   int zmm0h_regnum = tdep->zmm0h_regnum;
 217
 218   if (zmm0h_regnum < 0)
 219     return 0;
 220
 221   regnum -= zmm0h_regnum;
 222   return regnum >= 0 && regnum < tdep->num_zmm_regs;
 223 }
 224
 225 int
 226 i386_zmm_regnum_p (struct gdbarch *gdbarch, int regnum)
 227 {
 228   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 229   int zmm0_regnum = tdep->zmm0_regnum;
 230
 231   if (zmm0_regnum < 0)
 232     return 0;
 233
 234   regnum -= zmm0_regnum;
 235   return regnum >= 0 && regnum < tdep->num_zmm_regs;
 236 }
 237
 238 int
 239 i386_k_regnum_p (struct gdbarch *gdbarch, int regnum)
 240 {
 241   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 242   int k0_regnum = tdep->k0_regnum;
 243
 244   if (k0_regnum < 0)
 245     return 0;
 246
 247   regnum -= k0_regnum;
 248   return regnum >= 0 && regnum < I387_NUM_K_REGS;
 249 }
 250
 251 static int
 252 i386_ymmh_regnum_p (struct gdbarch *gdbarch, int regnum)
 253 {
 254   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 255   int ymm0h_regnum = tdep->ymm0h_regnum;
 256
 257   if (ymm0h_regnum < 0)
 258     return 0;
 259
 260   regnum -= ymm0h_regnum;
 261   return regnum >= 0 && regnum < tdep->num_ymm_regs;
 262 }
 263
 264 /* AVX register?  */
 265
 266 int
 267 i386_ymm_regnum_p (struct gdbarch *gdbarch, int regnum)
 268 {
 269   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 270   int ymm0_regnum = tdep->ymm0_regnum;
 271
 272   if (ymm0_regnum < 0)
 273     return 0;
 274
 275   regnum -= ymm0_regnum;
 276   return regnum >= 0 && regnum < tdep->num_ymm_regs;
 277 }
 278
 279 static int
 280 i386_ymmh_avx512_regnum_p (struct gdbarch *gdbarch, int regnum)
 281 {
 282   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 283   int ymm16h_regnum = tdep->ymm16h_regnum;
 284
 285   if (ymm16h_regnum < 0)
 286     return 0;
 287
 288   regnum -= ymm16h_regnum;
 289   return regnum >= 0 && regnum < tdep->num_ymm_avx512_regs;
 290 }
 291
 292 int
 293 i386_ymm_avx512_regnum_p (struct gdbarch *gdbarch, int regnum)
 294 {
 295   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 296   int ymm16_regnum = tdep->ymm16_regnum;
 297
 298   if (ymm16_regnum < 0)
 299     return 0;
 300
 301   regnum -= ymm16_regnum;
 302   return regnum >= 0 && regnum < tdep->num_ymm_avx512_regs;
 303 }
 304
 305 /* BND register?  */
 306
 307 int
 308 i386_bnd_regnum_p (struct gdbarch *gdbarch, int regnum)
 309 {
 310   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 311   int bnd0_regnum = tdep->bnd0_regnum;
 312
 313   if (bnd0_regnum < 0)
 314     return 0;
 315
 316   regnum -= bnd0_regnum;
 317   return regnum >= 0 && regnum < I387_NUM_BND_REGS;
 318 }
 319
 320 /* SSE register?  */
 321
 322 int
 323 i386_xmm_regnum_p (struct gdbarch *gdbarch, int regnum)
 324 {
 325   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 326   int num_xmm_regs = I387_NUM_XMM_REGS (tdep);
 327
 328   if (num_xmm_regs == 0)
 329     return 0;
 330
 331   regnum -= I387_XMM0_REGNUM (tdep);
 332   return regnum >= 0 && regnum < num_xmm_regs;
 333 }
 334
 335 /* XMM_512 register?  */
 336
 337 int
 338 i386_xmm_avx512_regnum_p (struct gdbarch *gdbarch, int regnum)
 339 {
 340   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 341   int num_xmm_avx512_regs = I387_NUM_XMM_AVX512_REGS (tdep);
 342
 343   if (num_xmm_avx512_regs == 0)
 344     return 0;
 345
 346   regnum -= I387_XMM16_REGNUM (tdep);
 347   return regnum >= 0 && regnum < num_xmm_avx512_regs;
 348 }
 349
 350 static int
 351 i386_mxcsr_regnum_p (struct gdbarch *gdbarch, int regnum)
 352 {
 353   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 354
 355   if (I387_NUM_XMM_REGS (tdep) == 0)
 356     return 0;
 357
 358   return (regnum == I387_MXCSR_REGNUM (tdep));
 359 }
 360
 361 /* FP register?  */
 362
 363 int
 364 i386_fp_regnum_p (struct gdbarch *gdbarch, int regnum)
 365 {
 366   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 367
 368   if (I387_ST0_REGNUM (tdep) < 0)
 369     return 0;
 370
 371   return (I387_ST0_REGNUM (tdep) <= regnum
 372           && regnum < I387_FCTRL_REGNUM (tdep));
 373 }
 374
 375 int
 376 i386_fpc_regnum_p (struct gdbarch *gdbarch, int regnum)
 377 {
 378   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 379
 380   if (I387_ST0_REGNUM (tdep) < 0)
 381     return 0;
 382
 383   return (I387_FCTRL_REGNUM (tdep) <= regnum
 384           && regnum < I387_XMM0_REGNUM (tdep));
 385 }
 386
 387 /* BNDr (raw) register?  */
 388
 389 static int
 390 i386_bndr_regnum_p (struct gdbarch *gdbarch, int regnum)
 391 {
 392   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 393
 394    if (I387_BND0R_REGNUM (tdep) < 0)
 395      return 0;
 396
 397   regnum -= tdep->bnd0r_regnum;
 398   return regnum >= 0 && regnum < I387_NUM_BND_REGS;
 399 }
 400
 401 /* BND control register?  */
 402
 403 static int
 404 i386_mpx_ctrl_regnum_p (struct gdbarch *gdbarch, int regnum)
 405 {
 406   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 407
 408    if (I387_BNDCFGU_REGNUM (tdep) < 0)
 409      return 0;
 410
 411   regnum -= I387_BNDCFGU_REGNUM (tdep);
 412   return regnum >= 0 && regnum < I387_NUM_MPX_CTRL_REGS;
 413 }
 414
 415 /* Return the name of register REGNUM, or the empty string if it is
 416    an anonymous register.  */
 417
 418 static const char *
 419 i386_register_name (struct gdbarch *gdbarch, int regnum)
 420 {
 421   /* Hide the upper YMM registers.  */
 422   if (i386_ymmh_regnum_p (gdbarch, regnum))
 423     return "";
 424
 425   /* Hide the upper YMM16-31 registers.  */
 426   if (i386_ymmh_avx512_regnum_p (gdbarch, regnum))
 427     return "";
 428
 429   /* Hide the upper ZMM registers.  */
 430   if (i386_zmmh_regnum_p (gdbarch, regnum))
 431     return "";
 432
 433   return tdesc_register_name (gdbarch, regnum);
 434 }
 435
 436 /* Return the name of register REGNUM.  */
 437
 438 const char *
 439 i386_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
 440 {
 441   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 442   if (i386_bnd_regnum_p (gdbarch, regnum))
 443     return i386_bnd_names[regnum - tdep->bnd0_regnum];
 444   if (i386_mmx_regnum_p (gdbarch, regnum))
 445     return i386_mmx_names[regnum - I387_MM0_REGNUM (tdep)];
 446   else if (i386_ymm_regnum_p (gdbarch, regnum))
 447     return i386_ymm_names[regnum - tdep->ymm0_regnum];
 448   else if (i386_zmm_regnum_p (gdbarch, regnum))
 449     return i386_zmm_names[regnum - tdep->zmm0_regnum];
 450   else if (i386_byte_regnum_p (gdbarch, regnum))
 451     return i386_byte_names[regnum - tdep->al_regnum];
 452   else if (i386_word_regnum_p (gdbarch, regnum))
 453     return i386_word_names[regnum - tdep->ax_regnum];
 454
 455   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 456 }
 457
 458 /* Convert a dbx register number REG to the appropriate register
 459    number used by GDB.  */
 460
 461 static int
 462 i386_dbx_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 463 {
 464   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 465
 466   /* This implements what GCC calls the "default" register map
 467      (dbx_register_map[]).  */
 468
 469   if (reg >= 0 && reg <= 7)
 470     {
 471       /* General-purpose registers.  The debug info calls %ebp
 472          register 4, and %esp register 5.  */
 473       if (reg == 4)
 474         return 5;
 475       else if (reg == 5)
 476         return 4;
 477       else return reg;
 478     }
 479   else if (reg >= 12 && reg <= 19)
 480     {
 481       /* Floating-point registers.  */
 482       return reg - 12 + I387_ST0_REGNUM (tdep);
 483     }
 484   else if (reg >= 21 && reg <= 28)
 485     {
 486       /* SSE registers.  */
 487       int ymm0_regnum = tdep->ymm0_regnum;
 488
 489       if (ymm0_regnum >= 0
 490           && i386_xmm_regnum_p (gdbarch, reg))
 491         return reg - 21 + ymm0_regnum;
 492       else
 493         return reg - 21 + I387_XMM0_REGNUM (tdep);
 494     }
 495   else if (reg >= 29 && reg <= 36)
 496     {
 497       /* MMX registers.  */
 498       return reg - 29 + I387_MM0_REGNUM (tdep);
 499     }
 500
 501   /* This will hopefully provoke a warning.  */
 502   return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 503 }
 504
 505 /* Convert SVR4 DWARF register number REG to the appropriate register number
 506    used by GDB.  */
 507
 508 static int
 509 i386_svr4_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 510 {
 511   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 512
 513   /* This implements the GCC register map that tries to be compatible
 514      with the SVR4 C compiler for DWARF (svr4_dbx_register_map[]).  */
 515
 516   /* The SVR4 register numbering includes %eip and %eflags, and
 517      numbers the floating point registers differently.  */
 518   if (reg >= 0 && reg <= 9)
 519     {
 520       /* General-purpose registers.  */
 521       return reg;
 522     }
 523   else if (reg >= 11 && reg <= 18)
 524     {
 525       /* Floating-point registers.  */
 526       return reg - 11 + I387_ST0_REGNUM (tdep);
 527     }
 528   else if (reg >= 21 && reg <= 36)
 529     {
 530       /* The SSE and MMX registers have the same numbers as with dbx.  */
 531       return i386_dbx_reg_to_regnum (gdbarch, reg);
 532     }
 533
 534   switch (reg)
 535     {
 536     case 37: return I387_FCTRL_REGNUM (tdep);
 537     case 38: return I387_FSTAT_REGNUM (tdep);
 538     case 39: return I387_MXCSR_REGNUM (tdep);
 539     case 40: return I386_ES_REGNUM;
 540     case 41: return I386_CS_REGNUM;
 541     case 42: return I386_SS_REGNUM;
 542     case 43: return I386_DS_REGNUM;
 543     case 44: return I386_FS_REGNUM;
 544     case 45: return I386_GS_REGNUM;
 545     }
 546
 547   return -1;
 548 }
 549
 550 /* Wrapper on i386_svr4_dwarf_reg_to_regnum to return
 551    num_regs + num_pseudo_regs for other debug formats.  */
 552
 553 static int
 554 i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 555 {
 556   int regnum = i386_svr4_dwarf_reg_to_regnum (gdbarch, reg);
 557
 558   if (regnum == -1)
 559     return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 560   return regnum;
 561 }
 562
 563 \f
 564
 565 /* This is the variable that is set with "set disassembly-flavor", and
 566    its legitimate values.  */
 567 static const char att_flavor[] = "att";
 568 static const char intel_flavor[] = "intel";
 569 static const char *const valid_flavors[] =
 570 {
 571   att_flavor,
 572   intel_flavor,
 573   NULL
 574 };
 575 static const char *disassembly_flavor = att_flavor;
 576 \f
 577
 578 /* Use the program counter to determine the contents and size of a
 579    breakpoint instruction.  Return a pointer to a string of bytes that
 580    encode a breakpoint instruction, store the length of the string in
 581    *LEN and optionally adjust *PC to point to the correct memory
 582    location for inserting the breakpoint.
 583
 584    On the i386 we have a single breakpoint that fits in a single byte
 585    and can be inserted anywhere.
 586
 587    This function is 64-bit safe.  */
 588
 589 static const gdb_byte *
 590 i386_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
 591 {
 592   static gdb_byte break_insn[] = { 0xcc }; /* int 3 */
 593
 594   *len = sizeof (break_insn);
 595   return break_insn;
 596 }
 597 \f
 598 /* Displaced instruction handling.  */
 599
 600 /* Skip the legacy instruction prefixes in INSN.
 601    Not all prefixes are valid for any particular insn
 602    but we needn't care, the insn will fault if it's invalid.
 603    The result is a pointer to the first opcode byte,
 604    or NULL if we run off the end of the buffer.  */
 605
 606 static gdb_byte *
 607 i386_skip_prefixes (gdb_byte *insn, size_t max_len)
 608 {
 609   gdb_byte *end = insn + max_len;
 610
 611   while (insn < end)
 612     {
 613       switch (*insn)
 614         {
 615         case DATA_PREFIX_OPCODE:
 616         case ADDR_PREFIX_OPCODE:
 617         case CS_PREFIX_OPCODE:
 618         case DS_PREFIX_OPCODE:
 619         case ES_PREFIX_OPCODE:
 620         case FS_PREFIX_OPCODE:
 621         case GS_PREFIX_OPCODE:
 622         case SS_PREFIX_OPCODE:
 623         case LOCK_PREFIX_OPCODE:
 624         case REPE_PREFIX_OPCODE:
 625         case REPNE_PREFIX_OPCODE:
 626           ++insn;
 627           continue;
 628         default:
 629           return insn;
 630         }
 631     }
 632
 633   return NULL;
 634 }
 635
 636 static int
 637 i386_absolute_jmp_p (const gdb_byte *insn)
 638 {
 639   /* jmp far (absolute address in operand).  */
 640   if (insn[0] == 0xea)
 641     return 1;
 642
 643   if (insn[0] == 0xff)
 644     {
 645       /* jump near, absolute indirect (/4).  */
 646       if ((insn[1] & 0x38) == 0x20)
 647         return 1;
 648
 649       /* jump far, absolute indirect (/5).  */
 650       if ((insn[1] & 0x38) == 0x28)
 651         return 1;
 652     }
 653
 654   return 0;
 655 }
 656
 657 /* Return non-zero if INSN is a jump, zero otherwise.  */
 658
 659 static int
 660 i386_jmp_p (const gdb_byte *insn)
 661 {
 662   /* jump short, relative.  */
 663   if (insn[0] == 0xeb)
 664     return 1;
 665
 666   /* jump near, relative.  */
 667   if (insn[0] == 0xe9)
 668     return 1;
 669
 670   return i386_absolute_jmp_p (insn);
 671 }
 672
 673 static int
 674 i386_absolute_call_p (const gdb_byte *insn)
 675 {
 676   /* call far, absolute.  */
 677   if (insn[0] == 0x9a)
 678     return 1;
 679
 680   if (insn[0] == 0xff)
 681     {
 682       /* Call near, absolute indirect (/2).  */
 683       if ((insn[1] & 0x38) == 0x10)
 684         return 1;
 685
 686       /* Call far, absolute indirect (/3).  */
 687       if ((insn[1] & 0x38) == 0x18)
 688         return 1;
 689     }
 690
 691   return 0;
 692 }
 693
 694 static int
 695 i386_ret_p (const gdb_byte *insn)
 696 {
 697   switch (insn[0])
 698     {
 699     case 0xc2: /* ret near, pop N bytes.  */
 700     case 0xc3: /* ret near */
 701     case 0xca: /* ret far, pop N bytes.  */
 702     case 0xcb: /* ret far */
 703     case 0xcf: /* iret */
 704       return 1;
 705
 706     default:
 707       return 0;
 708     }
 709 }
 710
 711 static int
 712 i386_call_p (const gdb_byte *insn)
 713 {
 714   if (i386_absolute_call_p (insn))
 715     return 1;
 716
 717   /* call near, relative.  */
 718   if (insn[0] == 0xe8)
 719     return 1;
 720
 721   return 0;
 722 }
 723
 724 /* Return non-zero if INSN is a system call, and set *LENGTHP to its
 725    length in bytes.  Otherwise, return zero.  */
 726
 727 static int
 728 i386_syscall_p (const gdb_byte *insn, int *lengthp)
 729 {
 730   /* Is it 'int $0x80'?  */
 731   if ((insn[0] == 0xcd && insn[1] == 0x80)
 732       /* Or is it 'sysenter'?  */
 733       || (insn[0] == 0x0f && insn[1] == 0x34)
 734       /* Or is it 'syscall'?  */
 735       || (insn[0] == 0x0f && insn[1] == 0x05))
 736     {
 737       *lengthp = 2;
 738       return 1;
 739     }
 740
 741   return 0;
 742 }
 743
 744 /* The gdbarch insn_is_call method.  */
 745
 746 static int
 747 i386_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
 748 {
 749   gdb_byte buf[I386_MAX_INSN_LEN], *insn;
 750
 751   read_code (addr, buf, I386_MAX_INSN_LEN);
 752   insn = i386_skip_prefixes (buf, I386_MAX_INSN_LEN);
 753
 754   return i386_call_p (insn);
 755 }
 756
 757 /* The gdbarch insn_is_ret method.  */
 758
 759 static int
 760 i386_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
 761 {
 762   gdb_byte buf[I386_MAX_INSN_LEN], *insn;
 763
 764   read_code (addr, buf, I386_MAX_INSN_LEN);
 765   insn = i386_skip_prefixes (buf, I386_MAX_INSN_LEN);
 766
 767   return i386_ret_p (insn);
 768 }
 769
 770 /* The gdbarch insn_is_jump method.  */
 771
 772 static int
 773 i386_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
 774 {
 775   gdb_byte buf[I386_MAX_INSN_LEN], *insn;
 776
 777   read_code (addr, buf, I386_MAX_INSN_LEN);
 778   insn = i386_skip_prefixes (buf, I386_MAX_INSN_LEN);
 779
 780   return i386_jmp_p (insn);
 781 }
 782
 783 /* Some kernels may run one past a syscall insn, so we have to cope.
 784    Otherwise this is just simple_displaced_step_copy_insn.  */
 785
 786 struct displaced_step_closure *
 787 i386_displaced_step_copy_insn (struct gdbarch *gdbarch,
 788                                CORE_ADDR from, CORE_ADDR to,
 789                                struct regcache *regs)
 790 {
 791   size_t len = gdbarch_max_insn_length (gdbarch);
 792   gdb_byte *buf = (gdb_byte *) xmalloc (len);
 793
 794   read_memory (from, buf, len);
 795
 796   /* GDB may get control back after the insn after the syscall.
 797      Presumably this is a kernel bug.
 798      If this is a syscall, make sure there's a nop afterwards.  */
 799   {
 800     int syscall_length;
 801     gdb_byte *insn;
 802
 803     insn = i386_skip_prefixes (buf, len);
 804     if (insn != NULL && i386_syscall_p (insn, &syscall_length))
 805       insn[syscall_length] = NOP_OPCODE;
 806   }
 807
 808   write_memory (to, buf, len);
 809
 810   if (debug_displaced)
 811     {
 812       fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
 813                           paddress (gdbarch, from), paddress (gdbarch, to));
 814       displaced_step_dump_bytes (gdb_stdlog, buf, len);
 815     }
 816
 817   return (struct displaced_step_closure *) buf;
 818 }
 819
 820 /* Fix up the state of registers and memory after having single-stepped
 821    a displaced instruction.  */
 822
 823 void
 824 i386_displaced_step_fixup (struct gdbarch *gdbarch,
 825                            struct displaced_step_closure *closure,
 826                            CORE_ADDR from, CORE_ADDR to,
 827                            struct regcache *regs)
 828 {
 829   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 830
 831   /* The offset we applied to the instruction's address.
 832      This could well be negative (when viewed as a signed 32-bit
 833      value), but ULONGEST won't reflect that, so take care when
 834      applying it.  */
 835   ULONGEST insn_offset = to - from;
 836
 837   /* Since we use simple_displaced_step_copy_insn, our closure is a
 838      copy of the instruction.  */
 839   gdb_byte *insn = (gdb_byte *) closure;
 840   /* The start of the insn, needed in case we see some prefixes.  */
 841   gdb_byte *insn_start = insn;
 842
 843   if (debug_displaced)
 844     fprintf_unfiltered (gdb_stdlog,
 845                         "displaced: fixup (%s, %s), "
 846                         "insn = 0x%02x 0x%02x ...\n",
 847                         paddress (gdbarch, from), paddress (gdbarch, to),
 848                         insn[0], insn[1]);
 849
 850   /* The list of issues to contend with here is taken from
 851      resume_execution in arch/i386/kernel/kprobes.c, Linux 2.6.20.
 852      Yay for Free Software!  */
 853
 854   /* Relocate the %eip, if necessary.  */
 855
 856   /* The instruction recognizers we use assume any leading prefixes
 857      have been skipped.  */
 858   {
 859     /* This is the size of the buffer in closure.  */
 860     size_t max_insn_len = gdbarch_max_insn_length (gdbarch);
 861     gdb_byte *opcode = i386_skip_prefixes (insn, max_insn_len);
 862     /* If there are too many prefixes, just ignore the insn.
 863        It will fault when run.  */
 864     if (opcode != NULL)
 865       insn = opcode;
 866   }
 867
 868   /* Except in the case of absolute or indirect jump or call
 869      instructions, or a return instruction, the new eip is relative to
 870      the displaced instruction; make it relative.  Well, signal
 871      handler returns don't need relocation either, but we use the
 872      value of %eip to recognize those; see below.  */
 873   if (! i386_absolute_jmp_p (insn)
 874       && ! i386_absolute_call_p (insn)
 875       && ! i386_ret_p (insn))
 876     {
 877       ULONGEST orig_eip;
 878       int insn_len;
 879
 880       regcache_cooked_read_unsigned (regs, I386_EIP_REGNUM, &orig_eip);
 881
 882       /* A signal trampoline system call changes the %eip, resuming
 883          execution of the main program after the signal handler has
 884          returned.  That makes them like 'return' instructions; we
 885          shouldn't relocate %eip.
 886
 887          But most system calls don't, and we do need to relocate %eip.
 888
 889          Our heuristic for distinguishing these cases: if stepping
 890          over the system call instruction left control directly after
 891          the instruction, the we relocate --- control almost certainly
 892          doesn't belong in the displaced copy.  Otherwise, we assume
 893          the instruction has put control where it belongs, and leave
 894          it unrelocated.  Goodness help us if there are PC-relative
 895          system calls.  */
 896       if (i386_syscall_p (insn, &insn_len)
 897           && orig_eip != to + (insn - insn_start) + insn_len
 898           /* GDB can get control back after the insn after the syscall.
 899              Presumably this is a kernel bug.
 900              i386_displaced_step_copy_insn ensures its a nop,
 901              we add one to the length for it.  */
 902           && orig_eip != to + (insn - insn_start) + insn_len + 1)
 903         {
 904           if (debug_displaced)
 905             fprintf_unfiltered (gdb_stdlog,
 906                                 "displaced: syscall changed %%eip; "
 907                                 "not relocating\n");
 908         }
 909       else
 910         {
 911           ULONGEST eip = (orig_eip - insn_offset) & 0xffffffffUL;
 912
 913           /* If we just stepped over a breakpoint insn, we don't backup
 914              the pc on purpose; this is to match behaviour without
 915              stepping.  */
 916
 917           regcache_cooked_write_unsigned (regs, I386_EIP_REGNUM, eip);
 918
 919           if (debug_displaced)
 920             fprintf_unfiltered (gdb_stdlog,
 921                                 "displaced: "
 922                                 "relocated %%eip from %s to %s\n",
 923                                 paddress (gdbarch, orig_eip),
 924                                 paddress (gdbarch, eip));
 925         }
 926     }
 927
 928   /* If the instruction was PUSHFL, then the TF bit will be set in the
 929      pushed value, and should be cleared.  We'll leave this for later,
 930      since GDB already messes up the TF flag when stepping over a
 931      pushfl.  */
 932
 933   /* If the instruction was a call, the return address now atop the
 934      stack is the address following the copied instruction.  We need
 935      to make it the address following the original instruction.  */
 936   if (i386_call_p (insn))
 937     {
 938       ULONGEST esp;
 939       ULONGEST retaddr;
 940       const ULONGEST retaddr_len = 4;
 941
 942       regcache_cooked_read_unsigned (regs, I386_ESP_REGNUM, &esp);
 943       retaddr = read_memory_unsigned_integer (esp, retaddr_len, byte_order);
 944       retaddr = (retaddr - insn_offset) & 0xffffffffUL;
 945       write_memory_unsigned_integer (esp, retaddr_len, byte_order, retaddr);
 946
 947       if (debug_displaced)
 948         fprintf_unfiltered (gdb_stdlog,
 949                             "displaced: relocated return addr at %s to %s\n",
 950                             paddress (gdbarch, esp),
 951                             paddress (gdbarch, retaddr));
 952     }
 953 }
 954
 955 static void
 956 append_insns (CORE_ADDR *to, ULONGEST len, const gdb_byte *buf)
 957 {
 958   target_write_memory (*to, buf, len);
 959   *to += len;
 960 }
 961
 962 static void
 963 i386_relocate_instruction (struct gdbarch *gdbarch,
 964                            CORE_ADDR *to, CORE_ADDR oldloc)
 965 {
 966   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 967   gdb_byte buf[I386_MAX_INSN_LEN];
 968   int offset = 0, rel32, newrel;
 969   int insn_length;
 970   gdb_byte *insn = buf;
 971
 972   read_memory (oldloc, buf, I386_MAX_INSN_LEN);
 973
 974   insn_length = gdb_buffered_insn_length (gdbarch, insn,
 975                                           I386_MAX_INSN_LEN, oldloc);
 976
 977   /* Get past the prefixes.  */
 978   insn = i386_skip_prefixes (insn, I386_MAX_INSN_LEN);
 979
 980   /* Adjust calls with 32-bit relative addresses as push/jump, with
 981      the address pushed being the location where the original call in
 982      the user program would return to.  */
 983   if (insn[0] == 0xe8)
 984     {
 985       gdb_byte push_buf[16];
 986       unsigned int ret_addr;
 987
 988       /* Where "ret" in the original code will return to.  */
 989       ret_addr = oldloc + insn_length;
 990       push_buf[0] = 0x68; /* pushq $...  */
 991       store_unsigned_integer (&push_buf[1], 4, byte_order, ret_addr);
 992       /* Push the push.  */
 993       append_insns (to, 5, push_buf);
 994
 995       /* Convert the relative call to a relative jump.  */
 996       insn[0] = 0xe9;
 997
 998       /* Adjust the destination offset.  */
 999       rel32 = extract_signed_integer (insn + 1, 4, byte_order);
1000       newrel = (oldloc - *to) + rel32;
1001       store_signed_integer (insn + 1, 4, byte_order, newrel);
1002
1003       if (debug_displaced)
1004         fprintf_unfiltered (gdb_stdlog,
1005                             "Adjusted insn rel32=%s at %s to"
1006                             " rel32=%s at %s\n",
1007                             hex_string (rel32), paddress (gdbarch, oldloc),
1008                             hex_string (newrel), paddress (gdbarch, *to));
1009
1010       /* Write the adjusted jump into its displaced location.  */
1011       append_insns (to, 5, insn);
1012       return;
1013     }
1014
1015   /* Adjust jumps with 32-bit relative addresses.  Calls are already
1016      handled above.  */
1017   if (insn[0] == 0xe9)
1018     offset = 1;
1019   /* Adjust conditional jumps.  */
1020   else if (insn[0] == 0x0f && (insn[1] & 0xf0) == 0x80)
1021     offset = 2;
1022
1023   if (offset)
1024     {
1025       rel32 = extract_signed_integer (insn + offset, 4, byte_order);
1026       newrel = (oldloc - *to) + rel32;
1027       store_signed_integer (insn + offset, 4, byte_order, newrel);
1028       if (debug_displaced)
1029         fprintf_unfiltered (gdb_stdlog,
1030                             "Adjusted insn rel32=%s at %s to"
1031                             " rel32=%s at %s\n",
1032                             hex_string (rel32), paddress (gdbarch, oldloc),
1033                             hex_string (newrel), paddress (gdbarch, *to));
1034     }
1035
1036   /* Write the adjusted instructions into their displaced
1037      location.  */
1038   append_insns (to, insn_length, buf);
1039 }
1040
1041 \f
1042 #ifdef I386_REGNO_TO_SYMMETRY
1043 #error "The Sequent Symmetry is no longer supported."
1044 #endif
1045
1046 /* According to the System V ABI, the registers %ebp, %ebx, %edi, %esi
1047    and %esp "belong" to the calling function.  Therefore these
1048    registers should be saved if they're going to be modified.  */
1049
1050 /* The maximum number of saved registers.  This should include all
1051    registers mentioned above, and %eip.  */
1052 #define I386_NUM_SAVED_REGS     I386_NUM_GREGS
1053
1054 struct i386_frame_cache
1055 {
1056   /* Base address.  */
1057   CORE_ADDR base;
1058   int base_p;
1059   LONGEST sp_offset;
1060   CORE_ADDR pc;
1061
1062   /* Saved registers.  */
1063   CORE_ADDR saved_regs[I386_NUM_SAVED_REGS];
1064   CORE_ADDR saved_sp;
1065   int saved_sp_reg;
1066   int pc_in_eax;
1067
1068   /* Stack space reserved for local variables.  */
1069   long locals;
1070 };
1071
1072 /* Allocate and initialize a frame cache.  */
1073
1074 static struct i386_frame_cache *
1075 i386_alloc_frame_cache (void)
1076 {
1077   struct i386_frame_cache *cache;
1078   int i;
1079
1080   cache = FRAME_OBSTACK_ZALLOC (struct i386_frame_cache);
1081
1082   /* Base address.  */
1083   cache->base_p = 0;
1084   cache->base = 0;
1085   cache->sp_offset = -4;
1086   cache->pc = 0;
1087
1088   /* Saved registers.  We initialize these to -1 since zero is a valid
1089      offset (that's where %ebp is supposed to be stored).  */
1090   for (i = 0; i < I386_NUM_SAVED_REGS; i++)
1091     cache->saved_regs[i] = -1;
1092   cache->saved_sp = 0;
1093   cache->saved_sp_reg = -1;
1094   cache->pc_in_eax = 0;
1095
1096   /* Frameless until proven otherwise.  */
1097   cache->locals = -1;
1098
1099   return cache;
1100 }
1101
1102 /* If the instruction at PC is a jump, return the address of its
1103    target.  Otherwise, return PC.  */
1104
1105 static CORE_ADDR
1106 i386_follow_jump (struct gdbarch *gdbarch, CORE_ADDR pc)
1107 {
1108   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1109   gdb_byte op;
1110   long delta = 0;
1111   int data16 = 0;
1112
1113   if (target_read_code (pc, &op, 1))
1114     return pc;
1115
1116   if (op == 0x66)
1117     {
1118       data16 = 1;
1119
1120       op = read_code_unsigned_integer (pc + 1, 1, byte_order);
1121     }
1122
1123   switch (op)
1124     {
1125     case 0xe9:
1126       /* Relative jump: if data16 == 0, disp32, else disp16.  */
1127       if (data16)
1128         {
1129           delta = read_memory_integer (pc + 2, 2, byte_order);
1130
1131           /* Include the size of the jmp instruction (including the
1132              0x66 prefix).  */
1133           delta += 4;
1134         }
1135       else
1136         {
1137           delta = read_memory_integer (pc + 1, 4, byte_order);
1138
1139           /* Include the size of the jmp instruction.  */
1140           delta += 5;
1141         }
1142       break;
1143     case 0xeb:
1144       /* Relative jump, disp8 (ignore data16).  */
1145       delta = read_memory_integer (pc + data16 + 1, 1, byte_order);
1146
1147       delta += data16 + 2;
1148       break;
1149     }
1150
1151   return pc + delta;
1152 }
1153
1154 /* Check whether PC points at a prologue for a function returning a
1155    structure or union.  If so, it updates CACHE and returns the
1156    address of the first instruction after the code sequence that
1157    removes the "hidden" argument from the stack or CURRENT_PC,
1158    whichever is smaller.  Otherwise, return PC.  */
1159
1160 static CORE_ADDR
1161 i386_analyze_struct_return (CORE_ADDR pc, CORE_ADDR current_pc,
1162                             struct i386_frame_cache *cache)
1163 {
1164   /* Functions that return a structure or union start with:
1165
1166         popl %eax             0x58
1167         xchgl %eax, (%esp)    0x87 0x04 0x24
1168      or xchgl %eax, 0(%esp)   0x87 0x44 0x24 0x00
1169
1170      (the System V compiler puts out the second `xchg' instruction,
1171      and the assembler doesn't try to optimize it, so the 'sib' form
1172      gets generated).  This sequence is used to get the address of the
1173      return buffer for a function that returns a structure.  */
1174   static gdb_byte proto1[3] = { 0x87, 0x04, 0x24 };
1175   static gdb_byte proto2[4] = { 0x87, 0x44, 0x24, 0x00 };
1176   gdb_byte buf[4];
1177   gdb_byte op;
1178
1179   if (current_pc <= pc)
1180     return pc;
1181
1182   if (target_read_code (pc, &op, 1))
1183     return pc;
1184
1185   if (op != 0x58)               /* popl %eax */
1186     return pc;
1187
1188   if (target_read_code (pc + 1, buf, 4))
1189     return pc;
1190
1191   if (memcmp (buf, proto1, 3) != 0 && memcmp (buf, proto2, 4) != 0)
1192     return pc;
1193
1194   if (current_pc == pc)
1195     {
1196       cache->sp_offset += 4;
1197       return current_pc;
1198     }
1199
1200   if (current_pc == pc + 1)
1201     {
1202       cache->pc_in_eax = 1;
1203       return current_pc;
1204     }
1205
1206   if (buf[1] == proto1[1])
1207     return pc + 4;
1208   else
1209     return pc + 5;
1210 }
1211
1212 static CORE_ADDR
1213 i386_skip_probe (CORE_ADDR pc)
1214 {
1215   /* A function may start with
1216
1217         pushl constant
1218         call _probe
1219         addl $4, %esp
1220
1221      followed by
1222
1223         pushl %ebp
1224
1225      etc.  */
1226   gdb_byte buf[8];
1227   gdb_byte op;
1228
1229   if (target_read_code (pc, &op, 1))
1230     return pc;
1231
1232   if (op == 0x68 || op == 0x6a)
1233     {
1234       int delta;
1235
1236       /* Skip past the `pushl' instruction; it has either a one-byte or a
1237          four-byte operand, depending on the opcode.  */
1238       if (op == 0x68)
1239         delta = 5;
1240       else
1241         delta = 2;
1242
1243       /* Read the following 8 bytes, which should be `call _probe' (6
1244          bytes) followed by `addl $4,%esp' (2 bytes).  */
1245       read_memory (pc + delta, buf, sizeof (buf));
1246       if (buf[0] == 0xe8 && buf[6] == 0xc4 && buf[7] == 0x4)
1247         pc += delta + sizeof (buf);
1248     }
1249
1250   return pc;
1251 }
1252
1253 /* GCC 4.1 and later, can put code in the prologue to realign the
1254    stack pointer.  Check whether PC points to such code, and update
1255    CACHE accordingly.  Return the first instruction after the code
1256    sequence or CURRENT_PC, whichever is smaller.  If we don't
1257    recognize the code, return PC.  */
1258
1259 static CORE_ADDR
1260 i386_analyze_stack_align (CORE_ADDR pc, CORE_ADDR current_pc,
1261                           struct i386_frame_cache *cache)
1262 {
1263   /* There are 2 code sequences to re-align stack before the frame
1264      gets set up:
1265
1266         1. Use a caller-saved saved register:
1267
1268                 leal  4(%esp), %reg
1269                 andl  $-XXX, %esp
1270                 pushl -4(%reg)
1271
1272         2. Use a callee-saved saved register:
1273
1274                 pushl %reg
1275                 leal  8(%esp), %reg
1276                 andl  $-XXX, %esp
1277                 pushl -4(%reg)
1278
1279      "andl $-XXX, %esp" can be either 3 bytes or 6 bytes:
1280
1281         0x83 0xe4 0xf0                  andl $-16, %esp
1282         0x81 0xe4 0x00 0xff 0xff 0xff   andl $-256, %esp
1283    */
1284
1285   gdb_byte buf[14];
1286   int reg;
1287   int offset, offset_and;
1288   static int regnums[8] = {
1289     I386_EAX_REGNUM,            /* %eax */
1290     I386_ECX_REGNUM,            /* %ecx */
1291     I386_EDX_REGNUM,            /* %edx */
1292     I386_EBX_REGNUM,            /* %ebx */
1293     I386_ESP_REGNUM,            /* %esp */
1294     I386_EBP_REGNUM,            /* %ebp */
1295     I386_ESI_REGNUM,            /* %esi */
1296     I386_EDI_REGNUM             /* %edi */
1297   };
1298
1299   if (target_read_code (pc, buf, sizeof buf))
1300     return pc;
1301
1302   /* Check caller-saved saved register.  The first instruction has
1303      to be "leal 4(%esp), %reg".  */
1304   if (buf[0] == 0x8d && buf[2] == 0x24 && buf[3] == 0x4)
1305     {
1306       /* MOD must be binary 10 and R/M must be binary 100.  */
1307       if ((buf[1] & 0xc7) != 0x44)
1308         return pc;
1309
1310       /* REG has register number.  */
1311       reg = (buf[1] >> 3) & 7;
1312       offset = 4;
1313     }
1314   else
1315     {
1316       /* Check callee-saved saved register.  The first instruction
1317          has to be "pushl %reg".  */
1318       if ((buf[0] & 0xf8) != 0x50)
1319         return pc;
1320
1321       /* Get register.  */
1322       reg = buf[0] & 0x7;
1323
1324       /* The next instruction has to be "leal 8(%esp), %reg".  */
1325       if (buf[1] != 0x8d || buf[3] != 0x24 || buf[4] != 0x8)
1326         return pc;
1327
1328       /* MOD must be binary 10 and R/M must be binary 100.  */
1329       if ((buf[2] & 0xc7) != 0x44)
1330         return pc;
1331
1332       /* REG has register number.  Registers in pushl and leal have to
1333          be the same.  */
1334       if (reg != ((buf[2] >> 3) & 7))
1335         return pc;
1336
1337       offset = 5;
1338     }
1339
1340   /* Rigister can't be %esp nor %ebp.  */
1341   if (reg == 4 || reg == 5)
1342     return pc;
1343
1344   /* The next instruction has to be "andl $-XXX, %esp".  */
1345   if (buf[offset + 1] != 0xe4
1346       || (buf[offset] != 0x81 && buf[offset] != 0x83))
1347     return pc;
1348
1349   offset_and = offset;
1350   offset += buf[offset] == 0x81 ? 6 : 3;
1351
1352   /* The next instruction has to be "pushl -4(%reg)".  8bit -4 is
1353      0xfc.  REG must be binary 110 and MOD must be binary 01.  */
1354   if (buf[offset] != 0xff
1355       || buf[offset + 2] != 0xfc
1356       || (buf[offset + 1] & 0xf8) != 0x70)
1357     return pc;
1358
1359   /* R/M has register.  Registers in leal and pushl have to be the
1360      same.  */
1361   if (reg != (buf[offset + 1] & 7))
1362     return pc;
1363
1364   if (current_pc > pc + offset_and)
1365     cache->saved_sp_reg = regnums[reg];
1366
1367   return min (pc + offset + 3, current_pc);
1368 }
1369
1370 /* Maximum instruction length we need to handle.  */
1371 #define I386_MAX_MATCHED_INSN_LEN       6
1372
1373 /* Instruction description.  */
1374 struct i386_insn
1375 {
1376   size_t len;
1377   gdb_byte insn[I386_MAX_MATCHED_INSN_LEN];
1378   gdb_byte mask[I386_MAX_MATCHED_INSN_LEN];
1379 };
1380
1381 /* Return whether instruction at PC matches PATTERN.  */
1382
1383 static int
1384 i386_match_pattern (CORE_ADDR pc, struct i386_insn pattern)
1385 {
1386   gdb_byte op;
1387
1388   if (target_read_code (pc, &op, 1))
1389     return 0;
1390
1391   if ((op & pattern.mask[0]) == pattern.insn[0])
1392     {
1393       gdb_byte buf[I386_MAX_MATCHED_INSN_LEN - 1];
1394       int insn_matched = 1;
1395       size_t i;
1396
1397       gdb_assert (pattern.len > 1);
1398       gdb_assert (pattern.len <= I386_MAX_MATCHED_INSN_LEN);
1399
1400       if (target_read_code (pc + 1, buf, pattern.len - 1))
1401         return 0;
1402
1403       for (i = 1; i < pattern.len; i++)
1404         {
1405           if ((buf[i - 1] & pattern.mask[i]) != pattern.insn[i])
1406             insn_matched = 0;
1407         }
1408       return insn_matched;
1409     }
1410   return 0;
1411 }
1412
1413 /* Search for the instruction at PC in the list INSN_PATTERNS.  Return
1414    the first instruction description that matches.  Otherwise, return
1415    NULL.  */
1416
1417 static struct i386_insn *
1418 i386_match_insn (CORE_ADDR pc, struct i386_insn *insn_patterns)
1419 {
1420   struct i386_insn *pattern;
1421
1422   for (pattern = insn_patterns; pattern->len > 0; pattern++)
1423     {
1424       if (i386_match_pattern (pc, *pattern))
1425         return pattern;
1426     }
1427
1428   return NULL;
1429 }
1430
1431 /* Return whether PC points inside a sequence of instructions that
1432    matches INSN_PATTERNS.  */
1433
1434 static int
1435 i386_match_insn_block (CORE_ADDR pc, struct i386_insn *insn_patterns)
1436 {
1437   CORE_ADDR current_pc;
1438   int ix, i;
1439   struct i386_insn *insn;
1440
1441   insn = i386_match_insn (pc, insn_patterns);
1442   if (insn == NULL)
1443     return 0;
1444
1445   current_pc = pc;
1446   ix = insn - insn_patterns;
1447   for (i = ix - 1; i >= 0; i--)
1448     {
1449       current_pc -= insn_patterns[i].len;
1450
1451       if (!i386_match_pattern (current_pc, insn_patterns[i]))
1452         return 0;
1453     }
1454
1455   current_pc = pc + insn->len;
1456   for (insn = insn_patterns + ix + 1; insn->len > 0; insn++)
1457     {
1458       if (!i386_match_pattern (current_pc, *insn))
1459         return 0;
1460
1461       current_pc += insn->len;
1462     }
1463
1464   return 1;
1465 }
1466
1467 /* Some special instructions that might be migrated by GCC into the
1468    part of the prologue that sets up the new stack frame.  Because the
1469    stack frame hasn't been setup yet, no registers have been saved
1470    yet, and only the scratch registers %eax, %ecx and %edx can be
1471    touched.  */
1472
1473 struct i386_insn i386_frame_setup_skip_insns[] =
1474 {
1475   /* Check for `movb imm8, r' and `movl imm32, r'.
1476
1477      ??? Should we handle 16-bit operand-sizes here?  */
1478
1479   /* `movb imm8, %al' and `movb imm8, %ah' */
1480   /* `movb imm8, %cl' and `movb imm8, %ch' */
1481   { 2, { 0xb0, 0x00 }, { 0xfa, 0x00 } },
1482   /* `movb imm8, %dl' and `movb imm8, %dh' */
1483   { 2, { 0xb2, 0x00 }, { 0xfb, 0x00 } },
1484   /* `movl imm32, %eax' and `movl imm32, %ecx' */
1485   { 5, { 0xb8 }, { 0xfe } },
1486   /* `movl imm32, %edx' */
1487   { 5, { 0xba }, { 0xff } },
1488
1489   /* Check for `mov imm32, r32'.  Note that there is an alternative
1490      encoding for `mov m32, %eax'.
1491
1492      ??? Should we handle SIB adressing here?
1493      ??? Should we handle 16-bit operand-sizes here?  */
1494
1495   /* `movl m32, %eax' */
1496   { 5, { 0xa1 }, { 0xff } },
1497   /* `movl m32, %eax' and `mov; m32, %ecx' */
1498   { 6, { 0x89, 0x05 }, {0xff, 0xf7 } },
1499   /* `movl m32, %edx' */
1500   { 6, { 0x89, 0x15 }, {0xff, 0xff } },
1501
1502   /* Check for `xorl r32, r32' and the equivalent `subl r32, r32'.
1503      Because of the symmetry, there are actually two ways to encode
1504      these instructions; opcode bytes 0x29 and 0x2b for `subl' and
1505      opcode bytes 0x31 and 0x33 for `xorl'.  */
1506
1507   /* `subl %eax, %eax' */
1508   { 2, { 0x29, 0xc0 }, { 0xfd, 0xff } },
1509   /* `subl %ecx, %ecx' */
1510   { 2, { 0x29, 0xc9 }, { 0xfd, 0xff } },
1511   /* `subl %edx, %edx' */
1512   { 2, { 0x29, 0xd2 }, { 0xfd, 0xff } },
1513   /* `xorl %eax, %eax' */
1514   { 2, { 0x31, 0xc0 }, { 0xfd, 0xff } },
1515   /* `xorl %ecx, %ecx' */
1516   { 2, { 0x31, 0xc9 }, { 0xfd, 0xff } },
1517   /* `xorl %edx, %edx' */
1518   { 2, { 0x31, 0xd2 }, { 0xfd, 0xff } },
1519   { 0 }
1520 };
1521
1522
1523 /* Check whether PC points to a no-op instruction.  */
1524 static CORE_ADDR
1525 i386_skip_noop (CORE_ADDR pc)
1526 {
1527   gdb_byte op;
1528   int check = 1;
1529
1530   if (target_read_code (pc, &op, 1))
1531     return pc;
1532
1533   while (check)
1534     {
1535       check = 0;
1536       /* Ignore `nop' instruction.  */
1537       if (op == 0x90)
1538         {
1539           pc += 1;
1540           if (target_read_code (pc, &op, 1))
1541             return pc;
1542           check = 1;
1543         }
1544       /* Ignore no-op instruction `mov %edi, %edi'.
1545          Microsoft system dlls often start with
1546          a `mov %edi,%edi' instruction.
1547          The 5 bytes before the function start are
1548          filled with `nop' instructions.
1549          This pattern can be used for hot-patching:
1550          The `mov %edi, %edi' instruction can be replaced by a
1551          near jump to the location of the 5 `nop' instructions
1552          which can be replaced by a 32-bit jump to anywhere
1553          in the 32-bit address space.  */
1554
1555       else if (op == 0x8b)
1556         {
1557           if (target_read_code (pc + 1, &op, 1))
1558             return pc;
1559
1560           if (op == 0xff)
1561             {
1562               pc += 2;
1563               if (target_read_code (pc, &op, 1))
1564                 return pc;
1565
1566               check = 1;
1567             }
1568         }
1569     }
1570   return pc;
1571 }
1572
1573 /* Check whether PC points at a code that sets up a new stack frame.
1574    If so, it updates CACHE and returns the address of the first
1575    instruction after the sequence that sets up the frame or LIMIT,
1576    whichever is smaller.  If we don't recognize the code, return PC.  */
1577
1578 static CORE_ADDR
1579 i386_analyze_frame_setup (struct gdbarch *gdbarch,
1580                           CORE_ADDR pc, CORE_ADDR limit,
1581                           struct i386_frame_cache *cache)
1582 {
1583   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1584   struct i386_insn *insn;
1585   gdb_byte op;
1586   int skip = 0;
1587
1588   if (limit <= pc)
1589     return limit;
1590
1591   if (target_read_code (pc, &op, 1))
1592     return pc;
1593
1594   if (op == 0x55)               /* pushl %ebp */
1595     {
1596       /* Take into account that we've executed the `pushl %ebp' that
1597          starts this instruction sequence.  */
1598       cache->saved_regs[I386_EBP_REGNUM] = 0;
1599       cache->sp_offset += 4;
1600       pc++;
1601
1602       /* If that's all, return now.  */
1603       if (limit <= pc)
1604         return limit;
1605
1606       /* Check for some special instructions that might be migrated by
1607          GCC into the prologue and skip them.  At this point in the
1608          prologue, code should only touch the scratch registers %eax,
1609          %ecx and %edx, so while the number of posibilities is sheer,
1610          it is limited.
1611
1612          Make sure we only skip these instructions if we later see the
1613          `movl %esp, %ebp' that actually sets up the frame.  */
1614       while (pc + skip < limit)
1615         {
1616           insn = i386_match_insn (pc + skip, i386_frame_setup_skip_insns);
1617           if (insn == NULL)
1618             break;
1619
1620           skip += insn->len;
1621         }
1622
1623       /* If that's all, return now.  */
1624       if (limit <= pc + skip)
1625         return limit;
1626
1627       if (target_read_code (pc + skip, &op, 1))
1628         return pc + skip;
1629
1630       /* The i386 prologue looks like
1631
1632          push   %ebp
1633          mov    %esp,%ebp
1634          sub    $0x10,%esp
1635
1636          and a different prologue can be generated for atom.
1637
1638          push   %ebp
1639          lea    (%esp),%ebp
1640          lea    -0x10(%esp),%esp
1641
1642          We handle both of them here.  */
1643
1644       switch (op)
1645         {
1646           /* Check for `movl %esp, %ebp' -- can be written in two ways.  */
1647         case 0x8b:
1648           if (read_code_unsigned_integer (pc + skip + 1, 1, byte_order)
1649               != 0xec)
1650             return pc;
1651           pc += (skip + 2);
1652           break;
1653         case 0x89:
1654           if (read_code_unsigned_integer (pc + skip + 1, 1, byte_order)
1655               != 0xe5)
1656             return pc;
1657           pc += (skip + 2);
1658           break;
1659         case 0x8d: /* Check for 'lea (%ebp), %ebp'.  */
1660           if (read_code_unsigned_integer (pc + skip + 1, 2, byte_order)
1661               != 0x242c)
1662             return pc;
1663           pc += (skip + 3);
1664           break;
1665         default:
1666           return pc;
1667         }
1668
1669       /* OK, we actually have a frame.  We just don't know how large
1670          it is yet.  Set its size to zero.  We'll adjust it if
1671          necessary.  We also now commit to skipping the special
1672          instructions mentioned before.  */
1673       cache->locals = 0;
1674
1675       /* If that's all, return now.  */
1676       if (limit <= pc)
1677         return limit;
1678
1679       /* Check for stack adjustment
1680
1681             subl $XXX, %esp
1682          or
1683             lea -XXX(%esp),%esp
1684
1685          NOTE: You can't subtract a 16-bit immediate from a 32-bit
1686          reg, so we don't have to worry about a data16 prefix.  */
1687       if (target_read_code (pc, &op, 1))
1688         return pc;
1689       if (op == 0x83)
1690         {
1691           /* `subl' with 8-bit immediate.  */
1692           if (read_code_unsigned_integer (pc + 1, 1, byte_order) != 0xec)
1693             /* Some instruction starting with 0x83 other than `subl'.  */
1694             return pc;
1695
1696           /* `subl' with signed 8-bit immediate (though it wouldn't
1697              make sense to be negative).  */
1698           cache->locals = read_code_integer (pc + 2, 1, byte_order);
1699           return pc + 3;
1700         }
1701       else if (op == 0x81)
1702         {
1703           /* Maybe it is `subl' with a 32-bit immediate.  */
1704           if (read_code_unsigned_integer (pc + 1, 1, byte_order) != 0xec)
1705             /* Some instruction starting with 0x81 other than `subl'.  */
1706             return pc;
1707
1708           /* It is `subl' with a 32-bit immediate.  */
1709           cache->locals = read_code_integer (pc + 2, 4, byte_order);
1710           return pc + 6;
1711         }
1712       else if (op == 0x8d)
1713         {
1714           /* The ModR/M byte is 0x64.  */
1715           if (read_code_unsigned_integer (pc + 1, 1, byte_order) != 0x64)
1716             return pc;
1717           /* 'lea' with 8-bit displacement.  */
1718           cache->locals = -1 * read_code_integer (pc + 3, 1, byte_order);
1719           return pc + 4;
1720         }
1721       else
1722         {
1723           /* Some instruction other than `subl' nor 'lea'.  */
1724           return pc;
1725         }
1726     }
1727   else if (op == 0xc8)          /* enter */
1728     {
1729       cache->locals = read_code_unsigned_integer (pc + 1, 2, byte_order);
1730       return pc + 4;
1731     }
1732
1733   return pc;
1734 }
1735
1736 /* Check whether PC points at code that saves registers on the stack.
1737    If so, it updates CACHE and returns the address of the first
1738    instruction after the register saves or CURRENT_PC, whichever is
1739    smaller.  Otherwise, return PC.  */
1740
1741 static CORE_ADDR
1742 i386_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
1743                              struct i386_frame_cache *cache)
1744 {
1745   CORE_ADDR offset = 0;
1746   gdb_byte op;
1747   int i;
1748
1749   if (cache->locals > 0)
1750     offset -= cache->locals;
1751   for (i = 0; i < 8 && pc < current_pc; i++)
1752     {
1753       if (target_read_code (pc, &op, 1))
1754         return pc;
1755       if (op < 0x50 || op > 0x57)
1756         break;
1757
1758       offset -= 4;
1759       cache->saved_regs[op - 0x50] = offset;
1760       cache->sp_offset += 4;
1761       pc++;
1762     }
1763
1764   return pc;
1765 }
1766
1767 /* Do a full analysis of the prologue at PC and update CACHE
1768    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
1769    address where the analysis stopped.
1770
1771    We handle these cases:
1772
1773    The startup sequence can be at the start of the function, or the
1774    function can start with a branch to startup code at the end.
1775
1776    %ebp can be set up with either the 'enter' instruction, or "pushl
1777    %ebp, movl %esp, %ebp" (`enter' is too slow to be useful, but was
1778    once used in the System V compiler).
1779
1780    Local space is allocated just below the saved %ebp by either the
1781    'enter' instruction, or by "subl $<size>, %esp".  'enter' has a
1782    16-bit unsigned argument for space to allocate, and the 'addl'
1783    instruction could have either a signed byte, or 32-bit immediate.
1784
1785    Next, the registers used by this function are pushed.  With the
1786    System V compiler they will always be in the order: %edi, %esi,
1787    %ebx (and sometimes a harmless bug causes it to also save but not
1788    restore %eax); however, the code below is willing to see the pushes
1789    in any order, and will handle up to 8 of them.
1790
1791    If the setup sequence is at the end of the function, then the next
1792    instruction will be a branch back to the start.  */
1793
1794 static CORE_ADDR
1795 i386_analyze_prologue (struct gdbarch *gdbarch,
1796                        CORE_ADDR pc, CORE_ADDR current_pc,
1797                        struct i386_frame_cache *cache)
1798 {
1799   pc = i386_skip_noop (pc);
1800   pc = i386_follow_jump (gdbarch, pc);
1801   pc = i386_analyze_struct_return (pc, current_pc, cache);
1802   pc = i386_skip_probe (pc);
1803   pc = i386_analyze_stack_align (pc, current_pc, cache);
1804   pc = i386_analyze_frame_setup (gdbarch, pc, current_pc, cache);
1805   return i386_analyze_register_saves (pc, current_pc, cache);
1806 }
1807
1808 /* Return PC of first real instruction.  */
1809
1810 static CORE_ADDR
1811 i386_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
1812 {
1813   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1814
1815   static gdb_byte pic_pat[6] =
1816   {
1817     0xe8, 0, 0, 0, 0,           /* call 0x0 */
1818     0x5b,                       /* popl %ebx */
1819   };
1820   struct i386_frame_cache cache;
1821   CORE_ADDR pc;
1822   gdb_byte op;
1823   int i;
1824   CORE_ADDR func_addr;
1825
1826   if (find_pc_partial_function (start_pc, NULL, &func_addr, NULL))
1827     {
1828       CORE_ADDR post_prologue_pc
1829         = skip_prologue_using_sal (gdbarch, func_addr);
1830       struct compunit_symtab *cust = find_pc_compunit_symtab (func_addr);
1831
1832       /* Clang always emits a line note before the prologue and another
1833          one after.  We trust clang to emit usable line notes.  */
1834       if (post_prologue_pc
1835           && (cust != NULL
1836               && COMPUNIT_PRODUCER (cust) != NULL
1837               && startswith (COMPUNIT_PRODUCER (cust), "clang ")))
1838         return max (start_pc, post_prologue_pc);
1839     }
1840
1841   cache.locals = -1;
1842   pc = i386_analyze_prologue (gdbarch, start_pc, 0xffffffff, &cache);
1843   if (cache.locals < 0)
1844     return start_pc;
1845
1846   /* Found valid frame setup.  */
1847
1848   /* The native cc on SVR4 in -K PIC mode inserts the following code
1849      to get the address of the global offset table (GOT) into register
1850      %ebx:
1851
1852         call    0x0
1853         popl    %ebx
1854         movl    %ebx,x(%ebp)    (optional)
1855         addl    y,%ebx
1856
1857      This code is with the rest of the prologue (at the end of the
1858      function), so we have to skip it to get to the first real
1859      instruction at the start of the function.  */
1860
1861   for (i = 0; i < 6; i++)
1862     {
1863       if (target_read_code (pc + i, &op, 1))
1864         return pc;
1865
1866       if (pic_pat[i] != op)
1867         break;
1868     }
1869   if (i == 6)
1870     {
1871       int delta = 6;
1872
1873       if (target_read_code (pc + delta, &op, 1))
1874         return pc;
1875
1876       if (op == 0x89)           /* movl %ebx, x(%ebp) */
1877         {
1878           op = read_code_unsigned_integer (pc + delta + 1, 1, byte_order);
1879
1880           if (op == 0x5d)       /* One byte offset from %ebp.  */
1881             delta += 3;
1882           else if (op == 0x9d)  /* Four byte offset from %ebp.  */
1883             delta += 6;
1884           else                  /* Unexpected instruction.  */
1885             delta = 0;
1886
1887           if (target_read_code (pc + delta, &op, 1))
1888             return pc;
1889         }
1890
1891       /* addl y,%ebx */
1892       if (delta > 0 && op == 0x81
1893           && read_code_unsigned_integer (pc + delta + 1, 1, byte_order)
1894              == 0xc3)
1895         {
1896           pc += delta + 6;
1897         }
1898     }
1899
1900   /* If the function starts with a branch (to startup code at the end)
1901      the last instruction should bring us back to the first
1902      instruction of the real code.  */
1903   if (i386_follow_jump (gdbarch, start_pc) != start_pc)
1904     pc = i386_follow_jump (gdbarch, pc);
1905
1906   return pc;
1907 }
1908
1909 /* Check that the code pointed to by PC corresponds to a call to
1910    __main, skip it if so.  Return PC otherwise.  */
1911
1912 CORE_ADDR
1913 i386_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1914 {
1915   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1916   gdb_byte op;
1917
1918   if (target_read_code (pc, &op, 1))
1919     return pc;
1920   if (op == 0xe8)
1921     {
1922       gdb_byte buf[4];
1923
1924       if (target_read_code (pc + 1, buf, sizeof buf) == 0)
1925         {
1926           /* Make sure address is computed correctly as a 32bit
1927              integer even if CORE_ADDR is 64 bit wide.  */
1928           struct bound_minimal_symbol s;
1929           CORE_ADDR call_dest;
1930
1931           call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
1932           call_dest = call_dest & 0xffffffffU;
1933           s = lookup_minimal_symbol_by_pc (call_dest);
1934           if (s.minsym != NULL
1935               && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
1936               && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
1937             pc += 5;
1938         }
1939     }
1940
1941   return pc;
1942 }
1943
1944 /* This function is 64-bit safe.  */
1945
1946 static CORE_ADDR
1947 i386_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1948 {
1949   gdb_byte buf[8];
1950
1951   frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
1952   return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
1953 }
1954 \f
1955
1956 /* Normal frames.  */
1957
1958 static void
1959 i386_frame_cache_1 (struct frame_info *this_frame,
1960                     struct i386_frame_cache *cache)
1961 {
1962   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1963   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1964   gdb_byte buf[4];
1965   int i;
1966
1967   cache->pc = get_frame_func (this_frame);
1968
1969   /* In principle, for normal frames, %ebp holds the frame pointer,
1970      which holds the base address for the current stack frame.
1971      However, for functions that don't need it, the frame pointer is
1972      optional.  For these "frameless" functions the frame pointer is
1973      actually the frame pointer of the calling frame.  Signal
1974      trampolines are just a special case of a "frameless" function.
1975      They (usually) share their frame pointer with the frame that was
1976      in progress when the signal occurred.  */
1977
1978   get_frame_register (this_frame, I386_EBP_REGNUM, buf);
1979   cache->base = extract_unsigned_integer (buf, 4, byte_order);
1980   if (cache->base == 0)
1981     {
1982       cache->base_p = 1;
1983       return;
1984     }
1985
1986   /* For normal frames, %eip is stored at 4(%ebp).  */
1987   cache->saved_regs[I386_EIP_REGNUM] = 4;
1988
1989   if (cache->pc != 0)
1990     i386_analyze_prologue (gdbarch, cache->pc, get_frame_pc (this_frame),
1991                            cache);
1992
1993   if (cache->locals < 0)
1994     {
1995       /* We didn't find a valid frame, which means that CACHE->base
1996          currently holds the frame pointer for our calling frame.  If
1997          we're at the start of a function, or somewhere half-way its
1998          prologue, the function's frame probably hasn't been fully
1999          setup yet.  Try to reconstruct the base address for the stack
2000          frame by looking at the stack pointer.  For truly "frameless"
2001          functions this might work too.  */
2002
2003       if (cache->saved_sp_reg != -1)
2004         {
2005           /* Saved stack pointer has been saved.  */
2006           get_frame_register (this_frame, cache->saved_sp_reg, buf);
2007           cache->saved_sp = extract_unsigned_integer (buf, 4, byte_order);
2008
2009           /* We're halfway aligning the stack.  */
2010           cache->base = ((cache->saved_sp - 4) & 0xfffffff0) - 4;
2011           cache->saved_regs[I386_EIP_REGNUM] = cache->saved_sp - 4;
2012
2013           /* This will be added back below.  */
2014           cache->saved_regs[I386_EIP_REGNUM] -= cache->base;
2015         }
2016       else if (cache->pc != 0
2017                || target_read_code (get_frame_pc (this_frame), buf, 1))
2018         {
2019           /* We're in a known function, but did not find a frame
2020              setup.  Assume that the function does not use %ebp.
2021              Alternatively, we may have jumped to an invalid
2022              address; in that case there is definitely no new
2023              frame in %ebp.  */
2024           get_frame_register (this_frame, I386_ESP_REGNUM, buf);
2025           cache->base = extract_unsigned_integer (buf, 4, byte_order)
2026                         + cache->sp_offset;
2027         }
2028       else
2029         /* We're in an unknown function.  We could not find the start
2030            of the function to analyze the prologue; our best option is
2031            to assume a typical frame layout with the caller's %ebp
2032            saved.  */
2033         cache->saved_regs[I386_EBP_REGNUM] = 0;
2034     }
2035
2036   if (cache->saved_sp_reg != -1)
2037     {
2038       /* Saved stack pointer has been saved (but the SAVED_SP_REG
2039          register may be unavailable).  */
2040       if (cache->saved_sp == 0
2041           && deprecated_frame_register_read (this_frame,
2042                                              cache->saved_sp_reg, buf))
2043         cache->saved_sp = extract_unsigned_integer (buf, 4, byte_order);
2044     }
2045   /* Now that we have the base address for the stack frame we can
2046      calculate the value of %esp in the calling frame.  */
2047   else if (cache->saved_sp == 0)
2048     cache->saved_sp = cache->base + 8;
2049
2050   /* Adjust all the saved registers such that they contain addresses
2051      instead of offsets.  */
2052   for (i = 0; i < I386_NUM_SAVED_REGS; i++)
2053     if (cache->saved_regs[i] != -1)
2054       cache->saved_regs[i] += cache->base;
2055
2056   cache->base_p = 1;
2057 }
2058
2059 static struct i386_frame_cache *
2060 i386_frame_cache (struct frame_info *this_frame, void **this_cache)
2061 {
2062   struct i386_frame_cache *cache;
2063
2064   if (*this_cache)
2065     return (struct i386_frame_cache *) *this_cache;
2066
2067   cache = i386_alloc_frame_cache ();
2068   *this_cache = cache;
2069
2070   TRY
2071     {
2072       i386_frame_cache_1 (this_frame, cache);
2073     }
2074   CATCH (ex, RETURN_MASK_ERROR)
2075     {
2076       if (ex.error != NOT_AVAILABLE_ERROR)
2077         throw_exception (ex);
2078     }
2079   END_CATCH
2080
2081   return cache;
2082 }
2083
2084 static void
2085 i386_frame_this_id (struct frame_info *this_frame, void **this_cache,
2086                     struct frame_id *this_id)
2087 {
2088   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
2089
2090   if (!cache->base_p)
2091     (*this_id) = frame_id_build_unavailable_stack (cache->pc);
2092   else if (cache->base == 0)
2093     {
2094       /* This marks the outermost frame.  */
2095     }
2096   else
2097     {
2098       /* See the end of i386_push_dummy_call.  */
2099       (*this_id) = frame_id_build (cache->base + 8, cache->pc);
2100     }
2101 }
2102
2103 static enum unwind_stop_reason
2104 i386_frame_unwind_stop_reason (struct frame_info *this_frame,
2105                                void **this_cache)
2106 {
2107   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
2108
2109   if (!cache->base_p)
2110     return UNWIND_UNAVAILABLE;
2111
2112   /* This marks the outermost frame.  */
2113   if (cache->base == 0)
2114     return UNWIND_OUTERMOST;
2115
2116   return UNWIND_NO_REASON;
2117 }
2118
2119 static struct value *
2120 i386_frame_prev_register (struct frame_info *this_frame, void **this_cache,
2121                           int regnum)
2122 {
2123   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
2124
2125   gdb_assert (regnum >= 0);
2126
2127   /* The System V ABI says that:
2128
2129      "The flags register contains the system flags, such as the
2130      direction flag and the carry flag.  The direction flag must be
2131      set to the forward (that is, zero) direction before entry and
2132      upon exit from a function.  Other user flags have no specified
2133      role in the standard calling sequence and are not preserved."
2134
2135      To guarantee the "upon exit" part of that statement we fake a
2136      saved flags register that has its direction flag cleared.
2137
2138      Note that GCC doesn't seem to rely on the fact that the direction
2139      flag is cleared after a function return; it always explicitly
2140      clears the flag before operations where it matters.
2141
2142      FIXME: kettenis/20030316: I'm not quite sure whether this is the
2143      right thing to do.  The way we fake the flags register here makes
2144      it impossible to change it.  */
2145
2146   if (regnum == I386_EFLAGS_REGNUM)
2147     {
2148       ULONGEST val;
2149
2150       val = get_frame_register_unsigned (this_frame, regnum);
2151       val &= ~(1 << 10);
2152       return frame_unwind_got_constant (this_frame, regnum, val);
2153     }
2154
2155   if (regnum == I386_EIP_REGNUM && cache->pc_in_eax)
2156     return frame_unwind_got_register (this_frame, regnum, I386_EAX_REGNUM);
2157
2158   if (regnum == I386_ESP_REGNUM
2159       && (cache->saved_sp != 0 || cache->saved_sp_reg != -1))
2160     {
2161       /* If the SP has been saved, but we don't know where, then this
2162          means that SAVED_SP_REG register was found unavailable back
2163          when we built the cache.  */
2164       if (cache->saved_sp == 0)
2165         return frame_unwind_got_register (this_frame, regnum,
2166                                           cache->saved_sp_reg);
2167       else
2168         return frame_unwind_got_constant (this_frame, regnum,
2169                                           cache->saved_sp);
2170     }
2171
2172   if (regnum < I386_NUM_SAVED_REGS && cache->saved_regs[regnum] != -1)
2173     return frame_unwind_got_memory (this_frame, regnum,
2174                                     cache->saved_regs[regnum]);
2175
2176   return frame_unwind_got_register (this_frame, regnum, regnum);
2177 }
2178
2179 static const struct frame_unwind i386_frame_unwind =
2180 {
2181   NORMAL_FRAME,
2182   i386_frame_unwind_stop_reason,
2183   i386_frame_this_id,
2184   i386_frame_prev_register,
2185   NULL,
2186   default_frame_sniffer
2187 };
2188
2189 /* Normal frames, but in a function epilogue.  */
2190
2191 /* Implement the stack_frame_destroyed_p gdbarch method.
2192
2193    The epilogue is defined here as the 'ret' instruction, which will
2194    follow any instruction such as 'leave' or 'pop %ebp' that destroys
2195    the function's stack frame.  */
2196
2197 static int
2198 i386_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2199 {
2200   gdb_byte insn;
2201   struct compunit_symtab *cust;
2202
2203   cust = find_pc_compunit_symtab (pc);
2204   if (cust != NULL && COMPUNIT_EPILOGUE_UNWIND_VALID (cust))
2205     return 0;
2206
2207   if (target_read_memory (pc, &insn, 1))
2208     return 0;   /* Can't read memory at pc.  */
2209
2210   if (insn != 0xc3)     /* 'ret' instruction.  */
2211     return 0;
2212
2213   return 1;
2214 }
2215
2216 static int
2217 i386_epilogue_frame_sniffer (const struct frame_unwind *self,
2218                              struct frame_info *this_frame,
2219                              void **this_prologue_cache)
2220 {
2221   if (frame_relative_level (this_frame) == 0)
2222     return i386_stack_frame_destroyed_p (get_frame_arch (this_frame),
2223                                          get_frame_pc (this_frame));
2224   else
2225     return 0;
2226 }
2227
2228 static struct i386_frame_cache *
2229 i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
2230 {
2231   struct i386_frame_cache *cache;
2232   CORE_ADDR sp;
2233
2234   if (*this_cache)
2235     return (struct i386_frame_cache *) *this_cache;
2236
2237   cache = i386_alloc_frame_cache ();
2238   *this_cache = cache;
2239
2240   TRY
2241     {
2242       cache->pc = get_frame_func (this_frame);
2243
2244       /* At this point the stack looks as if we just entered the
2245          function, with the return address at the top of the
2246          stack.  */
2247       sp = get_frame_register_unsigned (this_frame, I386_ESP_REGNUM);
2248       cache->base = sp + cache->sp_offset;
2249       cache->saved_sp = cache->base + 8;
2250       cache->saved_regs[I386_EIP_REGNUM] = cache->base + 4;
2251
2252       cache->base_p = 1;
2253     }
2254   CATCH (ex, RETURN_MASK_ERROR)
2255     {
2256       if (ex.error != NOT_AVAILABLE_ERROR)
2257         throw_exception (ex);
2258     }
2259   END_CATCH
2260
2261   return cache;
2262 }
2263
2264 static enum unwind_stop_reason
2265 i386_epilogue_frame_unwind_stop_reason (struct frame_info *this_frame,
2266                                         void **this_cache)
2267 {
2268   struct i386_frame_cache *cache =
2269     i386_epilogue_frame_cache (this_frame, this_cache);
2270
2271   if (!cache->base_p)
2272     return UNWIND_UNAVAILABLE;
2273
2274   return UNWIND_NO_REASON;
2275 }
2276
2277 static void
2278 i386_epilogue_frame_this_id (struct frame_info *this_frame,
2279                              void **this_cache,
2280                              struct frame_id *this_id)
2281 {
2282   struct i386_frame_cache *cache =
2283     i386_epilogue_frame_cache (this_frame, this_cache);
2284
2285   if (!cache->base_p)
2286     (*this_id) = frame_id_build_unavailable_stack (cache->pc);
2287   else
2288     (*this_id) = frame_id_build (cache->base + 8, cache->pc);
2289 }
2290
2291 static struct value *
2292 i386_epilogue_frame_prev_register (struct frame_info *this_frame,
2293                                    void **this_cache, int regnum)
2294 {
2295   /* Make sure we've initialized the cache.  */
2296   i386_epilogue_frame_cache (this_frame, this_cache);
2297
2298   return i386_frame_prev_register (this_frame, this_cache, regnum);
2299 }
2300
2301 static const struct frame_unwind i386_epilogue_frame_unwind =
2302 {
2303   NORMAL_FRAME,
2304   i386_epilogue_frame_unwind_stop_reason,
2305   i386_epilogue_frame_this_id,
2306   i386_epilogue_frame_prev_register,
2307   NULL,
2308   i386_epilogue_frame_sniffer
2309 };
2310 \f
2311
2312 /* Stack-based trampolines.  */
2313
2314 /* These trampolines are used on cross x86 targets, when taking the
2315    address of a nested function.  When executing these trampolines,
2316    no stack frame is set up, so we are in a similar situation as in
2317    epilogues and i386_epilogue_frame_this_id can be re-used.  */
2318
2319 /* Static chain passed in register.  */
2320
2321 struct i386_insn i386_tramp_chain_in_reg_insns[] =
2322 {
2323   /* `movl imm32, %eax' and `movl imm32, %ecx' */
2324   { 5, { 0xb8 }, { 0xfe } },
2325
2326   /* `jmp imm32' */
2327   { 5, { 0xe9 }, { 0xff } },
2328
2329   {0}
2330 };
2331
2332 /* Static chain passed on stack (when regparm=3).  */
2333
2334 struct i386_insn i386_tramp_chain_on_stack_insns[] =
2335 {
2336   /* `push imm32' */
2337   { 5, { 0x68 }, { 0xff } },
2338
2339   /* `jmp imm32' */
2340   { 5, { 0xe9 }, { 0xff } },
2341
2342   {0}
2343 };
2344
2345 /* Return whether PC points inside a stack trampoline.   */
2346
2347 static int
2348 i386_in_stack_tramp_p (CORE_ADDR pc)
2349 {
2350   gdb_byte insn;
2351   const char *name;
2352
2353   /* A stack trampoline is detected if no name is associated
2354     to the current pc and if it points inside a trampoline
2355     sequence.  */
2356
2357   find_pc_partial_function (pc, &name, NULL, NULL);
2358   if (name)
2359     return 0;
2360
2361   if (target_read_memory (pc, &insn, 1))
2362     return 0;
2363
2364   if (!i386_match_insn_block (pc, i386_tramp_chain_in_reg_insns)
2365       && !i386_match_insn_block (pc, i386_tramp_chain_on_stack_insns))
2366     return 0;
2367
2368   return 1;
2369 }
2370
2371 static int
2372 i386_stack_tramp_frame_sniffer (const struct frame_unwind *self,
2373                                 struct frame_info *this_frame,
2374                                 void **this_cache)
2375 {
2376   if (frame_relative_level (this_frame) == 0)
2377     return i386_in_stack_tramp_p (get_frame_pc (this_frame));
2378   else
2379     return 0;
2380 }
2381
2382 static const struct frame_unwind i386_stack_tramp_frame_unwind =
2383 {
2384   NORMAL_FRAME,
2385   i386_epilogue_frame_unwind_stop_reason,
2386   i386_epilogue_frame_this_id,
2387   i386_epilogue_frame_prev_register,
2388   NULL,
2389   i386_stack_tramp_frame_sniffer
2390 };
2391 \f
2392 /* Generate a bytecode expression to get the value of the saved PC.  */
2393
2394 static void
2395 i386_gen_return_address (struct gdbarch *gdbarch,
2396                          struct agent_expr *ax, struct axs_value *value,
2397                          CORE_ADDR scope)
2398 {
2399   /* The following sequence assumes the traditional use of the base
2400      register.  */
2401   ax_reg (ax, I386_EBP_REGNUM);
2402   ax_const_l (ax, 4);
2403   ax_simple (ax, aop_add);
2404   value->type = register_type (gdbarch, I386_EIP_REGNUM);
2405   value->kind = axs_lvalue_memory;
2406 }
2407 \f
2408
2409 /* Signal trampolines.  */
2410
2411 static struct i386_frame_cache *
2412 i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
2413 {
2414   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2415   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2416   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2417   struct i386_frame_cache *cache;
2418   CORE_ADDR addr;
2419   gdb_byte buf[4];
2420
2421   if (*this_cache)
2422     return (struct i386_frame_cache *) *this_cache;
2423
2424   cache = i386_alloc_frame_cache ();
2425
2426   TRY
2427     {
2428       get_frame_register (this_frame, I386_ESP_REGNUM, buf);
2429       cache->base = extract_unsigned_integer (buf, 4, byte_order) - 4;
2430
2431       addr = tdep->sigcontext_addr (this_frame);
2432       if (tdep->sc_reg_offset)
2433         {
2434           int i;
2435
2436           gdb_assert (tdep->sc_num_regs <= I386_NUM_SAVED_REGS);
2437
2438           for (i = 0; i < tdep->sc_num_regs; i++)
2439             if (tdep->sc_reg_offset[i] != -1)
2440               cache->saved_regs[i] = addr + tdep->sc_reg_offset[i];
2441         }
2442       else
2443         {
2444           cache->saved_regs[I386_EIP_REGNUM] = addr + tdep->sc_pc_offset;
2445           cache->saved_regs[I386_ESP_REGNUM] = addr + tdep->sc_sp_offset;
2446         }
2447
2448       cache->base_p = 1;
2449     }
2450   CATCH (ex, RETURN_MASK_ERROR)
2451     {
2452       if (ex.error != NOT_AVAILABLE_ERROR)
2453         throw_exception (ex);
2454     }
2455   END_CATCH
2456
2457   *this_cache = cache;
2458   return cache;
2459 }
2460
2461 static enum unwind_stop_reason
2462 i386_sigtramp_frame_unwind_stop_reason (struct frame_info *this_frame,
2463                                         void **this_cache)
2464 {
2465   struct i386_frame_cache *cache =
2466     i386_sigtramp_frame_cache (this_frame, this_cache);
2467
2468   if (!cache->base_p)
2469     return UNWIND_UNAVAILABLE;
2470
2471   return UNWIND_NO_REASON;
2472 }
2473
2474 static void
2475 i386_sigtramp_frame_this_id (struct frame_info *this_frame, void **this_cache,
2476                              struct frame_id *this_id)
2477 {
2478   struct i386_frame_cache *cache =
2479     i386_sigtramp_frame_cache (this_frame, this_cache);
2480
2481   if (!cache->base_p)
2482     (*this_id) = frame_id_build_unavailable_stack (get_frame_pc (this_frame));
2483   else
2484     {
2485       /* See the end of i386_push_dummy_call.  */
2486       (*this_id) = frame_id_build (cache->base + 8, get_frame_pc (this_frame));
2487     }
2488 }
2489
2490 static struct value *
2491 i386_sigtramp_frame_prev_register (struct frame_info *this_frame,
2492                                    void **this_cache, int regnum)
2493 {
2494   /* Make sure we've initialized the cache.  */
2495   i386_sigtramp_frame_cache (this_frame, this_cache);
2496
2497   return i386_frame_prev_register (this_frame, this_cache, regnum);
2498 }
2499
2500 static int
2501 i386_sigtramp_frame_sniffer (const struct frame_unwind *self,
2502                              struct frame_info *this_frame,
2503                              void **this_prologue_cache)
2504 {
2505   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
2506
2507   /* We shouldn't even bother if we don't have a sigcontext_addr
2508      handler.  */
2509   if (tdep->sigcontext_addr == NULL)
2510     return 0;
2511
2512   if (tdep->sigtramp_p != NULL)
2513     {
2514       if (tdep->sigtramp_p (this_frame))
2515         return 1;
2516     }
2517
2518   if (tdep->sigtramp_start != 0)
2519     {
2520       CORE_ADDR pc = get_frame_pc (this_frame);
2521
2522       gdb_assert (tdep->sigtramp_end != 0);
2523       if (pc >= tdep->sigtramp_start && pc < tdep->sigtramp_end)
2524         return 1;
2525     }
2526
2527   return 0;
2528 }
2529
2530 static const struct frame_unwind i386_sigtramp_frame_unwind =
2531 {
2532   SIGTRAMP_FRAME,
2533   i386_sigtramp_frame_unwind_stop_reason,
2534   i386_sigtramp_frame_this_id,
2535   i386_sigtramp_frame_prev_register,
2536   NULL,
2537   i386_sigtramp_frame_sniffer
2538 };
2539 \f
2540
2541 static CORE_ADDR
2542 i386_frame_base_address (struct frame_info *this_frame, void **this_cache)
2543 {
2544   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
2545
2546   return cache->base;
2547 }
2548
2549 static const struct frame_base i386_frame_base =
2550 {
2551   &i386_frame_unwind,
2552   i386_frame_base_address,
2553   i386_frame_base_address,
2554   i386_frame_base_address
2555 };
2556
2557 static struct frame_id
2558 i386_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2559 {
2560   CORE_ADDR fp;
2561
2562   fp = get_frame_register_unsigned (this_frame, I386_EBP_REGNUM);
2563
2564   /* See the end of i386_push_dummy_call.  */
2565   return frame_id_build (fp + 8, get_frame_pc (this_frame));
2566 }
2567
2568 /* _Decimal128 function return values need 16-byte alignment on the
2569    stack.  */
2570
2571 static CORE_ADDR
2572 i386_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2573 {
2574   return sp & -(CORE_ADDR)16;
2575 }
2576 \f
2577
2578 /* Figure out where the longjmp will land.  Slurp the args out of the
2579    stack.  We expect the first arg to be a pointer to the jmp_buf
2580    structure from which we extract the address that we will land at.
2581    This address is copied into PC.  This routine returns non-zero on
2582    success.  */
2583
2584 static int
2585 i386_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
2586 {
2587   gdb_byte buf[4];
2588   CORE_ADDR sp, jb_addr;
2589   struct gdbarch *gdbarch = get_frame_arch (frame);
2590   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2591   int jb_pc_offset = gdbarch_tdep (gdbarch)->jb_pc_offset;
2592
2593   /* If JB_PC_OFFSET is -1, we have no way to find out where the
2594      longjmp will land.  */
2595   if (jb_pc_offset == -1)
2596     return 0;
2597
2598   get_frame_register (frame, I386_ESP_REGNUM, buf);
2599   sp = extract_unsigned_integer (buf, 4, byte_order);
2600   if (target_read_memory (sp + 4, buf, 4))
2601     return 0;
2602
2603   jb_addr = extract_unsigned_integer (buf, 4, byte_order);
2604   if (target_read_memory (jb_addr + jb_pc_offset, buf, 4))
2605     return 0;
2606
2607   *pc = extract_unsigned_integer (buf, 4, byte_order);
2608   return 1;
2609 }
2610 \f
2611
2612 /* Check whether TYPE must be 16-byte-aligned when passed as a
2613    function argument.  16-byte vectors, _Decimal128 and structures or
2614    unions containing such types must be 16-byte-aligned; other
2615    arguments are 4-byte-aligned.  */
2616
2617 static int
2618 i386_16_byte_align_p (struct type *type)
2619 {
2620   type = check_typedef (type);
2621   if ((TYPE_CODE (type) == TYPE_CODE_DECFLOAT
2622        || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)))
2623       && TYPE_LENGTH (type) == 16)
2624     return 1;
2625   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
2626     return i386_16_byte_align_p (TYPE_TARGET_TYPE (type));
2627   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2628       || TYPE_CODE (type) == TYPE_CODE_UNION)
2629     {
2630       int i;
2631       for (i = 0; i < TYPE_NFIELDS (type); i++)
2632         {
2633           if (i386_16_byte_align_p (TYPE_FIELD_TYPE (type, i)))
2634             return 1;
2635         }
2636     }
2637   return 0;
2638 }
2639
2640 /* Implementation for set_gdbarch_push_dummy_code.  */
2641
2642 static CORE_ADDR
2643 i386_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr,
2644                       struct value **args, int nargs, struct type *value_type,
2645                       CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
2646                       struct regcache *regcache)
2647 {
2648   /* Use 0xcc breakpoint - 1 byte.  */
2649   *bp_addr = sp - 1;
2650   *real_pc = funaddr;
2651
2652   /* Keep the stack aligned.  */
2653   return sp - 16;
2654 }
2655
2656 static CORE_ADDR
2657 i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2658                       struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
2659                       struct value **args, CORE_ADDR sp, int struct_return,
2660                       CORE_ADDR struct_addr)
2661 {
2662   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2663   gdb_byte buf[4];
2664   int i;
2665   int write_pass;
2666   int args_space = 0;
2667
2668   /* Determine the total space required for arguments and struct
2669      return address in a first pass (allowing for 16-byte-aligned
2670      arguments), then push arguments in a second pass.  */
2671
2672   for (write_pass = 0; write_pass < 2; write_pass++)
2673     {
2674       int args_space_used = 0;
2675
2676       if (struct_return)
2677         {
2678           if (write_pass)
2679             {
2680               /* Push value address.  */
2681               store_unsigned_integer (buf, 4, byte_order, struct_addr);
2682               write_memory (sp, buf, 4);
2683               args_space_used += 4;
2684             }
2685           else
2686             args_space += 4;
2687         }
2688
2689       for (i = 0; i < nargs; i++)
2690         {
2691           int len = TYPE_LENGTH (value_enclosing_type (args[i]));
2692
2693           if (write_pass)
2694             {
2695               if (i386_16_byte_align_p (value_enclosing_type (args[i])))
2696                 args_space_used = align_up (args_space_used, 16);
2697
2698               write_memory (sp + args_space_used,
2699                             value_contents_all (args[i]), len);
2700               /* The System V ABI says that:
2701
2702               "An argument's size is increased, if necessary, to make it a
2703               multiple of [32-bit] words.  This may require tail padding,
2704               depending on the size of the argument."
2705
2706               This makes sure the stack stays word-aligned.  */
2707               args_space_used += align_up (len, 4);
2708             }
2709           else
2710             {
2711               if (i386_16_byte_align_p (value_enclosing_type (args[i])))
2712                 args_space = align_up (args_space, 16);
2713               args_space += align_up (len, 4);
2714             }
2715         }
2716
2717       if (!write_pass)
2718         {
2719           sp -= args_space;
2720
2721           /* The original System V ABI only requires word alignment,
2722              but modern incarnations need 16-byte alignment in order
2723              to support SSE.  Since wasting a few bytes here isn't
2724              harmful we unconditionally enforce 16-byte alignment.  */
2725           sp &= ~0xf;
2726         }
2727     }
2728
2729   /* Store return address.  */
2730   sp -= 4;
2731   store_unsigned_integer (buf, 4, byte_order, bp_addr);
2732   write_memory (sp, buf, 4);
2733
2734   /* Finally, update the stack pointer...  */
2735   store_unsigned_integer (buf, 4, byte_order, sp);
2736   regcache_cooked_write (regcache, I386_ESP_REGNUM, buf);
2737
2738   /* ...and fake a frame pointer.  */
2739   regcache_cooked_write (regcache, I386_EBP_REGNUM, buf);
2740
2741   /* MarkK wrote: This "+ 8" is all over the place:
2742      (i386_frame_this_id, i386_sigtramp_frame_this_id,
2743      i386_dummy_id).  It's there, since all frame unwinders for
2744      a given target have to agree (within a certain margin) on the
2745      definition of the stack address of a frame.  Otherwise frame id
2746      comparison might not work correctly.  Since DWARF2/GCC uses the
2747      stack address *before* the function call as a frame's CFA.  On
2748      the i386, when %ebp is used as a frame pointer, the offset
2749      between the contents %ebp and the CFA as defined by GCC.  */
2750   return sp + 8;
2751 }
2752
2753 /* These registers are used for returning integers (and on some
2754    targets also for returning `struct' and `union' values when their
2755    size and alignment match an integer type).  */
2756 #define LOW_RETURN_REGNUM       I386_EAX_REGNUM /* %eax */
2757 #define HIGH_RETURN_REGNUM      I386_EDX_REGNUM /* %edx */
2758
2759 /* Read, for architecture GDBARCH, a function return value of TYPE
2760    from REGCACHE, and copy that into VALBUF.  */
2761
2762 static void
2763 i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
2764                            struct regcache *regcache, gdb_byte *valbuf)
2765 {
2766   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2767   int len = TYPE_LENGTH (type);
2768   gdb_byte buf[I386_MAX_REGISTER_SIZE];
2769
2770   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2771     {
2772       if (tdep->st0_regnum < 0)
2773         {
2774           warning (_("Cannot find floating-point return value."));
2775           memset (valbuf, 0, len);
2776           return;
2777         }
2778
2779       /* Floating-point return values can be found in %st(0).  Convert
2780          its contents to the desired type.  This is probably not
2781          exactly how it would happen on the target itself, but it is
2782          the best we can do.  */
2783       regcache_raw_read (regcache, I386_ST0_REGNUM, buf);
2784       convert_typed_floating (buf, i387_ext_type (gdbarch), valbuf, type);
2785     }
2786   else
2787     {
2788       int low_size = register_size (gdbarch, LOW_RETURN_REGNUM);
2789       int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM);
2790
2791       if (len <= low_size)
2792         {
2793           regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
2794           memcpy (valbuf, buf, len);
2795         }
2796       else if (len <= (low_size + high_size))
2797         {
2798           regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
2799           memcpy (valbuf, buf, low_size);
2800           regcache_raw_read (regcache, HIGH_RETURN_REGNUM, buf);
2801           memcpy (valbuf + low_size, buf, len - low_size);
2802         }
2803       else
2804         internal_error (__FILE__, __LINE__,
2805                         _("Cannot extract return value of %d bytes long."),
2806                         len);
2807     }
2808 }
2809
2810 /* Write, for architecture GDBARCH, a function return value of TYPE
2811    from VALBUF into REGCACHE.  */
2812
2813 static void
2814 i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
2815                          struct regcache *regcache, const gdb_byte *valbuf)
2816 {
2817   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2818   int len = TYPE_LENGTH (type);
2819
2820   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2821     {
2822       ULONGEST fstat;
2823       gdb_byte buf[I386_MAX_REGISTER_SIZE];
2824
2825       if (tdep->st0_regnum < 0)
2826         {
2827           warning (_("Cannot set floating-point return value."));
2828           return;
2829         }
2830
2831       /* Returning floating-point values is a bit tricky.  Apart from
2832          storing the return value in %st(0), we have to simulate the
2833          state of the FPU at function return point.  */
2834
2835       /* Convert the value found in VALBUF to the extended
2836          floating-point format used by the FPU.  This is probably
2837          not exactly how it would happen on the target itself, but
2838          it is the best we can do.  */
2839       convert_typed_floating (valbuf, type, buf, i387_ext_type (gdbarch));
2840       regcache_raw_write (regcache, I386_ST0_REGNUM, buf);
2841
2842       /* Set the top of the floating-point register stack to 7.  The
2843          actual value doesn't really matter, but 7 is what a normal
2844          function return would end up with if the program started out
2845          with a freshly initialized FPU.  */
2846       regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
2847       fstat |= (7 << 11);
2848       regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM (tdep), fstat);
2849
2850       /* Mark %st(1) through %st(7) as empty.  Since we set the top of
2851          the floating-point register stack to 7, the appropriate value
2852          for the tag word is 0x3fff.  */
2853       regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM (tdep), 0x3fff);
2854     }
2855   else
2856     {
2857       int low_size = register_size (gdbarch, LOW_RETURN_REGNUM);
2858       int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM);
2859
2860       if (len <= low_size)
2861         regcache_raw_write_part (regcache, LOW_RETURN_REGNUM, 0, len, valbuf);
2862       else if (len <= (low_size + high_size))
2863         {
2864           regcache_raw_write (regcache, LOW_RETURN_REGNUM, valbuf);
2865           regcache_raw_write_part (regcache, HIGH_RETURN_REGNUM, 0,
2866                                    len - low_size, valbuf + low_size);
2867         }
2868       else
2869         internal_error (__FILE__, __LINE__,
2870                         _("Cannot store return value of %d bytes long."), len);
2871     }
2872 }
2873 \f
2874
2875 /* This is the variable that is set with "set struct-convention", and
2876    its legitimate values.  */
2877 static const char default_struct_convention[] = "default";
2878 static const char pcc_struct_convention[] = "pcc";
2879 static const char reg_struct_convention[] = "reg";
2880 static const char *const valid_conventions[] =
2881 {
2882   default_struct_convention,
2883   pcc_struct_convention,
2884   reg_struct_convention,
2885   NULL
2886 };
2887 static const char *struct_convention = default_struct_convention;
2888
2889 /* Return non-zero if TYPE, which is assumed to be a structure,
2890    a union type, or an array type, should be returned in registers
2891    for architecture GDBARCH.  */
2892
2893 static int
2894 i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
2895 {
2896   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2897   enum type_code code = TYPE_CODE (type);
2898   int len = TYPE_LENGTH (type);
2899
2900   gdb_assert (code == TYPE_CODE_STRUCT
2901               || code == TYPE_CODE_UNION
2902               || code == TYPE_CODE_ARRAY);
2903
2904   if (struct_convention == pcc_struct_convention
2905       || (struct_convention == default_struct_convention
2906           && tdep->struct_return == pcc_struct_return))
2907     return 0;
2908
2909   /* Structures consisting of a single `float', `double' or 'long
2910      double' member are returned in %st(0).  */
2911   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2912     {
2913       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
2914       if (TYPE_CODE (type) == TYPE_CODE_FLT)
2915         return (len == 4 || len == 8 || len == 12);
2916     }
2917
2918   return (len == 1 || len == 2 || len == 4 || len == 8);
2919 }
2920
2921 /* Determine, for architecture GDBARCH, how a return value of TYPE
2922    should be returned.  If it is supposed to be returned in registers,
2923    and READBUF is non-zero, read the appropriate value from REGCACHE,
2924    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
2925    from WRITEBUF into REGCACHE.  */
2926
2927 static enum return_value_convention
2928 i386_return_value (struct gdbarch *gdbarch, struct value *function,
2929                    struct type *type, struct regcache *regcache,
2930                    gdb_byte *readbuf, const gdb_byte *writebuf)
2931 {
2932   enum type_code code = TYPE_CODE (type);
2933
2934   if (((code == TYPE_CODE_STRUCT
2935         || code == TYPE_CODE_UNION
2936         || code == TYPE_CODE_ARRAY)
2937        && !i386_reg_struct_return_p (gdbarch, type))
2938       /* Complex double and long double uses the struct return covention.  */
2939       || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 16)
2940       || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 24)
2941       /* 128-bit decimal float uses the struct return convention.  */
2942       || (code == TYPE_CODE_DECFLOAT && TYPE_LENGTH (type) == 16))
2943     {
2944       /* The System V ABI says that:
2945
2946          "A function that returns a structure or union also sets %eax
2947          to the value of the original address of the caller's area
2948          before it returns.  Thus when the caller receives control
2949          again, the address of the returned object resides in register
2950          %eax and can be used to access the object."
2951
2952          So the ABI guarantees that we can always find the return
2953          value just after the function has returned.  */
2954
2955       /* Note that the ABI doesn't mention functions returning arrays,
2956          which is something possible in certain languages such as Ada.
2957          In this case, the value is returned as if it was wrapped in
2958          a record, so the convention applied to records also applies
2959          to arrays.  */
2960
2961       if (readbuf)
2962         {
2963           ULONGEST addr;
2964
2965           regcache_raw_read_unsigned (regcache, I386_EAX_REGNUM, &addr);
2966           read_memory (addr, readbuf, TYPE_LENGTH (type));
2967         }
2968
2969       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
2970     }
2971
2972   /* This special case is for structures consisting of a single
2973      `float', `double' or 'long double' member.  These structures are
2974      returned in %st(0).  For these structures, we call ourselves
2975      recursively, changing TYPE into the type of the first member of
2976      the structure.  Since that should work for all structures that
2977      have only one member, we don't bother to check the member's type
2978      here.  */
2979   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2980     {
2981       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
2982       return i386_return_value (gdbarch, function, type, regcache,
2983                                 readbuf, writebuf);
2984     }
2985
2986   if (readbuf)
2987     i386_extract_return_value (gdbarch, type, regcache, readbuf);
2988   if (writebuf)
2989     i386_store_return_value (gdbarch, type, regcache, writebuf);
2990
2991   return RETURN_VALUE_REGISTER_CONVENTION;
2992 }
2993 \f
2994
2995 struct type *
2996 i387_ext_type (struct gdbarch *gdbarch)
2997 {
2998   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2999
3000   if (!tdep->i387_ext_type)
3001     {
3002       tdep->i387_ext_type = tdesc_find_type (gdbarch, "i387_ext");
3003       gdb_assert (tdep->i387_ext_type != NULL);
3004     }
3005
3006   return tdep->i387_ext_type;
3007 }
3008
3009 /* Construct type for pseudo BND registers.  We can't use
3010    tdesc_find_type since a complement of one value has to be used
3011    to describe the upper bound.  */
3012
3013 static struct type *
3014 i386_bnd_type (struct gdbarch *gdbarch)
3015 {
3016   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3017
3018
3019   if (!tdep->i386_bnd_type)
3020     {
3021       struct type *t, *bound_t;
3022       const struct builtin_type *bt = builtin_type (gdbarch);
3023
3024       /* The type we're building is described bellow:  */
3025 #if 0
3026       struct __bound128
3027       {
3028         void *lbound;
3029         void *ubound;           /* One complement of raw ubound field.  */
3030       };
3031 #endif
3032
3033       t = arch_composite_type (gdbarch,
3034                                "__gdb_builtin_type_bound128", TYPE_CODE_STRUCT);
3035
3036       append_composite_type_field (t, "lbound", bt->builtin_data_ptr);
3037       append_composite_type_field (t, "ubound", bt->builtin_data_ptr);
3038
3039       TYPE_NAME (t) = "builtin_type_bound128";
3040       tdep->i386_bnd_type = t;
3041     }
3042
3043   return tdep->i386_bnd_type;
3044 }
3045
3046 /* Construct vector type for pseudo ZMM registers.  We can't use
3047    tdesc_find_type since ZMM isn't described in target description.  */
3048
3049 static struct type *
3050 i386_zmm_type (struct gdbarch *gdbarch)
3051 {
3052   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3053
3054   if (!tdep->i386_zmm_type)
3055     {
3056       const struct builtin_type *bt = builtin_type (gdbarch);
3057
3058       /* The type we're building is this:  */
3059 #if 0
3060       union __gdb_builtin_type_vec512i
3061       {
3062         int128_t uint128[4];
3063         int64_t v4_int64[8];
3064         int32_t v8_int32[16];
3065         int16_t v16_int16[32];
3066         int8_t v32_int8[64];
3067         double v4_double[8];
3068         float v8_float[16];
3069       };
3070 #endif
3071
3072       struct type *t;
3073
3074       t = arch_composite_type (gdbarch,
3075                                "__gdb_builtin_type_vec512i", TYPE_CODE_UNION);
3076       append_composite_type_field (t, "v16_float",
3077                                    init_vector_type (bt->builtin_float, 16));
3078       append_composite_type_field (t, "v8_double",
3079                                    init_vector_type (bt->builtin_double, 8));
3080       append_composite_type_field (t, "v64_int8",
3081                                    init_vector_type (bt->builtin_int8, 64));
3082       append_composite_type_field (t, "v32_int16",
3083                                    init_vector_type (bt->builtin_int16, 32));
3084       append_composite_type_field (t, "v16_int32",
3085                                    init_vector_type (bt->builtin_int32, 16));
3086       append_composite_type_field (t, "v8_int64",
3087                                    init_vector_type (bt->builtin_int64, 8));
3088       append_composite_type_field (t, "v4_int128",
3089                                    init_vector_type (bt->builtin_int128, 4));
3090
3091       TYPE_VECTOR (t) = 1;
3092       TYPE_NAME (t) = "builtin_type_vec512i";
3093       tdep->i386_zmm_type = t;
3094     }
3095
3096   return tdep->i386_zmm_type;
3097 }
3098
3099 /* Construct vector type for pseudo YMM registers.  We can't use
3100    tdesc_find_type since YMM isn't described in target description.  */
3101
3102 static struct type *
3103 i386_ymm_type (struct gdbarch *gdbarch)
3104 {
3105   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3106
3107   if (!tdep->i386_ymm_type)
3108     {
3109       const struct builtin_type *bt = builtin_type (gdbarch);
3110
3111       /* The type we're building is this: */
3112 #if 0
3113       union __gdb_builtin_type_vec256i
3114       {
3115         int128_t uint128[2];
3116         int64_t v2_int64[4];
3117         int32_t v4_int32[8];
3118         int16_t v8_int16[16];
3119         int8_t v16_int8[32];
3120         double v2_double[4];
3121         float v4_float[8];
3122       };
3123 #endif
3124
3125       struct type *t;
3126
3127       t = arch_composite_type (gdbarch,
3128                                "__gdb_builtin_type_vec256i", TYPE_CODE_UNION);
3129       append_composite_type_field (t, "v8_float",
3130                                    init_vector_type (bt->builtin_float, 8));
3131       append_composite_type_field (t, "v4_double",
3132                                    init_vector_type (bt->builtin_double, 4));
3133       append_composite_type_field (t, "v32_int8",
3134                                    init_vector_type (bt->builtin_int8, 32));
3135       append_composite_type_field (t, "v16_int16",
3136                                    init_vector_type (bt->builtin_int16, 16));
3137       append_composite_type_field (t, "v8_int32",
3138                                    init_vector_type (bt->builtin_int32, 8));
3139       append_composite_type_field (t, "v4_int64",
3140                                    init_vector_type (bt->builtin_int64, 4));
3141       append_composite_type_field (t, "v2_int128",
3142                                    init_vector_type (bt->builtin_int128, 2));
3143
3144       TYPE_VECTOR (t) = 1;
3145       TYPE_NAME (t) = "builtin_type_vec256i";
3146       tdep->i386_ymm_type = t;
3147     }
3148
3149   return tdep->i386_ymm_type;
3150 }
3151
3152 /* Construct vector type for MMX registers.  */
3153 static struct type *
3154 i386_mmx_type (struct gdbarch *gdbarch)
3155 {
3156   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3157
3158   if (!tdep->i386_mmx_type)
3159     {
3160       const struct builtin_type *bt = builtin_type (gdbarch);
3161
3162       /* The type we're building is this: */
3163 #if 0
3164       union __gdb_builtin_type_vec64i
3165       {
3166         int64_t uint64;
3167         int32_t v2_int32[2];
3168         int16_t v4_int16[4];
3169         int8_t v8_int8[8];
3170       };
3171 #endif
3172
3173       struct type *t;
3174
3175       t = arch_composite_type (gdbarch,
3176                                "__gdb_builtin_type_vec64i", TYPE_CODE_UNION);
3177
3178       append_composite_type_field (t, "uint64", bt->builtin_int64);
3179       append_composite_type_field (t, "v2_int32",
3180                                    init_vector_type (bt->builtin_int32, 2));
3181       append_composite_type_field (t, "v4_int16",
3182                                    init_vector_type (bt->builtin_int16, 4));
3183       append_composite_type_field (t, "v8_int8",
3184                                    init_vector_type (bt->builtin_int8, 8));
3185
3186       TYPE_VECTOR (t) = 1;
3187       TYPE_NAME (t) = "builtin_type_vec64i";
3188       tdep->i386_mmx_type = t;
3189     }
3190
3191   return tdep->i386_mmx_type;
3192 }
3193
3194 /* Return the GDB type object for the "standard" data type of data in
3195    register REGNUM.  */
3196
3197 struct type *
3198 i386_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
3199 {
3200   if (i386_bnd_regnum_p (gdbarch, regnum))
3201     return i386_bnd_type (gdbarch);
3202   if (i386_mmx_regnum_p (gdbarch, regnum))
3203     return i386_mmx_type (gdbarch);
3204   else if (i386_ymm_regnum_p (gdbarch, regnum))
3205     return i386_ymm_type (gdbarch);
3206   else if (i386_ymm_avx512_regnum_p (gdbarch, regnum))
3207     return i386_ymm_type (gdbarch);
3208   else if (i386_zmm_regnum_p (gdbarch, regnum))
3209     return i386_zmm_type (gdbarch);
3210   else
3211     {
3212       const struct builtin_type *bt = builtin_type (gdbarch);
3213       if (i386_byte_regnum_p (gdbarch, regnum))
3214         return bt->builtin_int8;
3215       else if (i386_word_regnum_p (gdbarch, regnum))
3216         return bt->builtin_int16;
3217       else if (i386_dword_regnum_p (gdbarch, regnum))
3218         return bt->builtin_int32;
3219       else if (i386_k_regnum_p (gdbarch, regnum))
3220         return bt->builtin_int64;
3221     }
3222
3223   internal_error (__FILE__, __LINE__, _("invalid regnum"));
3224 }
3225
3226 /* Map a cooked register onto a raw register or memory.  For the i386,
3227    the MMX registers need to be mapped onto floating point registers.  */
3228
3229 static int
3230 i386_mmx_regnum_to_fp_regnum (struct regcache *regcache, int regnum)
3231 {
3232   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
3233   int mmxreg, fpreg;
3234   ULONGEST fstat;
3235   int tos;
3236
3237   mmxreg = regnum - tdep->mm0_regnum;
3238   regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
3239   tos = (fstat >> 11) & 0x7;
3240   fpreg = (mmxreg + tos) % 8;
3241
3242   return (I387_ST0_REGNUM (tdep) + fpreg);
3243 }
3244
3245 /* A helper function for us by i386_pseudo_register_read_value and
3246    amd64_pseudo_register_read_value.  It does all the work but reads
3247    the data into an already-allocated value.  */
3248
3249 void
3250 i386_pseudo_register_read_into_value (struct gdbarch *gdbarch,
3251                                       struct regcache *regcache,
3252                                       int regnum,
3253                                       struct value *result_value)
3254 {
3255   gdb_byte raw_buf[MAX_REGISTER_SIZE];
3256   enum register_status status;
3257   gdb_byte *buf = value_contents_raw (result_value);
3258
3259   if (i386_mmx_regnum_p (gdbarch, regnum))
3260     {
3261       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
3262
3263       /* Extract (always little endian).  */
3264       status = regcache_raw_read (regcache, fpnum, raw_buf);
3265       if (status != REG_VALID)
3266         mark_value_bytes_unavailable (result_value, 0,
3267                                       TYPE_LENGTH (value_type (result_value)));
3268       else
3269         memcpy (buf, raw_buf, register_size (gdbarch, regnum));
3270     }
3271   else
3272     {
3273       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3274       if (i386_bnd_regnum_p (gdbarch, regnum))
3275         {
3276           regnum -= tdep->bnd0_regnum;
3277
3278           /* Extract (always little endian).  Read lower 128bits.  */
3279           status = regcache_raw_read (regcache,
3280                                       I387_BND0R_REGNUM (tdep) + regnum,
3281                                       raw_buf);
3282           if (status != REG_VALID)
3283             mark_value_bytes_unavailable (result_value, 0, 16);
3284           else
3285             {
3286               enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3287               LONGEST upper, lower;
3288               int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
3289
3290               lower = extract_unsigned_integer (raw_buf, 8, byte_order);
3291               upper = extract_unsigned_integer (raw_buf + 8, 8, byte_order);
3292               upper = ~upper;
3293
3294               memcpy (buf, &lower, size);
3295               memcpy (buf + size, &upper, size);
3296             }
3297         }
3298       else if (i386_k_regnum_p (gdbarch, regnum))
3299         {
3300           regnum -= tdep->k0_regnum;
3301
3302           /* Extract (always little endian).  */
3303           status = regcache_raw_read (regcache,
3304                                       tdep->k0_regnum + regnum,
3305                                       raw_buf);
3306           if (status != REG_VALID)
3307             mark_value_bytes_unavailable (result_value, 0, 8);
3308           else
3309             memcpy (buf, raw_buf, 8);
3310         }
3311       else if (i386_zmm_regnum_p (gdbarch, regnum))
3312         {
3313           regnum -= tdep->zmm0_regnum;
3314
3315           if (regnum < num_lower_zmm_regs)
3316             {
3317               /* Extract (always little endian).  Read lower 128bits.  */
3318               status = regcache_raw_read (regcache,
3319                                           I387_XMM0_REGNUM (tdep) + regnum,
3320                                           raw_buf);
3321               if (status != REG_VALID)
3322                 mark_value_bytes_unavailable (result_value, 0, 16);
3323               else
3324                 memcpy (buf, raw_buf, 16);
3325
3326               /* Extract (always little endian).  Read upper 128bits.  */
3327               status = regcache_raw_read (regcache,
3328                                           tdep->ymm0h_regnum + regnum,
3329                                           raw_buf);
3330               if (status != REG_VALID)
3331                 mark_value_bytes_unavailable (result_value, 16, 16);
3332               else
3333                 memcpy (buf + 16, raw_buf, 16);
3334             }
3335           else
3336             {
3337               /* Extract (always little endian).  Read lower 128bits.  */
3338               status = regcache_raw_read (regcache,
3339                                           I387_XMM16_REGNUM (tdep) + regnum
3340                                           - num_lower_zmm_regs,
3341                                           raw_buf);
3342               if (status != REG_VALID)
3343                 mark_value_bytes_unavailable (result_value, 0, 16);
3344               else
3345                 memcpy (buf, raw_buf, 16);
3346
3347               /* Extract (always little endian).  Read upper 128bits.  */
3348               status = regcache_raw_read (regcache,
3349                                           I387_YMM16H_REGNUM (tdep) + regnum
3350                                           - num_lower_zmm_regs,
3351                                           raw_buf);
3352               if (status != REG_VALID)
3353                 mark_value_bytes_unavailable (result_value, 16, 16);
3354               else
3355                 memcpy (buf + 16, raw_buf, 16);
3356             }
3357
3358           /* Read upper 256bits.  */
3359           status = regcache_raw_read (regcache,
3360                                       tdep->zmm0h_regnum + regnum,
3361                                       raw_buf);
3362           if (status != REG_VALID)
3363             mark_value_bytes_unavailable (result_value, 32, 32);
3364           else
3365             memcpy (buf + 32, raw_buf, 32);
3366         }
3367       else if (i386_ymm_regnum_p (gdbarch, regnum))
3368         {
3369           regnum -= tdep->ymm0_regnum;
3370
3371           /* Extract (always little endian).  Read lower 128bits.  */
3372           status = regcache_raw_read (regcache,
3373                                       I387_XMM0_REGNUM (tdep) + regnum,
3374                                       raw_buf);
3375           if (status != REG_VALID)
3376             mark_value_bytes_unavailable (result_value, 0, 16);
3377           else
3378             memcpy (buf, raw_buf, 16);
3379           /* Read upper 128bits.  */
3380           status = regcache_raw_read (regcache,
3381                                       tdep->ymm0h_regnum + regnum,
3382                                       raw_buf);
3383           if (status != REG_VALID)
3384             mark_value_bytes_unavailable (result_value, 16, 32);
3385           else
3386             memcpy (buf + 16, raw_buf, 16);
3387         }
3388       else if (i386_ymm_avx512_regnum_p (gdbarch, regnum))
3389         {
3390           regnum -= tdep->ymm16_regnum;
3391           /* Extract (always little endian).  Read lower 128bits.  */
3392           status = regcache_raw_read (regcache,
3393                                       I387_XMM16_REGNUM (tdep) + regnum,
3394                                       raw_buf);
3395           if (status != REG_VALID)
3396             mark_value_bytes_unavailable (result_value, 0, 16);
3397           else
3398             memcpy (buf, raw_buf, 16);
3399           /* Read upper 128bits.  */
3400           status = regcache_raw_read (regcache,
3401                                       tdep->ymm16h_regnum + regnum,
3402                                       raw_buf);
3403           if (status != REG_VALID)
3404             mark_value_bytes_unavailable (result_value, 16, 16);
3405           else
3406             memcpy (buf + 16, raw_buf, 16);
3407         }
3408       else if (i386_word_regnum_p (gdbarch, regnum))
3409         {
3410           int gpnum = regnum - tdep->ax_regnum;
3411
3412           /* Extract (always little endian).  */
3413           status = regcache_raw_read (regcache, gpnum, raw_buf);
3414           if (status != REG_VALID)
3415             mark_value_bytes_unavailable (result_value, 0,
3416                                           TYPE_LENGTH (value_type (result_value)));
3417           else
3418             memcpy (buf, raw_buf, 2);
3419         }
3420       else if (i386_byte_regnum_p (gdbarch, regnum))
3421         {
3422           /* Check byte pseudo registers last since this function will
3423              be called from amd64_pseudo_register_read, which handles
3424              byte pseudo registers differently.  */
3425           int gpnum = regnum - tdep->al_regnum;
3426
3427           /* Extract (always little endian).  We read both lower and
3428              upper registers.  */
3429           status = regcache_raw_read (regcache, gpnum % 4, raw_buf);
3430           if (status != REG_VALID)
3431             mark_value_bytes_unavailable (result_value, 0,
3432                                           TYPE_LENGTH (value_type (result_value)));
3433           else if (gpnum >= 4)
3434             memcpy (buf, raw_buf + 1, 1);
3435           else
3436             memcpy (buf, raw_buf, 1);
3437         }
3438       else
3439         internal_error (__FILE__, __LINE__, _("invalid regnum"));
3440     }
3441 }
3442
3443 static struct value *
3444 i386_pseudo_register_read_value (struct gdbarch *gdbarch,
3445                                  struct regcache *regcache,
3446                                  int regnum)
3447 {
3448   struct value *result;
3449
3450   result = allocate_value (register_type (gdbarch, regnum));
3451   VALUE_LVAL (result) = lval_register;
3452   VALUE_REGNUM (result) = regnum;
3453
3454   i386_pseudo_register_read_into_value (gdbarch, regcache, regnum, result);
3455
3456   return result;
3457 }
3458
3459 void
3460 i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
3461                             int regnum, const gdb_byte *buf)
3462 {
3463   gdb_byte raw_buf[MAX_REGISTER_SIZE];
3464
3465   if (i386_mmx_regnum_p (gdbarch, regnum))
3466     {
3467       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
3468
3469       /* Read ...  */
3470       regcache_raw_read (regcache, fpnum, raw_buf);
3471       /* ... Modify ... (always little endian).  */
3472       memcpy (raw_buf, buf, register_size (gdbarch, regnum));
3473       /* ... Write.  */
3474       regcache_raw_write (regcache, fpnum, raw_buf);
3475     }
3476   else
3477     {
3478       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3479
3480       if (i386_bnd_regnum_p (gdbarch, regnum))
3481         {
3482           ULONGEST upper, lower;
3483           int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
3484           enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3485
3486           /* New values from input value.  */
3487           regnum -= tdep->bnd0_regnum;
3488           lower = extract_unsigned_integer (buf, size, byte_order);
3489           upper = extract_unsigned_integer (buf + size, size, byte_order);
3490
3491           /* Fetching register buffer.  */
3492           regcache_raw_read (regcache,
3493                              I387_BND0R_REGNUM (tdep) + regnum,
3494                              raw_buf);
3495
3496           upper = ~upper;
3497
3498           /* Set register bits.  */
3499           memcpy (raw_buf, &lower, 8);
3500           memcpy (raw_buf + 8, &upper, 8);
3501
3502
3503           regcache_raw_write (regcache,
3504                               I387_BND0R_REGNUM (tdep) + regnum,
3505                               raw_buf);
3506         }
3507       else if (i386_k_regnum_p (gdbarch, regnum))
3508         {
3509           regnum -= tdep->k0_regnum;
3510
3511           regcache_raw_write (regcache,
3512                               tdep->k0_regnum + regnum,
3513                               buf);
3514         }
3515       else if (i386_zmm_regnum_p (gdbarch, regnum))
3516         {
3517           regnum -= tdep->zmm0_regnum;
3518
3519           if (regnum < num_lower_zmm_regs)
3520             {
3521               /* Write lower 128bits.  */
3522               regcache_raw_write (regcache,
3523                                   I387_XMM0_REGNUM (tdep) + regnum,
3524                                   buf);
3525               /* Write upper 128bits.  */
3526               regcache_raw_write (regcache,
3527                                   I387_YMM0_REGNUM (tdep) + regnum,
3528                                   buf + 16);
3529             }
3530           else
3531             {
3532               /* Write lower 128bits.  */
3533               regcache_raw_write (regcache,
3534                                   I387_XMM16_REGNUM (tdep) + regnum
3535                                   - num_lower_zmm_regs,
3536                                   buf);
3537               /* Write upper 128bits.  */
3538               regcache_raw_write (regcache,
3539                                   I387_YMM16H_REGNUM (tdep) + regnum
3540                                   - num_lower_zmm_regs,
3541                                   buf + 16);
3542             }
3543           /* Write upper 256bits.  */
3544           regcache_raw_write (regcache,
3545                               tdep->zmm0h_regnum + regnum,
3546                               buf + 32);
3547         }
3548       else if (i386_ymm_regnum_p (gdbarch, regnum))
3549         {
3550           regnum -= tdep->ymm0_regnum;
3551
3552           /* ... Write lower 128bits.  */
3553           regcache_raw_write (regcache,
3554                              I387_XMM0_REGNUM (tdep) + regnum,
3555                              buf);
3556           /* ... Write upper 128bits.  */
3557           regcache_raw_write (regcache,
3558                              tdep->ymm0h_regnum + regnum,
3559                              buf + 16);
3560         }
3561       else if (i386_ymm_avx512_regnum_p (gdbarch, regnum))
3562         {
3563           regnum -= tdep->ymm16_regnum;
3564
3565           /* ... Write lower 128bits.  */
3566           regcache_raw_write (regcache,
3567                               I387_XMM16_REGNUM (tdep) + regnum,
3568                               buf);
3569           /* ... Write upper 128bits.  */
3570           regcache_raw_write (regcache,
3571                               tdep->ymm16h_regnum + regnum,
3572                               buf + 16);
3573         }
3574       else if (i386_word_regnum_p (gdbarch, regnum))
3575         {
3576           int gpnum = regnum - tdep->ax_regnum;
3577
3578           /* Read ...  */
3579           regcache_raw_read (regcache, gpnum, raw_buf);
3580           /* ... Modify ... (always little endian).  */
3581           memcpy (raw_buf, buf, 2);
3582           /* ... Write.  */
3583           regcache_raw_write (regcache, gpnum, raw_buf);
3584         }
3585       else if (i386_byte_regnum_p (gdbarch, regnum))
3586         {
3587           /* Check byte pseudo registers last since this function will
3588              be called from amd64_pseudo_register_read, which handles
3589              byte pseudo registers differently.  */
3590           int gpnum = regnum - tdep->al_regnum;
3591
3592           /* Read ...  We read both lower and upper registers.  */
3593           regcache_raw_read (regcache, gpnum % 4, raw_buf);
3594           /* ... Modify ... (always little endian).  */
3595           if (gpnum >= 4)
3596             memcpy (raw_buf + 1, buf, 1);
3597           else
3598             memcpy (raw_buf, buf, 1);
3599           /* ... Write.  */
3600           regcache_raw_write (regcache, gpnum % 4, raw_buf);
3601         }
3602       else
3603         internal_error (__FILE__, __LINE__, _("invalid regnum"));
3604     }
3605 }
3606 \f
3607
3608 /* Return the register number of the register allocated by GCC after
3609    REGNUM, or -1 if there is no such register.  */
3610
3611 static int
3612 i386_next_regnum (int regnum)
3613 {
3614   /* GCC allocates the registers in the order:
3615
3616      %eax, %edx, %ecx, %ebx, %esi, %edi, %ebp, %esp, ...
3617
3618      Since storing a variable in %esp doesn't make any sense we return
3619      -1 for %ebp and for %esp itself.  */
3620   static int next_regnum[] =
3621   {
3622     I386_EDX_REGNUM,            /* Slot for %eax.  */
3623     I386_EBX_REGNUM,            /* Slot for %ecx.  */
3624     I386_ECX_REGNUM,            /* Slot for %edx.  */
3625     I386_ESI_REGNUM,            /* Slot for %ebx.  */
3626     -1, -1,                     /* Slots for %esp and %ebp.  */
3627     I386_EDI_REGNUM,            /* Slot for %esi.  */
3628     I386_EBP_REGNUM             /* Slot for %edi.  */
3629   };
3630
3631   if (regnum >= 0 && regnum < sizeof (next_regnum) / sizeof (next_regnum[0]))
3632     return next_regnum[regnum];
3633
3634   return -1;
3635 }
3636
3637 /* Return nonzero if a value of type TYPE stored in register REGNUM
3638    needs any special handling.  */
3639
3640 static int
3641 i386_convert_register_p (struct gdbarch *gdbarch,
3642                          int regnum, struct type *type)
3643 {
3644   int len = TYPE_LENGTH (type);
3645
3646   /* Values may be spread across multiple registers.  Most debugging
3647      formats aren't expressive enough to specify the locations, so
3648      some heuristics is involved.  Right now we only handle types that
3649      have a length that is a multiple of the word size, since GCC
3650      doesn't seem to put any other types into registers.  */
3651   if (len > 4 && len % 4 == 0)
3652     {
3653       int last_regnum = regnum;
3654
3655       while (len > 4)
3656         {
3657           last_regnum = i386_next_regnum (last_regnum);
3658           len -= 4;
3659         }
3660
3661       if (last_regnum != -1)
3662         return 1;
3663     }
3664
3665   return i387_convert_register_p (gdbarch, regnum, type);
3666 }
3667
3668 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
3669    return its contents in TO.  */
3670
3671 static int
3672 i386_register_to_value (struct frame_info *frame, int regnum,
3673                         struct type *type, gdb_byte *to,
3674                         int *optimizedp, int *unavailablep)
3675 {
3676   struct gdbarch *gdbarch = get_frame_arch (frame);
3677   int len = TYPE_LENGTH (type);
3678
3679   if (i386_fp_regnum_p (gdbarch, regnum))
3680     return i387_register_to_value (frame, regnum, type, to,
3681                                    optimizedp, unavailablep);
3682
3683   /* Read a value spread across multiple registers.  */
3684
3685   gdb_assert (len > 4 && len % 4 == 0);
3686
3687   while (len > 0)
3688     {
3689       gdb_assert (regnum != -1);
3690       gdb_assert (register_size (gdbarch, regnum) == 4);
3691
3692       if (!get_frame_register_bytes (frame, regnum, 0,
3693                                      register_size (gdbarch, regnum),
3694                                      to, optimizedp, unavailablep))
3695         return 0;
3696
3697       regnum = i386_next_regnum (regnum);
3698       len -= 4;
3699       to += 4;
3700     }
3701
3702   *optimizedp = *unavailablep = 0;
3703   return 1;
3704 }
3705
3706 /* Write the contents FROM of a value of type TYPE into register
3707    REGNUM in frame FRAME.  */
3708
3709 static void
3710 i386_value_to_register (struct frame_info *frame, int regnum,
3711                         struct type *type, const gdb_byte *from)
3712 {
3713   int len = TYPE_LENGTH (type);
3714
3715   if (i386_fp_regnum_p (get_frame_arch (frame), regnum))
3716     {
3717       i387_value_to_register (frame, regnum, type, from);
3718       return;
3719     }
3720
3721   /* Write a value spread across multiple registers.  */
3722
3723   gdb_assert (len > 4 && len % 4 == 0);
3724
3725   while (len > 0)
3726     {
3727       gdb_assert (regnum != -1);
3728       gdb_assert (register_size (get_frame_arch (frame), regnum) == 4);
3729
3730       put_frame_register (frame, regnum, from);
3731       regnum = i386_next_regnum (regnum);
3732       len -= 4;
3733       from += 4;
3734     }
3735 }
3736 \f
3737 /* Supply register REGNUM from the buffer specified by GREGS and LEN
3738    in the general-purpose register set REGSET to register cache
3739    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
3740
3741 void
3742 i386_supply_gregset (const struct regset *regset, struct regcache *regcache,
3743                      int regnum, const void *gregs, size_t len)
3744 {
3745   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3746   const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3747   const gdb_byte *regs = (const gdb_byte *) gregs;
3748   int i;
3749
3750   gdb_assert (len >= tdep->sizeof_gregset);
3751
3752   for (i = 0; i < tdep->gregset_num_regs; i++)
3753     {
3754       if ((regnum == i || regnum == -1)
3755           && tdep->gregset_reg_offset[i] != -1)
3756         regcache_raw_supply (regcache, i, regs + tdep->gregset_reg_offset[i]);
3757     }
3758 }
3759
3760 /* Collect register REGNUM from the register cache REGCACHE and store
3761    it in the buffer specified by GREGS and LEN as described by the
3762    general-purpose register set REGSET.  If REGNUM is -1, do this for
3763    all registers in REGSET.  */
3764
3765 static void
3766 i386_collect_gregset (const struct regset *regset,
3767                       const struct regcache *regcache,
3768                       int regnum, void *gregs, size_t len)
3769 {
3770   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3771   const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3772   gdb_byte *regs = (gdb_byte *) gregs;
3773   int i;
3774
3775   gdb_assert (len >= tdep->sizeof_gregset);
3776
3777   for (i = 0; i < tdep->gregset_num_regs; i++)
3778     {
3779       if ((regnum == i || regnum == -1)
3780           && tdep->gregset_reg_offset[i] != -1)
3781         regcache_raw_collect (regcache, i, regs + tdep->gregset_reg_offset[i]);
3782     }
3783 }
3784
3785 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
3786    in the floating-point register set REGSET to register cache
3787    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
3788
3789 static void
3790 i386_supply_fpregset (const struct regset *regset, struct regcache *regcache,
3791                       int regnum, const void *fpregs, size_t len)
3792 {
3793   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3794   const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3795
3796   if (len == I387_SIZEOF_FXSAVE)
3797     {
3798       i387_supply_fxsave (regcache, regnum, fpregs);
3799       return;
3800     }
3801
3802   gdb_assert (len >= tdep->sizeof_fpregset);
3803   i387_supply_fsave (regcache, regnum, fpregs);
3804 }
3805
3806 /* Collect register REGNUM from the register cache REGCACHE and store
3807    it in the buffer specified by FPREGS and LEN as described by the
3808    floating-point register set REGSET.  If REGNUM is -1, do this for
3809    all registers in REGSET.  */
3810
3811 static void
3812 i386_collect_fpregset (const struct regset *regset,
3813                        const struct regcache *regcache,
3814                        int regnum, void *fpregs, size_t len)
3815 {
3816   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3817   const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3818
3819   if (len == I387_SIZEOF_FXSAVE)
3820     {
3821       i387_collect_fxsave (regcache, regnum, fpregs);
3822       return;
3823     }
3824
3825   gdb_assert (len >= tdep->sizeof_fpregset);
3826   i387_collect_fsave (regcache, regnum, fpregs);
3827 }
3828
3829 /* Register set definitions.  */
3830
3831 const struct regset i386_gregset =
3832   {
3833     NULL, i386_supply_gregset, i386_collect_gregset
3834   };
3835
3836 const struct regset i386_fpregset =
3837   {
3838     NULL, i386_supply_fpregset, i386_collect_fpregset
3839   };
3840
3841 /* Default iterator over core file register note sections.  */
3842
3843 void
3844 i386_iterate_over_regset_sections (struct gdbarch *gdbarch,
3845                                    iterate_over_regset_sections_cb *cb,
3846                                    void *cb_data,
3847                                    const struct regcache *regcache)
3848 {
3849   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3850
3851   cb (".reg", tdep->sizeof_gregset, &i386_gregset, NULL, cb_data);
3852   if (tdep->sizeof_fpregset)
3853     cb (".reg2", tdep->sizeof_fpregset, tdep->fpregset, NULL, cb_data);
3854 }
3855 \f
3856
3857 /* Stuff for WIN32 PE style DLL's but is pretty generic really.  */
3858
3859 CORE_ADDR
3860 i386_pe_skip_trampoline_code (struct frame_info *frame,
3861                               CORE_ADDR pc, char *name)
3862 {
3863   struct gdbarch *gdbarch = get_frame_arch (frame);
3864   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3865
3866   /* jmp *(dest) */
3867   if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
3868     {
3869       unsigned long indirect =
3870         read_memory_unsigned_integer (pc + 2, 4, byte_order);
3871       struct minimal_symbol *indsym =
3872         indirect ? lookup_minimal_symbol_by_pc (indirect).minsym : 0;
3873       const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : 0;
3874
3875       if (symname)
3876         {
3877           if (startswith (symname, "__imp_")
3878               || startswith (symname, "_imp_"))
3879             return name ? 1 :
3880                    read_memory_unsigned_integer (indirect, 4, byte_order);
3881         }
3882     }
3883   return 0;                     /* Not a trampoline.  */
3884 }
3885 \f
3886
3887 /* Return whether the THIS_FRAME corresponds to a sigtramp
3888    routine.  */
3889
3890 int
3891 i386_sigtramp_p (struct frame_info *this_frame)
3892 {
3893   CORE_ADDR pc = get_frame_pc (this_frame);
3894   const char *name;
3895
3896   find_pc_partial_function (pc, &name, NULL, NULL);
3897   return (name && strcmp ("_sigtramp", name) == 0);
3898 }
3899 \f
3900
3901 /* We have two flavours of disassembly.  The machinery on this page
3902    deals with switching between those.  */
3903
3904 static int
3905 i386_print_insn (bfd_vma pc, struct disassemble_info *info)
3906 {
3907   gdb_assert (disassembly_flavor == att_flavor
3908               || disassembly_flavor == intel_flavor);
3909
3910   /* FIXME: kettenis/20020915: Until disassembler_options is properly
3911      constified, cast to prevent a compiler warning.  */
3912   info->disassembler_options = (char *) disassembly_flavor;
3913
3914   return print_insn_i386 (pc, info);
3915 }
3916 \f
3917
3918 /* There are a few i386 architecture variants that differ only
3919    slightly from the generic i386 target.  For now, we don't give them
3920    their own source file, but include them here.  As a consequence,
3921    they'll always be included.  */
3922
3923 /* System V Release 4 (SVR4).  */
3924
3925 /* Return whether THIS_FRAME corresponds to a SVR4 sigtramp
3926    routine.  */
3927
3928 static int
3929 i386_svr4_sigtramp_p (struct frame_info *this_frame)
3930 {
3931   CORE_ADDR pc = get_frame_pc (this_frame);
3932   const char *name;
3933
3934   /* The origin of these symbols is currently unknown.  */
3935   find_pc_partial_function (pc, &name, NULL, NULL);
3936   return (name && (strcmp ("_sigreturn", name) == 0
3937                    || strcmp ("sigvechandler", name) == 0));
3938 }
3939
3940 /* Assuming THIS_FRAME is for a SVR4 sigtramp routine, return the
3941    address of the associated sigcontext (ucontext) structure.  */
3942
3943 static CORE_ADDR
3944 i386_svr4_sigcontext_addr (struct frame_info *this_frame)
3945 {
3946   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3947   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3948   gdb_byte buf[4];
3949   CORE_ADDR sp;
3950
3951   get_frame_register (this_frame, I386_ESP_REGNUM, buf);
3952   sp = extract_unsigned_integer (buf, 4, byte_order);
3953
3954   return read_memory_unsigned_integer (sp + 8, 4, byte_order);
3955 }
3956
3957 \f
3958
3959 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
3960    gdbarch.h.  */
3961
3962 int
3963 i386_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
3964 {
3965   return (*s == '$' /* Literal number.  */
3966           || (isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement.  */
3967           || (*s == '(' && s[1] == '%') /* Register indirection.  */
3968           || (*s == '%' && isalpha (s[1]))); /* Register access.  */
3969 }
3970
3971 /* Helper function for i386_stap_parse_special_token.
3972
3973    This function parses operands of the form `-8+3+1(%rbp)', which
3974    must be interpreted as `*(-8 + 3 - 1 + (void *) $eax)'.
3975
3976    Return 1 if the operand was parsed successfully, zero
3977    otherwise.  */
3978
3979 static int
3980 i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
3981                                        struct stap_parse_info *p)
3982 {
3983   const char *s = p->arg;
3984
3985   if (isdigit (*s) || *s == '-' || *s == '+')
3986     {
3987       int got_minus[3];
3988       int i;
3989       long displacements[3];
3990       const char *start;
3991       char *regname;
3992       int len;
3993       struct stoken str;
3994       char *endp;
3995
3996       got_minus[0] = 0;
3997       if (*s == '+')
3998         ++s;
3999       else if (*s == '-')
4000         {
4001           ++s;
4002           got_minus[0] = 1;
4003         }
4004
4005       if (!isdigit ((unsigned char) *s))
4006         return 0;
4007
4008       displacements[0] = strtol (s, &endp, 10);
4009       s = endp;
4010
4011       if (*s != '+' && *s != '-')
4012         {
4013           /* We are not dealing with a triplet.  */
4014           return 0;
4015         }
4016
4017       got_minus[1] = 0;
4018       if (*s == '+')
4019         ++s;
4020       else
4021         {
4022           ++s;
4023           got_minus[1] = 1;
4024         }
4025
4026       if (!isdigit ((unsigned char) *s))
4027         return 0;
4028
4029       displacements[1] = strtol (s, &endp, 10);
4030       s = endp;
4031
4032       if (*s != '+' && *s != '-')
4033         {
4034           /* We are not dealing with a triplet.  */
4035           return 0;
4036         }
4037
4038       got_minus[2] = 0;
4039       if (*s == '+')
4040         ++s;
4041       else
4042         {
4043           ++s;
4044           got_minus[2] = 1;
4045         }
4046
4047       if (!isdigit ((unsigned char) *s))
4048         return 0;
4049
4050       displacements[2] = strtol (s, &endp, 10);
4051       s = endp;
4052
4053       if (*s != '(' || s[1] != '%')
4054         return 0;
4055
4056       s += 2;
4057       start = s;
4058
4059       while (isalnum (*s))
4060         ++s;
4061
4062       if (*s++ != ')')
4063         return 0;
4064
4065       len = s - start - 1;
4066       regname = (char *) alloca (len + 1);
4067
4068       strncpy (regname, start, len);
4069       regname[len] = '\0';
4070
4071       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
4072         error (_("Invalid register name `%s' on expression `%s'."),
4073                regname, p->saved_arg);
4074
4075       for (i = 0; i < 3; i++)
4076         {
4077           write_exp_elt_opcode (&p->pstate, OP_LONG);
4078           write_exp_elt_type
4079             (&p->pstate, builtin_type (gdbarch)->builtin_long);
4080           write_exp_elt_longcst (&p->pstate, displacements[i]);
4081           write_exp_elt_opcode (&p->pstate, OP_LONG);
4082           if (got_minus[i])
4083             write_exp_elt_opcode (&p->pstate, UNOP_NEG);
4084         }
4085
4086       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
4087       str.ptr = regname;
4088       str.length = len;
4089       write_exp_string (&p->pstate, str);
4090       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
4091
4092       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
4093       write_exp_elt_type (&p->pstate,
4094                           builtin_type (gdbarch)->builtin_data_ptr);
4095       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
4096
4097       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
4098       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
4099       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
4100
4101       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
4102       write_exp_elt_type (&p->pstate,
4103                           lookup_pointer_type (p->arg_type));
4104       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
4105
4106       write_exp_elt_opcode (&p->pstate, UNOP_IND);
4107
4108       p->arg = s;
4109
4110       return 1;
4111     }
4112
4113   return 0;
4114 }
4115
4116 /* Helper function for i386_stap_parse_special_token.
4117
4118    This function parses operands of the form `register base +
4119    (register index * size) + offset', as represented in
4120    `(%rcx,%rax,8)', or `[OFFSET](BASE_REG,INDEX_REG[,SIZE])'.
4121
4122    Return 1 if the operand was parsed successfully, zero
4123    otherwise.  */
4124
4125 static int
4126 i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
4127                                               struct stap_parse_info *p)
4128 {
4129   const char *s = p->arg;
4130
4131   if (isdigit (*s) || *s == '(' || *s == '-' || *s == '+')
4132     {
4133       int offset_minus = 0;
4134       long offset = 0;
4135       int size_minus = 0;
4136       long size = 0;
4137       const char *start;
4138       char *base;
4139       int len_base;
4140       char *index;
4141       int len_index;
4142       struct stoken base_token, index_token;
4143
4144       if (*s == '+')
4145         ++s;
4146       else if (*s == '-')
4147         {
4148           ++s;
4149           offset_minus = 1;
4150         }
4151
4152       if (offset_minus && !isdigit (*s))
4153         return 0;
4154
4155       if (isdigit (*s))
4156         {
4157           char *endp;
4158
4159           offset = strtol (s, &endp, 10);
4160           s = endp;
4161         }
4162
4163       if (*s != '(' || s[1] != '%')
4164         return 0;
4165
4166       s += 2;
4167       start = s;
4168
4169       while (isalnum (*s))
4170         ++s;
4171
4172       if (*s != ',' || s[1] != '%')
4173         return 0;
4174
4175       len_base = s - start;
4176       base = (char *) alloca (len_base + 1);
4177       strncpy (base, start, len_base);
4178       base[len_base] = '\0';
4179
4180       if (user_reg_map_name_to_regnum (gdbarch, base, len_base) == -1)
4181         error (_("Invalid register name `%s' on expression `%s'."),
4182                base, p->saved_arg);
4183
4184       s += 2;
4185       start = s;
4186
4187       while (isalnum (*s))
4188         ++s;
4189
4190       len_index = s - start;
4191       index = (char *) alloca (len_index + 1);
4192       strncpy (index, start, len_index);
4193       index[len_index] = '\0';
4194
4195       if (user_reg_map_name_to_regnum (gdbarch, index, len_index) == -1)
4196         error (_("Invalid register name `%s' on expression `%s'."),
4197                index, p->saved_arg);
4198
4199       if (*s != ',' && *s != ')')
4200         return 0;
4201
4202       if (*s == ',')
4203         {
4204           char *endp;
4205
4206           ++s;
4207           if (*s == '+')
4208             ++s;
4209           else if (*s == '-')
4210             {
4211               ++s;
4212               size_minus = 1;
4213             }
4214
4215           size = strtol (s, &endp, 10);
4216           s = endp;
4217
4218           if (*s != ')')
4219             return 0;
4220         }
4221
4222       ++s;
4223
4224       if (offset)
4225         {
4226           write_exp_elt_opcode (&p->pstate, OP_LONG);
4227           write_exp_elt_type (&p->pstate,
4228                               builtin_type (gdbarch)->builtin_long);
4229           write_exp_elt_longcst (&p->pstate, offset);
4230           write_exp_elt_opcode (&p->pstate, OP_LONG);
4231           if (offset_minus)
4232             write_exp_elt_opcode (&p->pstate, UNOP_NEG);
4233         }
4234
4235       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
4236       base_token.ptr = base;
4237       base_token.length = len_base;
4238       write_exp_string (&p->pstate, base_token);
4239       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
4240
4241       if (offset)
4242         write_exp_elt_opcode (&p->pstate, BINOP_ADD);
4243
4244       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
4245       index_token.ptr = index;
4246       index_token.length = len_index;
4247       write_exp_string (&p->pstate, index_token);
4248       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
4249
4250       if (size)
4251         {
4252           write_exp_elt_opcode (&p->pstate, OP_LONG);
4253           write_exp_elt_type (&p->pstate,
4254                               builtin_type (gdbarch)->builtin_long);
4255           write_exp_elt_longcst (&p->pstate, size);
4256           write_exp_elt_opcode (&p->pstate, OP_LONG);
4257           if (size_minus)
4258             write_exp_elt_opcode (&p->pstate, UNOP_NEG);
4259           write_exp_elt_opcode (&p->pstate, BINOP_MUL);
4260         }
4261
4262       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
4263
4264       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
4265       write_exp_elt_type (&p->pstate,
4266                           lookup_pointer_type (p->arg_type));
4267       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
4268
4269       write_exp_elt_opcode (&p->pstate, UNOP_IND);
4270
4271       p->arg = s;
4272
4273       return 1;
4274     }
4275
4276   return 0;
4277 }
4278
4279 /* Implementation of `gdbarch_stap_parse_special_token', as defined in
4280    gdbarch.h.  */
4281
4282 int
4283 i386_stap_parse_special_token (struct gdbarch *gdbarch,
4284                                struct stap_parse_info *p)
4285 {
4286   /* In order to parse special tokens, we use a state-machine that go
4287      through every known token and try to get a match.  */
4288   enum
4289     {
4290       TRIPLET,
4291       THREE_ARG_DISPLACEMENT,
4292       DONE
4293     };
4294   int current_state;
4295
4296   current_state = TRIPLET;
4297
4298   /* The special tokens to be parsed here are:
4299
4300      - `register base + (register index * size) + offset', as represented
4301      in `(%rcx,%rax,8)', or `[OFFSET](BASE_REG,INDEX_REG[,SIZE])'.
4302
4303      - Operands of the form `-8+3+1(%rbp)', which must be interpreted as
4304      `*(-8 + 3 - 1 + (void *) $eax)'.  */
4305
4306   while (current_state != DONE)
4307     {
4308       switch (current_state)
4309         {
4310         case TRIPLET:
4311           if (i386_stap_parse_special_token_triplet (gdbarch, p))
4312             return 1;
4313           break;
4314
4315         case THREE_ARG_DISPLACEMENT:
4316           if (i386_stap_parse_special_token_three_arg_disp (gdbarch, p))
4317             return 1;
4318           break;
4319         }
4320
4321       /* Advancing to the next state.  */
4322       ++current_state;
4323     }
4324
4325   return 0;
4326 }
4327
4328 \f
4329
4330 /* gdbarch gnu_triplet_regexp method.  Both arches are acceptable as GDB always
4331    also supplies -m64 or -m32 by gdbarch_gcc_target_options.  */
4332
4333 static const char *
4334 i386_gnu_triplet_regexp (struct gdbarch *gdbarch)
4335 {
4336   return "(x86_64|i.86)";
4337 }
4338
4339 \f
4340
4341 /* Generic ELF.  */
4342
4343 void
4344 i386_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
4345 {
4346   static const char *const stap_integer_prefixes[] = { "$", NULL };
4347   static const char *const stap_register_prefixes[] = { "%", NULL };
4348   static const char *const stap_register_indirection_prefixes[] = { "(",
4349                                                                     NULL };
4350   static const char *const stap_register_indirection_suffixes[] = { ")",
4351                                                                     NULL };
4352
4353   /* We typically use stabs-in-ELF with the SVR4 register numbering.  */
4354   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
4355
4356   /* Registering SystemTap handlers.  */
4357   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
4358   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
4359   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
4360                                           stap_register_indirection_prefixes);
4361   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
4362                                           stap_register_indirection_suffixes);
4363   set_gdbarch_stap_is_single_operand (gdbarch,
4364                                       i386_stap_is_single_operand);
4365   set_gdbarch_stap_parse_special_token (gdbarch,
4366                                         i386_stap_parse_special_token);
4367
4368   set_gdbarch_gnu_triplet_regexp (gdbarch, i386_gnu_triplet_regexp);
4369 }
4370
4371 /* System V Release 4 (SVR4).  */
4372
4373 void
4374 i386_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
4375 {
4376   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4377
4378   /* System V Release 4 uses ELF.  */
4379   i386_elf_init_abi (info, gdbarch);
4380
4381   /* System V Release 4 has shared libraries.  */
4382   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
4383
4384   tdep->sigtramp_p = i386_svr4_sigtramp_p;
4385   tdep->sigcontext_addr = i386_svr4_sigcontext_addr;
4386   tdep->sc_pc_offset = 36 + 14 * 4;
4387   tdep->sc_sp_offset = 36 + 17 * 4;
4388
4389   tdep->jb_pc_offset = 20;
4390 }
4391
4392 /* DJGPP.  */
4393
4394 static void
4395 i386_go32_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
4396 {
4397   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4398
4399   /* DJGPP doesn't have any special frames for signal handlers.  */
4400   tdep->sigtramp_p = NULL;
4401
4402   tdep->jb_pc_offset = 36;
4403
4404   /* DJGPP does not support the SSE registers.  */
4405   if (! tdesc_has_registers (info.target_desc))
4406     tdep->tdesc = tdesc_i386_mmx;
4407
4408   /* Native compiler is GCC, which uses the SVR4 register numbering
4409      even in COFF and STABS.  See the comment in i386_gdbarch_init,
4410      before the calls to set_gdbarch_stab_reg_to_regnum and
4411      set_gdbarch_sdb_reg_to_regnum.  */
4412   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
4413   set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
4414
4415   set_gdbarch_has_dos_based_file_system (gdbarch, 1);
4416
4417   set_gdbarch_gnu_triplet_regexp (gdbarch, i386_gnu_triplet_regexp);
4418 }
4419 \f
4420
4421 /* i386 register groups.  In addition to the normal groups, add "mmx"
4422    and "sse".  */
4423
4424 static struct reggroup *i386_sse_reggroup;
4425 static struct reggroup *i386_mmx_reggroup;
4426
4427 static void
4428 i386_init_reggroups (void)
4429 {
4430   i386_sse_reggroup = reggroup_new ("sse", USER_REGGROUP);
4431   i386_mmx_reggroup = reggroup_new ("mmx", USER_REGGROUP);
4432 }
4433
4434 static void
4435 i386_add_reggroups (struct gdbarch *gdbarch)
4436 {
4437   reggroup_add (gdbarch, i386_sse_reggroup);
4438   reggroup_add (gdbarch, i386_mmx_reggroup);
4439   reggroup_add (gdbarch, general_reggroup);
4440   reggroup_add (gdbarch, float_reggroup);
4441   reggroup_add (gdbarch, all_reggroup);
4442   reggroup_add (gdbarch, save_reggroup);
4443   reggroup_add (gdbarch, restore_reggroup);
4444   reggroup_add (gdbarch, vector_reggroup);
4445   reggroup_add (gdbarch, system_reggroup);
4446 }
4447
4448 int
4449 i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
4450                           struct reggroup *group)
4451 {
4452   const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4453   int fp_regnum_p, mmx_regnum_p, xmm_regnum_p, mxcsr_regnum_p,
4454       ymm_regnum_p, ymmh_regnum_p, ymm_avx512_regnum_p, ymmh_avx512_regnum_p,
4455       bndr_regnum_p, bnd_regnum_p, k_regnum_p, zmm_regnum_p, zmmh_regnum_p,
4456       zmm_avx512_regnum_p, mpx_ctrl_regnum_p, xmm_avx512_regnum_p,
4457       avx512_p, avx_p, sse_p;
4458
4459   /* Don't include pseudo registers, except for MMX, in any register
4460      groups.  */
4461   if (i386_byte_regnum_p (gdbarch, regnum))
4462     return 0;
4463
4464   if (i386_word_regnum_p (gdbarch, regnum))
4465     return 0;
4466
4467   if (i386_dword_regnum_p (gdbarch, regnum))
4468     return 0;
4469
4470   mmx_regnum_p = i386_mmx_regnum_p (gdbarch, regnum);
4471   if (group == i386_mmx_reggroup)
4472     return mmx_regnum_p;
4473
4474   xmm_regnum_p = i386_xmm_regnum_p (gdbarch, regnum);
4475   xmm_avx512_regnum_p = i386_xmm_avx512_regnum_p (gdbarch, regnum);
4476   mxcsr_regnum_p = i386_mxcsr_regnum_p (gdbarch, regnum);
4477   if (group == i386_sse_reggroup)
4478     return xmm_regnum_p || xmm_avx512_regnum_p || mxcsr_regnum_p;
4479
4480   ymm_regnum_p = i386_ymm_regnum_p (gdbarch, regnum);
4481   ymm_avx512_regnum_p = i386_ymm_avx512_regnum_p (gdbarch, regnum);
4482   zmm_regnum_p = i386_zmm_regnum_p (gdbarch, regnum);
4483
4484   avx512_p = ((tdep->xcr0 & X86_XSTATE_AVX512_MASK)
4485               == X86_XSTATE_AVX512_MASK);
4486   avx_p = ((tdep->xcr0 & X86_XSTATE_AVX512_MASK)
4487            == X86_XSTATE_AVX_MASK) && !avx512_p;
4488   sse_p = ((tdep->xcr0 & X86_XSTATE_AVX512_MASK)
4489            == X86_XSTATE_SSE_MASK) && !avx512_p && ! avx_p;
4490
4491   if (group == vector_reggroup)
4492     return (mmx_regnum_p
4493             || (zmm_regnum_p && avx512_p)
4494             || ((ymm_regnum_p || ymm_avx512_regnum_p) && avx_p)
4495             || ((xmm_regnum_p || xmm_avx512_regnum_p) && sse_p)
4496             || mxcsr_regnum_p);
4497
4498   fp_regnum_p = (i386_fp_regnum_p (gdbarch, regnum)
4499                  || i386_fpc_regnum_p (gdbarch, regnum));
4500   if (group == float_reggroup)
4501     return fp_regnum_p;
4502
4503   /* For "info reg all", don't include upper YMM registers nor XMM
4504      registers when AVX is supported.  */
4505   ymmh_regnum_p = i386_ymmh_regnum_p (gdbarch, regnum);
4506   ymmh_avx512_regnum_p = i386_ymmh_avx512_regnum_p (gdbarch, regnum);
4507   zmmh_regnum_p = i386_zmmh_regnum_p (gdbarch, regnum);
4508   if (group == all_reggroup
4509       && (((xmm_regnum_p || xmm_avx512_regnum_p) && !sse_p)
4510           || ((ymm_regnum_p || ymm_avx512_regnum_p) && !avx_p)
4511           || ymmh_regnum_p
4512           || ymmh_avx512_regnum_p
4513           || zmmh_regnum_p))
4514     return 0;
4515
4516   bnd_regnum_p = i386_bnd_regnum_p (gdbarch, regnum);
4517   if (group == all_reggroup
4518       && ((bnd_regnum_p && (tdep->xcr0 & X86_XSTATE_MPX_MASK))))
4519     return bnd_regnum_p;
4520
4521   bndr_regnum_p = i386_bndr_regnum_p (gdbarch, regnum);
4522   if (group == all_reggroup
4523       && ((bndr_regnum_p && (tdep->xcr0 & X86_XSTATE_MPX_MASK))))
4524     return 0;
4525
4526   mpx_ctrl_regnum_p = i386_mpx_ctrl_regnum_p (gdbarch, regnum);
4527   if (group == all_reggroup
4528       && ((mpx_ctrl_regnum_p && (tdep->xcr0 & X86_XSTATE_MPX_MASK))))
4529     return mpx_ctrl_regnum_p;
4530
4531   if (group == general_reggroup)
4532     return (!fp_regnum_p
4533             && !mmx_regnum_p
4534             && !mxcsr_regnum_p
4535             && !xmm_regnum_p
4536             && !xmm_avx512_regnum_p
4537             && !ymm_regnum_p
4538             && !ymmh_regnum_p
4539             && !ymm_avx512_regnum_p
4540             && !ymmh_avx512_regnum_p
4541             && !bndr_regnum_p
4542             && !bnd_regnum_p
4543             && !mpx_ctrl_regnum_p
4544             && !zmm_regnum_p
4545             && !zmmh_regnum_p);
4546
4547   return default_register_reggroup_p (gdbarch, regnum, group);
4548 }
4549 \f
4550
4551 /* Get the ARGIth function argument for the current function.  */
4552
4553 static CORE_ADDR
4554 i386_fetch_pointer_argument (struct frame_info *frame, int argi,
4555                              struct type *type)
4556 {
4557   struct gdbarch *gdbarch = get_frame_arch (frame);
4558   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4559   CORE_ADDR sp = get_frame_register_unsigned (frame, I386_ESP_REGNUM);
4560   return read_memory_unsigned_integer (sp + (4 * (argi + 1)), 4, byte_order);
4561 }
4562
4563 #define PREFIX_REPZ     0x01
4564 #define PREFIX_REPNZ    0x02
4565 #define PREFIX_LOCK     0x04
4566 #define PREFIX_DATA     0x08
4567 #define PREFIX_ADDR     0x10
4568
4569 /* operand size */
4570 enum
4571 {
4572   OT_BYTE = 0,
4573   OT_WORD,
4574   OT_LONG,
4575   OT_QUAD,
4576   OT_DQUAD,
4577 };
4578
4579 /* i386 arith/logic operations */
4580 enum
4581 {
4582   OP_ADDL,
4583   OP_ORL,
4584   OP_ADCL,
4585   OP_SBBL,
4586   OP_ANDL,
4587   OP_SUBL,
4588   OP_XORL,
4589   OP_CMPL,
4590 };
4591
4592 struct i386_record_s
4593 {
4594   struct gdbarch *gdbarch;
4595   struct regcache *regcache;
4596   CORE_ADDR orig_addr;
4597   CORE_ADDR addr;
4598   int aflag;
4599   int dflag;
4600   int override;
4601   uint8_t modrm;
4602   uint8_t mod, reg, rm;
4603   int ot;
4604   uint8_t rex_x;
4605   uint8_t rex_b;
4606   int rip_offset;
4607   int popl_esp_hack;
4608   const int *regmap;
4609 };
4610
4611 /* Parse the "modrm" part of the memory address irp->addr points at.
4612    Returns -1 if something goes wrong, 0 otherwise.  */
4613
4614 static int
4615 i386_record_modrm (struct i386_record_s *irp)
4616 {
4617   struct gdbarch *gdbarch = irp->gdbarch;
4618
4619   if (record_read_memory (gdbarch, irp->addr, &irp->modrm, 1))
4620     return -1;
4621
4622   irp->addr++;
4623   irp->mod = (irp->modrm >> 6) & 3;
4624   irp->reg = (irp->modrm >> 3) & 7;
4625   irp->rm = irp->modrm & 7;
4626
4627   return 0;
4628 }
4629
4630 /* Extract the memory address that the current instruction writes to,
4631    and return it in *ADDR.  Return -1 if something goes wrong.  */
4632
4633 static int
4634 i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
4635 {
4636   struct gdbarch *gdbarch = irp->gdbarch;
4637   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4638   gdb_byte buf[4];
4639   ULONGEST offset64;
4640
4641   *addr = 0;
4642   if (irp->aflag || irp->regmap[X86_RECORD_R8_REGNUM])
4643     {
4644       /* 32/64 bits */
4645       int havesib = 0;
4646       uint8_t scale = 0;
4647       uint8_t byte;
4648       uint8_t index = 0;
4649       uint8_t base = irp->rm;
4650
4651       if (base == 4)
4652         {
4653           havesib = 1;
4654           if (record_read_memory (gdbarch, irp->addr, &byte, 1))
4655             return -1;
4656           irp->addr++;
4657           scale = (byte >> 6) & 3;
4658           index = ((byte >> 3) & 7) | irp->rex_x;
4659           base = (byte & 7);
4660         }
4661       base |= irp->rex_b;
4662
4663       switch (irp->mod)
4664         {
4665         case 0:
4666           if ((base & 7) == 5)
4667             {
4668               base = 0xff;
4669               if (record_read_memory (gdbarch, irp->addr, buf, 4))
4670                 return -1;
4671               irp->addr += 4;
4672               *addr = extract_signed_integer (buf, 4, byte_order);
4673               if (irp->regmap[X86_RECORD_R8_REGNUM] && !havesib)
4674                 *addr += irp->addr + irp->rip_offset;
4675             }
4676           break;
4677         case 1:
4678           if (record_read_memory (gdbarch, irp->addr, buf, 1))
4679             return -1;
4680           irp->addr++;
4681           *addr = (int8_t) buf[0];
4682           break;
4683         case 2:
4684           if (record_read_memory (gdbarch, irp->addr, buf, 4))
4685             return -1;
4686           *addr = extract_signed_integer (buf, 4, byte_order);
4687           irp->addr += 4;
4688           break;
4689         }
4690
4691       offset64 = 0;
4692       if (base != 0xff)
4693         {
4694           if (base == 4 && irp->popl_esp_hack)
4695             *addr += irp->popl_esp_hack;
4696           regcache_raw_read_unsigned (irp->regcache, irp->regmap[base],
4697                                       &offset64);
4698         }
4699       if (irp->aflag == 2)
4700         {
4701           *addr += offset64;
4702         }
4703       else
4704         *addr = (uint32_t) (offset64 + *addr);
4705
4706       if (havesib && (index != 4 || scale != 0))
4707         {
4708           regcache_raw_read_unsigned (irp->regcache, irp->regmap[index],
4709                                       &offset64);
4710           if (irp->aflag == 2)
4711             *addr += offset64 << scale;
4712           else
4713             *addr = (uint32_t) (*addr + (offset64 << scale));
4714         }
4715
4716       if (!irp->aflag)
4717         {
4718           /* Since we are in 64-bit mode with ADDR32 prefix, zero-extend
4719              address from 32-bit to 64-bit.  */
4720             *addr = (uint32_t) *addr;
4721         }
4722     }
4723   else
4724     {
4725       /* 16 bits */
4726       switch (irp->mod)
4727         {
4728         case 0:
4729           if (irp->rm == 6)
4730             {
4731               if (record_read_memory (gdbarch, irp->addr, buf, 2))
4732                 return -1;
4733               irp->addr += 2;
4734               *addr = extract_signed_integer (buf, 2, byte_order);
4735               irp->rm = 0;
4736               goto no_rm;
4737             }
4738           break;
4739         case 1:
4740           if (record_read_memory (gdbarch, irp->addr, buf, 1))
4741             return -1;
4742           irp->addr++;
4743           *addr = (int8_t) buf[0];
4744           break;
4745         case 2:
4746           if (record_read_memory (gdbarch, irp->addr, buf, 2))
4747             return -1;
4748           irp->addr += 2;
4749           *addr = extract_signed_integer (buf, 2, byte_order);
4750           break;
4751         }
4752
4753       switch (irp->rm)
4754         {
4755         case 0:
4756           regcache_raw_read_unsigned (irp->regcache,
4757                                       irp->regmap[X86_RECORD_REBX_REGNUM],
4758                                       &offset64);
4759           *addr = (uint32_t) (*addr + offset64);
4760           regcache_raw_read_unsigned (irp->regcache,
4761                                       irp->regmap[X86_RECORD_RESI_REGNUM],
4762                                       &offset64);
4763           *addr = (uint32_t) (*addr + offset64);
4764           break;
4765         case 1:
4766           regcache_raw_read_unsigned (irp->regcache,
4767                                       irp->regmap[X86_RECORD_REBX_REGNUM],
4768                                       &offset64);
4769           *addr = (uint32_t) (*addr + offset64);
4770           regcache_raw_read_unsigned (irp->regcache,
4771                                       irp->regmap[X86_RECORD_REDI_REGNUM],
4772                                       &offset64);
4773           *addr = (uint32_t) (*addr + offset64);
4774           break;
4775         case 2:
4776           regcache_raw_read_unsigned (irp->regcache,
4777                                       irp->regmap[X86_RECORD_REBP_REGNUM],
4778                                       &offset64);
4779           *addr = (uint32_t) (*addr + offset64);
4780           regcache_raw_read_unsigned (irp->regcache,
4781                                       irp->regmap[X86_RECORD_RESI_REGNUM],
4782                                       &offset64);
4783           *addr = (uint32_t) (*addr + offset64);
4784           break;
4785         case 3:
4786           regcache_raw_read_unsigned (irp->regcache,
4787                                       irp->regmap[X86_RECORD_REBP_REGNUM],
4788                                       &offset64);
4789           *addr = (uint32_t) (*addr + offset64);
4790           regcache_raw_read_unsigned (irp->regcache,
4791                                       irp->regmap[X86_RECORD_REDI_REGNUM],
4792                                       &offset64);
4793           *addr = (uint32_t) (*addr + offset64);
4794           break;
4795         case 4:
4796           regcache_raw_read_unsigned (irp->regcache,
4797                                       irp->regmap[X86_RECORD_RESI_REGNUM],
4798                                       &offset64);
4799           *addr = (uint32_t) (*addr + offset64);
4800           break;
4801         case 5:
4802           regcache_raw_read_unsigned (irp->regcache,
4803                                       irp->regmap[X86_RECORD_REDI_REGNUM],
4804                                       &offset64);
4805           *addr = (uint32_t) (*addr + offset64);
4806           break;
4807         case 6:
4808           regcache_raw_read_unsigned (irp->regcache,
4809                                       irp->regmap[X86_RECORD_REBP_REGNUM],
4810                                       &offset64);
4811           *addr = (uint32_t) (*addr + offset64);
4812           break;
4813         case 7:
4814           regcache_raw_read_unsigned (irp->regcache,
4815                                       irp->regmap[X86_RECORD_REBX_REGNUM],
4816                                       &offset64);
4817           *addr = (uint32_t) (*addr + offset64);
4818           break;
4819         }
4820       *addr &= 0xffff;
4821     }
4822
4823  no_rm:
4824   return 0;
4825 }
4826
4827 /* Record the address and contents of the memory that will be changed
4828    by the current instruction.  Return -1 if something goes wrong, 0
4829    otherwise.  */
4830
4831 static int
4832 i386_record_lea_modrm (struct i386_record_s *irp)
4833 {
4834   struct gdbarch *gdbarch = irp->gdbarch;
4835   uint64_t addr;
4836
4837   if (irp->override >= 0)
4838     {
4839       if (record_full_memory_query)
4840         {
4841           int q;
4842
4843           target_terminal_ours ();
4844           q = yquery (_("\
4845 Process record ignores the memory change of instruction at address %s\n\
4846 because it can't get the value of the segment register.\n\
4847 Do you want to stop the program?"),
4848                       paddress (gdbarch, irp->orig_addr));
4849             target_terminal_inferior ();
4850             if (q)
4851               return -1;
4852         }
4853
4854       return 0;
4855     }
4856
4857   if (i386_record_lea_modrm_addr (irp, &addr))
4858     return -1;
4859
4860   if (record_full_arch_list_add_mem (addr, 1 << irp->ot))
4861     return -1;
4862
4863   return 0;
4864 }
4865
4866 /* Record the effects of a push operation.  Return -1 if something
4867    goes wrong, 0 otherwise.  */
4868
4869 static int
4870 i386_record_push (struct i386_record_s *irp, int size)
4871 {
4872   ULONGEST addr;
4873
4874   if (record_full_arch_list_add_reg (irp->regcache,
4875                                      irp->regmap[X86_RECORD_RESP_REGNUM]))
4876     return -1;
4877   regcache_raw_read_unsigned (irp->regcache,
4878                               irp->regmap[X86_RECORD_RESP_REGNUM],
4879                               &addr);
4880   if (record_full_arch_list_add_mem ((CORE_ADDR) addr - size, size))
4881     return -1;
4882
4883   return 0;
4884 }
4885
4886
4887 /* Defines contents to record.  */
4888 #define I386_SAVE_FPU_REGS              0xfffd
4889 #define I386_SAVE_FPU_ENV               0xfffe
4890 #define I386_SAVE_FPU_ENV_REG_STACK     0xffff
4891
4892 /* Record the values of the floating point registers which will be
4893    changed by the current instruction.  Returns -1 if something is
4894    wrong, 0 otherwise.  */
4895
4896 static int i386_record_floats (struct gdbarch *gdbarch,
4897                                struct i386_record_s *ir,
4898                                uint32_t iregnum)
4899 {
4900   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4901   int i;
4902
4903   /* Oza: Because of floating point insn push/pop of fpu stack is going to
4904      happen.  Currently we store st0-st7 registers, but we need not store all
4905      registers all the time, in future we use ftag register and record only
4906      those who are not marked as an empty.  */
4907
4908   if (I386_SAVE_FPU_REGS == iregnum)
4909     {
4910       for (i = I387_ST0_REGNUM (tdep); i <= I387_ST0_REGNUM (tdep) + 7; i++)
4911         {
4912           if (record_full_arch_list_add_reg (ir->regcache, i))
4913             return -1;
4914         }
4915     }
4916   else if (I386_SAVE_FPU_ENV == iregnum)
4917     {
4918       for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
4919               {
4920               if (record_full_arch_list_add_reg (ir->regcache, i))
4921                 return -1;
4922               }
4923     }
4924   else if (I386_SAVE_FPU_ENV_REG_STACK == iregnum)
4925     {
4926       for (i = I387_ST0_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
4927       {
4928         if (record_full_arch_list_add_reg (ir->regcache, i))
4929           return -1;
4930       }
4931     }
4932   else if ((iregnum >= I387_ST0_REGNUM (tdep)) &&
4933            (iregnum <= I387_FOP_REGNUM (tdep)))
4934     {
4935       if (record_full_arch_list_add_reg (ir->regcache,iregnum))
4936         return -1;
4937     }
4938   else
4939     {
4940       /* Parameter error.  */
4941       return -1;
4942     }
4943   if(I386_SAVE_FPU_ENV != iregnum)
4944     {
4945     for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
4946       {
4947       if (record_full_arch_list_add_reg (ir->regcache, i))
4948         return -1;
4949       }
4950     }
4951   return 0;
4952 }
4953
4954 /* Parse the current instruction, and record the values of the
4955    registers and memory that will be changed by the current
4956    instruction.  Returns -1 if something goes wrong, 0 otherwise.  */
4957
4958 #define I386_RECORD_FULL_ARCH_LIST_ADD_REG(regnum) \
4959     record_full_arch_list_add_reg (ir.regcache, ir.regmap[(regnum)])
4960
4961 int
4962 i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
4963                      CORE_ADDR input_addr)
4964 {
4965   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4966   int prefixes = 0;
4967   int regnum = 0;
4968   uint32_t opcode;
4969   uint8_t opcode8;
4970   ULONGEST addr;
4971   gdb_byte buf[MAX_REGISTER_SIZE];
4972   struct i386_record_s ir;
4973   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4974   uint8_t rex_w = -1;
4975   uint8_t rex_r = 0;
4976
4977   memset (&ir, 0, sizeof (struct i386_record_s));
4978   ir.regcache = regcache;
4979   ir.addr = input_addr;
4980   ir.orig_addr = input_addr;
4981   ir.aflag = 1;
4982   ir.dflag = 1;
4983   ir.override = -1;
4984   ir.popl_esp_hack = 0;
4985   ir.regmap = tdep->record_regmap;
4986   ir.gdbarch = gdbarch;
4987
4988   if (record_debug > 1)
4989     fprintf_unfiltered (gdb_stdlog, "Process record: i386_process_record "
4990                                     "addr = %s\n",
4991                         paddress (gdbarch, ir.addr));
4992
4993   /* prefixes */
4994   while (1)
4995     {
4996       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
4997         return -1;
4998       ir.addr++;
4999       switch (opcode8)  /* Instruction prefixes */
5000         {
5001         case REPE_PREFIX_OPCODE:
5002           prefixes |= PREFIX_REPZ;
5003           break;
5004         case REPNE_PREFIX_OPCODE:
5005           prefixes |= PREFIX_REPNZ;
5006           break;
5007         case LOCK_PREFIX_OPCODE:
5008           prefixes |= PREFIX_LOCK;
5009           break;
5010         case CS_PREFIX_OPCODE:
5011           ir.override = X86_RECORD_CS_REGNUM;
5012           break;
5013         case SS_PREFIX_OPCODE:
5014           ir.override = X86_RECORD_SS_REGNUM;
5015           break;
5016         case DS_PREFIX_OPCODE:
5017           ir.override = X86_RECORD_DS_REGNUM;
5018           break;
5019         case ES_PREFIX_OPCODE:
5020           ir.override = X86_RECORD_ES_REGNUM;
5021           break;
5022         case FS_PREFIX_OPCODE:
5023           ir.override = X86_RECORD_FS_REGNUM;
5024           break;
5025         case GS_PREFIX_OPCODE:
5026           ir.override = X86_RECORD_GS_REGNUM;
5027           break;
5028         case DATA_PREFIX_OPCODE:
5029           prefixes |= PREFIX_DATA;
5030           break;
5031         case ADDR_PREFIX_OPCODE:
5032           prefixes |= PREFIX_ADDR;
5033           break;
5034         case 0x40:      /* i386 inc %eax */
5035         case 0x41:      /* i386 inc %ecx */
5036         case 0x42:      /* i386 inc %edx */
5037         case 0x43:      /* i386 inc %ebx */
5038         case 0x44:      /* i386 inc %esp */
5039         case 0x45:      /* i386 inc %ebp */
5040         case 0x46:      /* i386 inc %esi */
5041         case 0x47:      /* i386 inc %edi */
5042         case 0x48:      /* i386 dec %eax */
5043         case 0x49:      /* i386 dec %ecx */
5044         case 0x4a:      /* i386 dec %edx */
5045         case 0x4b:      /* i386 dec %ebx */
5046         case 0x4c:      /* i386 dec %esp */
5047         case 0x4d:      /* i386 dec %ebp */
5048         case 0x4e:      /* i386 dec %esi */
5049         case 0x4f:      /* i386 dec %edi */
5050           if (ir.regmap[X86_RECORD_R8_REGNUM])  /* 64 bit target */
5051             {
5052                /* REX */
5053                rex_w = (opcode8 >> 3) & 1;
5054                rex_r = (opcode8 & 0x4) << 1;
5055                ir.rex_x = (opcode8 & 0x2) << 2;
5056                ir.rex_b = (opcode8 & 0x1) << 3;
5057             }
5058           else                                  /* 32 bit target */
5059             goto out_prefixes;
5060           break;
5061         default:
5062           goto out_prefixes;
5063           break;
5064         }
5065     }
5066  out_prefixes:
5067   if (ir.regmap[X86_RECORD_R8_REGNUM] && rex_w == 1)
5068     {
5069       ir.dflag = 2;
5070     }
5071   else
5072     {
5073       if (prefixes & PREFIX_DATA)
5074         ir.dflag ^= 1;
5075     }
5076   if (prefixes & PREFIX_ADDR)
5077     ir.aflag ^= 1;
5078   else if (ir.regmap[X86_RECORD_R8_REGNUM])
5079     ir.aflag = 2;
5080
5081   /* Now check op code.  */
5082   opcode = (uint32_t) opcode8;
5083  reswitch:
5084   switch (opcode)
5085     {
5086     case 0x0f:
5087       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
5088         return -1;
5089       ir.addr++;
5090       opcode = (uint32_t) opcode8 | 0x0f00;
5091       goto reswitch;
5092       break;
5093
5094     case 0x00:    /* arith & logic */
5095     case 0x01:
5096     case 0x02:
5097     case 0x03:
5098     case 0x04:
5099     case 0x05:
5100     case 0x08:
5101     case 0x09:
5102     case 0x0a:
5103     case 0x0b:
5104     case 0x0c:
5105     case 0x0d:
5106     case 0x10:
5107     case 0x11:
5108     case 0x12:
5109     case 0x13:
5110     case 0x14:
5111     case 0x15:
5112     case 0x18:
5113     case 0x19:
5114     case 0x1a:
5115     case 0x1b:
5116     case 0x1c:
5117     case 0x1d:
5118     case 0x20:
5119     case 0x21:
5120     case 0x22:
5121     case 0x23:
5122     case 0x24:
5123     case 0x25:
5124     case 0x28:
5125     case 0x29:
5126     case 0x2a:
5127     case 0x2b:
5128     case 0x2c:
5129     case 0x2d:
5130     case 0x30:
5131     case 0x31:
5132     case 0x32:
5133     case 0x33:
5134     case 0x34:
5135     case 0x35:
5136     case 0x38:
5137     case 0x39:
5138     case 0x3a:
5139     case 0x3b:
5140     case 0x3c:
5141     case 0x3d:
5142       if (((opcode >> 3) & 7) != OP_CMPL)
5143         {
5144           if ((opcode & 1) == 0)
5145             ir.ot = OT_BYTE;
5146           else
5147             ir.ot = ir.dflag + OT_WORD;
5148
5149           switch ((opcode >> 1) & 3)
5150             {
5151             case 0:    /* OP Ev, Gv */
5152               if (i386_record_modrm (&ir))
5153                 return -1;
5154               if (ir.mod != 3)
5155                 {
5156                   if (i386_record_lea_modrm (&ir))
5157                     return -1;
5158                 }
5159               else
5160                 {
5161                   ir.rm |= ir.rex_b;
5162                   if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5163                     ir.rm &= 0x3;
5164                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5165                 }
5166               break;
5167             case 1:    /* OP Gv, Ev */
5168               if (i386_record_modrm (&ir))
5169                 return -1;
5170               ir.reg |= rex_r;
5171               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5172                 ir.reg &= 0x3;
5173               I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5174               break;
5175             case 2:    /* OP A, Iv */
5176               I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5177               break;
5178             }
5179         }
5180       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5181       break;
5182
5183     case 0x80:    /* GRP1 */
5184     case 0x81:
5185     case 0x82:
5186     case 0x83:
5187       if (i386_record_modrm (&ir))
5188         return -1;
5189
5190       if (ir.reg != OP_CMPL)
5191         {
5192           if ((opcode & 1) == 0)
5193             ir.ot = OT_BYTE;
5194           else
5195             ir.ot = ir.dflag + OT_WORD;
5196
5197           if (ir.mod != 3)
5198             {
5199               if (opcode == 0x83)
5200                 ir.rip_offset = 1;
5201               else
5202                 ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
5203               if (i386_record_lea_modrm (&ir))
5204                 return -1;
5205             }
5206           else
5207             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5208         }
5209       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5210       break;
5211
5212     case 0x40:      /* inc */
5213     case 0x41:
5214     case 0x42:
5215     case 0x43:
5216     case 0x44:
5217     case 0x45:
5218     case 0x46:
5219     case 0x47:
5220
5221     case 0x48:      /* dec */
5222     case 0x49:
5223     case 0x4a:
5224     case 0x4b:
5225     case 0x4c:
5226     case 0x4d:
5227     case 0x4e:
5228     case 0x4f:
5229
5230       I386_RECORD_FULL_ARCH_LIST_ADD_REG (opcode & 7);
5231       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5232       break;
5233
5234     case 0xf6:    /* GRP3 */
5235     case 0xf7:
5236       if ((opcode & 1) == 0)
5237         ir.ot = OT_BYTE;
5238       else
5239         ir.ot = ir.dflag + OT_WORD;
5240       if (i386_record_modrm (&ir))
5241         return -1;
5242
5243       if (ir.mod != 3 && ir.reg == 0)
5244         ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
5245
5246       switch (ir.reg)
5247         {
5248         case 0:    /* test */
5249           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5250           break;
5251         case 2:    /* not */
5252         case 3:    /* neg */
5253           if (ir.mod != 3)
5254             {
5255               if (i386_record_lea_modrm (&ir))
5256                 return -1;
5257             }
5258           else
5259             {
5260               ir.rm |= ir.rex_b;
5261               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5262                 ir.rm &= 0x3;
5263               I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5264             }
5265           if (ir.reg == 3)  /* neg */
5266             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5267           break;
5268         case 4:    /* mul  */
5269         case 5:    /* imul */
5270         case 6:    /* div  */
5271         case 7:    /* idiv */
5272           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5273           if (ir.ot != OT_BYTE)
5274             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
5275           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5276           break;
5277         default:
5278           ir.addr -= 2;
5279           opcode = opcode << 8 | ir.modrm;
5280           goto no_support;
5281           break;
5282         }
5283       break;
5284
5285     case 0xfe:    /* GRP4 */
5286     case 0xff:    /* GRP5 */
5287       if (i386_record_modrm (&ir))
5288         return -1;
5289       if (ir.reg >= 2 && opcode == 0xfe)
5290         {
5291           ir.addr -= 2;
5292           opcode = opcode << 8 | ir.modrm;
5293           goto no_support;
5294         }
5295       switch (ir.reg)
5296         {
5297         case 0:    /* inc */
5298         case 1:    /* dec */
5299           if ((opcode & 1) == 0)
5300             ir.ot = OT_BYTE;
5301           else
5302             ir.ot = ir.dflag + OT_WORD;
5303           if (ir.mod != 3)
5304             {
5305               if (i386_record_lea_modrm (&ir))
5306                 return -1;
5307             }
5308           else
5309             {
5310               ir.rm |= ir.rex_b;
5311               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5312                 ir.rm &= 0x3;
5313               I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5314             }
5315           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5316           break;
5317         case 2:    /* call */
5318           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
5319             ir.dflag = 2;
5320           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5321             return -1;
5322           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5323           break;
5324         case 3:    /* lcall */
5325           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
5326           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5327             return -1;
5328           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5329           break;
5330         case 4:    /* jmp  */
5331         case 5:    /* ljmp */
5332           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5333           break;
5334         case 6:    /* push */
5335           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
5336             ir.dflag = 2;
5337           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5338             return -1;
5339           break;
5340         default:
5341           ir.addr -= 2;
5342           opcode = opcode << 8 | ir.modrm;
5343           goto no_support;
5344           break;
5345         }
5346       break;
5347
5348     case 0x84:    /* test */
5349     case 0x85:
5350     case 0xa8:
5351     case 0xa9:
5352       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5353       break;
5354
5355     case 0x98:    /* CWDE/CBW */
5356       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5357       break;
5358
5359     case 0x99:    /* CDQ/CWD */
5360       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5361       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
5362       break;
5363
5364     case 0x0faf:  /* imul */
5365     case 0x69:
5366     case 0x6b:
5367       ir.ot = ir.dflag + OT_WORD;
5368       if (i386_record_modrm (&ir))
5369         return -1;
5370       if (opcode == 0x69)
5371         ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
5372       else if (opcode == 0x6b)
5373         ir.rip_offset = 1;
5374       ir.reg |= rex_r;
5375       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5376         ir.reg &= 0x3;
5377       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5378       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5379       break;
5380
5381     case 0x0fc0:  /* xadd */
5382     case 0x0fc1:
5383       if ((opcode & 1) == 0)
5384         ir.ot = OT_BYTE;
5385       else
5386         ir.ot = ir.dflag + OT_WORD;
5387       if (i386_record_modrm (&ir))
5388         return -1;
5389       ir.reg |= rex_r;
5390       if (ir.mod == 3)
5391         {
5392           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5393             ir.reg &= 0x3;
5394           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5395           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5396             ir.rm &= 0x3;
5397           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5398         }
5399       else
5400         {
5401           if (i386_record_lea_modrm (&ir))
5402             return -1;
5403           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5404             ir.reg &= 0x3;
5405           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5406         }
5407       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5408       break;
5409
5410     case 0x0fb0:  /* cmpxchg */
5411     case 0x0fb1:
5412       if ((opcode & 1) == 0)
5413         ir.ot = OT_BYTE;
5414       else
5415         ir.ot = ir.dflag + OT_WORD;
5416       if (i386_record_modrm (&ir))
5417         return -1;
5418       if (ir.mod == 3)
5419         {
5420           ir.reg |= rex_r;
5421           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5422           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5423             ir.reg &= 0x3;
5424           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5425         }
5426       else
5427         {
5428           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5429           if (i386_record_lea_modrm (&ir))
5430             return -1;
5431         }
5432       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5433       break;
5434
5435     case 0x0fc7:    /* cmpxchg8b */
5436       if (i386_record_modrm (&ir))
5437         return -1;
5438       if (ir.mod == 3)
5439         {
5440           ir.addr -= 2;
5441           opcode = opcode << 8 | ir.modrm;
5442           goto no_support;
5443         }
5444       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5445       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
5446       if (i386_record_lea_modrm (&ir))
5447         return -1;
5448       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5449       break;
5450
5451     case 0x50:    /* push */
5452     case 0x51:
5453     case 0x52:
5454     case 0x53:
5455     case 0x54:
5456     case 0x55:
5457     case 0x56:
5458     case 0x57:
5459     case 0x68:
5460     case 0x6a:
5461       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
5462         ir.dflag = 2;
5463       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5464         return -1;
5465       break;
5466
5467     case 0x06:    /* push es */
5468     case 0x0e:    /* push cs */
5469     case 0x16:    /* push ss */
5470     case 0x1e:    /* push ds */
5471       if (ir.regmap[X86_RECORD_R8_REGNUM])
5472         {
5473           ir.addr -= 1;
5474           goto no_support;
5475         }
5476       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5477         return -1;
5478       break;
5479
5480     case 0x0fa0:    /* push fs */
5481     case 0x0fa8:    /* push gs */
5482       if (ir.regmap[X86_RECORD_R8_REGNUM])
5483         {
5484           ir.addr -= 2;
5485           goto no_support;
5486         }
5487       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5488         return -1;
5489       break;
5490
5491     case 0x60:    /* pusha */
5492       if (ir.regmap[X86_RECORD_R8_REGNUM])
5493         {
5494           ir.addr -= 1;
5495           goto no_support;
5496         }
5497       if (i386_record_push (&ir, 1 << (ir.dflag + 4)))
5498         return -1;
5499       break;
5500
5501     case 0x58:    /* pop */
5502     case 0x59:
5503     case 0x5a:
5504     case 0x5b:
5505     case 0x5c:
5506     case 0x5d:
5507     case 0x5e:
5508     case 0x5f:
5509       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5510       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
5511       break;
5512
5513     case 0x61:    /* popa */
5514       if (ir.regmap[X86_RECORD_R8_REGNUM])
5515         {
5516           ir.addr -= 1;
5517           goto no_support;
5518         }
5519       for (regnum = X86_RECORD_REAX_REGNUM;
5520            regnum <= X86_RECORD_REDI_REGNUM;
5521            regnum++)
5522         I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
5523       break;
5524
5525     case 0x8f:    /* pop */
5526       if (ir.regmap[X86_RECORD_R8_REGNUM])
5527         ir.ot = ir.dflag ? OT_QUAD : OT_WORD;
5528       else
5529         ir.ot = ir.dflag + OT_WORD;
5530       if (i386_record_modrm (&ir))
5531         return -1;
5532       if (ir.mod == 3)
5533         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5534       else
5535         {
5536           ir.popl_esp_hack = 1 << ir.ot;
5537           if (i386_record_lea_modrm (&ir))
5538             return -1;
5539         }
5540       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5541       break;
5542
5543     case 0xc8:    /* enter */
5544       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
5545       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
5546         ir.dflag = 2;
5547       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5548         return -1;
5549       break;
5550
5551     case 0xc9:    /* leave */
5552       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5553       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
5554       break;
5555
5556     case 0x07:    /* pop es */
5557       if (ir.regmap[X86_RECORD_R8_REGNUM])
5558         {
5559           ir.addr -= 1;
5560           goto no_support;
5561         }
5562       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5563       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_ES_REGNUM);
5564       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5565       break;
5566
5567     case 0x17:    /* pop ss */
5568       if (ir.regmap[X86_RECORD_R8_REGNUM])
5569         {
5570           ir.addr -= 1;
5571           goto no_support;
5572         }
5573       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5574       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_SS_REGNUM);
5575       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5576       break;
5577
5578     case 0x1f:    /* pop ds */
5579       if (ir.regmap[X86_RECORD_R8_REGNUM])
5580         {
5581           ir.addr -= 1;
5582           goto no_support;
5583         }
5584       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5585       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_DS_REGNUM);
5586       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5587       break;
5588
5589     case 0x0fa1:    /* pop fs */
5590       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5591       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_FS_REGNUM);
5592       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5593       break;
5594
5595     case 0x0fa9:    /* pop gs */
5596       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5597       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
5598       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5599       break;
5600
5601     case 0x88:    /* mov */
5602     case 0x89:
5603     case 0xc6:
5604     case 0xc7:
5605       if ((opcode & 1) == 0)
5606         ir.ot = OT_BYTE;
5607       else
5608         ir.ot = ir.dflag + OT_WORD;
5609
5610       if (i386_record_modrm (&ir))
5611         return -1;
5612
5613       if (ir.mod != 3)
5614         {
5615           if (opcode == 0xc6 || opcode == 0xc7)
5616             ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
5617           if (i386_record_lea_modrm (&ir))
5618             return -1;
5619         }
5620       else
5621         {
5622           if (opcode == 0xc6 || opcode == 0xc7)
5623             ir.rm |= ir.rex_b;
5624           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5625             ir.rm &= 0x3;
5626           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5627         }
5628       break;
5629
5630     case 0x8a:    /* mov */
5631     case 0x8b:
5632       if ((opcode & 1) == 0)
5633         ir.ot = OT_BYTE;
5634       else
5635         ir.ot = ir.dflag + OT_WORD;
5636       if (i386_record_modrm (&ir))
5637         return -1;
5638       ir.reg |= rex_r;
5639       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5640         ir.reg &= 0x3;
5641       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5642       break;
5643
5644     case 0x8c:    /* mov seg */
5645       if (i386_record_modrm (&ir))
5646         return -1;
5647       if (ir.reg > 5)
5648         {
5649           ir.addr -= 2;
5650           opcode = opcode << 8 | ir.modrm;
5651           goto no_support;
5652         }
5653
5654       if (ir.mod == 3)
5655         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5656       else
5657         {
5658           ir.ot = OT_WORD;
5659           if (i386_record_lea_modrm (&ir))
5660             return -1;
5661         }
5662       break;
5663
5664     case 0x8e:    /* mov seg */
5665       if (i386_record_modrm (&ir))
5666         return -1;
5667       switch (ir.reg)
5668         {
5669         case 0:
5670           regnum = X86_RECORD_ES_REGNUM;
5671           break;
5672         case 2:
5673           regnum = X86_RECORD_SS_REGNUM;
5674           break;
5675         case 3:
5676           regnum = X86_RECORD_DS_REGNUM;
5677           break;
5678         case 4:
5679           regnum = X86_RECORD_FS_REGNUM;
5680           break;
5681         case 5:
5682           regnum = X86_RECORD_GS_REGNUM;
5683           break;
5684         default:
5685           ir.addr -= 2;
5686           opcode = opcode << 8 | ir.modrm;
5687           goto no_support;
5688           break;
5689         }
5690       I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
5691       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5692       break;
5693
5694     case 0x0fb6:    /* movzbS */
5695     case 0x0fb7:    /* movzwS */
5696     case 0x0fbe:    /* movsbS */
5697     case 0x0fbf:    /* movswS */
5698       if (i386_record_modrm (&ir))
5699         return -1;
5700       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
5701       break;
5702
5703     case 0x8d:      /* lea */
5704       if (i386_record_modrm (&ir))
5705         return -1;
5706       if (ir.mod == 3)
5707         {
5708           ir.addr -= 2;
5709           opcode = opcode << 8 | ir.modrm;
5710           goto no_support;
5711         }
5712       ir.ot = ir.dflag;
5713       ir.reg |= rex_r;
5714       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5715         ir.reg &= 0x3;
5716       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5717       break;
5718
5719     case 0xa0:    /* mov EAX */
5720     case 0xa1:
5721
5722     case 0xd7:    /* xlat */
5723       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5724       break;
5725
5726     case 0xa2:    /* mov EAX */
5727     case 0xa3:
5728       if (ir.override >= 0)
5729         {
5730           if (record_full_memory_query)
5731             {
5732               int q;
5733
5734               target_terminal_ours ();
5735               q = yquery (_("\
5736 Process record ignores the memory change of instruction at address %s\n\
5737 because it can't get the value of the segment register.\n\
5738 Do you want to stop the program?"),
5739                           paddress (gdbarch, ir.orig_addr));
5740               target_terminal_inferior ();
5741               if (q)
5742                 return -1;
5743             }
5744         }
5745       else
5746         {
5747           if ((opcode & 1) == 0)
5748             ir.ot = OT_BYTE;
5749           else
5750             ir.ot = ir.dflag + OT_WORD;
5751           if (ir.aflag == 2)
5752             {
5753               if (record_read_memory (gdbarch, ir.addr, buf, 8))
5754                 return -1;
5755               ir.addr += 8;
5756               addr = extract_unsigned_integer (buf, 8, byte_order);
5757             }
5758           else if (ir.aflag)
5759             {
5760               if (record_read_memory (gdbarch, ir.addr, buf, 4))
5761                 return -1;
5762               ir.addr += 4;
5763               addr = extract_unsigned_integer (buf, 4, byte_order);
5764             }
5765           else
5766             {
5767               if (record_read_memory (gdbarch, ir.addr, buf, 2))
5768                 return -1;
5769               ir.addr += 2;
5770               addr = extract_unsigned_integer (buf, 2, byte_order);
5771             }
5772           if (record_full_arch_list_add_mem (addr, 1 << ir.ot))
5773             return -1;
5774         }
5775       break;
5776
5777     case 0xb0:    /* mov R, Ib */
5778     case 0xb1:
5779     case 0xb2:
5780     case 0xb3:
5781     case 0xb4:
5782     case 0xb5:
5783     case 0xb6:
5784     case 0xb7:
5785       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((ir.regmap[X86_RECORD_R8_REGNUM])
5786                                           ? ((opcode & 0x7) | ir.rex_b)
5787                                           : ((opcode & 0x7) & 0x3));
5788       break;
5789
5790     case 0xb8:    /* mov R, Iv */
5791     case 0xb9:
5792     case 0xba:
5793     case 0xbb:
5794     case 0xbc:
5795     case 0xbd:
5796     case 0xbe:
5797     case 0xbf:
5798       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
5799       break;
5800
5801     case 0x91:    /* xchg R, EAX */
5802     case 0x92:
5803     case 0x93:
5804     case 0x94:
5805     case 0x95:
5806     case 0x96:
5807     case 0x97:
5808       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5809       I386_RECORD_FULL_ARCH_LIST_ADD_REG (opcode & 0x7);
5810       break;
5811
5812     case 0x86:    /* xchg Ev, Gv */
5813     case 0x87:
5814       if ((opcode & 1) == 0)
5815         ir.ot = OT_BYTE;
5816       else
5817         ir.ot = ir.dflag + OT_WORD;
5818       if (i386_record_modrm (&ir))
5819         return -1;
5820       if (ir.mod == 3)
5821         {
5822           ir.rm |= ir.rex_b;
5823           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5824             ir.rm &= 0x3;
5825           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5826         }
5827       else
5828         {
5829           if (i386_record_lea_modrm (&ir))
5830             return -1;
5831         }
5832       ir.reg |= rex_r;
5833       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5834         ir.reg &= 0x3;
5835       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5836       break;
5837
5838     case 0xc4:    /* les Gv */
5839     case 0xc5:    /* lds Gv */
5840       if (ir.regmap[X86_RECORD_R8_REGNUM])
5841         {
5842           ir.addr -= 1;
5843           goto no_support;
5844         }
5845       /* FALLTHROUGH */
5846     case 0x0fb2:    /* lss Gv */
5847     case 0x0fb4:    /* lfs Gv */
5848     case 0x0fb5:    /* lgs Gv */
5849       if (i386_record_modrm (&ir))
5850         return -1;
5851       if (ir.mod == 3)
5852         {
5853           if (opcode > 0xff)
5854             ir.addr -= 3;
5855           else
5856             ir.addr -= 2;
5857           opcode = opcode << 8 | ir.modrm;
5858           goto no_support;
5859         }
5860       switch (opcode)
5861         {
5862         case 0xc4:    /* les Gv */
5863           regnum = X86_RECORD_ES_REGNUM;
5864           break;
5865         case 0xc5:    /* lds Gv */
5866           regnum = X86_RECORD_DS_REGNUM;
5867           break;
5868         case 0x0fb2:  /* lss Gv */
5869           regnum = X86_RECORD_SS_REGNUM;
5870           break;
5871         case 0x0fb4:  /* lfs Gv */
5872           regnum = X86_RECORD_FS_REGNUM;
5873           break;
5874         case 0x0fb5:  /* lgs Gv */
5875           regnum = X86_RECORD_GS_REGNUM;
5876           break;
5877         }
5878       I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
5879       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
5880       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5881       break;
5882
5883     case 0xc0:    /* shifts */
5884     case 0xc1:
5885     case 0xd0:
5886     case 0xd1:
5887     case 0xd2:
5888     case 0xd3:
5889       if ((opcode & 1) == 0)
5890         ir.ot = OT_BYTE;
5891       else
5892         ir.ot = ir.dflag + OT_WORD;
5893       if (i386_record_modrm (&ir))
5894         return -1;
5895       if (ir.mod != 3 && (opcode == 0xd2 || opcode == 0xd3))
5896         {
5897           if (i386_record_lea_modrm (&ir))
5898             return -1;
5899         }
5900       else
5901         {
5902           ir.rm |= ir.rex_b;
5903           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5904             ir.rm &= 0x3;
5905           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5906         }
5907       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5908       break;
5909
5910     case 0x0fa4:
5911     case 0x0fa5:
5912     case 0x0fac:
5913     case 0x0fad:
5914       if (i386_record_modrm (&ir))
5915         return -1;
5916       if (ir.mod == 3)
5917         {
5918           if (record_full_arch_list_add_reg (ir.regcache, ir.rm))
5919             return -1;
5920         }
5921       else
5922         {
5923           if (i386_record_lea_modrm (&ir))
5924             return -1;
5925         }
5926       break;
5927
5928     case 0xd8:    /* Floats.  */
5929     case 0xd9:
5930     case 0xda:
5931     case 0xdb:
5932     case 0xdc:
5933     case 0xdd:
5934     case 0xde:
5935     case 0xdf:
5936       if (i386_record_modrm (&ir))
5937         return -1;
5938       ir.reg |= ((opcode & 7) << 3);
5939       if (ir.mod != 3)
5940         {
5941           /* Memory.  */
5942           uint64_t addr64;
5943
5944           if (i386_record_lea_modrm_addr (&ir, &addr64))
5945             return -1;
5946           switch (ir.reg)
5947             {
5948             case 0x02:
5949             case 0x12:
5950             case 0x22:
5951             case 0x32:
5952               /* For fcom, ficom nothing to do.  */
5953               break;
5954             case 0x03:
5955             case 0x13:
5956             case 0x23:
5957             case 0x33:
5958               /* For fcomp, ficomp pop FPU stack, store all.  */
5959               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5960                 return -1;
5961               break;
5962             case 0x00:
5963             case 0x01:
5964             case 0x04:
5965             case 0x05:
5966             case 0x06:
5967             case 0x07:
5968             case 0x10:
5969             case 0x11:
5970             case 0x14:
5971             case 0x15:
5972             case 0x16:
5973             case 0x17:
5974             case 0x20:
5975             case 0x21:
5976             case 0x24:
5977             case 0x25:
5978             case 0x26:
5979             case 0x27:
5980             case 0x30:
5981             case 0x31:
5982             case 0x34:
5983             case 0x35:
5984             case 0x36:
5985             case 0x37:
5986               /* For fadd, fmul, fsub, fsubr, fdiv, fdivr, fiadd, fimul,
5987                  fisub, fisubr, fidiv, fidivr, modR/M.reg is an extension
5988                  of code,  always affects st(0) register.  */
5989               if (i386_record_floats (gdbarch, &ir, I387_ST0_REGNUM (tdep)))
5990                 return -1;
5991               break;
5992             case 0x08:
5993             case 0x0a:
5994             case 0x0b:
5995             case 0x18:
5996             case 0x19:
5997             case 0x1a:
5998             case 0x1b:
5999             case 0x1d:
6000             case 0x28:
6001             case 0x29:
6002             case 0x2a:
6003             case 0x2b:
6004             case 0x38:
6005             case 0x39:
6006             case 0x3a:
6007             case 0x3b:
6008             case 0x3c:
6009             case 0x3d:
6010               switch (ir.reg & 7)
6011                 {
6012                 case 0:
6013                   /* Handling fld, fild.  */
6014                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
6015                     return -1;
6016                   break;
6017                 case 1:
6018                   switch (ir.reg >> 4)
6019                     {
6020                     case 0:
6021                       if (record_full_arch_list_add_mem (addr64, 4))
6022                         return -1;
6023                       break;
6024                     case 2:
6025                       if (record_full_arch_list_add_mem (addr64, 8))
6026                         return -1;
6027                       break;
6028                     case 3:
6029                       break;
6030                     default:
6031                       if (record_full_arch_list_add_mem (addr64, 2))
6032                         return -1;
6033                       break;
6034                     }
6035                   break;
6036                 default:
6037                   switch (ir.reg >> 4)
6038                     {
6039                     case 0:
6040                       if (record_full_arch_list_add_mem (addr64, 4))
6041                         return -1;
6042                       if (3 == (ir.reg & 7))
6043                         {
6044                           /* For fstp m32fp.  */
6045                           if (i386_record_floats (gdbarch, &ir,
6046                                                   I386_SAVE_FPU_REGS))
6047                             return -1;
6048                         }
6049                       break;
6050                     case 1:
6051                       if (record_full_arch_list_add_mem (addr64, 4))
6052                         return -1;
6053                       if ((3 == (ir.reg & 7))
6054                           || (5 == (ir.reg & 7))
6055                           || (7 == (ir.reg & 7)))
6056                         {
6057                           /* For fstp insn.  */
6058                           if (i386_record_floats (gdbarch, &ir,
6059                                                   I386_SAVE_FPU_REGS))
6060                             return -1;
6061                         }
6062                       break;
6063                     case 2:
6064                       if (record_full_arch_list_add_mem (addr64, 8))
6065                         return -1;
6066                       if (3 == (ir.reg & 7))
6067                         {
6068                           /* For fstp m64fp.  */
6069                           if (i386_record_floats (gdbarch, &ir,
6070                                                   I386_SAVE_FPU_REGS))
6071                             return -1;
6072                         }
6073                       break;
6074                     case 3:
6075                       if ((3 <= (ir.reg & 7)) && (6 <= (ir.reg & 7)))
6076                         {
6077                           /* For fistp, fbld, fild, fbstp.  */
6078                           if (i386_record_floats (gdbarch, &ir,
6079                                                   I386_SAVE_FPU_REGS))
6080                             return -1;
6081                         }
6082                       /* Fall through */
6083                     default:
6084                       if (record_full_arch_list_add_mem (addr64, 2))
6085                         return -1;
6086                       break;
6087                     }
6088                   break;
6089                 }
6090               break;
6091             case 0x0c:
6092               /* Insn fldenv.  */
6093               if (i386_record_floats (gdbarch, &ir,
6094                                       I386_SAVE_FPU_ENV_REG_STACK))
6095                 return -1;
6096               break;
6097             case 0x0d:
6098               /* Insn fldcw.  */
6099               if (i386_record_floats (gdbarch, &ir, I387_FCTRL_REGNUM (tdep)))
6100                 return -1;
6101               break;
6102             case 0x2c:
6103               /* Insn frstor.  */
6104               if (i386_record_floats (gdbarch, &ir,
6105                                       I386_SAVE_FPU_ENV_REG_STACK))
6106                 return -1;
6107               break;
6108             case 0x0e:
6109               if (ir.dflag)
6110                 {
6111                   if (record_full_arch_list_add_mem (addr64, 28))
6112                     return -1;
6113                 }
6114               else
6115                 {
6116                   if (record_full_arch_list_add_mem (addr64, 14))
6117                     return -1;
6118                 }
6119               break;
6120             case 0x0f:
6121             case 0x2f:
6122               if (record_full_arch_list_add_mem (addr64, 2))
6123                 return -1;
6124               /* Insn fstp, fbstp.  */
6125               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
6126                 return -1;
6127               break;
6128             case 0x1f:
6129             case 0x3e:
6130               if (record_full_arch_list_add_mem (addr64, 10))
6131                 return -1;
6132               break;
6133             case 0x2e:
6134               if (ir.dflag)
6135                 {
6136                   if (record_full_arch_list_add_mem (addr64, 28))
6137                     return -1;
6138                   addr64 += 28;
6139                 }
6140               else
6141                 {
6142                   if (record_full_arch_list_add_mem (addr64, 14))
6143                     return -1;
6144                   addr64 += 14;
6145                 }
6146               if (record_full_arch_list_add_mem (addr64, 80))
6147                 return -1;
6148               /* Insn fsave.  */
6149               if (i386_record_floats (gdbarch, &ir,
6150                                       I386_SAVE_FPU_ENV_REG_STACK))
6151                 return -1;
6152               break;
6153             case 0x3f:
6154               if (record_full_arch_list_add_mem (addr64, 8))
6155                 return -1;
6156               /* Insn fistp.  */
6157               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
6158                 return -1;
6159               break;
6160             default:
6161               ir.addr -= 2;
6162               opcode = opcode << 8 | ir.modrm;
6163               goto no_support;
6164               break;
6165             }
6166         }
6167       /* Opcode is an extension of modR/M byte.  */
6168       else
6169         {
6170           switch (opcode)
6171             {
6172             case 0xd8:
6173               if (i386_record_floats (gdbarch, &ir, I387_ST0_REGNUM (tdep)))
6174                 return -1;
6175               break;
6176             case 0xd9:
6177               if (0x0c == (ir.modrm >> 4))
6178                 {
6179                   if ((ir.modrm & 0x0f) <= 7)
6180                     {
6181                       if (i386_record_floats (gdbarch, &ir,
6182                                               I386_SAVE_FPU_REGS))
6183                         return -1;
6184                     }
6185                   else
6186                     {
6187                       if (i386_record_floats (gdbarch, &ir,
6188                                               I387_ST0_REGNUM (tdep)))
6189                         return -1;
6190                       /* If only st(0) is changing, then we have already
6191                          recorded.  */
6192                       if ((ir.modrm & 0x0f) - 0x08)
6193                         {
6194                           if (i386_record_floats (gdbarch, &ir,
6195                                                   I387_ST0_REGNUM (tdep) +
6196                                                   ((ir.modrm & 0x0f) - 0x08)))
6197                             return -1;
6198                         }
6199                     }
6200                 }
6201               else
6202                 {
6203                   switch (ir.modrm)
6204                     {
6205                     case 0xe0:
6206                     case 0xe1:
6207                     case 0xf0:
6208                     case 0xf5:
6209                     case 0xf8:
6210                     case 0xfa:
6211                     case 0xfc:
6212                     case 0xfe:
6213                     case 0xff:
6214                       if (i386_record_floats (gdbarch, &ir,
6215                                               I387_ST0_REGNUM (tdep)))
6216                         return -1;
6217                       break;
6218                     case 0xf1:
6219                     case 0xf2:
6220                     case 0xf3:
6221                     case 0xf4:
6222                     case 0xf6:
6223                     case 0xf7:
6224                     case 0xe8:
6225                     case 0xe9:
6226                     case 0xea:
6227                     case 0xeb:
6228                     case 0xec:
6229                     case 0xed:
6230                     case 0xee:
6231                     case 0xf9:
6232                     case 0xfb:
6233                       if (i386_record_floats (gdbarch, &ir,
6234                                               I386_SAVE_FPU_REGS))
6235                         return -1;
6236                       break;
6237                     case 0xfd:
6238                       if (i386_record_floats (gdbarch, &ir,
6239                                               I387_ST0_REGNUM (tdep)))
6240                         return -1;
6241                       if (i386_record_floats (gdbarch, &ir,
6242                                               I387_ST0_REGNUM (tdep) + 1))
6243                         return -1;
6244                       break;
6245                     }
6246                 }
6247               break;
6248             case 0xda:
6249               if (0xe9 == ir.modrm)
6250                 {
6251                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
6252                     return -1;
6253                 }
6254               else if ((0x0c == ir.modrm >> 4) || (0x0d == ir.modrm >> 4))
6255                 {
6256                   if (i386_record_floats (gdbarch, &ir,
6257                                           I387_ST0_REGNUM (tdep)))
6258                     return -1;
6259                   if (((ir.modrm & 0x0f) > 0) && ((ir.modrm & 0x0f) <= 7))
6260                     {
6261                       if (i386_record_floats (gdbarch, &ir,
6262                                               I387_ST0_REGNUM (tdep) +
6263                                               (ir.modrm & 0x0f)))
6264                         return -1;
6265                     }
6266                   else if ((ir.modrm & 0x0f) - 0x08)
6267                     {
6268                       if (i386_record_floats (gdbarch, &ir,
6269                                               I387_ST0_REGNUM (tdep) +
6270                                               ((ir.modrm & 0x0f) - 0x08)))
6271                         return -1;
6272                     }
6273                 }
6274               break;
6275             case 0xdb:
6276               if (0xe3 == ir.modrm)
6277                 {
6278                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_ENV))
6279                     return -1;
6280                 }
6281               else if ((0x0c == ir.modrm >> 4) || (0x0d == ir.modrm >> 4))
6282                 {
6283                   if (i386_record_floats (gdbarch, &ir,
6284                                           I387_ST0_REGNUM (tdep)))
6285                     return -1;
6286                   if (((ir.modrm & 0x0f) > 0) && ((ir.modrm & 0x0f) <= 7))
6287                     {
6288                       if (i386_record_floats (gdbarch, &ir,
6289                                               I387_ST0_REGNUM (tdep) +
6290                                               (ir.modrm & 0x0f)))
6291                         return -1;
6292                     }
6293                   else if ((ir.modrm & 0x0f) - 0x08)
6294                     {
6295                       if (i386_record_floats (gdbarch, &ir,
6296                                               I387_ST0_REGNUM (tdep) +
6297                                               ((ir.modrm & 0x0f) - 0x08)))
6298                         return -1;
6299                     }
6300                 }
6301               break;
6302             case 0xdc:
6303               if ((0x0c == ir.modrm >> 4)
6304                   || (0x0d == ir.modrm >> 4)
6305                   || (0x0f == ir.modrm >> 4))
6306                 {
6307                   if ((ir.modrm & 0x0f) <= 7)
6308                     {
6309                       if (i386_record_floats (gdbarch, &ir,
6310                                               I387_ST0_REGNUM (tdep) +
6311                                               (ir.modrm & 0x0f)))
6312                         return -1;
6313                     }
6314                   else
6315                     {
6316                       if (i386_record_floats (gdbarch, &ir,
6317                                               I387_ST0_REGNUM (tdep) +
6318                                               ((ir.modrm & 0x0f) - 0x08)))
6319                         return -1;
6320                     }
6321                 }
6322               break;
6323             case 0xdd:
6324               if (0x0c == ir.modrm >> 4)
6325                 {
6326                   if (i386_record_floats (gdbarch, &ir,
6327                                           I387_FTAG_REGNUM (tdep)))
6328                     return -1;
6329                 }
6330               else if ((0x0d == ir.modrm >> 4) || (0x0e == ir.modrm >> 4))
6331                 {
6332                   if ((ir.modrm & 0x0f) <= 7)
6333                     {
6334                       if (i386_record_floats (gdbarch, &ir,
6335                                               I387_ST0_REGNUM (tdep) +
6336                                               (ir.modrm & 0x0f)))
6337                         return -1;
6338                     }
6339                   else
6340                     {
6341                       if (i386_record_floats (gdbarch, &ir,
6342                                               I386_SAVE_FPU_REGS))
6343                         return -1;
6344                     }
6345                 }
6346               break;
6347             case 0xde:
6348               if ((0x0c == ir.modrm >> 4)
6349                   || (0x0e == ir.modrm >> 4)
6350                   || (0x0f == ir.modrm >> 4)
6351                   || (0xd9 == ir.modrm))
6352                 {
6353                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
6354                     return -1;
6355                 }
6356               break;
6357             case 0xdf:
6358               if (0xe0 == ir.modrm)
6359                 {
6360                   if (record_full_arch_list_add_reg (ir.regcache,
6361                                                      I386_EAX_REGNUM))
6362                     return -1;
6363                 }
6364               else if ((0x0f == ir.modrm >> 4) || (0x0e == ir.modrm >> 4))
6365                 {
6366                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
6367                     return -1;
6368                 }
6369               break;
6370             }
6371         }
6372       break;
6373       /* string ops */
6374     case 0xa4:    /* movsS */
6375     case 0xa5:
6376     case 0xaa:    /* stosS */
6377     case 0xab:
6378     case 0x6c:    /* insS */
6379     case 0x6d:
6380       regcache_raw_read_unsigned (ir.regcache,
6381                                   ir.regmap[X86_RECORD_RECX_REGNUM],
6382                                   &addr);
6383       if (addr)
6384         {
6385           ULONGEST es, ds;
6386
6387           if ((opcode & 1) == 0)
6388             ir.ot = OT_BYTE;
6389           else
6390             ir.ot = ir.dflag + OT_WORD;
6391           regcache_raw_read_unsigned (ir.regcache,
6392                                       ir.regmap[X86_RECORD_REDI_REGNUM],
6393                                       &addr);
6394
6395           regcache_raw_read_unsigned (ir.regcache,
6396                                       ir.regmap[X86_RECORD_ES_REGNUM],
6397                                       &es);
6398           regcache_raw_read_unsigned (ir.regcache,
6399                                       ir.regmap[X86_RECORD_DS_REGNUM],
6400                                       &ds);
6401           if (ir.aflag && (es != ds))
6402             {
6403               /* addr += ((uint32_t) read_register (I386_ES_REGNUM)) << 4; */
6404               if (record_full_memory_query)
6405                 {
6406                   int q;
6407
6408                   target_terminal_ours ();
6409                   q = yquery (_("\
6410 Process record ignores the memory change of instruction at address %s\n\
6411 because it can't get the value of the segment register.\n\
6412 Do you want to stop the program?"),
6413                               paddress (gdbarch, ir.orig_addr));
6414                   target_terminal_inferior ();
6415                   if (q)
6416                     return -1;
6417                 }
6418             }
6419           else
6420             {
6421               if (record_full_arch_list_add_mem (addr, 1 << ir.ot))
6422                 return -1;
6423             }
6424
6425           if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6426             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6427           if (opcode == 0xa4 || opcode == 0xa5)
6428             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6429           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
6430           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6431         }
6432       break;
6433
6434     case 0xa6:    /* cmpsS */
6435     case 0xa7:
6436       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
6437       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6438       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6439         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6440       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6441       break;
6442
6443     case 0xac:    /* lodsS */
6444     case 0xad:
6445       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6446       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6447       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6448         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6449       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6450       break;
6451
6452     case 0xae:    /* scasS */
6453     case 0xaf:
6454       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
6455       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6456         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6457       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6458       break;
6459
6460     case 0x6e:    /* outsS */
6461     case 0x6f:
6462       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6463       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6464         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6465       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6466       break;
6467
6468     case 0xe4:    /* port I/O */
6469     case 0xe5:
6470     case 0xec:
6471     case 0xed:
6472       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6473       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6474       break;
6475
6476     case 0xe6:
6477     case 0xe7:
6478     case 0xee:
6479     case 0xef:
6480       break;
6481
6482       /* control */
6483     case 0xc2:    /* ret im */
6484     case 0xc3:    /* ret */
6485       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
6486       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6487       break;
6488
6489     case 0xca:    /* lret im */
6490     case 0xcb:    /* lret */
6491     case 0xcf:    /* iret */
6492       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
6493       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
6494       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6495       break;
6496
6497     case 0xe8:    /* call im */
6498       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
6499         ir.dflag = 2;
6500       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
6501         return -1;
6502       break;
6503
6504     case 0x9a:    /* lcall im */
6505       if (ir.regmap[X86_RECORD_R8_REGNUM])
6506         {
6507           ir.addr -= 1;
6508           goto no_support;
6509         }
6510       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
6511       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
6512         return -1;
6513       break;
6514
6515     case 0xe9:    /* jmp im */
6516     case 0xea:    /* ljmp im */
6517     case 0xeb:    /* jmp Jb */
6518     case 0x70:    /* jcc Jb */
6519     case 0x71:
6520     case 0x72:
6521     case 0x73:
6522     case 0x74:
6523     case 0x75:
6524     case 0x76:
6525     case 0x77:
6526     case 0x78:
6527     case 0x79:
6528     case 0x7a:
6529     case 0x7b:
6530     case 0x7c:
6531     case 0x7d:
6532     case 0x7e:
6533     case 0x7f:
6534     case 0x0f80:  /* jcc Jv */
6535     case 0x0f81:
6536     case 0x0f82:
6537     case 0x0f83:
6538     case 0x0f84:
6539     case 0x0f85:
6540     case 0x0f86:
6541     case 0x0f87:
6542     case 0x0f88:
6543     case 0x0f89:
6544     case 0x0f8a:
6545     case 0x0f8b:
6546     case 0x0f8c:
6547     case 0x0f8d:
6548     case 0x0f8e:
6549     case 0x0f8f:
6550       break;
6551
6552     case 0x0f90:  /* setcc Gv */
6553     case 0x0f91:
6554     case 0x0f92:
6555     case 0x0f93:
6556     case 0x0f94:
6557     case 0x0f95:
6558     case 0x0f96:
6559     case 0x0f97:
6560     case 0x0f98:
6561     case 0x0f99:
6562     case 0x0f9a:
6563     case 0x0f9b:
6564     case 0x0f9c:
6565     case 0x0f9d:
6566     case 0x0f9e:
6567     case 0x0f9f:
6568       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6569       ir.ot = OT_BYTE;
6570       if (i386_record_modrm (&ir))
6571         return -1;
6572       if (ir.mod == 3)
6573         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rex_b ? (ir.rm | ir.rex_b)
6574                                             : (ir.rm & 0x3));
6575       else
6576         {
6577           if (i386_record_lea_modrm (&ir))
6578             return -1;
6579         }
6580       break;
6581
6582     case 0x0f40:    /* cmov Gv, Ev */
6583     case 0x0f41:
6584     case 0x0f42:
6585     case 0x0f43:
6586     case 0x0f44:
6587     case 0x0f45:
6588     case 0x0f46:
6589     case 0x0f47:
6590     case 0x0f48:
6591     case 0x0f49:
6592     case 0x0f4a:
6593     case 0x0f4b:
6594     case 0x0f4c:
6595     case 0x0f4d:
6596     case 0x0f4e:
6597     case 0x0f4f:
6598       if (i386_record_modrm (&ir))
6599         return -1;
6600       ir.reg |= rex_r;
6601       if (ir.dflag == OT_BYTE)
6602         ir.reg &= 0x3;
6603       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
6604       break;
6605
6606       /* flags */
6607     case 0x9c:    /* pushf */
6608       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6609       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
6610         ir.dflag = 2;
6611       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
6612         return -1;
6613       break;
6614
6615     case 0x9d:    /* popf */
6616       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
6617       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6618       break;
6619
6620     case 0x9e:    /* sahf */
6621       if (ir.regmap[X86_RECORD_R8_REGNUM])
6622         {
6623           ir.addr -= 1;
6624           goto no_support;
6625         }
6626       /* FALLTHROUGH */
6627     case 0xf5:    /* cmc */
6628     case 0xf8:    /* clc */
6629     case 0xf9:    /* stc */
6630     case 0xfc:    /* cld */
6631     case 0xfd:    /* std */
6632       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6633       break;
6634
6635     case 0x9f:    /* lahf */
6636       if (ir.regmap[X86_RECORD_R8_REGNUM])
6637         {
6638           ir.addr -= 1;
6639           goto no_support;
6640         }
6641       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6642       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6643       break;
6644
6645       /* bit operations */
6646     case 0x0fba:    /* bt/bts/btr/btc Gv, im */
6647       ir.ot = ir.dflag + OT_WORD;
6648       if (i386_record_modrm (&ir))
6649         return -1;
6650       if (ir.reg < 4)
6651         {
6652           ir.addr -= 2;
6653           opcode = opcode << 8 | ir.modrm;
6654           goto no_support;
6655         }
6656       if (ir.reg != 4)
6657         {
6658           if (ir.mod == 3)
6659             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6660           else
6661             {
6662               if (i386_record_lea_modrm (&ir))
6663                 return -1;
6664             }
6665         }
6666       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6667       break;
6668
6669     case 0x0fa3:    /* bt Gv, Ev */
6670       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6671       break;
6672
6673     case 0x0fab:    /* bts */
6674     case 0x0fb3:    /* btr */
6675     case 0x0fbb:    /* btc */
6676       ir.ot = ir.dflag + OT_WORD;
6677       if (i386_record_modrm (&ir))
6678         return -1;
6679       if (ir.mod == 3)
6680         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6681       else
6682         {
6683           uint64_t addr64;
6684           if (i386_record_lea_modrm_addr (&ir, &addr64))
6685             return -1;
6686           regcache_raw_read_unsigned (ir.regcache,
6687                                       ir.regmap[ir.reg | rex_r],
6688                                       &addr);
6689           switch (ir.dflag)
6690             {
6691             case 0:
6692               addr64 += ((int16_t) addr >> 4) << 4;
6693               break;
6694             case 1:
6695               addr64 += ((int32_t) addr >> 5) << 5;
6696               break;
6697             case 2:
6698               addr64 += ((int64_t) addr >> 6) << 6;
6699               break;
6700             }
6701           if (record_full_arch_list_add_mem (addr64, 1 << ir.ot))
6702             return -1;
6703           if (i386_record_lea_modrm (&ir))
6704             return -1;
6705         }
6706       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6707       break;
6708
6709     case 0x0fbc:    /* bsf */
6710     case 0x0fbd:    /* bsr */
6711       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
6712       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6713       break;
6714
6715       /* bcd */
6716     case 0x27:    /* daa */
6717     case 0x2f:    /* das */
6718     case 0x37:    /* aaa */
6719     case 0x3f:    /* aas */
6720     case 0xd4:    /* aam */
6721     case 0xd5:    /* aad */
6722       if (ir.regmap[X86_RECORD_R8_REGNUM])
6723         {
6724           ir.addr -= 1;
6725           goto no_support;
6726         }
6727       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6728       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6729       break;
6730
6731       /* misc */
6732     case 0x90:    /* nop */
6733       if (prefixes & PREFIX_LOCK)
6734         {
6735           ir.addr -= 1;
6736           goto no_support;
6737         }
6738       break;
6739
6740     case 0x9b:    /* fwait */
6741       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
6742         return -1;
6743       opcode = (uint32_t) opcode8;
6744       ir.addr++;
6745       goto reswitch;
6746       break;
6747
6748       /* XXX */
6749     case 0xcc:    /* int3 */
6750       printf_unfiltered (_("Process record does not support instruction "
6751                            "int3.\n"));
6752       ir.addr -= 1;
6753       goto no_support;
6754       break;
6755
6756       /* XXX */
6757     case 0xcd:    /* int */
6758       {
6759         int ret;
6760         uint8_t interrupt;
6761         if (record_read_memory (gdbarch, ir.addr, &interrupt, 1))
6762           return -1;
6763         ir.addr++;
6764         if (interrupt != 0x80
6765             || tdep->i386_intx80_record == NULL)
6766           {
6767             printf_unfiltered (_("Process record does not support "
6768                                  "instruction int 0x%02x.\n"),
6769                                interrupt);
6770             ir.addr -= 2;
6771             goto no_support;
6772           }
6773         ret = tdep->i386_intx80_record (ir.regcache);
6774         if (ret)
6775           return ret;
6776       }
6777       break;
6778
6779       /* XXX */
6780     case 0xce:    /* into */
6781       printf_unfiltered (_("Process record does not support "
6782                            "instruction into.\n"));
6783       ir.addr -= 1;
6784       goto no_support;
6785       break;
6786
6787     case 0xfa:    /* cli */
6788     case 0xfb:    /* sti */
6789       break;
6790
6791     case 0x62:    /* bound */
6792       printf_unfiltered (_("Process record does not support "
6793                            "instruction bound.\n"));
6794       ir.addr -= 1;
6795       goto no_support;
6796       break;
6797
6798     case 0x0fc8:    /* bswap reg */
6799     case 0x0fc9:
6800     case 0x0fca:
6801     case 0x0fcb:
6802     case 0x0fcc:
6803     case 0x0fcd:
6804     case 0x0fce:
6805     case 0x0fcf:
6806       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 7) | ir.rex_b);
6807       break;
6808
6809     case 0xd6:    /* salc */
6810       if (ir.regmap[X86_RECORD_R8_REGNUM])
6811         {
6812           ir.addr -= 1;
6813           goto no_support;
6814         }
6815       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6816       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6817       break;
6818
6819     case 0xe0:    /* loopnz */
6820     case 0xe1:    /* loopz */
6821     case 0xe2:    /* loop */
6822     case 0xe3:    /* jecxz */
6823       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6824       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6825       break;
6826
6827     case 0x0f30:    /* wrmsr */
6828       printf_unfiltered (_("Process record does not support "
6829                            "instruction wrmsr.\n"));
6830       ir.addr -= 2;
6831       goto no_support;
6832       break;
6833
6834     case 0x0f32:    /* rdmsr */
6835       printf_unfiltered (_("Process record does not support "
6836                            "instruction rdmsr.\n"));
6837       ir.addr -= 2;
6838       goto no_support;
6839       break;
6840
6841     case 0x0f31:    /* rdtsc */
6842       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6843       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
6844       break;
6845
6846     case 0x0f34:    /* sysenter */
6847       {
6848         int ret;
6849         if (ir.regmap[X86_RECORD_R8_REGNUM])
6850           {
6851             ir.addr -= 2;
6852             goto no_support;
6853           }
6854         if (tdep->i386_sysenter_record == NULL)
6855           {
6856             printf_unfiltered (_("Process record does not support "
6857                                  "instruction sysenter.\n"));
6858             ir.addr -= 2;
6859             goto no_support;
6860           }
6861         ret = tdep->i386_sysenter_record (ir.regcache);
6862         if (ret)
6863           return ret;
6864       }
6865       break;
6866
6867     case 0x0f35:    /* sysexit */
6868       printf_unfiltered (_("Process record does not support "
6869                            "instruction sysexit.\n"));
6870       ir.addr -= 2;
6871       goto no_support;
6872       break;
6873
6874     case 0x0f05:    /* syscall */
6875       {
6876         int ret;
6877         if (tdep->i386_syscall_record == NULL)
6878           {
6879             printf_unfiltered (_("Process record does not support "
6880                                  "instruction syscall.\n"));
6881             ir.addr -= 2;
6882             goto no_support;
6883           }
6884         ret = tdep->i386_syscall_record (ir.regcache);
6885         if (ret)
6886           return ret;
6887       }
6888       break;
6889
6890     case 0x0f07:    /* sysret */
6891       printf_unfiltered (_("Process record does not support "
6892                            "instruction sysret.\n"));
6893       ir.addr -= 2;
6894       goto no_support;
6895       break;
6896
6897     case 0x0fa2:    /* cpuid */
6898       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6899       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6900       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
6901       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
6902       break;
6903
6904     case 0xf4:    /* hlt */
6905       printf_unfiltered (_("Process record does not support "
6906                            "instruction hlt.\n"));
6907       ir.addr -= 1;
6908       goto no_support;
6909       break;
6910
6911     case 0x0f00:
6912       if (i386_record_modrm (&ir))
6913         return -1;
6914       switch (ir.reg)
6915         {
6916         case 0:  /* sldt */
6917         case 1:  /* str  */
6918           if (ir.mod == 3)
6919             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6920           else
6921             {
6922               ir.ot = OT_WORD;
6923               if (i386_record_lea_modrm (&ir))
6924                 return -1;
6925             }
6926           break;
6927         case 2:  /* lldt */
6928         case 3:  /* ltr */
6929           break;
6930         case 4:  /* verr */
6931         case 5:  /* verw */
6932           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6933           break;
6934         default:
6935           ir.addr -= 3;
6936           opcode = opcode << 8 | ir.modrm;
6937           goto no_support;
6938           break;
6939         }
6940       break;
6941
6942     case 0x0f01:
6943       if (i386_record_modrm (&ir))
6944         return -1;
6945       switch (ir.reg)
6946         {
6947         case 0:  /* sgdt */
6948           {
6949             uint64_t addr64;
6950
6951             if (ir.mod == 3)
6952               {
6953                 ir.addr -= 3;
6954                 opcode = opcode << 8 | ir.modrm;
6955                 goto no_support;
6956               }
6957             if (ir.override >= 0)
6958               {
6959                 if (record_full_memory_query)
6960                   {
6961                     int q;
6962
6963                     target_terminal_ours ();
6964                     q = yquery (_("\
6965 Process record ignores the memory change of instruction at address %s\n\
6966 because it can't get the value of the segment register.\n\
6967 Do you want to stop the program?"),
6968                                 paddress (gdbarch, ir.orig_addr));
6969                     target_terminal_inferior ();
6970                     if (q)
6971                       return -1;
6972                   }
6973               }
6974             else
6975               {
6976                 if (i386_record_lea_modrm_addr (&ir, &addr64))
6977                   return -1;
6978                 if (record_full_arch_list_add_mem (addr64, 2))
6979                   return -1;
6980                 addr64 += 2;
6981                 if (ir.regmap[X86_RECORD_R8_REGNUM])
6982                   {
6983                     if (record_full_arch_list_add_mem (addr64, 8))
6984                       return -1;
6985                   }
6986                 else
6987                   {
6988                     if (record_full_arch_list_add_mem (addr64, 4))
6989                       return -1;
6990                   }
6991               }
6992           }
6993           break;
6994         case 1:
6995           if (ir.mod == 3)
6996             {
6997               switch (ir.rm)
6998                 {
6999                 case 0:  /* monitor */
7000                   break;
7001                 case 1:  /* mwait */
7002                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7003                   break;
7004                 default:
7005                   ir.addr -= 3;
7006                   opcode = opcode << 8 | ir.modrm;
7007                   goto no_support;
7008                   break;
7009                 }
7010             }
7011           else
7012             {
7013               /* sidt */
7014               if (ir.override >= 0)
7015                 {
7016                   if (record_full_memory_query)
7017                     {
7018                       int q;
7019
7020                       target_terminal_ours ();
7021                       q = yquery (_("\
7022 Process record ignores the memory change of instruction at address %s\n\
7023 because it can't get the value of the segment register.\n\
7024 Do you want to stop the program?"),
7025                                   paddress (gdbarch, ir.orig_addr));
7026                       target_terminal_inferior ();
7027                       if (q)
7028                         return -1;
7029                     }
7030                 }
7031               else
7032                 {
7033                   uint64_t addr64;
7034
7035                   if (i386_record_lea_modrm_addr (&ir, &addr64))
7036                     return -1;
7037                   if (record_full_arch_list_add_mem (addr64, 2))
7038                     return -1;
7039                   addr64 += 2;
7040                   if (ir.regmap[X86_RECORD_R8_REGNUM])
7041                     {
7042                       if (record_full_arch_list_add_mem (addr64, 8))
7043                         return -1;
7044                     }
7045                   else
7046                     {
7047                       if (record_full_arch_list_add_mem (addr64, 4))
7048                         return -1;
7049                     }
7050                 }
7051             }
7052           break;
7053         case 2:  /* lgdt */
7054           if (ir.mod == 3)
7055             {
7056               /* xgetbv */
7057               if (ir.rm == 0)
7058                 {
7059                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
7060                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
7061                   break;
7062                 }
7063               /* xsetbv */
7064               else if (ir.rm == 1)
7065                 break;
7066             }
7067         case 3:  /* lidt */
7068           if (ir.mod == 3)
7069             {
7070               ir.addr -= 3;
7071               opcode = opcode << 8 | ir.modrm;
7072               goto no_support;
7073             }
7074           break;
7075         case 4:  /* smsw */
7076           if (ir.mod == 3)
7077             {
7078               if (record_full_arch_list_add_reg (ir.regcache, ir.rm | ir.rex_b))
7079                 return -1;
7080             }
7081           else
7082             {
7083               ir.ot = OT_WORD;
7084               if (i386_record_lea_modrm (&ir))
7085                 return -1;
7086             }
7087           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7088           break;
7089         case 6:  /* lmsw */
7090           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7091           break;
7092         case 7:  /* invlpg */
7093           if (ir.mod == 3)
7094             {
7095               if (ir.rm == 0 && ir.regmap[X86_RECORD_R8_REGNUM])
7096                 I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
7097               else
7098                 {
7099                   ir.addr -= 3;
7100                   opcode = opcode << 8 | ir.modrm;
7101                   goto no_support;
7102                 }
7103             }
7104           else
7105             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7106           break;
7107         default:
7108           ir.addr -= 3;
7109           opcode = opcode << 8 | ir.modrm;
7110           goto no_support;
7111           break;
7112         }
7113       break;
7114
7115     case 0x0f08:    /* invd */
7116     case 0x0f09:    /* wbinvd */
7117       break;
7118
7119     case 0x63:    /* arpl */
7120       if (i386_record_modrm (&ir))
7121         return -1;
7122       if (ir.mod == 3 || ir.regmap[X86_RECORD_R8_REGNUM])
7123         {
7124           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.regmap[X86_RECORD_R8_REGNUM]
7125                                               ? (ir.reg | rex_r) : ir.rm);
7126         }
7127       else
7128         {
7129           ir.ot = ir.dflag ? OT_LONG : OT_WORD;
7130           if (i386_record_lea_modrm (&ir))
7131             return -1;
7132         }
7133       if (!ir.regmap[X86_RECORD_R8_REGNUM])
7134         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7135       break;
7136
7137     case 0x0f02:    /* lar */
7138     case 0x0f03:    /* lsl */
7139       if (i386_record_modrm (&ir))
7140         return -1;
7141       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
7142       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7143       break;
7144
7145     case 0x0f18:
7146       if (i386_record_modrm (&ir))
7147         return -1;
7148       if (ir.mod == 3 && ir.reg == 3)
7149         {
7150           ir.addr -= 3;
7151           opcode = opcode << 8 | ir.modrm;
7152           goto no_support;
7153         }
7154       break;
7155
7156     case 0x0f19:
7157     case 0x0f1a:
7158     case 0x0f1b:
7159     case 0x0f1c:
7160     case 0x0f1d:
7161     case 0x0f1e:
7162     case 0x0f1f:
7163       /* nop (multi byte) */
7164       break;
7165
7166     case 0x0f20:    /* mov reg, crN */
7167     case 0x0f22:    /* mov crN, reg */
7168       if (i386_record_modrm (&ir))
7169         return -1;
7170       if ((ir.modrm & 0xc0) != 0xc0)
7171         {
7172           ir.addr -= 3;
7173           opcode = opcode << 8 | ir.modrm;
7174           goto no_support;
7175         }
7176       switch (ir.reg)
7177         {
7178         case 0:
7179         case 2:
7180         case 3:
7181         case 4:
7182         case 8:
7183           if (opcode & 2)
7184             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7185           else
7186             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
7187           break;
7188         default:
7189           ir.addr -= 3;
7190           opcode = opcode << 8 | ir.modrm;
7191           goto no_support;
7192           break;
7193         }
7194       break;
7195
7196     case 0x0f21:    /* mov reg, drN */
7197     case 0x0f23:    /* mov drN, reg */
7198       if (i386_record_modrm (&ir))
7199         return -1;
7200       if ((ir.modrm & 0xc0) != 0xc0 || ir.reg == 4
7201           || ir.reg == 5 || ir.reg >= 8)
7202         {
7203           ir.addr -= 3;
7204           opcode = opcode << 8 | ir.modrm;
7205           goto no_support;
7206         }
7207       if (opcode & 2)
7208         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7209       else
7210         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
7211       break;
7212
7213     case 0x0f06:    /* clts */
7214       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7215       break;
7216
7217     /* MMX 3DNow! SSE SSE2 SSE3 SSSE3 SSE4 */
7218
7219     case 0x0f0d:    /* 3DNow! prefetch */
7220       break;
7221
7222     case 0x0f0e:    /* 3DNow! femms */
7223     case 0x0f77:    /* emms */
7224       if (i386_fpc_regnum_p (gdbarch, I387_FTAG_REGNUM(tdep)))
7225         goto no_support;
7226       record_full_arch_list_add_reg (ir.regcache, I387_FTAG_REGNUM(tdep));
7227       break;
7228
7229     case 0x0f0f:    /* 3DNow! data */
7230       if (i386_record_modrm (&ir))
7231         return -1;
7232       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
7233         return -1;
7234       ir.addr++;
7235       switch (opcode8)
7236         {
7237         case 0x0c:    /* 3DNow! pi2fw */
7238         case 0x0d:    /* 3DNow! pi2fd */
7239         case 0x1c:    /* 3DNow! pf2iw */
7240         case 0x1d:    /* 3DNow! pf2id */
7241         case 0x8a:    /* 3DNow! pfnacc */
7242         case 0x8e:    /* 3DNow! pfpnacc */
7243         case 0x90:    /* 3DNow! pfcmpge */
7244         case 0x94:    /* 3DNow! pfmin */
7245         case 0x96:    /* 3DNow! pfrcp */
7246         case 0x97:    /* 3DNow! pfrsqrt */
7247         case 0x9a:    /* 3DNow! pfsub */
7248         case 0x9e:    /* 3DNow! pfadd */
7249         case 0xa0:    /* 3DNow! pfcmpgt */
7250         case 0xa4:    /* 3DNow! pfmax */
7251         case 0xa6:    /* 3DNow! pfrcpit1 */
7252         case 0xa7:    /* 3DNow! pfrsqit1 */
7253         case 0xaa:    /* 3DNow! pfsubr */
7254         case 0xae:    /* 3DNow! pfacc */
7255         case 0xb0:    /* 3DNow! pfcmpeq */
7256         case 0xb4:    /* 3DNow! pfmul */
7257         case 0xb6:    /* 3DNow! pfrcpit2 */
7258         case 0xb7:    /* 3DNow! pmulhrw */
7259         case 0xbb:    /* 3DNow! pswapd */
7260         case 0xbf:    /* 3DNow! pavgusb */
7261           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.reg))
7262             goto no_support_3dnow_data;
7263           record_full_arch_list_add_reg (ir.regcache, ir.reg);
7264           break;
7265
7266         default:
7267 no_support_3dnow_data:
7268           opcode = (opcode << 8) | opcode8;
7269           goto no_support;
7270           break;
7271         }
7272       break;
7273
7274     case 0x0faa:    /* rsm */
7275       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7276       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
7277       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
7278       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
7279       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
7280       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
7281       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
7282       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
7283       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
7284       break;
7285
7286     case 0x0fae:
7287       if (i386_record_modrm (&ir))
7288         return -1;
7289       switch(ir.reg)
7290         {
7291         case 0:    /* fxsave */
7292           {
7293             uint64_t tmpu64;
7294
7295             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7296             if (i386_record_lea_modrm_addr (&ir, &tmpu64))
7297               return -1;
7298             if (record_full_arch_list_add_mem (tmpu64, 512))
7299               return -1;
7300           }
7301           break;
7302
7303         case 1:    /* fxrstor */
7304           {
7305             int i;
7306
7307             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7308
7309             for (i = I387_MM0_REGNUM (tdep);
7310                  i386_mmx_regnum_p (gdbarch, i); i++)
7311               record_full_arch_list_add_reg (ir.regcache, i);
7312
7313             for (i = I387_XMM0_REGNUM (tdep);
7314                  i386_xmm_regnum_p (gdbarch, i); i++)
7315               record_full_arch_list_add_reg (ir.regcache, i);
7316
7317             if (i386_mxcsr_regnum_p (gdbarch, I387_MXCSR_REGNUM(tdep)))
7318               record_full_arch_list_add_reg (ir.regcache,
7319                                              I387_MXCSR_REGNUM(tdep));
7320
7321             for (i = I387_ST0_REGNUM (tdep);
7322                  i386_fp_regnum_p (gdbarch, i); i++)
7323               record_full_arch_list_add_reg (ir.regcache, i);
7324
7325             for (i = I387_FCTRL_REGNUM (tdep);
7326                  i386_fpc_regnum_p (gdbarch, i); i++)
7327               record_full_arch_list_add_reg (ir.regcache, i);
7328           }
7329           break;
7330
7331         case 2:    /* ldmxcsr */
7332           if (!i386_mxcsr_regnum_p (gdbarch, I387_MXCSR_REGNUM(tdep)))
7333             goto no_support;
7334           record_full_arch_list_add_reg (ir.regcache, I387_MXCSR_REGNUM(tdep));
7335           break;
7336
7337         case 3:    /* stmxcsr */
7338           ir.ot = OT_LONG;
7339           if (i386_record_lea_modrm (&ir))
7340             return -1;
7341           break;
7342
7343         case 5:    /* lfence */
7344         case 6:    /* mfence */
7345         case 7:    /* sfence clflush */
7346           break;
7347
7348         default:
7349           opcode = (opcode << 8) | ir.modrm;
7350           goto no_support;
7351           break;
7352         }
7353       break;
7354
7355     case 0x0fc3:    /* movnti */
7356       ir.ot = (ir.dflag == 2) ? OT_QUAD : OT_LONG;
7357       if (i386_record_modrm (&ir))
7358         return -1;
7359       if (ir.mod == 3)
7360         goto no_support;
7361       ir.reg |= rex_r;
7362       if (i386_record_lea_modrm (&ir))
7363         return -1;
7364       break;
7365
7366     /* Add prefix to opcode.  */
7367     case 0x0f10:
7368     case 0x0f11:
7369     case 0x0f12:
7370     case 0x0f13:
7371     case 0x0f14:
7372     case 0x0f15:
7373     case 0x0f16:
7374     case 0x0f17:
7375     case 0x0f28:
7376     case 0x0f29:
7377     case 0x0f2a:
7378     case 0x0f2b:
7379     case 0x0f2c:
7380     case 0x0f2d:
7381     case 0x0f2e:
7382     case 0x0f2f:
7383     case 0x0f38:
7384     case 0x0f39:
7385     case 0x0f3a:
7386     case 0x0f50:
7387     case 0x0f51:
7388     case 0x0f52:
7389     case 0x0f53:
7390     case 0x0f54:
7391     case 0x0f55:
7392     case 0x0f56:
7393     case 0x0f57:
7394     case 0x0f58:
7395     case 0x0f59:
7396     case 0x0f5a:
7397     case 0x0f5b:
7398     case 0x0f5c:
7399     case 0x0f5d:
7400     case 0x0f5e:
7401     case 0x0f5f:
7402     case 0x0f60:
7403     case 0x0f61:
7404     case 0x0f62:
7405     case 0x0f63:
7406     case 0x0f64:
7407     case 0x0f65:
7408     case 0x0f66:
7409     case 0x0f67:
7410     case 0x0f68:
7411     case 0x0f69:
7412     case 0x0f6a:
7413     case 0x0f6b:
7414     case 0x0f6c:
7415     case 0x0f6d:
7416     case 0x0f6e:
7417     case 0x0f6f:
7418     case 0x0f70:
7419     case 0x0f71:
7420     case 0x0f72:
7421     case 0x0f73:
7422     case 0x0f74:
7423     case 0x0f75:
7424     case 0x0f76:
7425     case 0x0f7c:
7426     case 0x0f7d:
7427     case 0x0f7e:
7428     case 0x0f7f:
7429     case 0x0fb8:
7430     case 0x0fc2:
7431     case 0x0fc4:
7432     case 0x0fc5:
7433     case 0x0fc6:
7434     case 0x0fd0:
7435     case 0x0fd1:
7436     case 0x0fd2:
7437     case 0x0fd3:
7438     case 0x0fd4:
7439     case 0x0fd5:
7440     case 0x0fd6:
7441     case 0x0fd7:
7442     case 0x0fd8:
7443     case 0x0fd9:
7444     case 0x0fda:
7445     case 0x0fdb:
7446     case 0x0fdc:
7447     case 0x0fdd:
7448     case 0x0fde:
7449     case 0x0fdf:
7450     case 0x0fe0:
7451     case 0x0fe1:
7452     case 0x0fe2:
7453     case 0x0fe3:
7454     case 0x0fe4:
7455     case 0x0fe5:
7456     case 0x0fe6:
7457     case 0x0fe7:
7458     case 0x0fe8:
7459     case 0x0fe9:
7460     case 0x0fea:
7461     case 0x0feb:
7462     case 0x0fec:
7463     case 0x0fed:
7464     case 0x0fee:
7465     case 0x0fef:
7466     case 0x0ff0:
7467     case 0x0ff1:
7468     case 0x0ff2:
7469     case 0x0ff3:
7470     case 0x0ff4:
7471     case 0x0ff5:
7472     case 0x0ff6:
7473     case 0x0ff7:
7474     case 0x0ff8:
7475     case 0x0ff9:
7476     case 0x0ffa:
7477     case 0x0ffb:
7478     case 0x0ffc:
7479     case 0x0ffd:
7480     case 0x0ffe:
7481       /* Mask out PREFIX_ADDR.  */
7482       switch ((prefixes & ~PREFIX_ADDR))
7483         {
7484         case PREFIX_REPNZ:
7485           opcode |= 0xf20000;
7486           break;
7487         case PREFIX_DATA:
7488           opcode |= 0x660000;
7489           break;
7490         case PREFIX_REPZ:
7491           opcode |= 0xf30000;
7492           break;
7493         }
7494 reswitch_prefix_add:
7495       switch (opcode)
7496         {
7497         case 0x0f38:
7498         case 0x660f38:
7499         case 0xf20f38:
7500         case 0x0f3a:
7501         case 0x660f3a:
7502           if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
7503             return -1;
7504           ir.addr++;
7505           opcode = (uint32_t) opcode8 | opcode << 8;
7506           goto reswitch_prefix_add;
7507           break;
7508
7509         case 0x0f10:        /* movups */
7510         case 0x660f10:      /* movupd */
7511         case 0xf30f10:      /* movss */
7512         case 0xf20f10:      /* movsd */
7513         case 0x0f12:        /* movlps */
7514         case 0x660f12:      /* movlpd */
7515         case 0xf30f12:      /* movsldup */
7516         case 0xf20f12:      /* movddup */
7517         case 0x0f14:        /* unpcklps */
7518         case 0x660f14:      /* unpcklpd */
7519         case 0x0f15:        /* unpckhps */
7520         case 0x660f15:      /* unpckhpd */
7521         case 0x0f16:        /* movhps */
7522         case 0x660f16:      /* movhpd */
7523         case 0xf30f16:      /* movshdup */
7524         case 0x0f28:        /* movaps */
7525         case 0x660f28:      /* movapd */
7526         case 0x0f2a:        /* cvtpi2ps */
7527         case 0x660f2a:      /* cvtpi2pd */
7528         case 0xf30f2a:      /* cvtsi2ss */
7529         case 0xf20f2a:      /* cvtsi2sd */
7530         case 0x0f2c:        /* cvttps2pi */
7531         case 0x660f2c:      /* cvttpd2pi */
7532         case 0x0f2d:        /* cvtps2pi */
7533         case 0x660f2d:      /* cvtpd2pi */
7534         case 0x660f3800:    /* pshufb */
7535         case 0x660f3801:    /* phaddw */
7536         case 0x660f3802:    /* phaddd */
7537         case 0x660f3803:    /* phaddsw */
7538         case 0x660f3804:    /* pmaddubsw */
7539         case 0x660f3805:    /* phsubw */
7540         case 0x660f3806:    /* phsubd */
7541         case 0x660f3807:    /* phsubsw */
7542         case 0x660f3808:    /* psignb */
7543         case 0x660f3809:    /* psignw */
7544         case 0x660f380a:    /* psignd */
7545         case 0x660f380b:    /* pmulhrsw */
7546         case 0x660f3810:    /* pblendvb */
7547         case 0x660f3814:    /* blendvps */
7548         case 0x660f3815:    /* blendvpd */
7549         case 0x660f381c:    /* pabsb */
7550         case 0x660f381d:    /* pabsw */
7551         case 0x660f381e:    /* pabsd */
7552         case 0x660f3820:    /* pmovsxbw */
7553         case 0x660f3821:    /* pmovsxbd */
7554         case 0x660f3822:    /* pmovsxbq */
7555         case 0x660f3823:    /* pmovsxwd */
7556         case 0x660f3824:    /* pmovsxwq */
7557         case 0x660f3825:    /* pmovsxdq */
7558         case 0x660f3828:    /* pmuldq */
7559         case 0x660f3829:    /* pcmpeqq */
7560         case 0x660f382a:    /* movntdqa */
7561         case 0x660f3a08:    /* roundps */
7562         case 0x660f3a09:    /* roundpd */
7563         case 0x660f3a0a:    /* roundss */
7564         case 0x660f3a0b:    /* roundsd */
7565         case 0x660f3a0c:    /* blendps */
7566         case 0x660f3a0d:    /* blendpd */
7567         case 0x660f3a0e:    /* pblendw */
7568         case 0x660f3a0f:    /* palignr */
7569         case 0x660f3a20:    /* pinsrb */
7570         case 0x660f3a21:    /* insertps */
7571         case 0x660f3a22:    /* pinsrd pinsrq */
7572         case 0x660f3a40:    /* dpps */
7573         case 0x660f3a41:    /* dppd */
7574         case 0x660f3a42:    /* mpsadbw */
7575         case 0x660f3a60:    /* pcmpestrm */
7576         case 0x660f3a61:    /* pcmpestri */
7577         case 0x660f3a62:    /* pcmpistrm */
7578         case 0x660f3a63:    /* pcmpistri */
7579         case 0x0f51:        /* sqrtps */
7580         case 0x660f51:      /* sqrtpd */
7581         case 0xf20f51:      /* sqrtsd */
7582         case 0xf30f51:      /* sqrtss */
7583         case 0x0f52:        /* rsqrtps */
7584         case 0xf30f52:      /* rsqrtss */
7585         case 0x0f53:        /* rcpps */
7586         case 0xf30f53:      /* rcpss */
7587         case 0x0f54:        /* andps */
7588         case 0x660f54:      /* andpd */
7589         case 0x0f55:        /* andnps */
7590         case 0x660f55:      /* andnpd */
7591         case 0x0f56:        /* orps */
7592         case 0x660f56:      /* orpd */
7593         case 0x0f57:        /* xorps */
7594         case 0x660f57:      /* xorpd */
7595         case 0x0f58:        /* addps */
7596         case 0x660f58:      /* addpd */
7597         case 0xf20f58:      /* addsd */
7598         case 0xf30f58:      /* addss */
7599         case 0x0f59:        /* mulps */
7600         case 0x660f59:      /* mulpd */
7601         case 0xf20f59:      /* mulsd */
7602         case 0xf30f59:      /* mulss */
7603         case 0x0f5a:        /* cvtps2pd */
7604         case 0x660f5a:      /* cvtpd2ps */
7605         case 0xf20f5a:      /* cvtsd2ss */
7606         case 0xf30f5a:      /* cvtss2sd */
7607         case 0x0f5b:        /* cvtdq2ps */
7608         case 0x660f5b:      /* cvtps2dq */
7609         case 0xf30f5b:      /* cvttps2dq */
7610         case 0x0f5c:        /* subps */
7611         case 0x660f5c:      /* subpd */
7612         case 0xf20f5c:      /* subsd */
7613         case 0xf30f5c:      /* subss */
7614         case 0x0f5d:        /* minps */
7615         case 0x660f5d:      /* minpd */
7616         case 0xf20f5d:      /* minsd */
7617         case 0xf30f5d:      /* minss */
7618         case 0x0f5e:        /* divps */
7619         case 0x660f5e:      /* divpd */
7620         case 0xf20f5e:      /* divsd */
7621         case 0xf30f5e:      /* divss */
7622         case 0x0f5f:        /* maxps */
7623         case 0x660f5f:      /* maxpd */
7624         case 0xf20f5f:      /* maxsd */
7625         case 0xf30f5f:      /* maxss */
7626         case 0x660f60:      /* punpcklbw */
7627         case 0x660f61:      /* punpcklwd */
7628         case 0x660f62:      /* punpckldq */
7629         case 0x660f63:      /* packsswb */
7630         case 0x660f64:      /* pcmpgtb */
7631         case 0x660f65:      /* pcmpgtw */
7632         case 0x660f66:      /* pcmpgtd */
7633         case 0x660f67:      /* packuswb */
7634         case 0x660f68:      /* punpckhbw */
7635         case 0x660f69:      /* punpckhwd */
7636         case 0x660f6a:      /* punpckhdq */
7637         case 0x660f6b:      /* packssdw */
7638         case 0x660f6c:      /* punpcklqdq */
7639         case 0x660f6d:      /* punpckhqdq */
7640         case 0x660f6e:      /* movd */
7641         case 0x660f6f:      /* movdqa */
7642         case 0xf30f6f:      /* movdqu */
7643         case 0x660f70:      /* pshufd */
7644         case 0xf20f70:      /* pshuflw */
7645         case 0xf30f70:      /* pshufhw */
7646         case 0x660f74:      /* pcmpeqb */
7647         case 0x660f75:      /* pcmpeqw */
7648         case 0x660f76:      /* pcmpeqd */
7649         case 0x660f7c:      /* haddpd */
7650         case 0xf20f7c:      /* haddps */
7651         case 0x660f7d:      /* hsubpd */
7652         case 0xf20f7d:      /* hsubps */
7653         case 0xf30f7e:      /* movq */
7654         case 0x0fc2:        /* cmpps */
7655         case 0x660fc2:      /* cmppd */
7656         case 0xf20fc2:      /* cmpsd */
7657         case 0xf30fc2:      /* cmpss */
7658         case 0x660fc4:      /* pinsrw */
7659         case 0x0fc6:        /* shufps */
7660         case 0x660fc6:      /* shufpd */
7661         case 0x660fd0:      /* addsubpd */
7662         case 0xf20fd0:      /* addsubps */
7663         case 0x660fd1:      /* psrlw */
7664         case 0x660fd2:      /* psrld */
7665         case 0x660fd3:      /* psrlq */
7666         case 0x660fd4:      /* paddq */
7667         case 0x660fd5:      /* pmullw */
7668         case 0xf30fd6:      /* movq2dq */
7669         case 0x660fd8:      /* psubusb */
7670         case 0x660fd9:      /* psubusw */
7671         case 0x660fda:      /* pminub */
7672         case 0x660fdb:      /* pand */
7673         case 0x660fdc:      /* paddusb */
7674         case 0x660fdd:      /* paddusw */
7675         case 0x660fde:      /* pmaxub */
7676         case 0x660fdf:      /* pandn */
7677         case 0x660fe0:      /* pavgb */
7678         case 0x660fe1:      /* psraw */
7679         case 0x660fe2:      /* psrad */
7680         case 0x660fe3:      /* pavgw */
7681         case 0x660fe4:      /* pmulhuw */
7682         case 0x660fe5:      /* pmulhw */
7683         case 0x660fe6:      /* cvttpd2dq */
7684         case 0xf20fe6:      /* cvtpd2dq */
7685         case 0xf30fe6:      /* cvtdq2pd */
7686         case 0x660fe8:      /* psubsb */
7687         case 0x660fe9:      /* psubsw */
7688         case 0x660fea:      /* pminsw */
7689         case 0x660feb:      /* por */
7690         case 0x660fec:      /* paddsb */
7691         case 0x660fed:      /* paddsw */
7692         case 0x660fee:      /* pmaxsw */
7693         case 0x660fef:      /* pxor */
7694         case 0xf20ff0:      /* lddqu */
7695         case 0x660ff1:      /* psllw */
7696         case 0x660ff2:      /* pslld */
7697         case 0x660ff3:      /* psllq */
7698         case 0x660ff4:      /* pmuludq */
7699         case 0x660ff5:      /* pmaddwd */
7700         case 0x660ff6:      /* psadbw */
7701         case 0x660ff8:      /* psubb */
7702         case 0x660ff9:      /* psubw */
7703         case 0x660ffa:      /* psubd */
7704         case 0x660ffb:      /* psubq */
7705         case 0x660ffc:      /* paddb */
7706         case 0x660ffd:      /* paddw */
7707         case 0x660ffe:      /* paddd */
7708           if (i386_record_modrm (&ir))
7709             return -1;
7710           ir.reg |= rex_r;
7711           if (!i386_xmm_regnum_p (gdbarch, I387_XMM0_REGNUM (tdep) + ir.reg))
7712             goto no_support;
7713           record_full_arch_list_add_reg (ir.regcache,
7714                                          I387_XMM0_REGNUM (tdep) + ir.reg);
7715           if ((opcode & 0xfffffffc) == 0x660f3a60)
7716             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7717           break;
7718
7719         case 0x0f11:        /* movups */
7720         case 0x660f11:      /* movupd */
7721         case 0xf30f11:      /* movss */
7722         case 0xf20f11:      /* movsd */
7723         case 0x0f13:        /* movlps */
7724         case 0x660f13:      /* movlpd */
7725         case 0x0f17:        /* movhps */
7726         case 0x660f17:      /* movhpd */
7727         case 0x0f29:        /* movaps */
7728         case 0x660f29:      /* movapd */
7729         case 0x660f3a14:    /* pextrb */
7730         case 0x660f3a15:    /* pextrw */
7731         case 0x660f3a16:    /* pextrd pextrq */
7732         case 0x660f3a17:    /* extractps */
7733         case 0x660f7f:      /* movdqa */
7734         case 0xf30f7f:      /* movdqu */
7735           if (i386_record_modrm (&ir))
7736             return -1;
7737           if (ir.mod == 3)
7738             {
7739               if (opcode == 0x0f13 || opcode == 0x660f13
7740                   || opcode == 0x0f17 || opcode == 0x660f17)
7741                 goto no_support;
7742               ir.rm |= ir.rex_b;
7743               if (!i386_xmm_regnum_p (gdbarch,
7744                                       I387_XMM0_REGNUM (tdep) + ir.rm))
7745                 goto no_support;
7746               record_full_arch_list_add_reg (ir.regcache,
7747                                              I387_XMM0_REGNUM (tdep) + ir.rm);
7748             }
7749           else
7750             {
7751               switch (opcode)
7752                 {
7753                   case 0x660f3a14:
7754                     ir.ot = OT_BYTE;
7755                     break;
7756                   case 0x660f3a15:
7757                     ir.ot = OT_WORD;
7758                     break;
7759                   case 0x660f3a16:
7760                     ir.ot = OT_LONG;
7761                     break;
7762                   case 0x660f3a17:
7763                     ir.ot = OT_QUAD;
7764                     break;
7765                   default:
7766                     ir.ot = OT_DQUAD;
7767                     break;
7768                 }
7769               if (i386_record_lea_modrm (&ir))
7770                 return -1;
7771             }
7772           break;
7773
7774         case 0x0f2b:      /* movntps */
7775         case 0x660f2b:    /* movntpd */
7776         case 0x0fe7:      /* movntq */
7777         case 0x660fe7:    /* movntdq */
7778           if (ir.mod == 3)
7779             goto no_support;
7780           if (opcode == 0x0fe7)
7781             ir.ot = OT_QUAD;
7782           else
7783             ir.ot = OT_DQUAD;
7784           if (i386_record_lea_modrm (&ir))
7785             return -1;
7786           break;
7787
7788         case 0xf30f2c:      /* cvttss2si */
7789         case 0xf20f2c:      /* cvttsd2si */
7790         case 0xf30f2d:      /* cvtss2si */
7791         case 0xf20f2d:      /* cvtsd2si */
7792         case 0xf20f38f0:    /* crc32 */
7793         case 0xf20f38f1:    /* crc32 */
7794         case 0x0f50:        /* movmskps */
7795         case 0x660f50:      /* movmskpd */
7796         case 0x0fc5:        /* pextrw */
7797         case 0x660fc5:      /* pextrw */
7798         case 0x0fd7:        /* pmovmskb */
7799         case 0x660fd7:      /* pmovmskb */
7800           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
7801           break;
7802
7803         case 0x0f3800:    /* pshufb */
7804         case 0x0f3801:    /* phaddw */
7805         case 0x0f3802:    /* phaddd */
7806         case 0x0f3803:    /* phaddsw */
7807         case 0x0f3804:    /* pmaddubsw */
7808         case 0x0f3805:    /* phsubw */
7809         case 0x0f3806:    /* phsubd */
7810         case 0x0f3807:    /* phsubsw */
7811         case 0x0f3808:    /* psignb */
7812         case 0x0f3809:    /* psignw */
7813         case 0x0f380a:    /* psignd */
7814         case 0x0f380b:    /* pmulhrsw */
7815         case 0x0f381c:    /* pabsb */
7816         case 0x0f381d:    /* pabsw */
7817         case 0x0f381e:    /* pabsd */
7818         case 0x0f382b:    /* packusdw */
7819         case 0x0f3830:    /* pmovzxbw */
7820         case 0x0f3831:    /* pmovzxbd */
7821         case 0x0f3832:    /* pmovzxbq */
7822         case 0x0f3833:    /* pmovzxwd */
7823         case 0x0f3834:    /* pmovzxwq */
7824         case 0x0f3835:    /* pmovzxdq */
7825         case 0x0f3837:    /* pcmpgtq */
7826         case 0x0f3838:    /* pminsb */
7827         case 0x0f3839:    /* pminsd */
7828         case 0x0f383a:    /* pminuw */
7829         case 0x0f383b:    /* pminud */
7830         case 0x0f383c:    /* pmaxsb */
7831         case 0x0f383d:    /* pmaxsd */
7832         case 0x0f383e:    /* pmaxuw */
7833         case 0x0f383f:    /* pmaxud */
7834         case 0x0f3840:    /* pmulld */
7835         case 0x0f3841:    /* phminposuw */
7836         case 0x0f3a0f:    /* palignr */
7837         case 0x0f60:      /* punpcklbw */
7838         case 0x0f61:      /* punpcklwd */
7839         case 0x0f62:      /* punpckldq */
7840         case 0x0f63:      /* packsswb */
7841         case 0x0f64:      /* pcmpgtb */
7842         case 0x0f65:      /* pcmpgtw */
7843         case 0x0f66:      /* pcmpgtd */
7844         case 0x0f67:      /* packuswb */
7845         case 0x0f68:      /* punpckhbw */
7846         case 0x0f69:      /* punpckhwd */
7847         case 0x0f6a:      /* punpckhdq */
7848         case 0x0f6b:      /* packssdw */
7849         case 0x0f6e:      /* movd */
7850         case 0x0f6f:      /* movq */
7851         case 0x0f70:      /* pshufw */
7852         case 0x0f74:      /* pcmpeqb */
7853         case 0x0f75:      /* pcmpeqw */
7854         case 0x0f76:      /* pcmpeqd */
7855         case 0x0fc4:      /* pinsrw */
7856         case 0x0fd1:      /* psrlw */
7857         case 0x0fd2:      /* psrld */
7858         case 0x0fd3:      /* psrlq */
7859         case 0x0fd4:      /* paddq */
7860         case 0x0fd5:      /* pmullw */
7861         case 0xf20fd6:    /* movdq2q */
7862         case 0x0fd8:      /* psubusb */
7863         case 0x0fd9:      /* psubusw */
7864         case 0x0fda:      /* pminub */
7865         case 0x0fdb:      /* pand */
7866         case 0x0fdc:      /* paddusb */
7867         case 0x0fdd:      /* paddusw */
7868         case 0x0fde:      /* pmaxub */
7869         case 0x0fdf:      /* pandn */
7870         case 0x0fe0:      /* pavgb */
7871         case 0x0fe1:      /* psraw */
7872         case 0x0fe2:      /* psrad */
7873         case 0x0fe3:      /* pavgw */
7874         case 0x0fe4:      /* pmulhuw */
7875         case 0x0fe5:      /* pmulhw */
7876         case 0x0fe8:      /* psubsb */
7877         case 0x0fe9:      /* psubsw */
7878         case 0x0fea:      /* pminsw */
7879         case 0x0feb:      /* por */
7880         case 0x0fec:      /* paddsb */
7881         case 0x0fed:      /* paddsw */
7882         case 0x0fee:      /* pmaxsw */
7883         case 0x0fef:      /* pxor */
7884         case 0x0ff1:      /* psllw */
7885         case 0x0ff2:      /* pslld */
7886         case 0x0ff3:      /* psllq */
7887         case 0x0ff4:      /* pmuludq */
7888         case 0x0ff5:      /* pmaddwd */
7889         case 0x0ff6:      /* psadbw */
7890         case 0x0ff8:      /* psubb */
7891         case 0x0ff9:      /* psubw */
7892         case 0x0ffa:      /* psubd */
7893         case 0x0ffb:      /* psubq */
7894         case 0x0ffc:      /* paddb */
7895         case 0x0ffd:      /* paddw */
7896         case 0x0ffe:      /* paddd */
7897           if (i386_record_modrm (&ir))
7898             return -1;
7899           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.reg))
7900             goto no_support;
7901           record_full_arch_list_add_reg (ir.regcache,
7902                                          I387_MM0_REGNUM (tdep) + ir.reg);
7903           break;
7904
7905         case 0x0f71:    /* psllw */
7906         case 0x0f72:    /* pslld */
7907         case 0x0f73:    /* psllq */
7908           if (i386_record_modrm (&ir))
7909             return -1;
7910           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.rm))
7911             goto no_support;
7912           record_full_arch_list_add_reg (ir.regcache,
7913                                          I387_MM0_REGNUM (tdep) + ir.rm);
7914           break;
7915
7916         case 0x660f71:    /* psllw */
7917         case 0x660f72:    /* pslld */
7918         case 0x660f73:    /* psllq */
7919           if (i386_record_modrm (&ir))
7920             return -1;
7921           ir.rm |= ir.rex_b;
7922           if (!i386_xmm_regnum_p (gdbarch, I387_XMM0_REGNUM (tdep) + ir.rm))
7923             goto no_support;
7924           record_full_arch_list_add_reg (ir.regcache,
7925                                          I387_XMM0_REGNUM (tdep) + ir.rm);
7926           break;
7927
7928         case 0x0f7e:      /* movd */
7929         case 0x660f7e:    /* movd */
7930           if (i386_record_modrm (&ir))
7931             return -1;
7932           if (ir.mod == 3)
7933             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
7934           else
7935             {
7936               if (ir.dflag == 2)
7937                 ir.ot = OT_QUAD;
7938               else
7939                 ir.ot = OT_LONG;
7940               if (i386_record_lea_modrm (&ir))
7941                 return -1;
7942             }
7943           break;
7944
7945         case 0x0f7f:    /* movq */
7946           if (i386_record_modrm (&ir))
7947             return -1;
7948           if (ir.mod == 3)
7949             {
7950               if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.rm))
7951                 goto no_support;
7952               record_full_arch_list_add_reg (ir.regcache,
7953                                              I387_MM0_REGNUM (tdep) + ir.rm);
7954             }
7955           else
7956             {
7957               ir.ot = OT_QUAD;
7958               if (i386_record_lea_modrm (&ir))
7959                 return -1;
7960             }
7961           break;
7962
7963         case 0xf30fb8:    /* popcnt */
7964           if (i386_record_modrm (&ir))
7965             return -1;
7966           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
7967           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7968           break;
7969
7970         case 0x660fd6:    /* movq */
7971           if (i386_record_modrm (&ir))
7972             return -1;
7973           if (ir.mod == 3)
7974             {
7975               ir.rm |= ir.rex_b;
7976               if (!i386_xmm_regnum_p (gdbarch,
7977                                       I387_XMM0_REGNUM (tdep) + ir.rm))
7978                 goto no_support;
7979               record_full_arch_list_add_reg (ir.regcache,
7980                                              I387_XMM0_REGNUM (tdep) + ir.rm);
7981             }
7982           else
7983             {
7984               ir.ot = OT_QUAD;
7985               if (i386_record_lea_modrm (&ir))
7986                 return -1;
7987             }
7988           break;
7989
7990         case 0x660f3817:    /* ptest */
7991         case 0x0f2e:        /* ucomiss */
7992         case 0x660f2e:      /* ucomisd */
7993         case 0x0f2f:        /* comiss */
7994         case 0x660f2f:      /* comisd */
7995           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7996           break;
7997
7998         case 0x0ff7:    /* maskmovq */
7999           regcache_raw_read_unsigned (ir.regcache,
8000                                       ir.regmap[X86_RECORD_REDI_REGNUM],
8001                                       &addr);
8002           if (record_full_arch_list_add_mem (addr, 64))
8003             return -1;
8004           break;
8005
8006         case 0x660ff7:    /* maskmovdqu */
8007           regcache_raw_read_unsigned (ir.regcache,
8008                                       ir.regmap[X86_RECORD_REDI_REGNUM],
8009                                       &addr);
8010           if (record_full_arch_list_add_mem (addr, 128))
8011             return -1;
8012           break;
8013
8014         default:
8015           goto no_support;
8016           break;
8017         }
8018       break;
8019
8020     default:
8021       goto no_support;
8022       break;
8023     }
8024
8025   /* In the future, maybe still need to deal with need_dasm.  */
8026   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REIP_REGNUM);
8027   if (record_full_arch_list_add_end ())
8028     return -1;
8029
8030   return 0;
8031
8032  no_support:
8033   printf_unfiltered (_("Process record does not support instruction 0x%02x "
8034                        "at address %s.\n"),
8035                      (unsigned int) (opcode),
8036                      paddress (gdbarch, ir.orig_addr));
8037   return -1;
8038 }
8039
8040 static const int i386_record_regmap[] =
8041 {
8042   I386_EAX_REGNUM, I386_ECX_REGNUM, I386_EDX_REGNUM, I386_EBX_REGNUM,
8043   I386_ESP_REGNUM, I386_EBP_REGNUM, I386_ESI_REGNUM, I386_EDI_REGNUM,
8044   0, 0, 0, 0, 0, 0, 0, 0,
8045   I386_EIP_REGNUM, I386_EFLAGS_REGNUM, I386_CS_REGNUM, I386_SS_REGNUM,
8046   I386_DS_REGNUM, I386_ES_REGNUM, I386_FS_REGNUM, I386_GS_REGNUM
8047 };
8048
8049 /* Check that the given address appears suitable for a fast
8050    tracepoint, which on x86-64 means that we need an instruction of at
8051    least 5 bytes, so that we can overwrite it with a 4-byte-offset
8052    jump and not have to worry about program jumps to an address in the
8053    middle of the tracepoint jump.  On x86, it may be possible to use
8054    4-byte jumps with a 2-byte offset to a trampoline located in the
8055    bottom 64 KiB of memory.  Returns 1 if OK, and writes a size
8056    of instruction to replace, and 0 if not, plus an explanatory
8057    string.  */
8058
8059 static int
8060 i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr,
8061                                char **msg)
8062 {
8063   int len, jumplen;
8064   static struct ui_file *gdb_null = NULL;
8065
8066   /*  Ask the target for the minimum instruction length supported.  */
8067   jumplen = target_get_min_fast_tracepoint_insn_len ();
8068
8069   if (jumplen < 0)
8070     {
8071       /* If the target does not support the get_min_fast_tracepoint_insn_len
8072          operation, assume that fast tracepoints will always be implemented
8073          using 4-byte relative jumps on both x86 and x86-64.  */
8074       jumplen = 5;
8075     }
8076   else if (jumplen == 0)
8077     {
8078       /* If the target does support get_min_fast_tracepoint_insn_len but
8079          returns zero, then the IPA has not loaded yet.  In this case,
8080          we optimistically assume that truncated 2-byte relative jumps
8081          will be available on x86, and compensate later if this assumption
8082          turns out to be incorrect.  On x86-64 architectures, 4-byte relative
8083          jumps will always be used.  */
8084       jumplen = (register_size (gdbarch, 0) == 8) ? 5 : 4;
8085     }
8086
8087   /* Dummy file descriptor for the disassembler.  */
8088   if (!gdb_null)
8089     gdb_null = ui_file_new ();
8090
8091   /* Check for fit.  */
8092   len = gdb_print_insn (gdbarch, addr, gdb_null, NULL);
8093
8094   if (len < jumplen)
8095     {
8096       /* Return a bit of target-specific detail to add to the caller's
8097          generic failure message.  */
8098       if (msg)
8099         *msg = xstrprintf (_("; instruction is only %d bytes long, "
8100                              "need at least %d bytes for the jump"),
8101                            len, jumplen);
8102       return 0;
8103     }
8104   else
8105     {
8106       if (msg)
8107         *msg = NULL;
8108       return 1;
8109     }
8110 }
8111
8112 static int
8113 i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
8114                        struct tdesc_arch_data *tdesc_data)
8115 {
8116   const struct target_desc *tdesc = tdep->tdesc;
8117   const struct tdesc_feature *feature_core;
8118
8119   const struct tdesc_feature *feature_sse, *feature_avx, *feature_mpx,
8120                              *feature_avx512;
8121   int i, num_regs, valid_p;
8122
8123   if (! tdesc_has_registers (tdesc))
8124     return 0;
8125
8126   /* Get core registers.  */
8127   feature_core = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.core");
8128   if (feature_core == NULL)
8129     return 0;
8130
8131   /* Get SSE registers.  */
8132   feature_sse = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.sse");
8133
8134   /* Try AVX registers.  */
8135   feature_avx = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx");
8136
8137   /* Try MPX registers.  */
8138   feature_mpx = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.mpx");
8139
8140   /* Try AVX512 registers.  */
8141   feature_avx512 = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx512");
8142
8143   valid_p = 1;
8144
8145   /* The XCR0 bits.  */
8146   if (feature_avx512)
8147     {
8148       /* AVX512 register description requires AVX register description.  */
8149       if (!feature_avx)
8150         return 0;
8151
8152       tdep->xcr0 = X86_XSTATE_MPX_AVX512_MASK;
8153
8154       /* It may have been set by OSABI initialization function.  */
8155       if (tdep->k0_regnum < 0)
8156         {
8157           tdep->k_register_names = i386_k_names;
8158           tdep->k0_regnum = I386_K0_REGNUM;
8159         }
8160
8161       for (i = 0; i < I387_NUM_K_REGS; i++)
8162         valid_p &= tdesc_numbered_register (feature_avx512, tdesc_data,
8163                                             tdep->k0_regnum + i,
8164                                             i386_k_names[i]);
8165
8166       if (tdep->num_zmm_regs == 0)
8167         {
8168           tdep->zmmh_register_names = i386_zmmh_names;
8169           tdep->num_zmm_regs = 8;
8170           tdep->zmm0h_regnum = I386_ZMM0H_REGNUM;
8171         }
8172
8173       for (i = 0; i < tdep->num_zmm_regs; i++)
8174         valid_p &= tdesc_numbered_register (feature_avx512, tdesc_data,
8175                                             tdep->zmm0h_regnum + i,
8176                                             tdep->zmmh_register_names[i]);
8177
8178       for (i = 0; i < tdep->num_xmm_avx512_regs; i++)
8179         valid_p &= tdesc_numbered_register (feature_avx512, tdesc_data,
8180                                             tdep->xmm16_regnum + i,
8181                                             tdep->xmm_avx512_register_names[i]);
8182
8183       for (i = 0; i < tdep->num_ymm_avx512_regs; i++)
8184         valid_p &= tdesc_numbered_register (feature_avx512, tdesc_data,
8185                                             tdep->ymm16h_regnum + i,
8186                                             tdep->ymm16h_register_names[i]);
8187     }
8188   if (feature_avx)
8189     {
8190       /* AVX register description requires SSE register description.  */
8191       if (!feature_sse)
8192         return 0;
8193
8194       if (!feature_avx512)
8195         tdep->xcr0 = X86_XSTATE_AVX_MASK;
8196
8197       /* It may have been set by OSABI initialization function.  */
8198       if (tdep->num_ymm_regs == 0)
8199         {
8200           tdep->ymmh_register_names = i386_ymmh_names;
8201           tdep->num_ymm_regs = 8;
8202           tdep->ymm0h_regnum = I386_YMM0H_REGNUM;
8203         }
8204
8205       for (i = 0; i < tdep->num_ymm_regs; i++)
8206         valid_p &= tdesc_numbered_register (feature_avx, tdesc_data,
8207                                             tdep->ymm0h_regnum + i,
8208                                             tdep->ymmh_register_names[i]);
8209     }
8210   else if (feature_sse)
8211     tdep->xcr0 = X86_XSTATE_SSE_MASK;
8212   else
8213     {
8214       tdep->xcr0 = X86_XSTATE_X87_MASK;
8215       tdep->num_xmm_regs = 0;
8216     }
8217
8218   num_regs = tdep->num_core_regs;
8219   for (i = 0; i < num_regs; i++)
8220     valid_p &= tdesc_numbered_register (feature_core, tdesc_data, i,
8221                                         tdep->register_names[i]);
8222
8223   if (feature_sse)
8224     {
8225       /* Need to include %mxcsr, so add one.  */
8226       num_regs += tdep->num_xmm_regs + 1;
8227       for (; i < num_regs; i++)
8228         valid_p &= tdesc_numbered_register (feature_sse, tdesc_data, i,
8229                                             tdep->register_names[i]);
8230     }
8231
8232   if (feature_mpx)
8233     {
8234       tdep->xcr0 |= X86_XSTATE_MPX_MASK;
8235
8236       if (tdep->bnd0r_regnum < 0)
8237         {
8238           tdep->mpx_register_names = i386_mpx_names;
8239           tdep->bnd0r_regnum = I386_BND0R_REGNUM;
8240           tdep->bndcfgu_regnum = I386_BNDCFGU_REGNUM;
8241         }
8242
8243       for (i = 0; i < I387_NUM_MPX_REGS; i++)
8244         valid_p &= tdesc_numbered_register (feature_mpx, tdesc_data,
8245             I387_BND0R_REGNUM (tdep) + i,
8246             tdep->mpx_register_names[i]);
8247     }
8248
8249   return valid_p;
8250 }
8251
8252 \f
8253 static struct gdbarch *
8254 i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
8255 {
8256   struct gdbarch_tdep *tdep;
8257   struct gdbarch *gdbarch;
8258   struct tdesc_arch_data *tdesc_data;
8259   const struct target_desc *tdesc;
8260   int mm0_regnum;
8261   int ymm0_regnum;
8262   int bnd0_regnum;
8263   int num_bnd_cooked;
8264   int k0_regnum;
8265   int zmm0_regnum;
8266
8267   /* If there is already a candidate, use it.  */
8268   arches = gdbarch_list_lookup_by_info (arches, &info);
8269   if (arches != NULL)
8270     return arches->gdbarch;
8271
8272   /* Allocate space for the new architecture.  */
8273   tdep = XCNEW (struct gdbarch_tdep);
8274   gdbarch = gdbarch_alloc (&info, tdep);
8275
8276   /* General-purpose registers.  */
8277   tdep->gregset_reg_offset = NULL;
8278   tdep->gregset_num_regs = I386_NUM_GREGS;
8279   tdep->sizeof_gregset = 0;
8280
8281   /* Floating-point registers.  */
8282   tdep->sizeof_fpregset = I387_SIZEOF_FSAVE;
8283   tdep->fpregset = &i386_fpregset;
8284
8285   /* The default settings include the FPU registers, the MMX registers
8286      and the SSE registers.  This can be overridden for a specific ABI
8287      by adjusting the members `st0_regnum', `mm0_regnum' and
8288      `num_xmm_regs' of `struct gdbarch_tdep', otherwise the registers
8289      will show up in the output of "info all-registers".  */
8290
8291   tdep->st0_regnum = I386_ST0_REGNUM;
8292
8293   /* I386_NUM_XREGS includes %mxcsr, so substract one.  */
8294   tdep->num_xmm_regs = I386_NUM_XREGS - 1;
8295
8296   tdep->jb_pc_offset = -1;
8297   tdep->struct_return = pcc_struct_return;
8298   tdep->sigtramp_start = 0;
8299   tdep->sigtramp_end = 0;
8300   tdep->sigtramp_p = i386_sigtramp_p;
8301   tdep->sigcontext_addr = NULL;
8302   tdep->sc_reg_offset = NULL;
8303   tdep->sc_pc_offset = -1;
8304   tdep->sc_sp_offset = -1;
8305
8306   tdep->xsave_xcr0_offset = -1;
8307
8308   tdep->record_regmap = i386_record_regmap;
8309
8310   set_gdbarch_long_long_align_bit (gdbarch, 32);
8311
8312   /* The format used for `long double' on almost all i386 targets is
8313      the i387 extended floating-point format.  In fact, of all targets
8314      in the GCC 2.95 tree, only OSF/1 does it different, and insists
8315      on having a `long double' that's not `long' at all.  */
8316   set_gdbarch_long_double_format (gdbarch, floatformats_i387_ext);
8317
8318   /* Although the i387 extended floating-point has only 80 significant
8319      bits, a `long double' actually takes up 96, probably to enforce
8320      alignment.  */
8321   set_gdbarch_long_double_bit (gdbarch, 96);
8322
8323   /* Register numbers of various important registers.  */
8324   set_gdbarch_sp_regnum (gdbarch, I386_ESP_REGNUM); /* %esp */
8325   set_gdbarch_pc_regnum (gdbarch, I386_EIP_REGNUM); /* %eip */
8326   set_gdbarch_ps_regnum (gdbarch, I386_EFLAGS_REGNUM); /* %eflags */
8327   set_gdbarch_fp0_regnum (gdbarch, I386_ST0_REGNUM); /* %st(0) */
8328
8329   /* NOTE: kettenis/20040418: GCC does have two possible register
8330      numbering schemes on the i386: dbx and SVR4.  These schemes
8331      differ in how they number %ebp, %esp, %eflags, and the
8332      floating-point registers, and are implemented by the arrays
8333      dbx_register_map[] and svr4_dbx_register_map in
8334      gcc/config/i386.c.  GCC also defines a third numbering scheme in
8335      gcc/config/i386.c, which it designates as the "default" register
8336      map used in 64bit mode.  This last register numbering scheme is
8337      implemented in dbx64_register_map, and is used for AMD64; see
8338      amd64-tdep.c.
8339
8340      Currently, each GCC i386 target always uses the same register
8341      numbering scheme across all its supported debugging formats
8342      i.e. SDB (COFF), stabs and DWARF 2.  This is because
8343      gcc/sdbout.c, gcc/dbxout.c and gcc/dwarf2out.c all use the
8344      DBX_REGISTER_NUMBER macro which is defined by each target's
8345      respective config header in a manner independent of the requested
8346      output debugging format.
8347
8348      This does not match the arrangement below, which presumes that
8349      the SDB and stabs numbering schemes differ from the DWARF and
8350      DWARF 2 ones.  The reason for this arrangement is that it is
8351      likely to get the numbering scheme for the target's
8352      default/native debug format right.  For targets where GCC is the
8353      native compiler (FreeBSD, NetBSD, OpenBSD, GNU/Linux) or for
8354      targets where the native toolchain uses a different numbering
8355      scheme for a particular debug format (stabs-in-ELF on Solaris)
8356      the defaults below will have to be overridden, like
8357      i386_elf_init_abi() does.  */
8358
8359   /* Use the dbx register numbering scheme for stabs and COFF.  */
8360   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_dbx_reg_to_regnum);
8361   set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_dbx_reg_to_regnum);
8362
8363   /* Use the SVR4 register numbering scheme for DWARF 2.  */
8364   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, i386_svr4_dwarf_reg_to_regnum);
8365
8366   /* We don't set gdbarch_stab_reg_to_regnum, since ECOFF doesn't seem to
8367      be in use on any of the supported i386 targets.  */
8368
8369   set_gdbarch_print_float_info (gdbarch, i387_print_float_info);
8370
8371   set_gdbarch_get_longjmp_target (gdbarch, i386_get_longjmp_target);
8372
8373   /* Call dummy code.  */
8374   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
8375   set_gdbarch_push_dummy_code (gdbarch, i386_push_dummy_code);
8376   set_gdbarch_push_dummy_call (gdbarch, i386_push_dummy_call);
8377   set_gdbarch_frame_align (gdbarch, i386_frame_align);
8378
8379   set_gdbarch_convert_register_p (gdbarch, i386_convert_register_p);
8380   set_gdbarch_register_to_value (gdbarch,  i386_register_to_value);
8381   set_gdbarch_value_to_register (gdbarch, i386_value_to_register);
8382
8383   set_gdbarch_return_value (gdbarch, i386_return_value);
8384
8385   set_gdbarch_skip_prologue (gdbarch, i386_skip_prologue);
8386
8387   /* Stack grows downward.  */
8388   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
8389
8390   set_gdbarch_breakpoint_from_pc (gdbarch, i386_breakpoint_from_pc);
8391   set_gdbarch_decr_pc_after_break (gdbarch, 1);
8392   set_gdbarch_max_insn_length (gdbarch, I386_MAX_INSN_LEN);
8393
8394   set_gdbarch_frame_args_skip (gdbarch, 8);
8395
8396   set_gdbarch_print_insn (gdbarch, i386_print_insn);
8397
8398   set_gdbarch_dummy_id (gdbarch, i386_dummy_id);
8399
8400   set_gdbarch_unwind_pc (gdbarch, i386_unwind_pc);
8401
8402   /* Add the i386 register groups.  */
8403   i386_add_reggroups (gdbarch);
8404   tdep->register_reggroup_p = i386_register_reggroup_p;
8405
8406   /* Helper for function argument information.  */
8407   set_gdbarch_fetch_pointer_argument (gdbarch, i386_fetch_pointer_argument);
8408
8409   /* Hook the function epilogue frame unwinder.  This unwinder is
8410      appended to the list first, so that it supercedes the DWARF
8411      unwinder in function epilogues (where the DWARF unwinder
8412      currently fails).  */
8413   frame_unwind_append_unwinder (gdbarch, &i386_epilogue_frame_unwind);
8414
8415   /* Hook in the DWARF CFI frame unwinder.  This unwinder is appended
8416      to the list before the prologue-based unwinders, so that DWARF
8417      CFI info will be used if it is available.  */
8418   dwarf2_append_unwinders (gdbarch);
8419
8420   frame_base_set_default (gdbarch, &i386_frame_base);
8421
8422   /* Pseudo registers may be changed by amd64_init_abi.  */
8423   set_gdbarch_pseudo_register_read_value (gdbarch,
8424                                           i386_pseudo_register_read_value);
8425   set_gdbarch_pseudo_register_write (gdbarch, i386_pseudo_register_write);
8426
8427   set_tdesc_pseudo_register_type (gdbarch, i386_pseudo_register_type);
8428   set_tdesc_pseudo_register_name (gdbarch, i386_pseudo_register_name);
8429
8430   /* Override the normal target description method to make the AVX
8431      upper halves anonymous.  */
8432   set_gdbarch_register_name (gdbarch, i386_register_name);
8433
8434   /* Even though the default ABI only includes general-purpose registers,
8435      floating-point registers and the SSE registers, we have to leave a
8436      gap for the upper AVX, MPX and AVX512 registers.  */
8437   set_gdbarch_num_regs (gdbarch, I386_AVX512_NUM_REGS);
8438
8439   set_gdbarch_gnu_triplet_regexp (gdbarch, i386_gnu_triplet_regexp);
8440
8441   /* Get the x86 target description from INFO.  */
8442   tdesc = info.target_desc;
8443   if (! tdesc_has_registers (tdesc))
8444     tdesc = tdesc_i386;
8445   tdep->tdesc = tdesc;
8446
8447   tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS;
8448   tdep->register_names = i386_register_names;
8449
8450   /* No upper YMM registers.  */
8451   tdep->ymmh_register_names = NULL;
8452   tdep->ymm0h_regnum = -1;
8453
8454   /* No upper ZMM registers.  */
8455   tdep->zmmh_register_names = NULL;
8456   tdep->zmm0h_regnum = -1;
8457
8458   /* No high XMM registers.  */
8459   tdep->xmm_avx512_register_names = NULL;
8460   tdep->xmm16_regnum = -1;
8461
8462   /* No upper YMM16-31 registers.  */
8463   tdep->ymm16h_register_names = NULL;
8464   tdep->ymm16h_regnum = -1;
8465
8466   tdep->num_byte_regs = 8;
8467   tdep->num_word_regs = 8;
8468   tdep->num_dword_regs = 0;
8469   tdep->num_mmx_regs = 8;
8470   tdep->num_ymm_regs = 0;
8471
8472   /* No MPX registers.  */
8473   tdep->bnd0r_regnum = -1;
8474   tdep->bndcfgu_regnum = -1;
8475
8476   /* No AVX512 registers.  */
8477   tdep->k0_regnum = -1;
8478   tdep->num_zmm_regs = 0;
8479   tdep->num_ymm_avx512_regs = 0;
8480   tdep->num_xmm_avx512_regs = 0;
8481
8482   tdesc_data = tdesc_data_alloc ();
8483
8484   set_gdbarch_relocate_instruction (gdbarch, i386_relocate_instruction);
8485
8486   set_gdbarch_gen_return_address (gdbarch, i386_gen_return_address);
8487
8488   set_gdbarch_insn_is_call (gdbarch, i386_insn_is_call);
8489   set_gdbarch_insn_is_ret (gdbarch, i386_insn_is_ret);
8490   set_gdbarch_insn_is_jump (gdbarch, i386_insn_is_jump);
8491
8492   /* Hook in ABI-specific overrides, if they have been registered.  */
8493   info.tdep_info = tdesc_data;
8494   gdbarch_init_osabi (info, gdbarch);
8495
8496   if (!i386_validate_tdesc_p (tdep, tdesc_data))
8497     {
8498       tdesc_data_cleanup (tdesc_data);
8499       xfree (tdep);
8500       gdbarch_free (gdbarch);
8501       return NULL;
8502     }
8503
8504   num_bnd_cooked = (tdep->bnd0r_regnum > 0 ? I387_NUM_BND_REGS : 0);
8505
8506   /* Wire in pseudo registers.  Number of pseudo registers may be
8507      changed.  */
8508   set_gdbarch_num_pseudo_regs (gdbarch, (tdep->num_byte_regs
8509                                          + tdep->num_word_regs
8510                                          + tdep->num_dword_regs
8511                                          + tdep->num_mmx_regs
8512                                          + tdep->num_ymm_regs
8513                                          + num_bnd_cooked
8514                                          + tdep->num_ymm_avx512_regs
8515                                          + tdep->num_zmm_regs));
8516
8517   /* Target description may be changed.  */
8518   tdesc = tdep->tdesc;
8519
8520   tdesc_use_registers (gdbarch, tdesc, tdesc_data);
8521
8522   /* Override gdbarch_register_reggroup_p set in tdesc_use_registers.  */
8523   set_gdbarch_register_reggroup_p (gdbarch, tdep->register_reggroup_p);
8524
8525   /* Make %al the first pseudo-register.  */
8526   tdep->al_regnum = gdbarch_num_regs (gdbarch);
8527   tdep->ax_regnum = tdep->al_regnum + tdep->num_byte_regs;
8528
8529   ymm0_regnum = tdep->ax_regnum + tdep->num_word_regs;
8530   if (tdep->num_dword_regs)
8531     {
8532       /* Support dword pseudo-register if it hasn't been disabled.  */
8533       tdep->eax_regnum = ymm0_regnum;
8534       ymm0_regnum += tdep->num_dword_regs;
8535     }
8536   else
8537     tdep->eax_regnum = -1;
8538
8539   mm0_regnum = ymm0_regnum;
8540   if (tdep->num_ymm_regs)
8541     {
8542       /* Support YMM pseudo-register if it is available.  */
8543       tdep->ymm0_regnum = ymm0_regnum;
8544       mm0_regnum += tdep->num_ymm_regs;
8545     }
8546   else
8547     tdep->ymm0_regnum = -1;
8548
8549   if (tdep->num_ymm_avx512_regs)
8550     {
8551       /* Support YMM16-31 pseudo registers if available.  */
8552       tdep->ymm16_regnum = mm0_regnum;
8553       mm0_regnum += tdep->num_ymm_avx512_regs;
8554     }
8555   else
8556     tdep->ymm16_regnum = -1;
8557
8558   if (tdep->num_zmm_regs)
8559     {
8560       /* Support ZMM pseudo-register if it is available.  */
8561       tdep->zmm0_regnum = mm0_regnum;
8562       mm0_regnum += tdep->num_zmm_regs;
8563     }
8564   else
8565     tdep->zmm0_regnum = -1;
8566
8567   bnd0_regnum = mm0_regnum;
8568   if (tdep->num_mmx_regs != 0)
8569     {
8570       /* Support MMX pseudo-register if MMX hasn't been disabled.  */
8571       tdep->mm0_regnum = mm0_regnum;
8572       bnd0_regnum += tdep->num_mmx_regs;
8573     }
8574   else
8575     tdep->mm0_regnum = -1;
8576
8577   if (tdep->bnd0r_regnum > 0)
8578       tdep->bnd0_regnum = bnd0_regnum;
8579   else
8580     tdep-> bnd0_regnum = -1;
8581
8582   /* Hook in the legacy prologue-based unwinders last (fallback).  */
8583   frame_unwind_append_unwinder (gdbarch, &i386_stack_tramp_frame_unwind);
8584   frame_unwind_append_unwinder (gdbarch, &i386_sigtramp_frame_unwind);
8585   frame_unwind_append_unwinder (gdbarch, &i386_frame_unwind);
8586
8587   /* If we have a register mapping, enable the generic core file
8588      support, unless it has already been enabled.  */
8589   if (tdep->gregset_reg_offset
8590       && !gdbarch_iterate_over_regset_sections_p (gdbarch))
8591     set_gdbarch_iterate_over_regset_sections
8592       (gdbarch, i386_iterate_over_regset_sections);
8593
8594   set_gdbarch_fast_tracepoint_valid_at (gdbarch,
8595                                         i386_fast_tracepoint_valid_at);
8596
8597   return gdbarch;
8598 }
8599
8600 static enum gdb_osabi
8601 i386_coff_osabi_sniffer (bfd *abfd)
8602 {
8603   if (strcmp (bfd_get_target (abfd), "coff-go32-exe") == 0
8604       || strcmp (bfd_get_target (abfd), "coff-go32") == 0)
8605     return GDB_OSABI_GO32;
8606
8607   return GDB_OSABI_UNKNOWN;
8608 }
8609 \f
8610
8611 /* Return the target description for a specified XSAVE feature mask.  */
8612
8613 const struct target_desc *
8614 i386_target_description (uint64_t xcr0)
8615 {
8616   switch (xcr0 & X86_XSTATE_ALL_MASK)
8617     {
8618     case X86_XSTATE_MPX_AVX512_MASK:
8619     case X86_XSTATE_AVX512_MASK:
8620       return tdesc_i386_avx512;
8621     case X86_XSTATE_MPX_MASK:
8622       return tdesc_i386_mpx;
8623     case X86_XSTATE_AVX_MASK:
8624       return tdesc_i386_avx;
8625     default:
8626       return tdesc_i386;
8627     }
8628 }
8629
8630 #define MPX_BASE_MASK (~(ULONGEST) 0xfff)
8631
8632 /* Find the bound directory base address.  */
8633
8634 static unsigned long
8635 i386_mpx_bd_base (void)
8636 {
8637   struct regcache *rcache;
8638   struct gdbarch_tdep *tdep;
8639   ULONGEST ret;
8640   enum register_status regstatus;
8641   struct gdb_exception except;
8642
8643   rcache = get_current_regcache ();
8644   tdep = gdbarch_tdep (get_regcache_arch (rcache));
8645
8646   regstatus = regcache_raw_read_unsigned (rcache, tdep->bndcfgu_regnum, &ret);
8647
8648   if (regstatus != REG_VALID)
8649     error (_("BNDCFGU register invalid, read status %d."), regstatus);
8650
8651   return ret & MPX_BASE_MASK;
8652 }
8653
8654 /* Check if the current target is MPX enabled.  */
8655
8656 static int
8657 i386_mpx_enabled (void)
8658 {
8659   const struct gdbarch_tdep *tdep = gdbarch_tdep (get_current_arch ());
8660   const struct target_desc *tdesc = tdep->tdesc;
8661
8662   return (tdesc_find_feature (tdesc, "org.gnu.gdb.i386.mpx") != NULL);
8663 }
8664
8665 #define MPX_BD_MASK     0xfffffff00000ULL       /* select bits [47:20]  */
8666 #define MPX_BT_MASK     0x0000000ffff8          /* select bits [19:3]   */
8667 #define MPX_BD_MASK_32  0xfffff000              /* select bits [31:12]  */
8668 #define MPX_BT_MASK_32  0x00000ffc              /* select bits [11:2]   */
8669
8670 /* Find the bound table entry given the pointer location and the base
8671    address of the table.  */
8672
8673 static CORE_ADDR
8674 i386_mpx_get_bt_entry (CORE_ADDR ptr, CORE_ADDR bd_base)
8675 {
8676   CORE_ADDR offset1;
8677   CORE_ADDR offset2;
8678   CORE_ADDR mpx_bd_mask, bd_ptr_r_shift, bd_ptr_l_shift;
8679   CORE_ADDR bt_mask, bt_select_r_shift, bt_select_l_shift;
8680   CORE_ADDR bd_entry_addr;
8681   CORE_ADDR bt_addr;
8682   CORE_ADDR bd_entry;
8683   struct gdbarch *gdbarch = get_current_arch ();
8684   struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
8685
8686
8687   if (gdbarch_ptr_bit (gdbarch) == 64)
8688     {
8689       mpx_bd_mask = (CORE_ADDR) MPX_BD_MASK;
8690       bd_ptr_r_shift = 20;
8691       bd_ptr_l_shift = 3;
8692       bt_select_r_shift = 3;
8693       bt_select_l_shift = 5;
8694       bt_mask = (CORE_ADDR) MPX_BT_MASK;
8695
8696       if ( sizeof (CORE_ADDR) == 4)
8697         error (_("bound table examination not supported\
8698  for 64-bit process with 32-bit GDB"));
8699     }
8700   else
8701     {
8702       mpx_bd_mask = MPX_BD_MASK_32;
8703       bd_ptr_r_shift = 12;
8704       bd_ptr_l_shift = 2;
8705       bt_select_r_shift = 2;
8706       bt_select_l_shift = 4;
8707       bt_mask = MPX_BT_MASK_32;
8708     }
8709
8710   offset1 = ((ptr & mpx_bd_mask) >> bd_ptr_r_shift) << bd_ptr_l_shift;
8711   bd_entry_addr = bd_base + offset1;
8712   bd_entry = read_memory_typed_address (bd_entry_addr, data_ptr_type);
8713
8714   if ((bd_entry & 0x1) == 0)
8715     error (_("Invalid bounds directory entry at %s."),
8716            paddress (get_current_arch (), bd_entry_addr));
8717
8718   /* Clearing status bit.  */
8719   bd_entry--;
8720   bt_addr = bd_entry & ~bt_select_r_shift;
8721   offset2 = ((ptr & bt_mask) >> bt_select_r_shift) << bt_select_l_shift;
8722
8723   return bt_addr + offset2;
8724 }
8725
8726 /* Print routine for the mpx bounds.  */
8727
8728 static void
8729 i386_mpx_print_bounds (const CORE_ADDR bt_entry[4])
8730 {
8731   struct ui_out *uiout = current_uiout;
8732   LONGEST size;
8733   struct gdbarch *gdbarch = get_current_arch ();
8734   CORE_ADDR onecompl = ~((CORE_ADDR) 0);
8735   int bounds_in_map = ((~bt_entry[1] == 0 && bt_entry[0] == onecompl) ? 1 : 0);
8736
8737   if (bounds_in_map == 1)
8738     {
8739       ui_out_text (uiout, "Null bounds on map:");
8740       ui_out_text (uiout, " pointer value = ");
8741       ui_out_field_core_addr (uiout, "pointer-value", gdbarch, bt_entry[2]);
8742       ui_out_text (uiout, ".");
8743       ui_out_text (uiout, "\n");
8744     }
8745   else
8746     {
8747       ui_out_text (uiout, "{lbound = ");
8748       ui_out_field_core_addr (uiout, "lower-bound", gdbarch, bt_entry[0]);
8749       ui_out_text (uiout, ", ubound = ");
8750
8751       /* The upper bound is stored in 1's complement.  */
8752       ui_out_field_core_addr (uiout, "upper-bound", gdbarch, ~bt_entry[1]);
8753       ui_out_text (uiout, "}: pointer value = ");
8754       ui_out_field_core_addr (uiout, "pointer-value", gdbarch, bt_entry[2]);
8755
8756       if (gdbarch_ptr_bit (gdbarch) == 64)
8757         size = ( (~(int64_t) bt_entry[1]) - (int64_t) bt_entry[0]);
8758       else
8759         size = ( ~((int32_t) bt_entry[1]) - (int32_t) bt_entry[0]);
8760
8761       /* In case the bounds are 0x0 and 0xffff... the difference will be -1.
8762          -1 represents in this sense full memory access, and there is no need
8763          one to the size.  */
8764
8765       size = (size > -1 ? size + 1 : size);
8766       ui_out_text (uiout, ", size = ");
8767       ui_out_field_fmt (uiout, "size", "%s", plongest (size));
8768
8769       ui_out_text (uiout, ", metadata = ");
8770       ui_out_field_core_addr (uiout, "metadata", gdbarch, bt_entry[3]);
8771       ui_out_text (uiout, "\n");
8772     }
8773 }
8774
8775 /* Implement the command "show mpx bound".  */
8776
8777 static void
8778 i386_mpx_info_bounds (char *args, int from_tty)
8779 {
8780   CORE_ADDR bd_base = 0;
8781   CORE_ADDR addr;
8782   CORE_ADDR bt_entry_addr = 0;
8783   CORE_ADDR bt_entry[4];
8784   int i;
8785   struct gdbarch *gdbarch = get_current_arch ();
8786   struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
8787
8788   if (!i386_mpx_enabled ())
8789     {
8790       printf_unfiltered (_("Intel(R) Memory Protection Extensions not "
8791                            "supported on this target.\n"));
8792       return;
8793     }
8794
8795   if (args == NULL)
8796     {
8797       printf_unfiltered (_("Address of pointer variable expected.\n"));
8798       return;
8799     }
8800
8801   addr = parse_and_eval_address (args);
8802
8803   bd_base = i386_mpx_bd_base ();
8804   bt_entry_addr = i386_mpx_get_bt_entry (addr, bd_base);
8805
8806   memset (bt_entry, 0, sizeof (bt_entry));
8807
8808   for (i = 0; i < 4; i++)
8809     bt_entry[i] = read_memory_typed_address (bt_entry_addr
8810                                              + i * TYPE_LENGTH (data_ptr_type),
8811                                              data_ptr_type);
8812
8813   i386_mpx_print_bounds (bt_entry);
8814 }
8815
8816 /* Implement the command "set mpx bound".  */
8817
8818 static void
8819 i386_mpx_set_bounds (char *args, int from_tty)
8820 {
8821   CORE_ADDR bd_base = 0;
8822   CORE_ADDR addr, lower, upper;
8823   CORE_ADDR bt_entry_addr = 0;
8824   CORE_ADDR bt_entry[2];
8825   const char *input = args;
8826   int i;
8827   struct gdbarch *gdbarch = get_current_arch ();
8828   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
8829   struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
8830
8831   if (!i386_mpx_enabled ())
8832     error (_("Intel(R) Memory Protection Extensions not supported\
8833  on this target."));
8834
8835   if (args == NULL)
8836     error (_("Pointer value expected."));
8837
8838   addr = value_as_address (parse_to_comma_and_eval (&input));
8839
8840   if (input[0] == ',')
8841     ++input;
8842   if (input[0] == '\0')
8843     error (_("wrong number of arguments: missing lower and upper bound."));
8844   lower = value_as_address (parse_to_comma_and_eval (&input));
8845
8846   if (input[0] == ',')
8847     ++input;
8848   if (input[0] == '\0')
8849     error (_("Wrong number of arguments; Missing upper bound."));
8850   upper = value_as_address (parse_to_comma_and_eval (&input));
8851
8852   bd_base = i386_mpx_bd_base ();
8853   bt_entry_addr = i386_mpx_get_bt_entry (addr, bd_base);
8854   for (i = 0; i < 2; i++)
8855     bt_entry[i] = read_memory_typed_address (bt_entry_addr
8856                                              + i * TYPE_LENGTH (data_ptr_type),
8857                                              data_ptr_type);
8858   bt_entry[0] = (uint64_t) lower;
8859   bt_entry[1] = ~(uint64_t) upper;
8860
8861   for (i = 0; i < 2; i++)
8862     write_memory_unsigned_integer (bt_entry_addr
8863                                    + i * TYPE_LENGTH (data_ptr_type),
8864                                    TYPE_LENGTH (data_ptr_type), byte_order,
8865                                    bt_entry[i]);
8866 }
8867
8868 static struct cmd_list_element *mpx_set_cmdlist, *mpx_show_cmdlist;
8869
8870 /* Helper function for the CLI commands.  */
8871
8872 static void
8873 set_mpx_cmd (char *args, int from_tty)
8874 {
8875   help_list (mpx_set_cmdlist, "set mpx ", all_commands, gdb_stdout);
8876 }
8877
8878 /* Helper function for the CLI commands.  */
8879
8880 static void
8881 show_mpx_cmd (char *args, int from_tty)
8882 {
8883   cmd_show_list (mpx_show_cmdlist, from_tty, "");
8884 }
8885
8886 /* Provide a prototype to silence -Wmissing-prototypes.  */
8887 void _initialize_i386_tdep (void);
8888
8889 void
8890 _initialize_i386_tdep (void)
8891 {
8892   register_gdbarch_init (bfd_arch_i386, i386_gdbarch_init);
8893
8894   /* Add the variable that controls the disassembly flavor.  */
8895   add_setshow_enum_cmd ("disassembly-flavor", no_class, valid_flavors,
8896                         &disassembly_flavor, _("\
8897 Set the disassembly flavor."), _("\
8898 Show the disassembly flavor."), _("\
8899 The valid values are \"att\" and \"intel\", and the default value is \"att\"."),
8900                         NULL,
8901                         NULL, /* FIXME: i18n: */
8902                         &setlist, &showlist);
8903
8904   /* Add the variable that controls the convention for returning
8905      structs.  */
8906   add_setshow_enum_cmd ("struct-convention", no_class, valid_conventions,
8907                         &struct_convention, _("\
8908 Set the convention for returning small structs."), _("\
8909 Show the convention for returning small structs."), _("\
8910 Valid values are \"default\", \"pcc\" and \"reg\", and the default value\n\
8911 is \"default\"."),
8912                         NULL,
8913                         NULL, /* FIXME: i18n: */
8914                         &setlist, &showlist);
8915
8916   /* Add "mpx" prefix for the set commands.  */
8917
8918   add_prefix_cmd ("mpx", class_support, set_mpx_cmd, _("\
8919 Set Intel(R) Memory Protection Extensions specific variables."),
8920                   &mpx_set_cmdlist, "set mpx ",
8921                   0 /* allow-unknown */, &setlist);
8922
8923   /* Add "mpx" prefix for the show commands.  */
8924
8925   add_prefix_cmd ("mpx", class_support, show_mpx_cmd, _("\
8926 Show Intel(R) Memory Protection Extensions specific variables."),
8927                   &mpx_show_cmdlist, "show mpx ",
8928                   0 /* allow-unknown */, &showlist);
8929
8930   /* Add "bound" command for the show mpx commands list.  */
8931
8932   add_cmd ("bound", no_class, i386_mpx_info_bounds,
8933            "Show the memory bounds for a given array/pointer storage\
8934  in the bound table.",
8935            &mpx_show_cmdlist);
8936
8937   /* Add "bound" command for the set mpx commands list.  */
8938
8939   add_cmd ("bound", no_class, i386_mpx_set_bounds,
8940            "Set the memory bounds for a given array/pointer storage\
8941  in the bound table.",
8942            &mpx_set_cmdlist);
8943
8944   gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour,
8945                                   i386_coff_osabi_sniffer);
8946
8947   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_SVR4,
8948                           i386_svr4_init_abi);
8949   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_GO32,
8950                           i386_go32_init_abi);
8951
8952   /* Initialize the i386-specific register groups.  */
8953   i386_init_reggroups ();
8954
8955   /* Initialize the standard target descriptions.  */
8956   initialize_tdesc_i386 ();
8957   initialize_tdesc_i386_mmx ();
8958   initialize_tdesc_i386_avx ();
8959   initialize_tdesc_i386_mpx ();
8960   initialize_tdesc_i386_avx512 ();
8961
8962   /* Tell remote stub that we support XML target description.  */
8963   register_remote_support_xml ("i386");
8964 }