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