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