gdb/i386-tdep.c

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