gdb/i386-tdep.c

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