gdb/i386-tdep.c

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