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