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