gdb/i386-tdep.c

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