gdb/i386-tdep.c

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