gdb/i386-tdep.c

   1 /* Intel 386 target-dependent stuff.
   2
   3    Copyright (C) 1988-2014 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   if (!cache->base_p)
1909     (*this_id) = frame_id_build_unavailable_stack (cache->pc);
1910   else if (cache->base == 0)
1911     {
1912       /* This marks the outermost frame.  */
1913     }
1914   else
1915     {
1916       /* See the end of i386_push_dummy_call.  */
1917       (*this_id) = frame_id_build (cache->base + 8, cache->pc);
1918     }
1919 }
1920
1921 static enum unwind_stop_reason
1922 i386_frame_unwind_stop_reason (struct frame_info *this_frame,
1923                                void **this_cache)
1924 {
1925   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
1926
1927   if (!cache->base_p)
1928     return UNWIND_UNAVAILABLE;
1929
1930   /* This marks the outermost frame.  */
1931   if (cache->base == 0)
1932     return UNWIND_OUTERMOST;
1933
1934   return UNWIND_NO_REASON;
1935 }
1936
1937 static struct value *
1938 i386_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1939                           int regnum)
1940 {
1941   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
1942
1943   gdb_assert (regnum >= 0);
1944
1945   /* The System V ABI says that:
1946
1947      "The flags register contains the system flags, such as the
1948      direction flag and the carry flag.  The direction flag must be
1949      set to the forward (that is, zero) direction before entry and
1950      upon exit from a function.  Other user flags have no specified
1951      role in the standard calling sequence and are not preserved."
1952
1953      To guarantee the "upon exit" part of that statement we fake a
1954      saved flags register that has its direction flag cleared.
1955
1956      Note that GCC doesn't seem to rely on the fact that the direction
1957      flag is cleared after a function return; it always explicitly
1958      clears the flag before operations where it matters.
1959
1960      FIXME: kettenis/20030316: I'm not quite sure whether this is the
1961      right thing to do.  The way we fake the flags register here makes
1962      it impossible to change it.  */
1963
1964   if (regnum == I386_EFLAGS_REGNUM)
1965     {
1966       ULONGEST val;
1967
1968       val = get_frame_register_unsigned (this_frame, regnum);
1969       val &= ~(1 << 10);
1970       return frame_unwind_got_constant (this_frame, regnum, val);
1971     }
1972
1973   if (regnum == I386_EIP_REGNUM && cache->pc_in_eax)
1974     return frame_unwind_got_register (this_frame, regnum, I386_EAX_REGNUM);
1975
1976   if (regnum == I386_ESP_REGNUM
1977       && (cache->saved_sp != 0 || cache->saved_sp_reg != -1))
1978     {
1979       /* If the SP has been saved, but we don't know where, then this
1980          means that SAVED_SP_REG register was found unavailable back
1981          when we built the cache.  */
1982       if (cache->saved_sp == 0)
1983         return frame_unwind_got_register (this_frame, regnum,
1984                                           cache->saved_sp_reg);
1985       else
1986         return frame_unwind_got_constant (this_frame, regnum,
1987                                           cache->saved_sp);
1988     }
1989
1990   if (regnum < I386_NUM_SAVED_REGS && cache->saved_regs[regnum] != -1)
1991     return frame_unwind_got_memory (this_frame, regnum,
1992                                     cache->saved_regs[regnum]);
1993
1994   return frame_unwind_got_register (this_frame, regnum, regnum);
1995 }
1996
1997 static const struct frame_unwind i386_frame_unwind =
1998 {
1999   NORMAL_FRAME,
2000   i386_frame_unwind_stop_reason,
2001   i386_frame_this_id,
2002   i386_frame_prev_register,
2003   NULL,
2004   default_frame_sniffer
2005 };
2006
2007 /* Normal frames, but in a function epilogue.  */
2008
2009 /* The epilogue is defined here as the 'ret' instruction, which will
2010    follow any instruction such as 'leave' or 'pop %ebp' that destroys
2011    the function's stack frame.  */
2012
2013 static int
2014 i386_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2015 {
2016   gdb_byte insn;
2017   struct symtab *symtab;
2018
2019   symtab = find_pc_symtab (pc);
2020   if (symtab && symtab->epilogue_unwind_valid)
2021     return 0;
2022
2023   if (target_read_memory (pc, &insn, 1))
2024     return 0;   /* Can't read memory at pc.  */
2025
2026   if (insn != 0xc3)     /* 'ret' instruction.  */
2027     return 0;
2028
2029   return 1;
2030 }
2031
2032 static int
2033 i386_epilogue_frame_sniffer (const struct frame_unwind *self,
2034                              struct frame_info *this_frame,
2035                              void **this_prologue_cache)
2036 {
2037   if (frame_relative_level (this_frame) == 0)
2038     return i386_in_function_epilogue_p (get_frame_arch (this_frame),
2039                                         get_frame_pc (this_frame));
2040   else
2041     return 0;
2042 }
2043
2044 static struct i386_frame_cache *
2045 i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
2046 {
2047   volatile struct gdb_exception ex;
2048   struct i386_frame_cache *cache;
2049   CORE_ADDR sp;
2050
2051   if (*this_cache)
2052     return *this_cache;
2053
2054   cache = i386_alloc_frame_cache ();
2055   *this_cache = cache;
2056
2057   TRY_CATCH (ex, RETURN_MASK_ERROR)
2058     {
2059       cache->pc = get_frame_func (this_frame);
2060
2061       /* At this point the stack looks as if we just entered the
2062          function, with the return address at the top of the
2063          stack.  */
2064       sp = get_frame_register_unsigned (this_frame, I386_ESP_REGNUM);
2065       cache->base = sp + cache->sp_offset;
2066       cache->saved_sp = cache->base + 8;
2067       cache->saved_regs[I386_EIP_REGNUM] = cache->base + 4;
2068
2069       cache->base_p = 1;
2070     }
2071   if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
2072     throw_exception (ex);
2073
2074   return cache;
2075 }
2076
2077 static enum unwind_stop_reason
2078 i386_epilogue_frame_unwind_stop_reason (struct frame_info *this_frame,
2079                                         void **this_cache)
2080 {
2081   struct i386_frame_cache *cache =
2082     i386_epilogue_frame_cache (this_frame, this_cache);
2083
2084   if (!cache->base_p)
2085     return UNWIND_UNAVAILABLE;
2086
2087   return UNWIND_NO_REASON;
2088 }
2089
2090 static void
2091 i386_epilogue_frame_this_id (struct frame_info *this_frame,
2092                              void **this_cache,
2093                              struct frame_id *this_id)
2094 {
2095   struct i386_frame_cache *cache =
2096     i386_epilogue_frame_cache (this_frame, this_cache);
2097
2098   if (!cache->base_p)
2099     (*this_id) = frame_id_build_unavailable_stack (cache->pc);
2100   else
2101     (*this_id) = frame_id_build (cache->base + 8, cache->pc);
2102 }
2103
2104 static struct value *
2105 i386_epilogue_frame_prev_register (struct frame_info *this_frame,
2106                                    void **this_cache, int regnum)
2107 {
2108   /* Make sure we've initialized the cache.  */
2109   i386_epilogue_frame_cache (this_frame, this_cache);
2110
2111   return i386_frame_prev_register (this_frame, this_cache, regnum);
2112 }
2113
2114 static const struct frame_unwind i386_epilogue_frame_unwind =
2115 {
2116   NORMAL_FRAME,
2117   i386_epilogue_frame_unwind_stop_reason,
2118   i386_epilogue_frame_this_id,
2119   i386_epilogue_frame_prev_register,
2120   NULL,
2121   i386_epilogue_frame_sniffer
2122 };
2123 \f
2124
2125 /* Stack-based trampolines.  */
2126
2127 /* These trampolines are used on cross x86 targets, when taking the
2128    address of a nested function.  When executing these trampolines,
2129    no stack frame is set up, so we are in a similar situation as in
2130    epilogues and i386_epilogue_frame_this_id can be re-used.  */
2131
2132 /* Static chain passed in register.  */
2133
2134 struct i386_insn i386_tramp_chain_in_reg_insns[] =
2135 {
2136   /* `movl imm32, %eax' and `movl imm32, %ecx' */
2137   { 5, { 0xb8 }, { 0xfe } },
2138
2139   /* `jmp imm32' */
2140   { 5, { 0xe9 }, { 0xff } },
2141
2142   {0}
2143 };
2144
2145 /* Static chain passed on stack (when regparm=3).  */
2146
2147 struct i386_insn i386_tramp_chain_on_stack_insns[] =
2148 {
2149   /* `push imm32' */
2150   { 5, { 0x68 }, { 0xff } },
2151
2152   /* `jmp imm32' */
2153   { 5, { 0xe9 }, { 0xff } },
2154
2155   {0}
2156 };
2157
2158 /* Return whether PC points inside a stack trampoline.   */
2159
2160 static int
2161 i386_in_stack_tramp_p (CORE_ADDR pc)
2162 {
2163   gdb_byte insn;
2164   const char *name;
2165
2166   /* A stack trampoline is detected if no name is associated
2167     to the current pc and if it points inside a trampoline
2168     sequence.  */
2169
2170   find_pc_partial_function (pc, &name, NULL, NULL);
2171   if (name)
2172     return 0;
2173
2174   if (target_read_memory (pc, &insn, 1))
2175     return 0;
2176
2177   if (!i386_match_insn_block (pc, i386_tramp_chain_in_reg_insns)
2178       && !i386_match_insn_block (pc, i386_tramp_chain_on_stack_insns))
2179     return 0;
2180
2181   return 1;
2182 }
2183
2184 static int
2185 i386_stack_tramp_frame_sniffer (const struct frame_unwind *self,
2186                                 struct frame_info *this_frame,
2187                                 void **this_cache)
2188 {
2189   if (frame_relative_level (this_frame) == 0)
2190     return i386_in_stack_tramp_p (get_frame_pc (this_frame));
2191   else
2192     return 0;
2193 }
2194
2195 static const struct frame_unwind i386_stack_tramp_frame_unwind =
2196 {
2197   NORMAL_FRAME,
2198   i386_epilogue_frame_unwind_stop_reason,
2199   i386_epilogue_frame_this_id,
2200   i386_epilogue_frame_prev_register,
2201   NULL,
2202   i386_stack_tramp_frame_sniffer
2203 };
2204 \f
2205 /* Generate a bytecode expression to get the value of the saved PC.  */
2206
2207 static void
2208 i386_gen_return_address (struct gdbarch *gdbarch,
2209                          struct agent_expr *ax, struct axs_value *value,
2210                          CORE_ADDR scope)
2211 {
2212   /* The following sequence assumes the traditional use of the base
2213      register.  */
2214   ax_reg (ax, I386_EBP_REGNUM);
2215   ax_const_l (ax, 4);
2216   ax_simple (ax, aop_add);
2217   value->type = register_type (gdbarch, I386_EIP_REGNUM);
2218   value->kind = axs_lvalue_memory;
2219 }
2220 \f
2221
2222 /* Signal trampolines.  */
2223
2224 static struct i386_frame_cache *
2225 i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
2226 {
2227   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2228   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2229   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2230   volatile struct gdb_exception ex;
2231   struct i386_frame_cache *cache;
2232   CORE_ADDR addr;
2233   gdb_byte buf[4];
2234
2235   if (*this_cache)
2236     return *this_cache;
2237
2238   cache = i386_alloc_frame_cache ();
2239
2240   TRY_CATCH (ex, RETURN_MASK_ERROR)
2241     {
2242       get_frame_register (this_frame, I386_ESP_REGNUM, buf);
2243       cache->base = extract_unsigned_integer (buf, 4, byte_order) - 4;
2244
2245       addr = tdep->sigcontext_addr (this_frame);
2246       if (tdep->sc_reg_offset)
2247         {
2248           int i;
2249
2250           gdb_assert (tdep->sc_num_regs <= I386_NUM_SAVED_REGS);
2251
2252           for (i = 0; i < tdep->sc_num_regs; i++)
2253             if (tdep->sc_reg_offset[i] != -1)
2254               cache->saved_regs[i] = addr + tdep->sc_reg_offset[i];
2255         }
2256       else
2257         {
2258           cache->saved_regs[I386_EIP_REGNUM] = addr + tdep->sc_pc_offset;
2259           cache->saved_regs[I386_ESP_REGNUM] = addr + tdep->sc_sp_offset;
2260         }
2261
2262       cache->base_p = 1;
2263     }
2264   if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
2265     throw_exception (ex);
2266
2267   *this_cache = cache;
2268   return cache;
2269 }
2270
2271 static enum unwind_stop_reason
2272 i386_sigtramp_frame_unwind_stop_reason (struct frame_info *this_frame,
2273                                         void **this_cache)
2274 {
2275   struct i386_frame_cache *cache =
2276     i386_sigtramp_frame_cache (this_frame, this_cache);
2277
2278   if (!cache->base_p)
2279     return UNWIND_UNAVAILABLE;
2280
2281   return UNWIND_NO_REASON;
2282 }
2283
2284 static void
2285 i386_sigtramp_frame_this_id (struct frame_info *this_frame, void **this_cache,
2286                              struct frame_id *this_id)
2287 {
2288   struct i386_frame_cache *cache =
2289     i386_sigtramp_frame_cache (this_frame, this_cache);
2290
2291   if (!cache->base_p)
2292     (*this_id) = frame_id_build_unavailable_stack (get_frame_pc (this_frame));
2293   else
2294     {
2295       /* See the end of i386_push_dummy_call.  */
2296       (*this_id) = frame_id_build (cache->base + 8, get_frame_pc (this_frame));
2297     }
2298 }
2299
2300 static struct value *
2301 i386_sigtramp_frame_prev_register (struct frame_info *this_frame,
2302                                    void **this_cache, int regnum)
2303 {
2304   /* Make sure we've initialized the cache.  */
2305   i386_sigtramp_frame_cache (this_frame, this_cache);
2306
2307   return i386_frame_prev_register (this_frame, this_cache, regnum);
2308 }
2309
2310 static int
2311 i386_sigtramp_frame_sniffer (const struct frame_unwind *self,
2312                              struct frame_info *this_frame,
2313                              void **this_prologue_cache)
2314 {
2315   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
2316
2317   /* We shouldn't even bother if we don't have a sigcontext_addr
2318      handler.  */
2319   if (tdep->sigcontext_addr == NULL)
2320     return 0;
2321
2322   if (tdep->sigtramp_p != NULL)
2323     {
2324       if (tdep->sigtramp_p (this_frame))
2325         return 1;
2326     }
2327
2328   if (tdep->sigtramp_start != 0)
2329     {
2330       CORE_ADDR pc = get_frame_pc (this_frame);
2331
2332       gdb_assert (tdep->sigtramp_end != 0);
2333       if (pc >= tdep->sigtramp_start && pc < tdep->sigtramp_end)
2334         return 1;
2335     }
2336
2337   return 0;
2338 }
2339
2340 static const struct frame_unwind i386_sigtramp_frame_unwind =
2341 {
2342   SIGTRAMP_FRAME,
2343   i386_sigtramp_frame_unwind_stop_reason,
2344   i386_sigtramp_frame_this_id,
2345   i386_sigtramp_frame_prev_register,
2346   NULL,
2347   i386_sigtramp_frame_sniffer
2348 };
2349 \f
2350
2351 static CORE_ADDR
2352 i386_frame_base_address (struct frame_info *this_frame, void **this_cache)
2353 {
2354   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
2355
2356   return cache->base;
2357 }
2358
2359 static const struct frame_base i386_frame_base =
2360 {
2361   &i386_frame_unwind,
2362   i386_frame_base_address,
2363   i386_frame_base_address,
2364   i386_frame_base_address
2365 };
2366
2367 static struct frame_id
2368 i386_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2369 {
2370   CORE_ADDR fp;
2371
2372   fp = get_frame_register_unsigned (this_frame, I386_EBP_REGNUM);
2373
2374   /* See the end of i386_push_dummy_call.  */
2375   return frame_id_build (fp + 8, get_frame_pc (this_frame));
2376 }
2377
2378 /* _Decimal128 function return values need 16-byte alignment on the
2379    stack.  */
2380
2381 static CORE_ADDR
2382 i386_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2383 {
2384   return sp & -(CORE_ADDR)16;
2385 }
2386 \f
2387
2388 /* Figure out where the longjmp will land.  Slurp the args out of the
2389    stack.  We expect the first arg to be a pointer to the jmp_buf
2390    structure from which we extract the address that we will land at.
2391    This address is copied into PC.  This routine returns non-zero on
2392    success.  */
2393
2394 static int
2395 i386_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
2396 {
2397   gdb_byte buf[4];
2398   CORE_ADDR sp, jb_addr;
2399   struct gdbarch *gdbarch = get_frame_arch (frame);
2400   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2401   int jb_pc_offset = gdbarch_tdep (gdbarch)->jb_pc_offset;
2402
2403   /* If JB_PC_OFFSET is -1, we have no way to find out where the
2404      longjmp will land.  */
2405   if (jb_pc_offset == -1)
2406     return 0;
2407
2408   get_frame_register (frame, I386_ESP_REGNUM, buf);
2409   sp = extract_unsigned_integer (buf, 4, byte_order);
2410   if (target_read_memory (sp + 4, buf, 4))
2411     return 0;
2412
2413   jb_addr = extract_unsigned_integer (buf, 4, byte_order);
2414   if (target_read_memory (jb_addr + jb_pc_offset, buf, 4))
2415     return 0;
2416
2417   *pc = extract_unsigned_integer (buf, 4, byte_order);
2418   return 1;
2419 }
2420 \f
2421
2422 /* Check whether TYPE must be 16-byte-aligned when passed as a
2423    function argument.  16-byte vectors, _Decimal128 and structures or
2424    unions containing such types must be 16-byte-aligned; other
2425    arguments are 4-byte-aligned.  */
2426
2427 static int
2428 i386_16_byte_align_p (struct type *type)
2429 {
2430   type = check_typedef (type);
2431   if ((TYPE_CODE (type) == TYPE_CODE_DECFLOAT
2432        || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)))
2433       && TYPE_LENGTH (type) == 16)
2434     return 1;
2435   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
2436     return i386_16_byte_align_p (TYPE_TARGET_TYPE (type));
2437   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2438       || TYPE_CODE (type) == TYPE_CODE_UNION)
2439     {
2440       int i;
2441       for (i = 0; i < TYPE_NFIELDS (type); i++)
2442         {
2443           if (i386_16_byte_align_p (TYPE_FIELD_TYPE (type, i)))
2444             return 1;
2445         }
2446     }
2447   return 0;
2448 }
2449
2450 /* Implementation for set_gdbarch_push_dummy_code.  */
2451
2452 static CORE_ADDR
2453 i386_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr,
2454                       struct value **args, int nargs, struct type *value_type,
2455                       CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
2456                       struct regcache *regcache)
2457 {
2458   /* Use 0xcc breakpoint - 1 byte.  */
2459   *bp_addr = sp - 1;
2460   *real_pc = funaddr;
2461
2462   /* Keep the stack aligned.  */
2463   return sp - 16;
2464 }
2465
2466 static CORE_ADDR
2467 i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
2468                       struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
2469                       struct value **args, CORE_ADDR sp, int struct_return,
2470                       CORE_ADDR struct_addr)
2471 {
2472   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2473   gdb_byte buf[4];
2474   int i;
2475   int write_pass;
2476   int args_space = 0;
2477
2478   /* Determine the total space required for arguments and struct
2479      return address in a first pass (allowing for 16-byte-aligned
2480      arguments), then push arguments in a second pass.  */
2481
2482   for (write_pass = 0; write_pass < 2; write_pass++)
2483     {
2484       int args_space_used = 0;
2485
2486       if (struct_return)
2487         {
2488           if (write_pass)
2489             {
2490               /* Push value address.  */
2491               store_unsigned_integer (buf, 4, byte_order, struct_addr);
2492               write_memory (sp, buf, 4);
2493               args_space_used += 4;
2494             }
2495           else
2496             args_space += 4;
2497         }
2498
2499       for (i = 0; i < nargs; i++)
2500         {
2501           int len = TYPE_LENGTH (value_enclosing_type (args[i]));
2502
2503           if (write_pass)
2504             {
2505               if (i386_16_byte_align_p (value_enclosing_type (args[i])))
2506                 args_space_used = align_up (args_space_used, 16);
2507
2508               write_memory (sp + args_space_used,
2509                             value_contents_all (args[i]), len);
2510               /* The System V ABI says that:
2511
2512               "An argument's size is increased, if necessary, to make it a
2513               multiple of [32-bit] words.  This may require tail padding,
2514               depending on the size of the argument."
2515
2516               This makes sure the stack stays word-aligned.  */
2517               args_space_used += align_up (len, 4);
2518             }
2519           else
2520             {
2521               if (i386_16_byte_align_p (value_enclosing_type (args[i])))
2522                 args_space = align_up (args_space, 16);
2523               args_space += align_up (len, 4);
2524             }
2525         }
2526
2527       if (!write_pass)
2528         {
2529           sp -= args_space;
2530
2531           /* The original System V ABI only requires word alignment,
2532              but modern incarnations need 16-byte alignment in order
2533              to support SSE.  Since wasting a few bytes here isn't
2534              harmful we unconditionally enforce 16-byte alignment.  */
2535           sp &= ~0xf;
2536         }
2537     }
2538
2539   /* Store return address.  */
2540   sp -= 4;
2541   store_unsigned_integer (buf, 4, byte_order, bp_addr);
2542   write_memory (sp, buf, 4);
2543
2544   /* Finally, update the stack pointer...  */
2545   store_unsigned_integer (buf, 4, byte_order, sp);
2546   regcache_cooked_write (regcache, I386_ESP_REGNUM, buf);
2547
2548   /* ...and fake a frame pointer.  */
2549   regcache_cooked_write (regcache, I386_EBP_REGNUM, buf);
2550
2551   /* MarkK wrote: This "+ 8" is all over the place:
2552      (i386_frame_this_id, i386_sigtramp_frame_this_id,
2553      i386_dummy_id).  It's there, since all frame unwinders for
2554      a given target have to agree (within a certain margin) on the
2555      definition of the stack address of a frame.  Otherwise frame id
2556      comparison might not work correctly.  Since DWARF2/GCC uses the
2557      stack address *before* the function call as a frame's CFA.  On
2558      the i386, when %ebp is used as a frame pointer, the offset
2559      between the contents %ebp and the CFA as defined by GCC.  */
2560   return sp + 8;
2561 }
2562
2563 /* These registers are used for returning integers (and on some
2564    targets also for returning `struct' and `union' values when their
2565    size and alignment match an integer type).  */
2566 #define LOW_RETURN_REGNUM       I386_EAX_REGNUM /* %eax */
2567 #define HIGH_RETURN_REGNUM      I386_EDX_REGNUM /* %edx */
2568
2569 /* Read, for architecture GDBARCH, a function return value of TYPE
2570    from REGCACHE, and copy that into VALBUF.  */
2571
2572 static void
2573 i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
2574                            struct regcache *regcache, gdb_byte *valbuf)
2575 {
2576   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2577   int len = TYPE_LENGTH (type);
2578   gdb_byte buf[I386_MAX_REGISTER_SIZE];
2579
2580   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2581     {
2582       if (tdep->st0_regnum < 0)
2583         {
2584           warning (_("Cannot find floating-point return value."));
2585           memset (valbuf, 0, len);
2586           return;
2587         }
2588
2589       /* Floating-point return values can be found in %st(0).  Convert
2590          its contents to the desired type.  This is probably not
2591          exactly how it would happen on the target itself, but it is
2592          the best we can do.  */
2593       regcache_raw_read (regcache, I386_ST0_REGNUM, buf);
2594       convert_typed_floating (buf, i387_ext_type (gdbarch), valbuf, type);
2595     }
2596   else
2597     {
2598       int low_size = register_size (gdbarch, LOW_RETURN_REGNUM);
2599       int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM);
2600
2601       if (len <= low_size)
2602         {
2603           regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
2604           memcpy (valbuf, buf, len);
2605         }
2606       else if (len <= (low_size + high_size))
2607         {
2608           regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
2609           memcpy (valbuf, buf, low_size);
2610           regcache_raw_read (regcache, HIGH_RETURN_REGNUM, buf);
2611           memcpy (valbuf + low_size, buf, len - low_size);
2612         }
2613       else
2614         internal_error (__FILE__, __LINE__,
2615                         _("Cannot extract return value of %d bytes long."),
2616                         len);
2617     }
2618 }
2619
2620 /* Write, for architecture GDBARCH, a function return value of TYPE
2621    from VALBUF into REGCACHE.  */
2622
2623 static void
2624 i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
2625                          struct regcache *regcache, const gdb_byte *valbuf)
2626 {
2627   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2628   int len = TYPE_LENGTH (type);
2629
2630   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2631     {
2632       ULONGEST fstat;
2633       gdb_byte buf[I386_MAX_REGISTER_SIZE];
2634
2635       if (tdep->st0_regnum < 0)
2636         {
2637           warning (_("Cannot set floating-point return value."));
2638           return;
2639         }
2640
2641       /* Returning floating-point values is a bit tricky.  Apart from
2642          storing the return value in %st(0), we have to simulate the
2643          state of the FPU at function return point.  */
2644
2645       /* Convert the value found in VALBUF to the extended
2646          floating-point format used by the FPU.  This is probably
2647          not exactly how it would happen on the target itself, but
2648          it is the best we can do.  */
2649       convert_typed_floating (valbuf, type, buf, i387_ext_type (gdbarch));
2650       regcache_raw_write (regcache, I386_ST0_REGNUM, buf);
2651
2652       /* Set the top of the floating-point register stack to 7.  The
2653          actual value doesn't really matter, but 7 is what a normal
2654          function return would end up with if the program started out
2655          with a freshly initialized FPU.  */
2656       regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
2657       fstat |= (7 << 11);
2658       regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM (tdep), fstat);
2659
2660       /* Mark %st(1) through %st(7) as empty.  Since we set the top of
2661          the floating-point register stack to 7, the appropriate value
2662          for the tag word is 0x3fff.  */
2663       regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM (tdep), 0x3fff);
2664     }
2665   else
2666     {
2667       int low_size = register_size (gdbarch, LOW_RETURN_REGNUM);
2668       int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM);
2669
2670       if (len <= low_size)
2671         regcache_raw_write_part (regcache, LOW_RETURN_REGNUM, 0, len, valbuf);
2672       else if (len <= (low_size + high_size))
2673         {
2674           regcache_raw_write (regcache, LOW_RETURN_REGNUM, valbuf);
2675           regcache_raw_write_part (regcache, HIGH_RETURN_REGNUM, 0,
2676                                    len - low_size, valbuf + low_size);
2677         }
2678       else
2679         internal_error (__FILE__, __LINE__,
2680                         _("Cannot store return value of %d bytes long."), len);
2681     }
2682 }
2683 \f
2684
2685 /* This is the variable that is set with "set struct-convention", and
2686    its legitimate values.  */
2687 static const char default_struct_convention[] = "default";
2688 static const char pcc_struct_convention[] = "pcc";
2689 static const char reg_struct_convention[] = "reg";
2690 static const char *const valid_conventions[] =
2691 {
2692   default_struct_convention,
2693   pcc_struct_convention,
2694   reg_struct_convention,
2695   NULL
2696 };
2697 static const char *struct_convention = default_struct_convention;
2698
2699 /* Return non-zero if TYPE, which is assumed to be a structure,
2700    a union type, or an array type, should be returned in registers
2701    for architecture GDBARCH.  */
2702
2703 static int
2704 i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
2705 {
2706   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2707   enum type_code code = TYPE_CODE (type);
2708   int len = TYPE_LENGTH (type);
2709
2710   gdb_assert (code == TYPE_CODE_STRUCT
2711               || code == TYPE_CODE_UNION
2712               || code == TYPE_CODE_ARRAY);
2713
2714   if (struct_convention == pcc_struct_convention
2715       || (struct_convention == default_struct_convention
2716           && tdep->struct_return == pcc_struct_return))
2717     return 0;
2718
2719   /* Structures consisting of a single `float', `double' or 'long
2720      double' member are returned in %st(0).  */
2721   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2722     {
2723       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
2724       if (TYPE_CODE (type) == TYPE_CODE_FLT)
2725         return (len == 4 || len == 8 || len == 12);
2726     }
2727
2728   return (len == 1 || len == 2 || len == 4 || len == 8);
2729 }
2730
2731 /* Determine, for architecture GDBARCH, how a return value of TYPE
2732    should be returned.  If it is supposed to be returned in registers,
2733    and READBUF is non-zero, read the appropriate value from REGCACHE,
2734    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
2735    from WRITEBUF into REGCACHE.  */
2736
2737 static enum return_value_convention
2738 i386_return_value (struct gdbarch *gdbarch, struct value *function,
2739                    struct type *type, struct regcache *regcache,
2740                    gdb_byte *readbuf, const gdb_byte *writebuf)
2741 {
2742   enum type_code code = TYPE_CODE (type);
2743
2744   if (((code == TYPE_CODE_STRUCT
2745         || code == TYPE_CODE_UNION
2746         || code == TYPE_CODE_ARRAY)
2747        && !i386_reg_struct_return_p (gdbarch, type))
2748       /* Complex double and long double uses the struct return covention.  */
2749       || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 16)
2750       || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 24)
2751       /* 128-bit decimal float uses the struct return convention.  */
2752       || (code == TYPE_CODE_DECFLOAT && TYPE_LENGTH (type) == 16))
2753     {
2754       /* The System V ABI says that:
2755
2756          "A function that returns a structure or union also sets %eax
2757          to the value of the original address of the caller's area
2758          before it returns.  Thus when the caller receives control
2759          again, the address of the returned object resides in register
2760          %eax and can be used to access the object."
2761
2762          So the ABI guarantees that we can always find the return
2763          value just after the function has returned.  */
2764
2765       /* Note that the ABI doesn't mention functions returning arrays,
2766          which is something possible in certain languages such as Ada.
2767          In this case, the value is returned as if it was wrapped in
2768          a record, so the convention applied to records also applies
2769          to arrays.  */
2770
2771       if (readbuf)
2772         {
2773           ULONGEST addr;
2774
2775           regcache_raw_read_unsigned (regcache, I386_EAX_REGNUM, &addr);
2776           read_memory (addr, readbuf, TYPE_LENGTH (type));
2777         }
2778
2779       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
2780     }
2781
2782   /* This special case is for structures consisting of a single
2783      `float', `double' or 'long double' member.  These structures are
2784      returned in %st(0).  For these structures, we call ourselves
2785      recursively, changing TYPE into the type of the first member of
2786      the structure.  Since that should work for all structures that
2787      have only one member, we don't bother to check the member's type
2788      here.  */
2789   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2790     {
2791       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
2792       return i386_return_value (gdbarch, function, type, regcache,
2793                                 readbuf, writebuf);
2794     }
2795
2796   if (readbuf)
2797     i386_extract_return_value (gdbarch, type, regcache, readbuf);
2798   if (writebuf)
2799     i386_store_return_value (gdbarch, type, regcache, writebuf);
2800
2801   return RETURN_VALUE_REGISTER_CONVENTION;
2802 }
2803 \f
2804
2805 struct type *
2806 i387_ext_type (struct gdbarch *gdbarch)
2807 {
2808   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2809
2810   if (!tdep->i387_ext_type)
2811     {
2812       tdep->i387_ext_type = tdesc_find_type (gdbarch, "i387_ext");
2813       gdb_assert (tdep->i387_ext_type != NULL);
2814     }
2815
2816   return tdep->i387_ext_type;
2817 }
2818
2819 /* Construct type for pseudo BND registers.  We can't use
2820    tdesc_find_type since a complement of one value has to be used
2821    to describe the upper bound.  */
2822
2823 static struct type *
2824 i386_bnd_type (struct gdbarch *gdbarch)
2825 {
2826   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2827
2828
2829   if (!tdep->i386_bnd_type)
2830     {
2831       struct type *t, *bound_t;
2832       const struct builtin_type *bt = builtin_type (gdbarch);
2833
2834       /* The type we're building is described bellow:  */
2835 #if 0
2836       struct __bound128
2837       {
2838         void *lbound;
2839         void *ubound;           /* One complement of raw ubound field.  */
2840       };
2841 #endif
2842
2843       t = arch_composite_type (gdbarch,
2844                                "__gdb_builtin_type_bound128", TYPE_CODE_STRUCT);
2845
2846       append_composite_type_field (t, "lbound", bt->builtin_data_ptr);
2847       append_composite_type_field (t, "ubound", bt->builtin_data_ptr);
2848
2849       TYPE_NAME (t) = "builtin_type_bound128";
2850       tdep->i386_bnd_type = t;
2851     }
2852
2853   return tdep->i386_bnd_type;
2854 }
2855
2856 /* Construct vector type for pseudo YMM registers.  We can't use
2857    tdesc_find_type since YMM isn't described in target description.  */
2858
2859 static struct type *
2860 i386_ymm_type (struct gdbarch *gdbarch)
2861 {
2862   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2863
2864   if (!tdep->i386_ymm_type)
2865     {
2866       const struct builtin_type *bt = builtin_type (gdbarch);
2867
2868       /* The type we're building is this: */
2869 #if 0
2870       union __gdb_builtin_type_vec256i
2871       {
2872         int128_t uint128[2];
2873         int64_t v2_int64[4];
2874         int32_t v4_int32[8];
2875         int16_t v8_int16[16];
2876         int8_t v16_int8[32];
2877         double v2_double[4];
2878         float v4_float[8];
2879       };
2880 #endif
2881
2882       struct type *t;
2883
2884       t = arch_composite_type (gdbarch,
2885                                "__gdb_builtin_type_vec256i", TYPE_CODE_UNION);
2886       append_composite_type_field (t, "v8_float",
2887                                    init_vector_type (bt->builtin_float, 8));
2888       append_composite_type_field (t, "v4_double",
2889                                    init_vector_type (bt->builtin_double, 4));
2890       append_composite_type_field (t, "v32_int8",
2891                                    init_vector_type (bt->builtin_int8, 32));
2892       append_composite_type_field (t, "v16_int16",
2893                                    init_vector_type (bt->builtin_int16, 16));
2894       append_composite_type_field (t, "v8_int32",
2895                                    init_vector_type (bt->builtin_int32, 8));
2896       append_composite_type_field (t, "v4_int64",
2897                                    init_vector_type (bt->builtin_int64, 4));
2898       append_composite_type_field (t, "v2_int128",
2899                                    init_vector_type (bt->builtin_int128, 2));
2900
2901       TYPE_VECTOR (t) = 1;
2902       TYPE_NAME (t) = "builtin_type_vec256i";
2903       tdep->i386_ymm_type = t;
2904     }
2905
2906   return tdep->i386_ymm_type;
2907 }
2908
2909 /* Construct vector type for MMX registers.  */
2910 static struct type *
2911 i386_mmx_type (struct gdbarch *gdbarch)
2912 {
2913   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2914
2915   if (!tdep->i386_mmx_type)
2916     {
2917       const struct builtin_type *bt = builtin_type (gdbarch);
2918
2919       /* The type we're building is this: */
2920 #if 0
2921       union __gdb_builtin_type_vec64i
2922       {
2923         int64_t uint64;
2924         int32_t v2_int32[2];
2925         int16_t v4_int16[4];
2926         int8_t v8_int8[8];
2927       };
2928 #endif
2929
2930       struct type *t;
2931
2932       t = arch_composite_type (gdbarch,
2933                                "__gdb_builtin_type_vec64i", TYPE_CODE_UNION);
2934
2935       append_composite_type_field (t, "uint64", bt->builtin_int64);
2936       append_composite_type_field (t, "v2_int32",
2937                                    init_vector_type (bt->builtin_int32, 2));
2938       append_composite_type_field (t, "v4_int16",
2939                                    init_vector_type (bt->builtin_int16, 4));
2940       append_composite_type_field (t, "v8_int8",
2941                                    init_vector_type (bt->builtin_int8, 8));
2942
2943       TYPE_VECTOR (t) = 1;
2944       TYPE_NAME (t) = "builtin_type_vec64i";
2945       tdep->i386_mmx_type = t;
2946     }
2947
2948   return tdep->i386_mmx_type;
2949 }
2950
2951 /* Return the GDB type object for the "standard" data type of data in
2952    register REGNUM.  */
2953
2954 struct type *
2955 i386_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
2956 {
2957   if (i386_bnd_regnum_p (gdbarch, regnum))
2958     return i386_bnd_type (gdbarch);
2959   if (i386_mmx_regnum_p (gdbarch, regnum))
2960     return i386_mmx_type (gdbarch);
2961   else if (i386_ymm_regnum_p (gdbarch, regnum))
2962     return i386_ymm_type (gdbarch);
2963   else
2964     {
2965       const struct builtin_type *bt = builtin_type (gdbarch);
2966       if (i386_byte_regnum_p (gdbarch, regnum))
2967         return bt->builtin_int8;
2968       else if (i386_word_regnum_p (gdbarch, regnum))
2969         return bt->builtin_int16;
2970       else if (i386_dword_regnum_p (gdbarch, regnum))
2971         return bt->builtin_int32;
2972     }
2973
2974   internal_error (__FILE__, __LINE__, _("invalid regnum"));
2975 }
2976
2977 /* Map a cooked register onto a raw register or memory.  For the i386,
2978    the MMX registers need to be mapped onto floating point registers.  */
2979
2980 static int
2981 i386_mmx_regnum_to_fp_regnum (struct regcache *regcache, int regnum)
2982 {
2983   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
2984   int mmxreg, fpreg;
2985   ULONGEST fstat;
2986   int tos;
2987
2988   mmxreg = regnum - tdep->mm0_regnum;
2989   regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
2990   tos = (fstat >> 11) & 0x7;
2991   fpreg = (mmxreg + tos) % 8;
2992
2993   return (I387_ST0_REGNUM (tdep) + fpreg);
2994 }
2995
2996 /* A helper function for us by i386_pseudo_register_read_value and
2997    amd64_pseudo_register_read_value.  It does all the work but reads
2998    the data into an already-allocated value.  */
2999
3000 void
3001 i386_pseudo_register_read_into_value (struct gdbarch *gdbarch,
3002                                       struct regcache *regcache,
3003                                       int regnum,
3004                                       struct value *result_value)
3005 {
3006   gdb_byte raw_buf[MAX_REGISTER_SIZE];
3007   enum register_status status;
3008   gdb_byte *buf = value_contents_raw (result_value);
3009
3010   if (i386_mmx_regnum_p (gdbarch, regnum))
3011     {
3012       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
3013
3014       /* Extract (always little endian).  */
3015       status = regcache_raw_read (regcache, fpnum, raw_buf);
3016       if (status != REG_VALID)
3017         mark_value_bytes_unavailable (result_value, 0,
3018                                       TYPE_LENGTH (value_type (result_value)));
3019       else
3020         memcpy (buf, raw_buf, register_size (gdbarch, regnum));
3021     }
3022   else
3023     {
3024       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3025       if (i386_bnd_regnum_p (gdbarch, regnum))
3026         {
3027           regnum -= tdep->bnd0_regnum;
3028
3029           /* Extract (always little endian).  Read lower 128bits.  */
3030           status = regcache_raw_read (regcache,
3031                                       I387_BND0R_REGNUM (tdep) + regnum,
3032                                       raw_buf);
3033           if (status != REG_VALID)
3034             mark_value_bytes_unavailable (result_value, 0, 16);
3035           else
3036             {
3037               enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3038               LONGEST upper, lower;
3039               int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
3040
3041               lower = extract_unsigned_integer (raw_buf, 8, byte_order);
3042               upper = extract_unsigned_integer (raw_buf + 8, 8, byte_order);
3043               upper = ~upper;
3044
3045               memcpy (buf, &lower, size);
3046               memcpy (buf + size, &upper, size);
3047             }
3048         }
3049       else if (i386_ymm_regnum_p (gdbarch, regnum))
3050         {
3051           regnum -= tdep->ymm0_regnum;
3052
3053           /* Extract (always little endian).  Read lower 128bits.  */
3054           status = regcache_raw_read (regcache,
3055                                       I387_XMM0_REGNUM (tdep) + regnum,
3056                                       raw_buf);
3057           if (status != REG_VALID)
3058             mark_value_bytes_unavailable (result_value, 0, 16);
3059           else
3060             memcpy (buf, raw_buf, 16);
3061           /* Read upper 128bits.  */
3062           status = regcache_raw_read (regcache,
3063                                       tdep->ymm0h_regnum + regnum,
3064                                       raw_buf);
3065           if (status != REG_VALID)
3066             mark_value_bytes_unavailable (result_value, 16, 32);
3067           else
3068             memcpy (buf + 16, raw_buf, 16);
3069         }
3070       else if (i386_word_regnum_p (gdbarch, regnum))
3071         {
3072           int gpnum = regnum - tdep->ax_regnum;
3073
3074           /* Extract (always little endian).  */
3075           status = regcache_raw_read (regcache, gpnum, raw_buf);
3076           if (status != REG_VALID)
3077             mark_value_bytes_unavailable (result_value, 0,
3078                                           TYPE_LENGTH (value_type (result_value)));
3079           else
3080             memcpy (buf, raw_buf, 2);
3081         }
3082       else if (i386_byte_regnum_p (gdbarch, regnum))
3083         {
3084           /* Check byte pseudo registers last since this function will
3085              be called from amd64_pseudo_register_read, which handles
3086              byte pseudo registers differently.  */
3087           int gpnum = regnum - tdep->al_regnum;
3088
3089           /* Extract (always little endian).  We read both lower and
3090              upper registers.  */
3091           status = regcache_raw_read (regcache, gpnum % 4, raw_buf);
3092           if (status != REG_VALID)
3093             mark_value_bytes_unavailable (result_value, 0,
3094                                           TYPE_LENGTH (value_type (result_value)));
3095           else if (gpnum >= 4)
3096             memcpy (buf, raw_buf + 1, 1);
3097           else
3098             memcpy (buf, raw_buf, 1);
3099         }
3100       else
3101         internal_error (__FILE__, __LINE__, _("invalid regnum"));
3102     }
3103 }
3104
3105 static struct value *
3106 i386_pseudo_register_read_value (struct gdbarch *gdbarch,
3107                                  struct regcache *regcache,
3108                                  int regnum)
3109 {
3110   struct value *result;
3111
3112   result = allocate_value (register_type (gdbarch, regnum));
3113   VALUE_LVAL (result) = lval_register;
3114   VALUE_REGNUM (result) = regnum;
3115
3116   i386_pseudo_register_read_into_value (gdbarch, regcache, regnum, result);
3117
3118   return result;
3119 }
3120
3121 void
3122 i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
3123                             int regnum, const gdb_byte *buf)
3124 {
3125   gdb_byte raw_buf[MAX_REGISTER_SIZE];
3126
3127   if (i386_mmx_regnum_p (gdbarch, regnum))
3128     {
3129       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
3130
3131       /* Read ...  */
3132       regcache_raw_read (regcache, fpnum, raw_buf);
3133       /* ... Modify ... (always little endian).  */
3134       memcpy (raw_buf, buf, register_size (gdbarch, regnum));
3135       /* ... Write.  */
3136       regcache_raw_write (regcache, fpnum, raw_buf);
3137     }
3138   else
3139     {
3140       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3141
3142       if (i386_bnd_regnum_p (gdbarch, regnum))
3143         {
3144           ULONGEST upper, lower;
3145           int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
3146           enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3147
3148           /* New values from input value.  */
3149           regnum -= tdep->bnd0_regnum;
3150           lower = extract_unsigned_integer (buf, size, byte_order);
3151           upper = extract_unsigned_integer (buf + size, size, byte_order);
3152
3153           /* Fetching register buffer.  */
3154           regcache_raw_read (regcache,
3155                              I387_BND0R_REGNUM (tdep) + regnum,
3156                              raw_buf);
3157
3158           upper = ~upper;
3159
3160           /* Set register bits.  */
3161           memcpy (raw_buf, &lower, 8);
3162           memcpy (raw_buf + 8, &upper, 8);
3163
3164
3165           regcache_raw_write (regcache,
3166                               I387_BND0R_REGNUM (tdep) + regnum,
3167                               raw_buf);
3168         }
3169       else if (i386_ymm_regnum_p (gdbarch, regnum))
3170         {
3171           regnum -= tdep->ymm0_regnum;
3172
3173           /* ... Write lower 128bits.  */
3174           regcache_raw_write (regcache,
3175                              I387_XMM0_REGNUM (tdep) + regnum,
3176                              buf);
3177           /* ... Write upper 128bits.  */
3178           regcache_raw_write (regcache,
3179                              tdep->ymm0h_regnum + regnum,
3180                              buf + 16);
3181         }
3182       else if (i386_word_regnum_p (gdbarch, regnum))
3183         {
3184           int gpnum = regnum - tdep->ax_regnum;
3185
3186           /* Read ...  */
3187           regcache_raw_read (regcache, gpnum, raw_buf);
3188           /* ... Modify ... (always little endian).  */
3189           memcpy (raw_buf, buf, 2);
3190           /* ... Write.  */
3191           regcache_raw_write (regcache, gpnum, raw_buf);
3192         }
3193       else if (i386_byte_regnum_p (gdbarch, regnum))
3194         {
3195           /* Check byte pseudo registers last since this function will
3196              be called from amd64_pseudo_register_read, which handles
3197              byte pseudo registers differently.  */
3198           int gpnum = regnum - tdep->al_regnum;
3199
3200           /* Read ...  We read both lower and upper registers.  */
3201           regcache_raw_read (regcache, gpnum % 4, raw_buf);
3202           /* ... Modify ... (always little endian).  */
3203           if (gpnum >= 4)
3204             memcpy (raw_buf + 1, buf, 1);
3205           else
3206             memcpy (raw_buf, buf, 1);
3207           /* ... Write.  */
3208           regcache_raw_write (regcache, gpnum % 4, raw_buf);
3209         }
3210       else
3211         internal_error (__FILE__, __LINE__, _("invalid regnum"));
3212     }
3213 }
3214 \f
3215
3216 /* Return the register number of the register allocated by GCC after
3217    REGNUM, or -1 if there is no such register.  */
3218
3219 static int
3220 i386_next_regnum (int regnum)
3221 {
3222   /* GCC allocates the registers in the order:
3223
3224      %eax, %edx, %ecx, %ebx, %esi, %edi, %ebp, %esp, ...
3225
3226      Since storing a variable in %esp doesn't make any sense we return
3227      -1 for %ebp and for %esp itself.  */
3228   static int next_regnum[] =
3229   {
3230     I386_EDX_REGNUM,            /* Slot for %eax.  */
3231     I386_EBX_REGNUM,            /* Slot for %ecx.  */
3232     I386_ECX_REGNUM,            /* Slot for %edx.  */
3233     I386_ESI_REGNUM,            /* Slot for %ebx.  */
3234     -1, -1,                     /* Slots for %esp and %ebp.  */
3235     I386_EDI_REGNUM,            /* Slot for %esi.  */
3236     I386_EBP_REGNUM             /* Slot for %edi.  */
3237   };
3238
3239   if (regnum >= 0 && regnum < sizeof (next_regnum) / sizeof (next_regnum[0]))
3240     return next_regnum[regnum];
3241
3242   return -1;
3243 }
3244
3245 /* Return nonzero if a value of type TYPE stored in register REGNUM
3246    needs any special handling.  */
3247
3248 static int
3249 i386_convert_register_p (struct gdbarch *gdbarch,
3250                          int regnum, struct type *type)
3251 {
3252   int len = TYPE_LENGTH (type);
3253
3254   /* Values may be spread across multiple registers.  Most debugging
3255      formats aren't expressive enough to specify the locations, so
3256      some heuristics is involved.  Right now we only handle types that
3257      have a length that is a multiple of the word size, since GCC
3258      doesn't seem to put any other types into registers.  */
3259   if (len > 4 && len % 4 == 0)
3260     {
3261       int last_regnum = regnum;
3262
3263       while (len > 4)
3264         {
3265           last_regnum = i386_next_regnum (last_regnum);
3266           len -= 4;
3267         }
3268
3269       if (last_regnum != -1)
3270         return 1;
3271     }
3272
3273   return i387_convert_register_p (gdbarch, regnum, type);
3274 }
3275
3276 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
3277    return its contents in TO.  */
3278
3279 static int
3280 i386_register_to_value (struct frame_info *frame, int regnum,
3281                         struct type *type, gdb_byte *to,
3282                         int *optimizedp, int *unavailablep)
3283 {
3284   struct gdbarch *gdbarch = get_frame_arch (frame);
3285   int len = TYPE_LENGTH (type);
3286
3287   if (i386_fp_regnum_p (gdbarch, regnum))
3288     return i387_register_to_value (frame, regnum, type, to,
3289                                    optimizedp, unavailablep);
3290
3291   /* Read a value spread across multiple registers.  */
3292
3293   gdb_assert (len > 4 && len % 4 == 0);
3294
3295   while (len > 0)
3296     {
3297       gdb_assert (regnum != -1);
3298       gdb_assert (register_size (gdbarch, regnum) == 4);
3299
3300       if (!get_frame_register_bytes (frame, regnum, 0,
3301                                      register_size (gdbarch, regnum),
3302                                      to, optimizedp, unavailablep))
3303         return 0;
3304
3305       regnum = i386_next_regnum (regnum);
3306       len -= 4;
3307       to += 4;
3308     }
3309
3310   *optimizedp = *unavailablep = 0;
3311   return 1;
3312 }
3313
3314 /* Write the contents FROM of a value of type TYPE into register
3315    REGNUM in frame FRAME.  */
3316
3317 static void
3318 i386_value_to_register (struct frame_info *frame, int regnum,
3319                         struct type *type, const gdb_byte *from)
3320 {
3321   int len = TYPE_LENGTH (type);
3322
3323   if (i386_fp_regnum_p (get_frame_arch (frame), regnum))
3324     {
3325       i387_value_to_register (frame, regnum, type, from);
3326       return;
3327     }
3328
3329   /* Write a value spread across multiple registers.  */
3330
3331   gdb_assert (len > 4 && len % 4 == 0);
3332
3333   while (len > 0)
3334     {
3335       gdb_assert (regnum != -1);
3336       gdb_assert (register_size (get_frame_arch (frame), regnum) == 4);
3337
3338       put_frame_register (frame, regnum, from);
3339       regnum = i386_next_regnum (regnum);
3340       len -= 4;
3341       from += 4;
3342     }
3343 }
3344 \f
3345 /* Supply register REGNUM from the buffer specified by GREGS and LEN
3346    in the general-purpose register set REGSET to register cache
3347    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
3348
3349 void
3350 i386_supply_gregset (const struct regset *regset, struct regcache *regcache,
3351                      int regnum, const void *gregs, size_t len)
3352 {
3353   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
3354   const gdb_byte *regs = gregs;
3355   int i;
3356
3357   gdb_assert (len == tdep->sizeof_gregset);
3358
3359   for (i = 0; i < tdep->gregset_num_regs; i++)
3360     {
3361       if ((regnum == i || regnum == -1)
3362           && tdep->gregset_reg_offset[i] != -1)
3363         regcache_raw_supply (regcache, i, regs + tdep->gregset_reg_offset[i]);
3364     }
3365 }
3366
3367 /* Collect register REGNUM from the register cache REGCACHE and store
3368    it in the buffer specified by GREGS and LEN as described by the
3369    general-purpose register set REGSET.  If REGNUM is -1, do this for
3370    all registers in REGSET.  */
3371
3372 void
3373 i386_collect_gregset (const struct regset *regset,
3374                       const struct regcache *regcache,
3375                       int regnum, void *gregs, size_t len)
3376 {
3377   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
3378   gdb_byte *regs = gregs;
3379   int i;
3380
3381   gdb_assert (len == tdep->sizeof_gregset);
3382
3383   for (i = 0; i < tdep->gregset_num_regs; i++)
3384     {
3385       if ((regnum == i || regnum == -1)
3386           && tdep->gregset_reg_offset[i] != -1)
3387         regcache_raw_collect (regcache, i, regs + tdep->gregset_reg_offset[i]);
3388     }
3389 }
3390
3391 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
3392    in the floating-point register set REGSET to register cache
3393    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
3394
3395 static void
3396 i386_supply_fpregset (const struct regset *regset, struct regcache *regcache,
3397                       int regnum, const void *fpregs, size_t len)
3398 {
3399   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
3400
3401   if (len == I387_SIZEOF_FXSAVE)
3402     {
3403       i387_supply_fxsave (regcache, regnum, fpregs);
3404       return;
3405     }
3406
3407   gdb_assert (len == tdep->sizeof_fpregset);
3408   i387_supply_fsave (regcache, regnum, fpregs);
3409 }
3410
3411 /* Collect register REGNUM from the register cache REGCACHE and store
3412    it in the buffer specified by FPREGS and LEN as described by the
3413    floating-point register set REGSET.  If REGNUM is -1, do this for
3414    all registers in REGSET.  */
3415
3416 static void
3417 i386_collect_fpregset (const struct regset *regset,
3418                        const struct regcache *regcache,
3419                        int regnum, void *fpregs, size_t len)
3420 {
3421   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
3422
3423   if (len == I387_SIZEOF_FXSAVE)
3424     {
3425       i387_collect_fxsave (regcache, regnum, fpregs);
3426       return;
3427     }
3428
3429   gdb_assert (len == tdep->sizeof_fpregset);
3430   i387_collect_fsave (regcache, regnum, fpregs);
3431 }
3432
3433 /* Similar to i386_supply_fpregset, but use XSAVE extended state.  */
3434
3435 static void
3436 i386_supply_xstateregset (const struct regset *regset,
3437                           struct regcache *regcache, int regnum,
3438                           const void *xstateregs, size_t len)
3439 {
3440   i387_supply_xsave (regcache, regnum, xstateregs);
3441 }
3442
3443 /* Similar to i386_collect_fpregset , but use XSAVE extended state.  */
3444
3445 static void
3446 i386_collect_xstateregset (const struct regset *regset,
3447                            const struct regcache *regcache,
3448                            int regnum, void *xstateregs, size_t len)
3449 {
3450   i387_collect_xsave (regcache, regnum, xstateregs, 1);
3451 }
3452
3453 /* Return the appropriate register set for the core section identified
3454    by SECT_NAME and SECT_SIZE.  */
3455
3456 const struct regset *
3457 i386_regset_from_core_section (struct gdbarch *gdbarch,
3458                                const char *sect_name, size_t sect_size)
3459 {
3460   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3461
3462   if (strcmp (sect_name, ".reg") == 0 && sect_size == tdep->sizeof_gregset)
3463     {
3464       if (tdep->gregset == NULL)
3465         tdep->gregset = regset_alloc (gdbarch, i386_supply_gregset,
3466                                       i386_collect_gregset);
3467       return tdep->gregset;
3468     }
3469
3470   if ((strcmp (sect_name, ".reg2") == 0 && sect_size == tdep->sizeof_fpregset)
3471       || (strcmp (sect_name, ".reg-xfp") == 0
3472           && sect_size == I387_SIZEOF_FXSAVE))
3473     {
3474       if (tdep->fpregset == NULL)
3475         tdep->fpregset = regset_alloc (gdbarch, i386_supply_fpregset,
3476                                        i386_collect_fpregset);
3477       return tdep->fpregset;
3478     }
3479
3480   if (strcmp (sect_name, ".reg-xstate") == 0)
3481     {
3482       if (tdep->xstateregset == NULL)
3483         tdep->xstateregset = regset_alloc (gdbarch,
3484                                            i386_supply_xstateregset,
3485                                            i386_collect_xstateregset);
3486
3487       return tdep->xstateregset;
3488     }
3489
3490   return NULL;
3491 }
3492 \f
3493
3494 /* Stuff for WIN32 PE style DLL's but is pretty generic really.  */
3495
3496 CORE_ADDR
3497 i386_pe_skip_trampoline_code (struct frame_info *frame,
3498                               CORE_ADDR pc, char *name)
3499 {
3500   struct gdbarch *gdbarch = get_frame_arch (frame);
3501   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3502
3503   /* jmp *(dest) */
3504   if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
3505     {
3506       unsigned long indirect =
3507         read_memory_unsigned_integer (pc + 2, 4, byte_order);
3508       struct minimal_symbol *indsym =
3509         indirect ? lookup_minimal_symbol_by_pc (indirect).minsym : 0;
3510       const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : 0;
3511
3512       if (symname)
3513         {
3514           if (strncmp (symname, "__imp_", 6) == 0
3515               || strncmp (symname, "_imp_", 5) == 0)
3516             return name ? 1 :
3517                    read_memory_unsigned_integer (indirect, 4, byte_order);
3518         }
3519     }
3520   return 0;                     /* Not a trampoline.  */
3521 }
3522 \f
3523
3524 /* Return whether the THIS_FRAME corresponds to a sigtramp
3525    routine.  */
3526
3527 int
3528 i386_sigtramp_p (struct frame_info *this_frame)
3529 {
3530   CORE_ADDR pc = get_frame_pc (this_frame);
3531   const char *name;
3532
3533   find_pc_partial_function (pc, &name, NULL, NULL);
3534   return (name && strcmp ("_sigtramp", name) == 0);
3535 }
3536 \f
3537
3538 /* We have two flavours of disassembly.  The machinery on this page
3539    deals with switching between those.  */
3540
3541 static int
3542 i386_print_insn (bfd_vma pc, struct disassemble_info *info)
3543 {
3544   gdb_assert (disassembly_flavor == att_flavor
3545               || disassembly_flavor == intel_flavor);
3546
3547   /* FIXME: kettenis/20020915: Until disassembler_options is properly
3548      constified, cast to prevent a compiler warning.  */
3549   info->disassembler_options = (char *) disassembly_flavor;
3550
3551   return print_insn_i386 (pc, info);
3552 }
3553 \f
3554
3555 /* There are a few i386 architecture variants that differ only
3556    slightly from the generic i386 target.  For now, we don't give them
3557    their own source file, but include them here.  As a consequence,
3558    they'll always be included.  */
3559
3560 /* System V Release 4 (SVR4).  */
3561
3562 /* Return whether THIS_FRAME corresponds to a SVR4 sigtramp
3563    routine.  */
3564
3565 static int
3566 i386_svr4_sigtramp_p (struct frame_info *this_frame)
3567 {
3568   CORE_ADDR pc = get_frame_pc (this_frame);
3569   const char *name;
3570
3571   /* The origin of these symbols is currently unknown.  */
3572   find_pc_partial_function (pc, &name, NULL, NULL);
3573   return (name && (strcmp ("_sigreturn", name) == 0
3574                    || strcmp ("sigvechandler", name) == 0));
3575 }
3576
3577 /* Assuming THIS_FRAME is for a SVR4 sigtramp routine, return the
3578    address of the associated sigcontext (ucontext) structure.  */
3579
3580 static CORE_ADDR
3581 i386_svr4_sigcontext_addr (struct frame_info *this_frame)
3582 {
3583   struct gdbarch *gdbarch = get_frame_arch (this_frame);
3584   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3585   gdb_byte buf[4];
3586   CORE_ADDR sp;
3587
3588   get_frame_register (this_frame, I386_ESP_REGNUM, buf);
3589   sp = extract_unsigned_integer (buf, 4, byte_order);
3590
3591   return read_memory_unsigned_integer (sp + 8, 4, byte_order);
3592 }
3593
3594 \f
3595
3596 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
3597    gdbarch.h.  */
3598
3599 int
3600 i386_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
3601 {
3602   return (*s == '$' /* Literal number.  */
3603           || (isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement.  */
3604           || (*s == '(' && s[1] == '%') /* Register indirection.  */
3605           || (*s == '%' && isalpha (s[1]))); /* Register access.  */
3606 }
3607
3608 /* Helper function for i386_stap_parse_special_token.
3609
3610    This function parses operands of the form `-8+3+1(%rbp)', which
3611    must be interpreted as `*(-8 + 3 - 1 + (void *) $eax)'.
3612
3613    Return 1 if the operand was parsed successfully, zero
3614    otherwise.  */
3615
3616 static int
3617 i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
3618                                        struct stap_parse_info *p)
3619 {
3620   const char *s = p->arg;
3621
3622   if (isdigit (*s) || *s == '-' || *s == '+')
3623     {
3624       int got_minus[3];
3625       int i;
3626       long displacements[3];
3627       const char *start;
3628       char *regname;
3629       int len;
3630       struct stoken str;
3631       char *endp;
3632
3633       got_minus[0] = 0;
3634       if (*s == '+')
3635         ++s;
3636       else if (*s == '-')
3637         {
3638           ++s;
3639           got_minus[0] = 1;
3640         }
3641
3642       displacements[0] = strtol (s, &endp, 10);
3643       s = endp;
3644
3645       if (*s != '+' && *s != '-')
3646         {
3647           /* We are not dealing with a triplet.  */
3648           return 0;
3649         }
3650
3651       got_minus[1] = 0;
3652       if (*s == '+')
3653         ++s;
3654       else
3655         {
3656           ++s;
3657           got_minus[1] = 1;
3658         }
3659
3660       displacements[1] = strtol (s, &endp, 10);
3661       s = endp;
3662
3663       if (*s != '+' && *s != '-')
3664         {
3665           /* We are not dealing with a triplet.  */
3666           return 0;
3667         }
3668
3669       got_minus[2] = 0;
3670       if (*s == '+')
3671         ++s;
3672       else
3673         {
3674           ++s;
3675           got_minus[2] = 1;
3676         }
3677
3678       displacements[2] = strtol (s, &endp, 10);
3679       s = endp;
3680
3681       if (*s != '(' || s[1] != '%')
3682         return 0;
3683
3684       s += 2;
3685       start = s;
3686
3687       while (isalnum (*s))
3688         ++s;
3689
3690       if (*s++ != ')')
3691         return 0;
3692
3693       len = s - start;
3694       regname = alloca (len + 1);
3695
3696       strncpy (regname, start, len);
3697       regname[len] = '\0';
3698
3699       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
3700         error (_("Invalid register name `%s' on expression `%s'."),
3701                regname, p->saved_arg);
3702
3703       for (i = 0; i < 3; i++)
3704         {
3705           write_exp_elt_opcode (OP_LONG);
3706           write_exp_elt_type (builtin_type (gdbarch)->builtin_long);
3707           write_exp_elt_longcst (displacements[i]);
3708           write_exp_elt_opcode (OP_LONG);
3709           if (got_minus[i])
3710             write_exp_elt_opcode (UNOP_NEG);
3711         }
3712
3713       write_exp_elt_opcode (OP_REGISTER);
3714       str.ptr = regname;
3715       str.length = len;
3716       write_exp_string (str);
3717       write_exp_elt_opcode (OP_REGISTER);
3718
3719       write_exp_elt_opcode (UNOP_CAST);
3720       write_exp_elt_type (builtin_type (gdbarch)->builtin_data_ptr);
3721       write_exp_elt_opcode (UNOP_CAST);
3722
3723       write_exp_elt_opcode (BINOP_ADD);
3724       write_exp_elt_opcode (BINOP_ADD);
3725       write_exp_elt_opcode (BINOP_ADD);
3726
3727       write_exp_elt_opcode (UNOP_CAST);
3728       write_exp_elt_type (lookup_pointer_type (p->arg_type));
3729       write_exp_elt_opcode (UNOP_CAST);
3730
3731       write_exp_elt_opcode (UNOP_IND);
3732
3733       p->arg = s;
3734
3735       return 1;
3736     }
3737
3738   return 0;
3739 }
3740
3741 /* Helper function for i386_stap_parse_special_token.
3742
3743    This function parses operands of the form `register base +
3744    (register index * size) + offset', as represented in
3745    `(%rcx,%rax,8)', or `[OFFSET](BASE_REG,INDEX_REG[,SIZE])'.
3746
3747    Return 1 if the operand was parsed successfully, zero
3748    otherwise.  */
3749
3750 static int
3751 i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
3752                                               struct stap_parse_info *p)
3753 {
3754   const char *s = p->arg;
3755
3756   if (isdigit (*s) || *s == '(' || *s == '-' || *s == '+')
3757     {
3758       int offset_minus = 0;
3759       long offset = 0;
3760       int size_minus = 0;
3761       long size = 0;
3762       const char *start;
3763       char *base;
3764       int len_base;
3765       char *index;
3766       int len_index;
3767       struct stoken base_token, index_token;
3768
3769       if (*s == '+')
3770         ++s;
3771       else if (*s == '-')
3772         {
3773           ++s;
3774           offset_minus = 1;
3775         }
3776
3777       if (offset_minus && !isdigit (*s))
3778         return 0;
3779
3780       if (isdigit (*s))
3781         {
3782           char *endp;
3783
3784           offset = strtol (s, &endp, 10);
3785           s = endp;
3786         }
3787
3788       if (*s != '(' || s[1] != '%')
3789         return 0;
3790
3791       s += 2;
3792       start = s;
3793
3794       while (isalnum (*s))
3795         ++s;
3796
3797       if (*s != ',' || s[1] != '%')
3798         return 0;
3799
3800       len_base = s - start;
3801       base = alloca (len_base + 1);
3802       strncpy (base, start, len_base);
3803       base[len_base] = '\0';
3804
3805       if (user_reg_map_name_to_regnum (gdbarch, base, len_base) == -1)
3806         error (_("Invalid register name `%s' on expression `%s'."),
3807                base, p->saved_arg);
3808
3809       s += 2;
3810       start = s;
3811
3812       while (isalnum (*s))
3813         ++s;
3814
3815       len_index = s - start;
3816       index = alloca (len_index + 1);
3817       strncpy (index, start, len_index);
3818       index[len_index] = '\0';
3819
3820       if (user_reg_map_name_to_regnum (gdbarch, index, len_index) == -1)
3821         error (_("Invalid register name `%s' on expression `%s'."),
3822                index, p->saved_arg);
3823
3824       if (*s != ',' && *s != ')')
3825         return 0;
3826
3827       if (*s == ',')
3828         {
3829           char *endp;
3830
3831           ++s;
3832           if (*s == '+')
3833             ++s;
3834           else if (*s == '-')
3835             {
3836               ++s;
3837               size_minus = 1;
3838             }
3839
3840           size = strtol (s, &endp, 10);
3841           s = endp;
3842
3843           if (*s != ')')
3844             return 0;
3845         }
3846
3847       ++s;
3848
3849       if (offset)
3850         {
3851           write_exp_elt_opcode (OP_LONG);
3852           write_exp_elt_type (builtin_type (gdbarch)->builtin_long);
3853           write_exp_elt_longcst (offset);
3854           write_exp_elt_opcode (OP_LONG);
3855           if (offset_minus)
3856             write_exp_elt_opcode (UNOP_NEG);
3857         }
3858
3859       write_exp_elt_opcode (OP_REGISTER);
3860       base_token.ptr = base;
3861       base_token.length = len_base;
3862       write_exp_string (base_token);
3863       write_exp_elt_opcode (OP_REGISTER);
3864
3865       if (offset)
3866         write_exp_elt_opcode (BINOP_ADD);
3867
3868       write_exp_elt_opcode (OP_REGISTER);
3869       index_token.ptr = index;
3870       index_token.length = len_index;
3871       write_exp_string (index_token);
3872       write_exp_elt_opcode (OP_REGISTER);
3873
3874       if (size)
3875         {
3876           write_exp_elt_opcode (OP_LONG);
3877           write_exp_elt_type (builtin_type (gdbarch)->builtin_long);
3878           write_exp_elt_longcst (size);
3879           write_exp_elt_opcode (OP_LONG);
3880           if (size_minus)
3881             write_exp_elt_opcode (UNOP_NEG);
3882           write_exp_elt_opcode (BINOP_MUL);
3883         }
3884
3885       write_exp_elt_opcode (BINOP_ADD);
3886
3887       write_exp_elt_opcode (UNOP_CAST);
3888       write_exp_elt_type (lookup_pointer_type (p->arg_type));
3889       write_exp_elt_opcode (UNOP_CAST);
3890
3891       write_exp_elt_opcode (UNOP_IND);
3892
3893       p->arg = s;
3894
3895       return 1;
3896     }
3897
3898   return 0;
3899 }
3900
3901 /* Implementation of `gdbarch_stap_parse_special_token', as defined in
3902    gdbarch.h.  */
3903
3904 int
3905 i386_stap_parse_special_token (struct gdbarch *gdbarch,
3906                                struct stap_parse_info *p)
3907 {
3908   /* In order to parse special tokens, we use a state-machine that go
3909      through every known token and try to get a match.  */
3910   enum
3911     {
3912       TRIPLET,
3913       THREE_ARG_DISPLACEMENT,
3914       DONE
3915     } current_state;
3916
3917   current_state = TRIPLET;
3918
3919   /* The special tokens to be parsed here are:
3920
3921      - `register base + (register index * size) + offset', as represented
3922      in `(%rcx,%rax,8)', or `[OFFSET](BASE_REG,INDEX_REG[,SIZE])'.
3923
3924      - Operands of the form `-8+3+1(%rbp)', which must be interpreted as
3925      `*(-8 + 3 - 1 + (void *) $eax)'.  */
3926
3927   while (current_state != DONE)
3928     {
3929       switch (current_state)
3930         {
3931         case TRIPLET:
3932           if (i386_stap_parse_special_token_triplet (gdbarch, p))
3933             return 1;
3934           break;
3935
3936         case THREE_ARG_DISPLACEMENT:
3937           if (i386_stap_parse_special_token_three_arg_disp (gdbarch, p))
3938             return 1;
3939           break;
3940         }
3941
3942       /* Advancing to the next state.  */
3943       ++current_state;
3944     }
3945
3946   return 0;
3947 }
3948
3949 \f
3950
3951 /* Generic ELF.  */
3952
3953 void
3954 i386_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
3955 {
3956   static const char *const stap_integer_prefixes[] = { "$", NULL };
3957   static const char *const stap_register_prefixes[] = { "%", NULL };
3958   static const char *const stap_register_indirection_prefixes[] = { "(",
3959                                                                     NULL };
3960   static const char *const stap_register_indirection_suffixes[] = { ")",
3961                                                                     NULL };
3962
3963   /* We typically use stabs-in-ELF with the SVR4 register numbering.  */
3964   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
3965
3966   /* Registering SystemTap handlers.  */
3967   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
3968   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
3969   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
3970                                           stap_register_indirection_prefixes);
3971   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
3972                                           stap_register_indirection_suffixes);
3973   set_gdbarch_stap_is_single_operand (gdbarch,
3974                                       i386_stap_is_single_operand);
3975   set_gdbarch_stap_parse_special_token (gdbarch,
3976                                         i386_stap_parse_special_token);
3977 }
3978
3979 /* System V Release 4 (SVR4).  */
3980
3981 void
3982 i386_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
3983 {
3984   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3985
3986   /* System V Release 4 uses ELF.  */
3987   i386_elf_init_abi (info, gdbarch);
3988
3989   /* System V Release 4 has shared libraries.  */
3990   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
3991
3992   tdep->sigtramp_p = i386_svr4_sigtramp_p;
3993   tdep->sigcontext_addr = i386_svr4_sigcontext_addr;
3994   tdep->sc_pc_offset = 36 + 14 * 4;
3995   tdep->sc_sp_offset = 36 + 17 * 4;
3996
3997   tdep->jb_pc_offset = 20;
3998 }
3999
4000 /* DJGPP.  */
4001
4002 static void
4003 i386_go32_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
4004 {
4005   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4006
4007   /* DJGPP doesn't have any special frames for signal handlers.  */
4008   tdep->sigtramp_p = NULL;
4009
4010   tdep->jb_pc_offset = 36;
4011
4012   /* DJGPP does not support the SSE registers.  */
4013   if (! tdesc_has_registers (info.target_desc))
4014     tdep->tdesc = tdesc_i386_mmx;
4015
4016   /* Native compiler is GCC, which uses the SVR4 register numbering
4017      even in COFF and STABS.  See the comment in i386_gdbarch_init,
4018      before the calls to set_gdbarch_stab_reg_to_regnum and
4019      set_gdbarch_sdb_reg_to_regnum.  */
4020   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
4021   set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
4022
4023   set_gdbarch_has_dos_based_file_system (gdbarch, 1);
4024 }
4025 \f
4026
4027 /* i386 register groups.  In addition to the normal groups, add "mmx"
4028    and "sse".  */
4029
4030 static struct reggroup *i386_sse_reggroup;
4031 static struct reggroup *i386_mmx_reggroup;
4032
4033 static void
4034 i386_init_reggroups (void)
4035 {
4036   i386_sse_reggroup = reggroup_new ("sse", USER_REGGROUP);
4037   i386_mmx_reggroup = reggroup_new ("mmx", USER_REGGROUP);
4038 }
4039
4040 static void
4041 i386_add_reggroups (struct gdbarch *gdbarch)
4042 {
4043   reggroup_add (gdbarch, i386_sse_reggroup);
4044   reggroup_add (gdbarch, i386_mmx_reggroup);
4045   reggroup_add (gdbarch, general_reggroup);
4046   reggroup_add (gdbarch, float_reggroup);
4047   reggroup_add (gdbarch, all_reggroup);
4048   reggroup_add (gdbarch, save_reggroup);
4049   reggroup_add (gdbarch, restore_reggroup);
4050   reggroup_add (gdbarch, vector_reggroup);
4051   reggroup_add (gdbarch, system_reggroup);
4052 }
4053
4054 int
4055 i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
4056                           struct reggroup *group)
4057 {
4058   const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4059   int fp_regnum_p, mmx_regnum_p, xmm_regnum_p, mxcsr_regnum_p,
4060       ymm_regnum_p, ymmh_regnum_p, bndr_regnum_p, bnd_regnum_p,
4061       mpx_ctrl_regnum_p;
4062
4063   /* Don't include pseudo registers, except for MMX, in any register
4064      groups.  */
4065   if (i386_byte_regnum_p (gdbarch, regnum))
4066     return 0;
4067
4068   if (i386_word_regnum_p (gdbarch, regnum))
4069     return 0;
4070
4071   if (i386_dword_regnum_p (gdbarch, regnum))
4072     return 0;
4073
4074   mmx_regnum_p = i386_mmx_regnum_p (gdbarch, regnum);
4075   if (group == i386_mmx_reggroup)
4076     return mmx_regnum_p;
4077
4078   xmm_regnum_p = i386_xmm_regnum_p (gdbarch, regnum);
4079   mxcsr_regnum_p = i386_mxcsr_regnum_p (gdbarch, regnum);
4080   if (group == i386_sse_reggroup)
4081     return xmm_regnum_p || mxcsr_regnum_p;
4082
4083   ymm_regnum_p = i386_ymm_regnum_p (gdbarch, regnum);
4084   if (group == vector_reggroup)
4085     return (mmx_regnum_p
4086             || ymm_regnum_p
4087             || mxcsr_regnum_p
4088             || (xmm_regnum_p
4089                 && ((tdep->xcr0 & I386_XSTATE_AVX_MASK)
4090                     == I386_XSTATE_SSE_MASK)));
4091
4092   fp_regnum_p = (i386_fp_regnum_p (gdbarch, regnum)
4093                  || i386_fpc_regnum_p (gdbarch, regnum));
4094   if (group == float_reggroup)
4095     return fp_regnum_p;
4096
4097   /* For "info reg all", don't include upper YMM registers nor XMM
4098      registers when AVX is supported.  */
4099   ymmh_regnum_p = i386_ymmh_regnum_p (gdbarch, regnum);
4100   if (group == all_reggroup
4101       && ((xmm_regnum_p
4102            && (tdep->xcr0 & I386_XSTATE_AVX))
4103           || ymmh_regnum_p))
4104     return 0;
4105
4106   bnd_regnum_p = i386_bnd_regnum_p (gdbarch, regnum);
4107   if (group == all_reggroup
4108       && ((bnd_regnum_p && (tdep->xcr0 & I386_XSTATE_MPX_MASK))))
4109     return bnd_regnum_p;
4110
4111   bndr_regnum_p = i386_bndr_regnum_p (gdbarch, regnum);
4112   if (group == all_reggroup
4113       && ((bndr_regnum_p && (tdep->xcr0 & I386_XSTATE_MPX_MASK))))
4114     return 0;
4115
4116   mpx_ctrl_regnum_p = i386_mpx_ctrl_regnum_p (gdbarch, regnum);
4117   if (group == all_reggroup
4118       && ((mpx_ctrl_regnum_p && (tdep->xcr0 & I386_XSTATE_MPX_MASK))))
4119     return mpx_ctrl_regnum_p;
4120
4121   if (group == general_reggroup)
4122     return (!fp_regnum_p
4123             && !mmx_regnum_p
4124             && !mxcsr_regnum_p
4125             && !xmm_regnum_p
4126             && !ymm_regnum_p
4127             && !ymmh_regnum_p
4128             && !bndr_regnum_p
4129             && !bnd_regnum_p
4130             && !mpx_ctrl_regnum_p);
4131
4132   return default_register_reggroup_p (gdbarch, regnum, group);
4133 }
4134 \f
4135
4136 /* Get the ARGIth function argument for the current function.  */
4137
4138 static CORE_ADDR
4139 i386_fetch_pointer_argument (struct frame_info *frame, int argi,
4140                              struct type *type)
4141 {
4142   struct gdbarch *gdbarch = get_frame_arch (frame);
4143   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4144   CORE_ADDR sp = get_frame_register_unsigned (frame, I386_ESP_REGNUM);
4145   return read_memory_unsigned_integer (sp + (4 * (argi + 1)), 4, byte_order);
4146 }
4147
4148 static void
4149 i386_skip_permanent_breakpoint (struct regcache *regcache)
4150 {
4151   CORE_ADDR current_pc = regcache_read_pc (regcache);
4152
4153  /* On i386, breakpoint is exactly 1 byte long, so we just
4154     adjust the PC in the regcache.  */
4155   current_pc += 1;
4156   regcache_write_pc (regcache, current_pc);
4157 }
4158
4159
4160 #define PREFIX_REPZ     0x01
4161 #define PREFIX_REPNZ    0x02
4162 #define PREFIX_LOCK     0x04
4163 #define PREFIX_DATA     0x08
4164 #define PREFIX_ADDR     0x10
4165
4166 /* operand size */
4167 enum
4168 {
4169   OT_BYTE = 0,
4170   OT_WORD,
4171   OT_LONG,
4172   OT_QUAD,
4173   OT_DQUAD,
4174 };
4175
4176 /* i386 arith/logic operations */
4177 enum
4178 {
4179   OP_ADDL,
4180   OP_ORL,
4181   OP_ADCL,
4182   OP_SBBL,
4183   OP_ANDL,
4184   OP_SUBL,
4185   OP_XORL,
4186   OP_CMPL,
4187 };
4188
4189 struct i386_record_s
4190 {
4191   struct gdbarch *gdbarch;
4192   struct regcache *regcache;
4193   CORE_ADDR orig_addr;
4194   CORE_ADDR addr;
4195   int aflag;
4196   int dflag;
4197   int override;
4198   uint8_t modrm;
4199   uint8_t mod, reg, rm;
4200   int ot;
4201   uint8_t rex_x;
4202   uint8_t rex_b;
4203   int rip_offset;
4204   int popl_esp_hack;
4205   const int *regmap;
4206 };
4207
4208 /* Parse the "modrm" part of the memory address irp->addr points at.
4209    Returns -1 if something goes wrong, 0 otherwise.  */
4210
4211 static int
4212 i386_record_modrm (struct i386_record_s *irp)
4213 {
4214   struct gdbarch *gdbarch = irp->gdbarch;
4215
4216   if (record_read_memory (gdbarch, irp->addr, &irp->modrm, 1))
4217     return -1;
4218
4219   irp->addr++;
4220   irp->mod = (irp->modrm >> 6) & 3;
4221   irp->reg = (irp->modrm >> 3) & 7;
4222   irp->rm = irp->modrm & 7;
4223
4224   return 0;
4225 }
4226
4227 /* Extract the memory address that the current instruction writes to,
4228    and return it in *ADDR.  Return -1 if something goes wrong.  */
4229
4230 static int
4231 i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
4232 {
4233   struct gdbarch *gdbarch = irp->gdbarch;
4234   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4235   gdb_byte buf[4];
4236   ULONGEST offset64;
4237
4238   *addr = 0;
4239   if (irp->aflag || irp->regmap[X86_RECORD_R8_REGNUM])
4240     {
4241       /* 32/64 bits */
4242       int havesib = 0;
4243       uint8_t scale = 0;
4244       uint8_t byte;
4245       uint8_t index = 0;
4246       uint8_t base = irp->rm;
4247
4248       if (base == 4)
4249         {
4250           havesib = 1;
4251           if (record_read_memory (gdbarch, irp->addr, &byte, 1))
4252             return -1;
4253           irp->addr++;
4254           scale = (byte >> 6) & 3;
4255           index = ((byte >> 3) & 7) | irp->rex_x;
4256           base = (byte & 7);
4257         }
4258       base |= irp->rex_b;
4259
4260       switch (irp->mod)
4261         {
4262         case 0:
4263           if ((base & 7) == 5)
4264             {
4265               base = 0xff;
4266               if (record_read_memory (gdbarch, irp->addr, buf, 4))
4267                 return -1;
4268               irp->addr += 4;
4269               *addr = extract_signed_integer (buf, 4, byte_order);
4270               if (irp->regmap[X86_RECORD_R8_REGNUM] && !havesib)
4271                 *addr += irp->addr + irp->rip_offset;
4272             }
4273           break;
4274         case 1:
4275           if (record_read_memory (gdbarch, irp->addr, buf, 1))
4276             return -1;
4277           irp->addr++;
4278           *addr = (int8_t) buf[0];
4279           break;
4280         case 2:
4281           if (record_read_memory (gdbarch, irp->addr, buf, 4))
4282             return -1;
4283           *addr = extract_signed_integer (buf, 4, byte_order);
4284           irp->addr += 4;
4285           break;
4286         }
4287
4288       offset64 = 0;
4289       if (base != 0xff)
4290         {
4291           if (base == 4 && irp->popl_esp_hack)
4292             *addr += irp->popl_esp_hack;
4293           regcache_raw_read_unsigned (irp->regcache, irp->regmap[base],
4294                                       &offset64);
4295         }
4296       if (irp->aflag == 2)
4297         {
4298           *addr += offset64;
4299         }
4300       else
4301         *addr = (uint32_t) (offset64 + *addr);
4302
4303       if (havesib && (index != 4 || scale != 0))
4304         {
4305           regcache_raw_read_unsigned (irp->regcache, irp->regmap[index],
4306                                       &offset64);
4307           if (irp->aflag == 2)
4308             *addr += offset64 << scale;
4309           else
4310             *addr = (uint32_t) (*addr + (offset64 << scale));
4311         }
4312
4313       if (!irp->aflag)
4314         {
4315           /* Since we are in 64-bit mode with ADDR32 prefix, zero-extend
4316              address from 32-bit to 64-bit.  */
4317             *addr = (uint32_t) *addr;
4318         }
4319     }
4320   else
4321     {
4322       /* 16 bits */
4323       switch (irp->mod)
4324         {
4325         case 0:
4326           if (irp->rm == 6)
4327             {
4328               if (record_read_memory (gdbarch, irp->addr, buf, 2))
4329                 return -1;
4330               irp->addr += 2;
4331               *addr = extract_signed_integer (buf, 2, byte_order);
4332               irp->rm = 0;
4333               goto no_rm;
4334             }
4335           break;
4336         case 1:
4337           if (record_read_memory (gdbarch, irp->addr, buf, 1))
4338             return -1;
4339           irp->addr++;
4340           *addr = (int8_t) buf[0];
4341           break;
4342         case 2:
4343           if (record_read_memory (gdbarch, irp->addr, buf, 2))
4344             return -1;
4345           irp->addr += 2;
4346           *addr = extract_signed_integer (buf, 2, byte_order);
4347           break;
4348         }
4349
4350       switch (irp->rm)
4351         {
4352         case 0:
4353           regcache_raw_read_unsigned (irp->regcache,
4354                                       irp->regmap[X86_RECORD_REBX_REGNUM],
4355                                       &offset64);
4356           *addr = (uint32_t) (*addr + offset64);
4357           regcache_raw_read_unsigned (irp->regcache,
4358                                       irp->regmap[X86_RECORD_RESI_REGNUM],
4359                                       &offset64);
4360           *addr = (uint32_t) (*addr + offset64);
4361           break;
4362         case 1:
4363           regcache_raw_read_unsigned (irp->regcache,
4364                                       irp->regmap[X86_RECORD_REBX_REGNUM],
4365                                       &offset64);
4366           *addr = (uint32_t) (*addr + offset64);
4367           regcache_raw_read_unsigned (irp->regcache,
4368                                       irp->regmap[X86_RECORD_REDI_REGNUM],
4369                                       &offset64);
4370           *addr = (uint32_t) (*addr + offset64);
4371           break;
4372         case 2:
4373           regcache_raw_read_unsigned (irp->regcache,
4374                                       irp->regmap[X86_RECORD_REBP_REGNUM],
4375                                       &offset64);
4376           *addr = (uint32_t) (*addr + offset64);
4377           regcache_raw_read_unsigned (irp->regcache,
4378                                       irp->regmap[X86_RECORD_RESI_REGNUM],
4379                                       &offset64);
4380           *addr = (uint32_t) (*addr + offset64);
4381           break;
4382         case 3:
4383           regcache_raw_read_unsigned (irp->regcache,
4384                                       irp->regmap[X86_RECORD_REBP_REGNUM],
4385                                       &offset64);
4386           *addr = (uint32_t) (*addr + offset64);
4387           regcache_raw_read_unsigned (irp->regcache,
4388                                       irp->regmap[X86_RECORD_REDI_REGNUM],
4389                                       &offset64);
4390           *addr = (uint32_t) (*addr + offset64);
4391           break;
4392         case 4:
4393           regcache_raw_read_unsigned (irp->regcache,
4394                                       irp->regmap[X86_RECORD_RESI_REGNUM],
4395                                       &offset64);
4396           *addr = (uint32_t) (*addr + offset64);
4397           break;
4398         case 5:
4399           regcache_raw_read_unsigned (irp->regcache,
4400                                       irp->regmap[X86_RECORD_REDI_REGNUM],
4401                                       &offset64);
4402           *addr = (uint32_t) (*addr + offset64);
4403           break;
4404         case 6:
4405           regcache_raw_read_unsigned (irp->regcache,
4406                                       irp->regmap[X86_RECORD_REBP_REGNUM],
4407                                       &offset64);
4408           *addr = (uint32_t) (*addr + offset64);
4409           break;
4410         case 7:
4411           regcache_raw_read_unsigned (irp->regcache,
4412                                       irp->regmap[X86_RECORD_REBX_REGNUM],
4413                                       &offset64);
4414           *addr = (uint32_t) (*addr + offset64);
4415           break;
4416         }
4417       *addr &= 0xffff;
4418     }
4419
4420  no_rm:
4421   return 0;
4422 }
4423
4424 /* Record the address and contents of the memory that will be changed
4425    by the current instruction.  Return -1 if something goes wrong, 0
4426    otherwise.  */
4427
4428 static int
4429 i386_record_lea_modrm (struct i386_record_s *irp)
4430 {
4431   struct gdbarch *gdbarch = irp->gdbarch;
4432   uint64_t addr;
4433
4434   if (irp->override >= 0)
4435     {
4436       if (record_full_memory_query)
4437         {
4438           int q;
4439
4440           target_terminal_ours ();
4441           q = yquery (_("\
4442 Process record ignores the memory change of instruction at address %s\n\
4443 because it can't get the value of the segment register.\n\
4444 Do you want to stop the program?"),
4445                       paddress (gdbarch, irp->orig_addr));
4446             target_terminal_inferior ();
4447             if (q)
4448               return -1;
4449         }
4450
4451       return 0;
4452     }
4453
4454   if (i386_record_lea_modrm_addr (irp, &addr))
4455     return -1;
4456
4457   if (record_full_arch_list_add_mem (addr, 1 << irp->ot))
4458     return -1;
4459
4460   return 0;
4461 }
4462
4463 /* Record the effects of a push operation.  Return -1 if something
4464    goes wrong, 0 otherwise.  */
4465
4466 static int
4467 i386_record_push (struct i386_record_s *irp, int size)
4468 {
4469   ULONGEST addr;
4470
4471   if (record_full_arch_list_add_reg (irp->regcache,
4472                                      irp->regmap[X86_RECORD_RESP_REGNUM]))
4473     return -1;
4474   regcache_raw_read_unsigned (irp->regcache,
4475                               irp->regmap[X86_RECORD_RESP_REGNUM],
4476                               &addr);
4477   if (record_full_arch_list_add_mem ((CORE_ADDR) addr - size, size))
4478     return -1;
4479
4480   return 0;
4481 }
4482
4483
4484 /* Defines contents to record.  */
4485 #define I386_SAVE_FPU_REGS              0xfffd
4486 #define I386_SAVE_FPU_ENV               0xfffe
4487 #define I386_SAVE_FPU_ENV_REG_STACK     0xffff
4488
4489 /* Record the values of the floating point registers which will be
4490    changed by the current instruction.  Returns -1 if something is
4491    wrong, 0 otherwise.  */
4492
4493 static int i386_record_floats (struct gdbarch *gdbarch,
4494                                struct i386_record_s *ir,
4495                                uint32_t iregnum)
4496 {
4497   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4498   int i;
4499
4500   /* Oza: Because of floating point insn push/pop of fpu stack is going to
4501      happen.  Currently we store st0-st7 registers, but we need not store all
4502      registers all the time, in future we use ftag register and record only
4503      those who are not marked as an empty.  */
4504
4505   if (I386_SAVE_FPU_REGS == iregnum)
4506     {
4507       for (i = I387_ST0_REGNUM (tdep); i <= I387_ST0_REGNUM (tdep) + 7; i++)
4508         {
4509           if (record_full_arch_list_add_reg (ir->regcache, i))
4510             return -1;
4511         }
4512     }
4513   else if (I386_SAVE_FPU_ENV == iregnum)
4514     {
4515       for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
4516               {
4517               if (record_full_arch_list_add_reg (ir->regcache, i))
4518                 return -1;
4519               }
4520     }
4521   else if (I386_SAVE_FPU_ENV_REG_STACK == iregnum)
4522     {
4523       for (i = I387_ST0_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
4524       {
4525         if (record_full_arch_list_add_reg (ir->regcache, i))
4526           return -1;
4527       }
4528     }
4529   else if ((iregnum >= I387_ST0_REGNUM (tdep)) &&
4530            (iregnum <= I387_FOP_REGNUM (tdep)))
4531     {
4532       if (record_full_arch_list_add_reg (ir->regcache,iregnum))
4533         return -1;
4534     }
4535   else
4536     {
4537       /* Parameter error.  */
4538       return -1;
4539     }
4540   if(I386_SAVE_FPU_ENV != iregnum)
4541     {
4542     for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
4543       {
4544       if (record_full_arch_list_add_reg (ir->regcache, i))
4545         return -1;
4546       }
4547     }
4548   return 0;
4549 }
4550
4551 /* Parse the current instruction, and record the values of the
4552    registers and memory that will be changed by the current
4553    instruction.  Returns -1 if something goes wrong, 0 otherwise.  */
4554
4555 #define I386_RECORD_FULL_ARCH_LIST_ADD_REG(regnum) \
4556     record_full_arch_list_add_reg (ir.regcache, ir.regmap[(regnum)])
4557
4558 int
4559 i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
4560                      CORE_ADDR input_addr)
4561 {
4562   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4563   int prefixes = 0;
4564   int regnum = 0;
4565   uint32_t opcode;
4566   uint8_t opcode8;
4567   ULONGEST addr;
4568   gdb_byte buf[MAX_REGISTER_SIZE];
4569   struct i386_record_s ir;
4570   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4571   uint8_t rex_w = -1;
4572   uint8_t rex_r = 0;
4573
4574   memset (&ir, 0, sizeof (struct i386_record_s));
4575   ir.regcache = regcache;
4576   ir.addr = input_addr;
4577   ir.orig_addr = input_addr;
4578   ir.aflag = 1;
4579   ir.dflag = 1;
4580   ir.override = -1;
4581   ir.popl_esp_hack = 0;
4582   ir.regmap = tdep->record_regmap;
4583   ir.gdbarch = gdbarch;
4584
4585   if (record_debug > 1)
4586     fprintf_unfiltered (gdb_stdlog, "Process record: i386_process_record "
4587                                     "addr = %s\n",
4588                         paddress (gdbarch, ir.addr));
4589
4590   /* prefixes */
4591   while (1)
4592     {
4593       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
4594         return -1;
4595       ir.addr++;
4596       switch (opcode8)  /* Instruction prefixes */
4597         {
4598         case REPE_PREFIX_OPCODE:
4599           prefixes |= PREFIX_REPZ;
4600           break;
4601         case REPNE_PREFIX_OPCODE:
4602           prefixes |= PREFIX_REPNZ;
4603           break;
4604         case LOCK_PREFIX_OPCODE:
4605           prefixes |= PREFIX_LOCK;
4606           break;
4607         case CS_PREFIX_OPCODE:
4608           ir.override = X86_RECORD_CS_REGNUM;
4609           break;
4610         case SS_PREFIX_OPCODE:
4611           ir.override = X86_RECORD_SS_REGNUM;
4612           break;
4613         case DS_PREFIX_OPCODE:
4614           ir.override = X86_RECORD_DS_REGNUM;
4615           break;
4616         case ES_PREFIX_OPCODE:
4617           ir.override = X86_RECORD_ES_REGNUM;
4618           break;
4619         case FS_PREFIX_OPCODE:
4620           ir.override = X86_RECORD_FS_REGNUM;
4621           break;
4622         case GS_PREFIX_OPCODE:
4623           ir.override = X86_RECORD_GS_REGNUM;
4624           break;
4625         case DATA_PREFIX_OPCODE:
4626           prefixes |= PREFIX_DATA;
4627           break;
4628         case ADDR_PREFIX_OPCODE:
4629           prefixes |= PREFIX_ADDR;
4630           break;
4631         case 0x40:      /* i386 inc %eax */
4632         case 0x41:      /* i386 inc %ecx */
4633         case 0x42:      /* i386 inc %edx */
4634         case 0x43:      /* i386 inc %ebx */
4635         case 0x44:      /* i386 inc %esp */
4636         case 0x45:      /* i386 inc %ebp */
4637         case 0x46:      /* i386 inc %esi */
4638         case 0x47:      /* i386 inc %edi */
4639         case 0x48:      /* i386 dec %eax */
4640         case 0x49:      /* i386 dec %ecx */
4641         case 0x4a:      /* i386 dec %edx */
4642         case 0x4b:      /* i386 dec %ebx */
4643         case 0x4c:      /* i386 dec %esp */
4644         case 0x4d:      /* i386 dec %ebp */
4645         case 0x4e:      /* i386 dec %esi */
4646         case 0x4f:      /* i386 dec %edi */
4647           if (ir.regmap[X86_RECORD_R8_REGNUM])  /* 64 bit target */
4648             {
4649                /* REX */
4650                rex_w = (opcode8 >> 3) & 1;
4651                rex_r = (opcode8 & 0x4) << 1;
4652                ir.rex_x = (opcode8 & 0x2) << 2;
4653                ir.rex_b = (opcode8 & 0x1) << 3;
4654             }
4655           else                                  /* 32 bit target */
4656             goto out_prefixes;
4657           break;
4658         default:
4659           goto out_prefixes;
4660           break;
4661         }
4662     }
4663  out_prefixes:
4664   if (ir.regmap[X86_RECORD_R8_REGNUM] && rex_w == 1)
4665     {
4666       ir.dflag = 2;
4667     }
4668   else
4669     {
4670       if (prefixes & PREFIX_DATA)
4671         ir.dflag ^= 1;
4672     }
4673   if (prefixes & PREFIX_ADDR)
4674     ir.aflag ^= 1;
4675   else if (ir.regmap[X86_RECORD_R8_REGNUM])
4676     ir.aflag = 2;
4677
4678   /* Now check op code.  */
4679   opcode = (uint32_t) opcode8;
4680  reswitch:
4681   switch (opcode)
4682     {
4683     case 0x0f:
4684       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
4685         return -1;
4686       ir.addr++;
4687       opcode = (uint32_t) opcode8 | 0x0f00;
4688       goto reswitch;
4689       break;
4690
4691     case 0x00:    /* arith & logic */
4692     case 0x01:
4693     case 0x02:
4694     case 0x03:
4695     case 0x04:
4696     case 0x05:
4697     case 0x08:
4698     case 0x09:
4699     case 0x0a:
4700     case 0x0b:
4701     case 0x0c:
4702     case 0x0d:
4703     case 0x10:
4704     case 0x11:
4705     case 0x12:
4706     case 0x13:
4707     case 0x14:
4708     case 0x15:
4709     case 0x18:
4710     case 0x19:
4711     case 0x1a:
4712     case 0x1b:
4713     case 0x1c:
4714     case 0x1d:
4715     case 0x20:
4716     case 0x21:
4717     case 0x22:
4718     case 0x23:
4719     case 0x24:
4720     case 0x25:
4721     case 0x28:
4722     case 0x29:
4723     case 0x2a:
4724     case 0x2b:
4725     case 0x2c:
4726     case 0x2d:
4727     case 0x30:
4728     case 0x31:
4729     case 0x32:
4730     case 0x33:
4731     case 0x34:
4732     case 0x35:
4733     case 0x38:
4734     case 0x39:
4735     case 0x3a:
4736     case 0x3b:
4737     case 0x3c:
4738     case 0x3d:
4739       if (((opcode >> 3) & 7) != OP_CMPL)
4740         {
4741           if ((opcode & 1) == 0)
4742             ir.ot = OT_BYTE;
4743           else
4744             ir.ot = ir.dflag + OT_WORD;
4745
4746           switch ((opcode >> 1) & 3)
4747             {
4748             case 0:    /* OP Ev, Gv */
4749               if (i386_record_modrm (&ir))
4750                 return -1;
4751               if (ir.mod != 3)
4752                 {
4753                   if (i386_record_lea_modrm (&ir))
4754                     return -1;
4755                 }
4756               else
4757                 {
4758                   ir.rm |= ir.rex_b;
4759                   if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4760                     ir.rm &= 0x3;
4761                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
4762                 }
4763               break;
4764             case 1:    /* OP Gv, Ev */
4765               if (i386_record_modrm (&ir))
4766                 return -1;
4767               ir.reg |= rex_r;
4768               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4769                 ir.reg &= 0x3;
4770               I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
4771               break;
4772             case 2:    /* OP A, Iv */
4773               I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4774               break;
4775             }
4776         }
4777       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4778       break;
4779
4780     case 0x80:    /* GRP1 */
4781     case 0x81:
4782     case 0x82:
4783     case 0x83:
4784       if (i386_record_modrm (&ir))
4785         return -1;
4786
4787       if (ir.reg != OP_CMPL)
4788         {
4789           if ((opcode & 1) == 0)
4790             ir.ot = OT_BYTE;
4791           else
4792             ir.ot = ir.dflag + OT_WORD;
4793
4794           if (ir.mod != 3)
4795             {
4796               if (opcode == 0x83)
4797                 ir.rip_offset = 1;
4798               else
4799                 ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
4800               if (i386_record_lea_modrm (&ir))
4801                 return -1;
4802             }
4803           else
4804             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
4805         }
4806       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4807       break;
4808
4809     case 0x40:      /* inc */
4810     case 0x41:
4811     case 0x42:
4812     case 0x43:
4813     case 0x44:
4814     case 0x45:
4815     case 0x46:
4816     case 0x47:
4817
4818     case 0x48:      /* dec */
4819     case 0x49:
4820     case 0x4a:
4821     case 0x4b:
4822     case 0x4c:
4823     case 0x4d:
4824     case 0x4e:
4825     case 0x4f:
4826
4827       I386_RECORD_FULL_ARCH_LIST_ADD_REG (opcode & 7);
4828       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4829       break;
4830
4831     case 0xf6:    /* GRP3 */
4832     case 0xf7:
4833       if ((opcode & 1) == 0)
4834         ir.ot = OT_BYTE;
4835       else
4836         ir.ot = ir.dflag + OT_WORD;
4837       if (i386_record_modrm (&ir))
4838         return -1;
4839
4840       if (ir.mod != 3 && ir.reg == 0)
4841         ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
4842
4843       switch (ir.reg)
4844         {
4845         case 0:    /* test */
4846           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4847           break;
4848         case 2:    /* not */
4849         case 3:    /* neg */
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           if (ir.reg == 3)  /* neg */
4863             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4864           break;
4865         case 4:    /* mul  */
4866         case 5:    /* imul */
4867         case 6:    /* div  */
4868         case 7:    /* idiv */
4869           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4870           if (ir.ot != OT_BYTE)
4871             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
4872           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4873           break;
4874         default:
4875           ir.addr -= 2;
4876           opcode = opcode << 8 | ir.modrm;
4877           goto no_support;
4878           break;
4879         }
4880       break;
4881
4882     case 0xfe:    /* GRP4 */
4883     case 0xff:    /* GRP5 */
4884       if (i386_record_modrm (&ir))
4885         return -1;
4886       if (ir.reg >= 2 && opcode == 0xfe)
4887         {
4888           ir.addr -= 2;
4889           opcode = opcode << 8 | ir.modrm;
4890           goto no_support;
4891         }
4892       switch (ir.reg)
4893         {
4894         case 0:    /* inc */
4895         case 1:    /* dec */
4896           if ((opcode & 1) == 0)
4897             ir.ot = OT_BYTE;
4898           else
4899             ir.ot = ir.dflag + OT_WORD;
4900           if (ir.mod != 3)
4901             {
4902               if (i386_record_lea_modrm (&ir))
4903                 return -1;
4904             }
4905           else
4906             {
4907               ir.rm |= ir.rex_b;
4908               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4909                 ir.rm &= 0x3;
4910               I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
4911             }
4912           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4913           break;
4914         case 2:    /* call */
4915           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
4916             ir.dflag = 2;
4917           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
4918             return -1;
4919           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4920           break;
4921         case 3:    /* lcall */
4922           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
4923           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
4924             return -1;
4925           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4926           break;
4927         case 4:    /* jmp  */
4928         case 5:    /* ljmp */
4929           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4930           break;
4931         case 6:    /* push */
4932           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
4933             ir.dflag = 2;
4934           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
4935             return -1;
4936           break;
4937         default:
4938           ir.addr -= 2;
4939           opcode = opcode << 8 | ir.modrm;
4940           goto no_support;
4941           break;
4942         }
4943       break;
4944
4945     case 0x84:    /* test */
4946     case 0x85:
4947     case 0xa8:
4948     case 0xa9:
4949       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4950       break;
4951
4952     case 0x98:    /* CWDE/CBW */
4953       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4954       break;
4955
4956     case 0x99:    /* CDQ/CWD */
4957       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4958       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
4959       break;
4960
4961     case 0x0faf:  /* imul */
4962     case 0x69:
4963     case 0x6b:
4964       ir.ot = ir.dflag + OT_WORD;
4965       if (i386_record_modrm (&ir))
4966         return -1;
4967       if (opcode == 0x69)
4968         ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
4969       else if (opcode == 0x6b)
4970         ir.rip_offset = 1;
4971       ir.reg |= rex_r;
4972       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4973         ir.reg &= 0x3;
4974       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
4975       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4976       break;
4977
4978     case 0x0fc0:  /* xadd */
4979     case 0x0fc1:
4980       if ((opcode & 1) == 0)
4981         ir.ot = OT_BYTE;
4982       else
4983         ir.ot = ir.dflag + OT_WORD;
4984       if (i386_record_modrm (&ir))
4985         return -1;
4986       ir.reg |= rex_r;
4987       if (ir.mod == 3)
4988         {
4989           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4990             ir.reg &= 0x3;
4991           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
4992           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4993             ir.rm &= 0x3;
4994           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
4995         }
4996       else
4997         {
4998           if (i386_record_lea_modrm (&ir))
4999             return -1;
5000           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5001             ir.reg &= 0x3;
5002           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5003         }
5004       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5005       break;
5006
5007     case 0x0fb0:  /* cmpxchg */
5008     case 0x0fb1:
5009       if ((opcode & 1) == 0)
5010         ir.ot = OT_BYTE;
5011       else
5012         ir.ot = ir.dflag + OT_WORD;
5013       if (i386_record_modrm (&ir))
5014         return -1;
5015       if (ir.mod == 3)
5016         {
5017           ir.reg |= rex_r;
5018           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5019           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5020             ir.reg &= 0x3;
5021           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5022         }
5023       else
5024         {
5025           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5026           if (i386_record_lea_modrm (&ir))
5027             return -1;
5028         }
5029       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5030       break;
5031
5032     case 0x0fc7:    /* cmpxchg8b */
5033       if (i386_record_modrm (&ir))
5034         return -1;
5035       if (ir.mod == 3)
5036         {
5037           ir.addr -= 2;
5038           opcode = opcode << 8 | ir.modrm;
5039           goto no_support;
5040         }
5041       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5042       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
5043       if (i386_record_lea_modrm (&ir))
5044         return -1;
5045       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5046       break;
5047
5048     case 0x50:    /* push */
5049     case 0x51:
5050     case 0x52:
5051     case 0x53:
5052     case 0x54:
5053     case 0x55:
5054     case 0x56:
5055     case 0x57:
5056     case 0x68:
5057     case 0x6a:
5058       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
5059         ir.dflag = 2;
5060       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5061         return -1;
5062       break;
5063
5064     case 0x06:    /* push es */
5065     case 0x0e:    /* push cs */
5066     case 0x16:    /* push ss */
5067     case 0x1e:    /* push ds */
5068       if (ir.regmap[X86_RECORD_R8_REGNUM])
5069         {
5070           ir.addr -= 1;
5071           goto no_support;
5072         }
5073       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5074         return -1;
5075       break;
5076
5077     case 0x0fa0:    /* push fs */
5078     case 0x0fa8:    /* push gs */
5079       if (ir.regmap[X86_RECORD_R8_REGNUM])
5080         {
5081           ir.addr -= 2;
5082           goto no_support;
5083         }
5084       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5085         return -1;
5086       break;
5087
5088     case 0x60:    /* pusha */
5089       if (ir.regmap[X86_RECORD_R8_REGNUM])
5090         {
5091           ir.addr -= 1;
5092           goto no_support;
5093         }
5094       if (i386_record_push (&ir, 1 << (ir.dflag + 4)))
5095         return -1;
5096       break;
5097
5098     case 0x58:    /* pop */
5099     case 0x59:
5100     case 0x5a:
5101     case 0x5b:
5102     case 0x5c:
5103     case 0x5d:
5104     case 0x5e:
5105     case 0x5f:
5106       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5107       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
5108       break;
5109
5110     case 0x61:    /* popa */
5111       if (ir.regmap[X86_RECORD_R8_REGNUM])
5112         {
5113           ir.addr -= 1;
5114           goto no_support;
5115         }
5116       for (regnum = X86_RECORD_REAX_REGNUM;
5117            regnum <= X86_RECORD_REDI_REGNUM;
5118            regnum++)
5119         I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
5120       break;
5121
5122     case 0x8f:    /* pop */
5123       if (ir.regmap[X86_RECORD_R8_REGNUM])
5124         ir.ot = ir.dflag ? OT_QUAD : OT_WORD;
5125       else
5126         ir.ot = ir.dflag + OT_WORD;
5127       if (i386_record_modrm (&ir))
5128         return -1;
5129       if (ir.mod == 3)
5130         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5131       else
5132         {
5133           ir.popl_esp_hack = 1 << ir.ot;
5134           if (i386_record_lea_modrm (&ir))
5135             return -1;
5136         }
5137       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5138       break;
5139
5140     case 0xc8:    /* enter */
5141       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
5142       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
5143         ir.dflag = 2;
5144       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
5145         return -1;
5146       break;
5147
5148     case 0xc9:    /* leave */
5149       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5150       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
5151       break;
5152
5153     case 0x07:    /* pop es */
5154       if (ir.regmap[X86_RECORD_R8_REGNUM])
5155         {
5156           ir.addr -= 1;
5157           goto no_support;
5158         }
5159       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5160       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_ES_REGNUM);
5161       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5162       break;
5163
5164     case 0x17:    /* pop ss */
5165       if (ir.regmap[X86_RECORD_R8_REGNUM])
5166         {
5167           ir.addr -= 1;
5168           goto no_support;
5169         }
5170       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5171       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_SS_REGNUM);
5172       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5173       break;
5174
5175     case 0x1f:    /* pop ds */
5176       if (ir.regmap[X86_RECORD_R8_REGNUM])
5177         {
5178           ir.addr -= 1;
5179           goto no_support;
5180         }
5181       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5182       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_DS_REGNUM);
5183       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5184       break;
5185
5186     case 0x0fa1:    /* pop fs */
5187       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5188       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_FS_REGNUM);
5189       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5190       break;
5191
5192     case 0x0fa9:    /* pop gs */
5193       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
5194       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
5195       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5196       break;
5197
5198     case 0x88:    /* mov */
5199     case 0x89:
5200     case 0xc6:
5201     case 0xc7:
5202       if ((opcode & 1) == 0)
5203         ir.ot = OT_BYTE;
5204       else
5205         ir.ot = ir.dflag + OT_WORD;
5206
5207       if (i386_record_modrm (&ir))
5208         return -1;
5209
5210       if (ir.mod != 3)
5211         {
5212           if (opcode == 0xc6 || opcode == 0xc7)
5213             ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
5214           if (i386_record_lea_modrm (&ir))
5215             return -1;
5216         }
5217       else
5218         {
5219           if (opcode == 0xc6 || opcode == 0xc7)
5220             ir.rm |= ir.rex_b;
5221           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5222             ir.rm &= 0x3;
5223           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5224         }
5225       break;
5226
5227     case 0x8a:    /* mov */
5228     case 0x8b:
5229       if ((opcode & 1) == 0)
5230         ir.ot = OT_BYTE;
5231       else
5232         ir.ot = ir.dflag + OT_WORD;
5233       if (i386_record_modrm (&ir))
5234         return -1;
5235       ir.reg |= rex_r;
5236       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5237         ir.reg &= 0x3;
5238       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5239       break;
5240
5241     case 0x8c:    /* mov seg */
5242       if (i386_record_modrm (&ir))
5243         return -1;
5244       if (ir.reg > 5)
5245         {
5246           ir.addr -= 2;
5247           opcode = opcode << 8 | ir.modrm;
5248           goto no_support;
5249         }
5250
5251       if (ir.mod == 3)
5252         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5253       else
5254         {
5255           ir.ot = OT_WORD;
5256           if (i386_record_lea_modrm (&ir))
5257             return -1;
5258         }
5259       break;
5260
5261     case 0x8e:    /* mov seg */
5262       if (i386_record_modrm (&ir))
5263         return -1;
5264       switch (ir.reg)
5265         {
5266         case 0:
5267           regnum = X86_RECORD_ES_REGNUM;
5268           break;
5269         case 2:
5270           regnum = X86_RECORD_SS_REGNUM;
5271           break;
5272         case 3:
5273           regnum = X86_RECORD_DS_REGNUM;
5274           break;
5275         case 4:
5276           regnum = X86_RECORD_FS_REGNUM;
5277           break;
5278         case 5:
5279           regnum = X86_RECORD_GS_REGNUM;
5280           break;
5281         default:
5282           ir.addr -= 2;
5283           opcode = opcode << 8 | ir.modrm;
5284           goto no_support;
5285           break;
5286         }
5287       I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
5288       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5289       break;
5290
5291     case 0x0fb6:    /* movzbS */
5292     case 0x0fb7:    /* movzwS */
5293     case 0x0fbe:    /* movsbS */
5294     case 0x0fbf:    /* movswS */
5295       if (i386_record_modrm (&ir))
5296         return -1;
5297       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
5298       break;
5299
5300     case 0x8d:      /* lea */
5301       if (i386_record_modrm (&ir))
5302         return -1;
5303       if (ir.mod == 3)
5304         {
5305           ir.addr -= 2;
5306           opcode = opcode << 8 | ir.modrm;
5307           goto no_support;
5308         }
5309       ir.ot = ir.dflag;
5310       ir.reg |= rex_r;
5311       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5312         ir.reg &= 0x3;
5313       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5314       break;
5315
5316     case 0xa0:    /* mov EAX */
5317     case 0xa1:
5318
5319     case 0xd7:    /* xlat */
5320       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5321       break;
5322
5323     case 0xa2:    /* mov EAX */
5324     case 0xa3:
5325       if (ir.override >= 0)
5326         {
5327           if (record_full_memory_query)
5328             {
5329               int q;
5330
5331               target_terminal_ours ();
5332               q = yquery (_("\
5333 Process record ignores the memory change of instruction at address %s\n\
5334 because it can't get the value of the segment register.\n\
5335 Do you want to stop the program?"),
5336                           paddress (gdbarch, ir.orig_addr));
5337               target_terminal_inferior ();
5338               if (q)
5339                 return -1;
5340             }
5341         }
5342       else
5343         {
5344           if ((opcode & 1) == 0)
5345             ir.ot = OT_BYTE;
5346           else
5347             ir.ot = ir.dflag + OT_WORD;
5348           if (ir.aflag == 2)
5349             {
5350               if (record_read_memory (gdbarch, ir.addr, buf, 8))
5351                 return -1;
5352               ir.addr += 8;
5353               addr = extract_unsigned_integer (buf, 8, byte_order);
5354             }
5355           else if (ir.aflag)
5356             {
5357               if (record_read_memory (gdbarch, ir.addr, buf, 4))
5358                 return -1;
5359               ir.addr += 4;
5360               addr = extract_unsigned_integer (buf, 4, byte_order);
5361             }
5362           else
5363             {
5364               if (record_read_memory (gdbarch, ir.addr, buf, 2))
5365                 return -1;
5366               ir.addr += 2;
5367               addr = extract_unsigned_integer (buf, 2, byte_order);
5368             }
5369           if (record_full_arch_list_add_mem (addr, 1 << ir.ot))
5370             return -1;
5371         }
5372       break;
5373
5374     case 0xb0:    /* mov R, Ib */
5375     case 0xb1:
5376     case 0xb2:
5377     case 0xb3:
5378     case 0xb4:
5379     case 0xb5:
5380     case 0xb6:
5381     case 0xb7:
5382       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((ir.regmap[X86_RECORD_R8_REGNUM])
5383                                           ? ((opcode & 0x7) | ir.rex_b)
5384                                           : ((opcode & 0x7) & 0x3));
5385       break;
5386
5387     case 0xb8:    /* mov R, Iv */
5388     case 0xb9:
5389     case 0xba:
5390     case 0xbb:
5391     case 0xbc:
5392     case 0xbd:
5393     case 0xbe:
5394     case 0xbf:
5395       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
5396       break;
5397
5398     case 0x91:    /* xchg R, EAX */
5399     case 0x92:
5400     case 0x93:
5401     case 0x94:
5402     case 0x95:
5403     case 0x96:
5404     case 0x97:
5405       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5406       I386_RECORD_FULL_ARCH_LIST_ADD_REG (opcode & 0x7);
5407       break;
5408
5409     case 0x86:    /* xchg Ev, Gv */
5410     case 0x87:
5411       if ((opcode & 1) == 0)
5412         ir.ot = OT_BYTE;
5413       else
5414         ir.ot = ir.dflag + OT_WORD;
5415       if (i386_record_modrm (&ir))
5416         return -1;
5417       if (ir.mod == 3)
5418         {
5419           ir.rm |= ir.rex_b;
5420           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5421             ir.rm &= 0x3;
5422           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5423         }
5424       else
5425         {
5426           if (i386_record_lea_modrm (&ir))
5427             return -1;
5428         }
5429       ir.reg |= rex_r;
5430       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5431         ir.reg &= 0x3;
5432       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
5433       break;
5434
5435     case 0xc4:    /* les Gv */
5436     case 0xc5:    /* lds Gv */
5437       if (ir.regmap[X86_RECORD_R8_REGNUM])
5438         {
5439           ir.addr -= 1;
5440           goto no_support;
5441         }
5442       /* FALLTHROUGH */
5443     case 0x0fb2:    /* lss Gv */
5444     case 0x0fb4:    /* lfs Gv */
5445     case 0x0fb5:    /* lgs Gv */
5446       if (i386_record_modrm (&ir))
5447         return -1;
5448       if (ir.mod == 3)
5449         {
5450           if (opcode > 0xff)
5451             ir.addr -= 3;
5452           else
5453             ir.addr -= 2;
5454           opcode = opcode << 8 | ir.modrm;
5455           goto no_support;
5456         }
5457       switch (opcode)
5458         {
5459         case 0xc4:    /* les Gv */
5460           regnum = X86_RECORD_ES_REGNUM;
5461           break;
5462         case 0xc5:    /* lds Gv */
5463           regnum = X86_RECORD_DS_REGNUM;
5464           break;
5465         case 0x0fb2:  /* lss Gv */
5466           regnum = X86_RECORD_SS_REGNUM;
5467           break;
5468         case 0x0fb4:  /* lfs Gv */
5469           regnum = X86_RECORD_FS_REGNUM;
5470           break;
5471         case 0x0fb5:  /* lgs Gv */
5472           regnum = X86_RECORD_GS_REGNUM;
5473           break;
5474         }
5475       I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
5476       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
5477       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5478       break;
5479
5480     case 0xc0:    /* shifts */
5481     case 0xc1:
5482     case 0xd0:
5483     case 0xd1:
5484     case 0xd2:
5485     case 0xd3:
5486       if ((opcode & 1) == 0)
5487         ir.ot = OT_BYTE;
5488       else
5489         ir.ot = ir.dflag + OT_WORD;
5490       if (i386_record_modrm (&ir))
5491         return -1;
5492       if (ir.mod != 3 && (opcode == 0xd2 || opcode == 0xd3))
5493         {
5494           if (i386_record_lea_modrm (&ir))
5495             return -1;
5496         }
5497       else
5498         {
5499           ir.rm |= ir.rex_b;
5500           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
5501             ir.rm &= 0x3;
5502           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
5503         }
5504       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5505       break;
5506
5507     case 0x0fa4:
5508     case 0x0fa5:
5509     case 0x0fac:
5510     case 0x0fad:
5511       if (i386_record_modrm (&ir))
5512         return -1;
5513       if (ir.mod == 3)
5514         {
5515           if (record_full_arch_list_add_reg (ir.regcache, ir.rm))
5516             return -1;
5517         }
5518       else
5519         {
5520           if (i386_record_lea_modrm (&ir))
5521             return -1;
5522         }
5523       break;
5524
5525     case 0xd8:    /* Floats.  */
5526     case 0xd9:
5527     case 0xda:
5528     case 0xdb:
5529     case 0xdc:
5530     case 0xdd:
5531     case 0xde:
5532     case 0xdf:
5533       if (i386_record_modrm (&ir))
5534         return -1;
5535       ir.reg |= ((opcode & 7) << 3);
5536       if (ir.mod != 3)
5537         {
5538           /* Memory.  */
5539           uint64_t addr64;
5540
5541           if (i386_record_lea_modrm_addr (&ir, &addr64))
5542             return -1;
5543           switch (ir.reg)
5544             {
5545             case 0x02:
5546             case 0x12:
5547             case 0x22:
5548             case 0x32:
5549               /* For fcom, ficom nothing to do.  */
5550               break;
5551             case 0x03:
5552             case 0x13:
5553             case 0x23:
5554             case 0x33:
5555               /* For fcomp, ficomp pop FPU stack, store all.  */
5556               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5557                 return -1;
5558               break;
5559             case 0x00:
5560             case 0x01:
5561             case 0x04:
5562             case 0x05:
5563             case 0x06:
5564             case 0x07:
5565             case 0x10:
5566             case 0x11:
5567             case 0x14:
5568             case 0x15:
5569             case 0x16:
5570             case 0x17:
5571             case 0x20:
5572             case 0x21:
5573             case 0x24:
5574             case 0x25:
5575             case 0x26:
5576             case 0x27:
5577             case 0x30:
5578             case 0x31:
5579             case 0x34:
5580             case 0x35:
5581             case 0x36:
5582             case 0x37:
5583               /* For fadd, fmul, fsub, fsubr, fdiv, fdivr, fiadd, fimul,
5584                  fisub, fisubr, fidiv, fidivr, modR/M.reg is an extension
5585                  of code,  always affects st(0) register.  */
5586               if (i386_record_floats (gdbarch, &ir, I387_ST0_REGNUM (tdep)))
5587                 return -1;
5588               break;
5589             case 0x08:
5590             case 0x0a:
5591             case 0x0b:
5592             case 0x18:
5593             case 0x19:
5594             case 0x1a:
5595             case 0x1b:
5596             case 0x1d:
5597             case 0x28:
5598             case 0x29:
5599             case 0x2a:
5600             case 0x2b:
5601             case 0x38:
5602             case 0x39:
5603             case 0x3a:
5604             case 0x3b:
5605             case 0x3c:
5606             case 0x3d:
5607               switch (ir.reg & 7)
5608                 {
5609                 case 0:
5610                   /* Handling fld, fild.  */
5611                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5612                     return -1;
5613                   break;
5614                 case 1:
5615                   switch (ir.reg >> 4)
5616                     {
5617                     case 0:
5618                       if (record_full_arch_list_add_mem (addr64, 4))
5619                         return -1;
5620                       break;
5621                     case 2:
5622                       if (record_full_arch_list_add_mem (addr64, 8))
5623                         return -1;
5624                       break;
5625                     case 3:
5626                       break;
5627                     default:
5628                       if (record_full_arch_list_add_mem (addr64, 2))
5629                         return -1;
5630                       break;
5631                     }
5632                   break;
5633                 default:
5634                   switch (ir.reg >> 4)
5635                     {
5636                     case 0:
5637                       if (record_full_arch_list_add_mem (addr64, 4))
5638                         return -1;
5639                       if (3 == (ir.reg & 7))
5640                         {
5641                           /* For fstp m32fp.  */
5642                           if (i386_record_floats (gdbarch, &ir,
5643                                                   I386_SAVE_FPU_REGS))
5644                             return -1;
5645                         }
5646                       break;
5647                     case 1:
5648                       if (record_full_arch_list_add_mem (addr64, 4))
5649                         return -1;
5650                       if ((3 == (ir.reg & 7))
5651                           || (5 == (ir.reg & 7))
5652                           || (7 == (ir.reg & 7)))
5653                         {
5654                           /* For fstp insn.  */
5655                           if (i386_record_floats (gdbarch, &ir,
5656                                                   I386_SAVE_FPU_REGS))
5657                             return -1;
5658                         }
5659                       break;
5660                     case 2:
5661                       if (record_full_arch_list_add_mem (addr64, 8))
5662                         return -1;
5663                       if (3 == (ir.reg & 7))
5664                         {
5665                           /* For fstp m64fp.  */
5666                           if (i386_record_floats (gdbarch, &ir,
5667                                                   I386_SAVE_FPU_REGS))
5668                             return -1;
5669                         }
5670                       break;
5671                     case 3:
5672                       if ((3 <= (ir.reg & 7)) && (6 <= (ir.reg & 7)))
5673                         {
5674                           /* For fistp, fbld, fild, fbstp.  */
5675                           if (i386_record_floats (gdbarch, &ir,
5676                                                   I386_SAVE_FPU_REGS))
5677                             return -1;
5678                         }
5679                       /* Fall through */
5680                     default:
5681                       if (record_full_arch_list_add_mem (addr64, 2))
5682                         return -1;
5683                       break;
5684                     }
5685                   break;
5686                 }
5687               break;
5688             case 0x0c:
5689               /* Insn fldenv.  */
5690               if (i386_record_floats (gdbarch, &ir,
5691                                       I386_SAVE_FPU_ENV_REG_STACK))
5692                 return -1;
5693               break;
5694             case 0x0d:
5695               /* Insn fldcw.  */
5696               if (i386_record_floats (gdbarch, &ir, I387_FCTRL_REGNUM (tdep)))
5697                 return -1;
5698               break;
5699             case 0x2c:
5700               /* Insn frstor.  */
5701               if (i386_record_floats (gdbarch, &ir,
5702                                       I386_SAVE_FPU_ENV_REG_STACK))
5703                 return -1;
5704               break;
5705             case 0x0e:
5706               if (ir.dflag)
5707                 {
5708                   if (record_full_arch_list_add_mem (addr64, 28))
5709                     return -1;
5710                 }
5711               else
5712                 {
5713                   if (record_full_arch_list_add_mem (addr64, 14))
5714                     return -1;
5715                 }
5716               break;
5717             case 0x0f:
5718             case 0x2f:
5719               if (record_full_arch_list_add_mem (addr64, 2))
5720                 return -1;
5721               /* Insn fstp, fbstp.  */
5722               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5723                 return -1;
5724               break;
5725             case 0x1f:
5726             case 0x3e:
5727               if (record_full_arch_list_add_mem (addr64, 10))
5728                 return -1;
5729               break;
5730             case 0x2e:
5731               if (ir.dflag)
5732                 {
5733                   if (record_full_arch_list_add_mem (addr64, 28))
5734                     return -1;
5735                   addr64 += 28;
5736                 }
5737               else
5738                 {
5739                   if (record_full_arch_list_add_mem (addr64, 14))
5740                     return -1;
5741                   addr64 += 14;
5742                 }
5743               if (record_full_arch_list_add_mem (addr64, 80))
5744                 return -1;
5745               /* Insn fsave.  */
5746               if (i386_record_floats (gdbarch, &ir,
5747                                       I386_SAVE_FPU_ENV_REG_STACK))
5748                 return -1;
5749               break;
5750             case 0x3f:
5751               if (record_full_arch_list_add_mem (addr64, 8))
5752                 return -1;
5753               /* Insn fistp.  */
5754               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5755                 return -1;
5756               break;
5757             default:
5758               ir.addr -= 2;
5759               opcode = opcode << 8 | ir.modrm;
5760               goto no_support;
5761               break;
5762             }
5763         }
5764       /* Opcode is an extension of modR/M byte.  */
5765       else
5766         {
5767           switch (opcode)
5768             {
5769             case 0xd8:
5770               if (i386_record_floats (gdbarch, &ir, I387_ST0_REGNUM (tdep)))
5771                 return -1;
5772               break;
5773             case 0xd9:
5774               if (0x0c == (ir.modrm >> 4))
5775                 {
5776                   if ((ir.modrm & 0x0f) <= 7)
5777                     {
5778                       if (i386_record_floats (gdbarch, &ir,
5779                                               I386_SAVE_FPU_REGS))
5780                         return -1;
5781                     }
5782                   else
5783                     {
5784                       if (i386_record_floats (gdbarch, &ir,
5785                                               I387_ST0_REGNUM (tdep)))
5786                         return -1;
5787                       /* If only st(0) is changing, then we have already
5788                          recorded.  */
5789                       if ((ir.modrm & 0x0f) - 0x08)
5790                         {
5791                           if (i386_record_floats (gdbarch, &ir,
5792                                                   I387_ST0_REGNUM (tdep) +
5793                                                   ((ir.modrm & 0x0f) - 0x08)))
5794                             return -1;
5795                         }
5796                     }
5797                 }
5798               else
5799                 {
5800                   switch (ir.modrm)
5801                     {
5802                     case 0xe0:
5803                     case 0xe1:
5804                     case 0xf0:
5805                     case 0xf5:
5806                     case 0xf8:
5807                     case 0xfa:
5808                     case 0xfc:
5809                     case 0xfe:
5810                     case 0xff:
5811                       if (i386_record_floats (gdbarch, &ir,
5812                                               I387_ST0_REGNUM (tdep)))
5813                         return -1;
5814                       break;
5815                     case 0xf1:
5816                     case 0xf2:
5817                     case 0xf3:
5818                     case 0xf4:
5819                     case 0xf6:
5820                     case 0xf7:
5821                     case 0xe8:
5822                     case 0xe9:
5823                     case 0xea:
5824                     case 0xeb:
5825                     case 0xec:
5826                     case 0xed:
5827                     case 0xee:
5828                     case 0xf9:
5829                     case 0xfb:
5830                       if (i386_record_floats (gdbarch, &ir,
5831                                               I386_SAVE_FPU_REGS))
5832                         return -1;
5833                       break;
5834                     case 0xfd:
5835                       if (i386_record_floats (gdbarch, &ir,
5836                                               I387_ST0_REGNUM (tdep)))
5837                         return -1;
5838                       if (i386_record_floats (gdbarch, &ir,
5839                                               I387_ST0_REGNUM (tdep) + 1))
5840                         return -1;
5841                       break;
5842                     }
5843                 }
5844               break;
5845             case 0xda:
5846               if (0xe9 == ir.modrm)
5847                 {
5848                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5849                     return -1;
5850                 }
5851               else if ((0x0c == ir.modrm >> 4) || (0x0d == ir.modrm >> 4))
5852                 {
5853                   if (i386_record_floats (gdbarch, &ir,
5854                                           I387_ST0_REGNUM (tdep)))
5855                     return -1;
5856                   if (((ir.modrm & 0x0f) > 0) && ((ir.modrm & 0x0f) <= 7))
5857                     {
5858                       if (i386_record_floats (gdbarch, &ir,
5859                                               I387_ST0_REGNUM (tdep) +
5860                                               (ir.modrm & 0x0f)))
5861                         return -1;
5862                     }
5863                   else if ((ir.modrm & 0x0f) - 0x08)
5864                     {
5865                       if (i386_record_floats (gdbarch, &ir,
5866                                               I387_ST0_REGNUM (tdep) +
5867                                               ((ir.modrm & 0x0f) - 0x08)))
5868                         return -1;
5869                     }
5870                 }
5871               break;
5872             case 0xdb:
5873               if (0xe3 == ir.modrm)
5874                 {
5875                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_ENV))
5876                     return -1;
5877                 }
5878               else if ((0x0c == ir.modrm >> 4) || (0x0d == ir.modrm >> 4))
5879                 {
5880                   if (i386_record_floats (gdbarch, &ir,
5881                                           I387_ST0_REGNUM (tdep)))
5882                     return -1;
5883                   if (((ir.modrm & 0x0f) > 0) && ((ir.modrm & 0x0f) <= 7))
5884                     {
5885                       if (i386_record_floats (gdbarch, &ir,
5886                                               I387_ST0_REGNUM (tdep) +
5887                                               (ir.modrm & 0x0f)))
5888                         return -1;
5889                     }
5890                   else if ((ir.modrm & 0x0f) - 0x08)
5891                     {
5892                       if (i386_record_floats (gdbarch, &ir,
5893                                               I387_ST0_REGNUM (tdep) +
5894                                               ((ir.modrm & 0x0f) - 0x08)))
5895                         return -1;
5896                     }
5897                 }
5898               break;
5899             case 0xdc:
5900               if ((0x0c == ir.modrm >> 4)
5901                   || (0x0d == ir.modrm >> 4)
5902                   || (0x0f == ir.modrm >> 4))
5903                 {
5904                   if ((ir.modrm & 0x0f) <= 7)
5905                     {
5906                       if (i386_record_floats (gdbarch, &ir,
5907                                               I387_ST0_REGNUM (tdep) +
5908                                               (ir.modrm & 0x0f)))
5909                         return -1;
5910                     }
5911                   else
5912                     {
5913                       if (i386_record_floats (gdbarch, &ir,
5914                                               I387_ST0_REGNUM (tdep) +
5915                                               ((ir.modrm & 0x0f) - 0x08)))
5916                         return -1;
5917                     }
5918                 }
5919               break;
5920             case 0xdd:
5921               if (0x0c == ir.modrm >> 4)
5922                 {
5923                   if (i386_record_floats (gdbarch, &ir,
5924                                           I387_FTAG_REGNUM (tdep)))
5925                     return -1;
5926                 }
5927               else if ((0x0d == ir.modrm >> 4) || (0x0e == ir.modrm >> 4))
5928                 {
5929                   if ((ir.modrm & 0x0f) <= 7)
5930                     {
5931                       if (i386_record_floats (gdbarch, &ir,
5932                                               I387_ST0_REGNUM (tdep) +
5933                                               (ir.modrm & 0x0f)))
5934                         return -1;
5935                     }
5936                   else
5937                     {
5938                       if (i386_record_floats (gdbarch, &ir,
5939                                               I386_SAVE_FPU_REGS))
5940                         return -1;
5941                     }
5942                 }
5943               break;
5944             case 0xde:
5945               if ((0x0c == ir.modrm >> 4)
5946                   || (0x0e == ir.modrm >> 4)
5947                   || (0x0f == ir.modrm >> 4)
5948                   || (0xd9 == ir.modrm))
5949                 {
5950                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5951                     return -1;
5952                 }
5953               break;
5954             case 0xdf:
5955               if (0xe0 == ir.modrm)
5956                 {
5957                   if (record_full_arch_list_add_reg (ir.regcache,
5958                                                      I386_EAX_REGNUM))
5959                     return -1;
5960                 }
5961               else if ((0x0f == ir.modrm >> 4) || (0x0e == ir.modrm >> 4))
5962                 {
5963                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
5964                     return -1;
5965                 }
5966               break;
5967             }
5968         }
5969       break;
5970       /* string ops */
5971     case 0xa4:    /* movsS */
5972     case 0xa5:
5973     case 0xaa:    /* stosS */
5974     case 0xab:
5975     case 0x6c:    /* insS */
5976     case 0x6d:
5977       regcache_raw_read_unsigned (ir.regcache,
5978                                   ir.regmap[X86_RECORD_RECX_REGNUM],
5979                                   &addr);
5980       if (addr)
5981         {
5982           ULONGEST es, ds;
5983
5984           if ((opcode & 1) == 0)
5985             ir.ot = OT_BYTE;
5986           else
5987             ir.ot = ir.dflag + OT_WORD;
5988           regcache_raw_read_unsigned (ir.regcache,
5989                                       ir.regmap[X86_RECORD_REDI_REGNUM],
5990                                       &addr);
5991
5992           regcache_raw_read_unsigned (ir.regcache,
5993                                       ir.regmap[X86_RECORD_ES_REGNUM],
5994                                       &es);
5995           regcache_raw_read_unsigned (ir.regcache,
5996                                       ir.regmap[X86_RECORD_DS_REGNUM],
5997                                       &ds);
5998           if (ir.aflag && (es != ds))
5999             {
6000               /* addr += ((uint32_t) read_register (I386_ES_REGNUM)) << 4; */
6001               if (record_full_memory_query)
6002                 {
6003                   int q;
6004
6005                   target_terminal_ours ();
6006                   q = yquery (_("\
6007 Process record ignores the memory change of instruction at address %s\n\
6008 because it can't get the value of the segment register.\n\
6009 Do you want to stop the program?"),
6010                               paddress (gdbarch, ir.orig_addr));
6011                   target_terminal_inferior ();
6012                   if (q)
6013                     return -1;
6014                 }
6015             }
6016           else
6017             {
6018               if (record_full_arch_list_add_mem (addr, 1 << ir.ot))
6019                 return -1;
6020             }
6021
6022           if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6023             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6024           if (opcode == 0xa4 || opcode == 0xa5)
6025             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6026           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
6027           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6028         }
6029       break;
6030
6031     case 0xa6:    /* cmpsS */
6032     case 0xa7:
6033       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
6034       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6035       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6036         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6037       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6038       break;
6039
6040     case 0xac:    /* lodsS */
6041     case 0xad:
6042       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6043       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6044       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6045         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6046       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6047       break;
6048
6049     case 0xae:    /* scasS */
6050     case 0xaf:
6051       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
6052       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6053         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6054       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6055       break;
6056
6057     case 0x6e:    /* outsS */
6058     case 0x6f:
6059       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6060       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
6061         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6062       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6063       break;
6064
6065     case 0xe4:    /* port I/O */
6066     case 0xe5:
6067     case 0xec:
6068     case 0xed:
6069       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6070       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6071       break;
6072
6073     case 0xe6:
6074     case 0xe7:
6075     case 0xee:
6076     case 0xef:
6077       break;
6078
6079       /* control */
6080     case 0xc2:    /* ret im */
6081     case 0xc3:    /* ret */
6082       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
6083       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6084       break;
6085
6086     case 0xca:    /* lret im */
6087     case 0xcb:    /* lret */
6088     case 0xcf:    /* iret */
6089       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
6090       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
6091       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6092       break;
6093
6094     case 0xe8:    /* call im */
6095       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
6096         ir.dflag = 2;
6097       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
6098         return -1;
6099       break;
6100
6101     case 0x9a:    /* lcall im */
6102       if (ir.regmap[X86_RECORD_R8_REGNUM])
6103         {
6104           ir.addr -= 1;
6105           goto no_support;
6106         }
6107       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
6108       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
6109         return -1;
6110       break;
6111
6112     case 0xe9:    /* jmp im */
6113     case 0xea:    /* ljmp im */
6114     case 0xeb:    /* jmp Jb */
6115     case 0x70:    /* jcc Jb */
6116     case 0x71:
6117     case 0x72:
6118     case 0x73:
6119     case 0x74:
6120     case 0x75:
6121     case 0x76:
6122     case 0x77:
6123     case 0x78:
6124     case 0x79:
6125     case 0x7a:
6126     case 0x7b:
6127     case 0x7c:
6128     case 0x7d:
6129     case 0x7e:
6130     case 0x7f:
6131     case 0x0f80:  /* jcc Jv */
6132     case 0x0f81:
6133     case 0x0f82:
6134     case 0x0f83:
6135     case 0x0f84:
6136     case 0x0f85:
6137     case 0x0f86:
6138     case 0x0f87:
6139     case 0x0f88:
6140     case 0x0f89:
6141     case 0x0f8a:
6142     case 0x0f8b:
6143     case 0x0f8c:
6144     case 0x0f8d:
6145     case 0x0f8e:
6146     case 0x0f8f:
6147       break;
6148
6149     case 0x0f90:  /* setcc Gv */
6150     case 0x0f91:
6151     case 0x0f92:
6152     case 0x0f93:
6153     case 0x0f94:
6154     case 0x0f95:
6155     case 0x0f96:
6156     case 0x0f97:
6157     case 0x0f98:
6158     case 0x0f99:
6159     case 0x0f9a:
6160     case 0x0f9b:
6161     case 0x0f9c:
6162     case 0x0f9d:
6163     case 0x0f9e:
6164     case 0x0f9f:
6165       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6166       ir.ot = OT_BYTE;
6167       if (i386_record_modrm (&ir))
6168         return -1;
6169       if (ir.mod == 3)
6170         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rex_b ? (ir.rm | ir.rex_b)
6171                                             : (ir.rm & 0x3));
6172       else
6173         {
6174           if (i386_record_lea_modrm (&ir))
6175             return -1;
6176         }
6177       break;
6178
6179     case 0x0f40:    /* cmov Gv, Ev */
6180     case 0x0f41:
6181     case 0x0f42:
6182     case 0x0f43:
6183     case 0x0f44:
6184     case 0x0f45:
6185     case 0x0f46:
6186     case 0x0f47:
6187     case 0x0f48:
6188     case 0x0f49:
6189     case 0x0f4a:
6190     case 0x0f4b:
6191     case 0x0f4c:
6192     case 0x0f4d:
6193     case 0x0f4e:
6194     case 0x0f4f:
6195       if (i386_record_modrm (&ir))
6196         return -1;
6197       ir.reg |= rex_r;
6198       if (ir.dflag == OT_BYTE)
6199         ir.reg &= 0x3;
6200       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
6201       break;
6202
6203       /* flags */
6204     case 0x9c:    /* pushf */
6205       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6206       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
6207         ir.dflag = 2;
6208       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
6209         return -1;
6210       break;
6211
6212     case 0x9d:    /* popf */
6213       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
6214       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6215       break;
6216
6217     case 0x9e:    /* sahf */
6218       if (ir.regmap[X86_RECORD_R8_REGNUM])
6219         {
6220           ir.addr -= 1;
6221           goto no_support;
6222         }
6223       /* FALLTHROUGH */
6224     case 0xf5:    /* cmc */
6225     case 0xf8:    /* clc */
6226     case 0xf9:    /* stc */
6227     case 0xfc:    /* cld */
6228     case 0xfd:    /* std */
6229       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6230       break;
6231
6232     case 0x9f:    /* lahf */
6233       if (ir.regmap[X86_RECORD_R8_REGNUM])
6234         {
6235           ir.addr -= 1;
6236           goto no_support;
6237         }
6238       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6239       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6240       break;
6241
6242       /* bit operations */
6243     case 0x0fba:    /* bt/bts/btr/btc Gv, im */
6244       ir.ot = ir.dflag + OT_WORD;
6245       if (i386_record_modrm (&ir))
6246         return -1;
6247       if (ir.reg < 4)
6248         {
6249           ir.addr -= 2;
6250           opcode = opcode << 8 | ir.modrm;
6251           goto no_support;
6252         }
6253       if (ir.reg != 4)
6254         {
6255           if (ir.mod == 3)
6256             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6257           else
6258             {
6259               if (i386_record_lea_modrm (&ir))
6260                 return -1;
6261             }
6262         }
6263       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6264       break;
6265
6266     case 0x0fa3:    /* bt Gv, Ev */
6267       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6268       break;
6269
6270     case 0x0fab:    /* bts */
6271     case 0x0fb3:    /* btr */
6272     case 0x0fbb:    /* btc */
6273       ir.ot = ir.dflag + OT_WORD;
6274       if (i386_record_modrm (&ir))
6275         return -1;
6276       if (ir.mod == 3)
6277         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6278       else
6279         {
6280           uint64_t addr64;
6281           if (i386_record_lea_modrm_addr (&ir, &addr64))
6282             return -1;
6283           regcache_raw_read_unsigned (ir.regcache,
6284                                       ir.regmap[ir.reg | rex_r],
6285                                       &addr);
6286           switch (ir.dflag)
6287             {
6288             case 0:
6289               addr64 += ((int16_t) addr >> 4) << 4;
6290               break;
6291             case 1:
6292               addr64 += ((int32_t) addr >> 5) << 5;
6293               break;
6294             case 2:
6295               addr64 += ((int64_t) addr >> 6) << 6;
6296               break;
6297             }
6298           if (record_full_arch_list_add_mem (addr64, 1 << ir.ot))
6299             return -1;
6300           if (i386_record_lea_modrm (&ir))
6301             return -1;
6302         }
6303       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6304       break;
6305
6306     case 0x0fbc:    /* bsf */
6307     case 0x0fbd:    /* bsr */
6308       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
6309       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6310       break;
6311
6312       /* bcd */
6313     case 0x27:    /* daa */
6314     case 0x2f:    /* das */
6315     case 0x37:    /* aaa */
6316     case 0x3f:    /* aas */
6317     case 0xd4:    /* aam */
6318     case 0xd5:    /* aad */
6319       if (ir.regmap[X86_RECORD_R8_REGNUM])
6320         {
6321           ir.addr -= 1;
6322           goto no_support;
6323         }
6324       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6325       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6326       break;
6327
6328       /* misc */
6329     case 0x90:    /* nop */
6330       if (prefixes & PREFIX_LOCK)
6331         {
6332           ir.addr -= 1;
6333           goto no_support;
6334         }
6335       break;
6336
6337     case 0x9b:    /* fwait */
6338       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
6339         return -1;
6340       opcode = (uint32_t) opcode8;
6341       ir.addr++;
6342       goto reswitch;
6343       break;
6344
6345       /* XXX */
6346     case 0xcc:    /* int3 */
6347       printf_unfiltered (_("Process record does not support instruction "
6348                            "int3.\n"));
6349       ir.addr -= 1;
6350       goto no_support;
6351       break;
6352
6353       /* XXX */
6354     case 0xcd:    /* int */
6355       {
6356         int ret;
6357         uint8_t interrupt;
6358         if (record_read_memory (gdbarch, ir.addr, &interrupt, 1))
6359           return -1;
6360         ir.addr++;
6361         if (interrupt != 0x80
6362             || tdep->i386_intx80_record == NULL)
6363           {
6364             printf_unfiltered (_("Process record does not support "
6365                                  "instruction int 0x%02x.\n"),
6366                                interrupt);
6367             ir.addr -= 2;
6368             goto no_support;
6369           }
6370         ret = tdep->i386_intx80_record (ir.regcache);
6371         if (ret)
6372           return ret;
6373       }
6374       break;
6375
6376       /* XXX */
6377     case 0xce:    /* into */
6378       printf_unfiltered (_("Process record does not support "
6379                            "instruction into.\n"));
6380       ir.addr -= 1;
6381       goto no_support;
6382       break;
6383
6384     case 0xfa:    /* cli */
6385     case 0xfb:    /* sti */
6386       break;
6387
6388     case 0x62:    /* bound */
6389       printf_unfiltered (_("Process record does not support "
6390                            "instruction bound.\n"));
6391       ir.addr -= 1;
6392       goto no_support;
6393       break;
6394
6395     case 0x0fc8:    /* bswap reg */
6396     case 0x0fc9:
6397     case 0x0fca:
6398     case 0x0fcb:
6399     case 0x0fcc:
6400     case 0x0fcd:
6401     case 0x0fce:
6402     case 0x0fcf:
6403       I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 7) | ir.rex_b);
6404       break;
6405
6406     case 0xd6:    /* salc */
6407       if (ir.regmap[X86_RECORD_R8_REGNUM])
6408         {
6409           ir.addr -= 1;
6410           goto no_support;
6411         }
6412       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6413       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6414       break;
6415
6416     case 0xe0:    /* loopnz */
6417     case 0xe1:    /* loopz */
6418     case 0xe2:    /* loop */
6419     case 0xe3:    /* jecxz */
6420       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6421       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6422       break;
6423
6424     case 0x0f30:    /* wrmsr */
6425       printf_unfiltered (_("Process record does not support "
6426                            "instruction wrmsr.\n"));
6427       ir.addr -= 2;
6428       goto no_support;
6429       break;
6430
6431     case 0x0f32:    /* rdmsr */
6432       printf_unfiltered (_("Process record does not support "
6433                            "instruction rdmsr.\n"));
6434       ir.addr -= 2;
6435       goto no_support;
6436       break;
6437
6438     case 0x0f31:    /* rdtsc */
6439       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6440       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
6441       break;
6442
6443     case 0x0f34:    /* sysenter */
6444       {
6445         int ret;
6446         if (ir.regmap[X86_RECORD_R8_REGNUM])
6447           {
6448             ir.addr -= 2;
6449             goto no_support;
6450           }
6451         if (tdep->i386_sysenter_record == NULL)
6452           {
6453             printf_unfiltered (_("Process record does not support "
6454                                  "instruction sysenter.\n"));
6455             ir.addr -= 2;
6456             goto no_support;
6457           }
6458         ret = tdep->i386_sysenter_record (ir.regcache);
6459         if (ret)
6460           return ret;
6461       }
6462       break;
6463
6464     case 0x0f35:    /* sysexit */
6465       printf_unfiltered (_("Process record does not support "
6466                            "instruction sysexit.\n"));
6467       ir.addr -= 2;
6468       goto no_support;
6469       break;
6470
6471     case 0x0f05:    /* syscall */
6472       {
6473         int ret;
6474         if (tdep->i386_syscall_record == NULL)
6475           {
6476             printf_unfiltered (_("Process record does not support "
6477                                  "instruction syscall.\n"));
6478             ir.addr -= 2;
6479             goto no_support;
6480           }
6481         ret = tdep->i386_syscall_record (ir.regcache);
6482         if (ret)
6483           return ret;
6484       }
6485       break;
6486
6487     case 0x0f07:    /* sysret */
6488       printf_unfiltered (_("Process record does not support "
6489                            "instruction sysret.\n"));
6490       ir.addr -= 2;
6491       goto no_support;
6492       break;
6493
6494     case 0x0fa2:    /* cpuid */
6495       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6496       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6497       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
6498       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
6499       break;
6500
6501     case 0xf4:    /* hlt */
6502       printf_unfiltered (_("Process record does not support "
6503                            "instruction hlt.\n"));
6504       ir.addr -= 1;
6505       goto no_support;
6506       break;
6507
6508     case 0x0f00:
6509       if (i386_record_modrm (&ir))
6510         return -1;
6511       switch (ir.reg)
6512         {
6513         case 0:  /* sldt */
6514         case 1:  /* str  */
6515           if (ir.mod == 3)
6516             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6517           else
6518             {
6519               ir.ot = OT_WORD;
6520               if (i386_record_lea_modrm (&ir))
6521                 return -1;
6522             }
6523           break;
6524         case 2:  /* lldt */
6525         case 3:  /* ltr */
6526           break;
6527         case 4:  /* verr */
6528         case 5:  /* verw */
6529           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6530           break;
6531         default:
6532           ir.addr -= 3;
6533           opcode = opcode << 8 | ir.modrm;
6534           goto no_support;
6535           break;
6536         }
6537       break;
6538
6539     case 0x0f01:
6540       if (i386_record_modrm (&ir))
6541         return -1;
6542       switch (ir.reg)
6543         {
6544         case 0:  /* sgdt */
6545           {
6546             uint64_t addr64;
6547
6548             if (ir.mod == 3)
6549               {
6550                 ir.addr -= 3;
6551                 opcode = opcode << 8 | ir.modrm;
6552                 goto no_support;
6553               }
6554             if (ir.override >= 0)
6555               {
6556                 if (record_full_memory_query)
6557                   {
6558                     int q;
6559
6560                     target_terminal_ours ();
6561                     q = yquery (_("\
6562 Process record ignores the memory change of instruction at address %s\n\
6563 because it can't get the value of the segment register.\n\
6564 Do you want to stop the program?"),
6565                                 paddress (gdbarch, ir.orig_addr));
6566                     target_terminal_inferior ();
6567                     if (q)
6568                       return -1;
6569                   }
6570               }
6571             else
6572               {
6573                 if (i386_record_lea_modrm_addr (&ir, &addr64))
6574                   return -1;
6575                 if (record_full_arch_list_add_mem (addr64, 2))
6576                   return -1;
6577                 addr64 += 2;
6578                 if (ir.regmap[X86_RECORD_R8_REGNUM])
6579                   {
6580                     if (record_full_arch_list_add_mem (addr64, 8))
6581                       return -1;
6582                   }
6583                 else
6584                   {
6585                     if (record_full_arch_list_add_mem (addr64, 4))
6586                       return -1;
6587                   }
6588               }
6589           }
6590           break;
6591         case 1:
6592           if (ir.mod == 3)
6593             {
6594               switch (ir.rm)
6595                 {
6596                 case 0:  /* monitor */
6597                   break;
6598                 case 1:  /* mwait */
6599                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6600                   break;
6601                 default:
6602                   ir.addr -= 3;
6603                   opcode = opcode << 8 | ir.modrm;
6604                   goto no_support;
6605                   break;
6606                 }
6607             }
6608           else
6609             {
6610               /* sidt */
6611               if (ir.override >= 0)
6612                 {
6613                   if (record_full_memory_query)
6614                     {
6615                       int q;
6616
6617                       target_terminal_ours ();
6618                       q = yquery (_("\
6619 Process record ignores the memory change of instruction at address %s\n\
6620 because it can't get the value of the segment register.\n\
6621 Do you want to stop the program?"),
6622                                   paddress (gdbarch, ir.orig_addr));
6623                       target_terminal_inferior ();
6624                       if (q)
6625                         return -1;
6626                     }
6627                 }
6628               else
6629                 {
6630                   uint64_t addr64;
6631
6632                   if (i386_record_lea_modrm_addr (&ir, &addr64))
6633                     return -1;
6634                   if (record_full_arch_list_add_mem (addr64, 2))
6635                     return -1;
6636                   addr64 += 2;
6637                   if (ir.regmap[X86_RECORD_R8_REGNUM])
6638                     {
6639                       if (record_full_arch_list_add_mem (addr64, 8))
6640                         return -1;
6641                     }
6642                   else
6643                     {
6644                       if (record_full_arch_list_add_mem (addr64, 4))
6645                         return -1;
6646                     }
6647                 }
6648             }
6649           break;
6650         case 2:  /* lgdt */
6651           if (ir.mod == 3)
6652             {
6653               /* xgetbv */
6654               if (ir.rm == 0)
6655                 {
6656                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6657                   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
6658                   break;
6659                 }
6660               /* xsetbv */
6661               else if (ir.rm == 1)
6662                 break;
6663             }
6664         case 3:  /* lidt */
6665           if (ir.mod == 3)
6666             {
6667               ir.addr -= 3;
6668               opcode = opcode << 8 | ir.modrm;
6669               goto no_support;
6670             }
6671           break;
6672         case 4:  /* smsw */
6673           if (ir.mod == 3)
6674             {
6675               if (record_full_arch_list_add_reg (ir.regcache, ir.rm | ir.rex_b))
6676                 return -1;
6677             }
6678           else
6679             {
6680               ir.ot = OT_WORD;
6681               if (i386_record_lea_modrm (&ir))
6682                 return -1;
6683             }
6684           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6685           break;
6686         case 6:  /* lmsw */
6687           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6688           break;
6689         case 7:  /* invlpg */
6690           if (ir.mod == 3)
6691             {
6692               if (ir.rm == 0 && ir.regmap[X86_RECORD_R8_REGNUM])
6693                 I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
6694               else
6695                 {
6696                   ir.addr -= 3;
6697                   opcode = opcode << 8 | ir.modrm;
6698                   goto no_support;
6699                 }
6700             }
6701           else
6702             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6703           break;
6704         default:
6705           ir.addr -= 3;
6706           opcode = opcode << 8 | ir.modrm;
6707           goto no_support;
6708           break;
6709         }
6710       break;
6711
6712     case 0x0f08:    /* invd */
6713     case 0x0f09:    /* wbinvd */
6714       break;
6715
6716     case 0x63:    /* arpl */
6717       if (i386_record_modrm (&ir))
6718         return -1;
6719       if (ir.mod == 3 || ir.regmap[X86_RECORD_R8_REGNUM])
6720         {
6721           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.regmap[X86_RECORD_R8_REGNUM]
6722                                               ? (ir.reg | rex_r) : ir.rm);
6723         }
6724       else
6725         {
6726           ir.ot = ir.dflag ? OT_LONG : OT_WORD;
6727           if (i386_record_lea_modrm (&ir))
6728             return -1;
6729         }
6730       if (!ir.regmap[X86_RECORD_R8_REGNUM])
6731         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6732       break;
6733
6734     case 0x0f02:    /* lar */
6735     case 0x0f03:    /* lsl */
6736       if (i386_record_modrm (&ir))
6737         return -1;
6738       I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
6739       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6740       break;
6741
6742     case 0x0f18:
6743       if (i386_record_modrm (&ir))
6744         return -1;
6745       if (ir.mod == 3 && ir.reg == 3)
6746         {
6747           ir.addr -= 3;
6748           opcode = opcode << 8 | ir.modrm;
6749           goto no_support;
6750         }
6751       break;
6752
6753     case 0x0f19:
6754     case 0x0f1a:
6755     case 0x0f1b:
6756     case 0x0f1c:
6757     case 0x0f1d:
6758     case 0x0f1e:
6759     case 0x0f1f:
6760       /* nop (multi byte) */
6761       break;
6762
6763     case 0x0f20:    /* mov reg, crN */
6764     case 0x0f22:    /* mov crN, reg */
6765       if (i386_record_modrm (&ir))
6766         return -1;
6767       if ((ir.modrm & 0xc0) != 0xc0)
6768         {
6769           ir.addr -= 3;
6770           opcode = opcode << 8 | ir.modrm;
6771           goto no_support;
6772         }
6773       switch (ir.reg)
6774         {
6775         case 0:
6776         case 2:
6777         case 3:
6778         case 4:
6779         case 8:
6780           if (opcode & 2)
6781             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6782           else
6783             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6784           break;
6785         default:
6786           ir.addr -= 3;
6787           opcode = opcode << 8 | ir.modrm;
6788           goto no_support;
6789           break;
6790         }
6791       break;
6792
6793     case 0x0f21:    /* mov reg, drN */
6794     case 0x0f23:    /* mov drN, reg */
6795       if (i386_record_modrm (&ir))
6796         return -1;
6797       if ((ir.modrm & 0xc0) != 0xc0 || ir.reg == 4
6798           || ir.reg == 5 || ir.reg >= 8)
6799         {
6800           ir.addr -= 3;
6801           opcode = opcode << 8 | ir.modrm;
6802           goto no_support;
6803         }
6804       if (opcode & 2)
6805         I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6806       else
6807         I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
6808       break;
6809
6810     case 0x0f06:    /* clts */
6811       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6812       break;
6813
6814     /* MMX 3DNow! SSE SSE2 SSE3 SSSE3 SSE4 */
6815
6816     case 0x0f0d:    /* 3DNow! prefetch */
6817       break;
6818
6819     case 0x0f0e:    /* 3DNow! femms */
6820     case 0x0f77:    /* emms */
6821       if (i386_fpc_regnum_p (gdbarch, I387_FTAG_REGNUM(tdep)))
6822         goto no_support;
6823       record_full_arch_list_add_reg (ir.regcache, I387_FTAG_REGNUM(tdep));
6824       break;
6825
6826     case 0x0f0f:    /* 3DNow! data */
6827       if (i386_record_modrm (&ir))
6828         return -1;
6829       if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
6830         return -1;
6831       ir.addr++;
6832       switch (opcode8)
6833         {
6834         case 0x0c:    /* 3DNow! pi2fw */
6835         case 0x0d:    /* 3DNow! pi2fd */
6836         case 0x1c:    /* 3DNow! pf2iw */
6837         case 0x1d:    /* 3DNow! pf2id */
6838         case 0x8a:    /* 3DNow! pfnacc */
6839         case 0x8e:    /* 3DNow! pfpnacc */
6840         case 0x90:    /* 3DNow! pfcmpge */
6841         case 0x94:    /* 3DNow! pfmin */
6842         case 0x96:    /* 3DNow! pfrcp */
6843         case 0x97:    /* 3DNow! pfrsqrt */
6844         case 0x9a:    /* 3DNow! pfsub */
6845         case 0x9e:    /* 3DNow! pfadd */
6846         case 0xa0:    /* 3DNow! pfcmpgt */
6847         case 0xa4:    /* 3DNow! pfmax */
6848         case 0xa6:    /* 3DNow! pfrcpit1 */
6849         case 0xa7:    /* 3DNow! pfrsqit1 */
6850         case 0xaa:    /* 3DNow! pfsubr */
6851         case 0xae:    /* 3DNow! pfacc */
6852         case 0xb0:    /* 3DNow! pfcmpeq */
6853         case 0xb4:    /* 3DNow! pfmul */
6854         case 0xb6:    /* 3DNow! pfrcpit2 */
6855         case 0xb7:    /* 3DNow! pmulhrw */
6856         case 0xbb:    /* 3DNow! pswapd */
6857         case 0xbf:    /* 3DNow! pavgusb */
6858           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.reg))
6859             goto no_support_3dnow_data;
6860           record_full_arch_list_add_reg (ir.regcache, ir.reg);
6861           break;
6862
6863         default:
6864 no_support_3dnow_data:
6865           opcode = (opcode << 8) | opcode8;
6866           goto no_support;
6867           break;
6868         }
6869       break;
6870
6871     case 0x0faa:    /* rsm */
6872       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6873       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
6874       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
6875       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
6876       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
6877       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
6878       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
6879       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
6880       I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
6881       break;
6882
6883     case 0x0fae:
6884       if (i386_record_modrm (&ir))
6885         return -1;
6886       switch(ir.reg)
6887         {
6888         case 0:    /* fxsave */
6889           {
6890             uint64_t tmpu64;
6891
6892             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6893             if (i386_record_lea_modrm_addr (&ir, &tmpu64))
6894               return -1;
6895             if (record_full_arch_list_add_mem (tmpu64, 512))
6896               return -1;
6897           }
6898           break;
6899
6900         case 1:    /* fxrstor */
6901           {
6902             int i;
6903
6904             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
6905
6906             for (i = I387_MM0_REGNUM (tdep);
6907                  i386_mmx_regnum_p (gdbarch, i); i++)
6908               record_full_arch_list_add_reg (ir.regcache, i);
6909
6910             for (i = I387_XMM0_REGNUM (tdep);
6911                  i386_xmm_regnum_p (gdbarch, i); i++)
6912               record_full_arch_list_add_reg (ir.regcache, i);
6913
6914             if (i386_mxcsr_regnum_p (gdbarch, I387_MXCSR_REGNUM(tdep)))
6915               record_full_arch_list_add_reg (ir.regcache,
6916                                              I387_MXCSR_REGNUM(tdep));
6917
6918             for (i = I387_ST0_REGNUM (tdep);
6919                  i386_fp_regnum_p (gdbarch, i); i++)
6920               record_full_arch_list_add_reg (ir.regcache, i);
6921
6922             for (i = I387_FCTRL_REGNUM (tdep);
6923                  i386_fpc_regnum_p (gdbarch, i); i++)
6924               record_full_arch_list_add_reg (ir.regcache, i);
6925           }
6926           break;
6927
6928         case 2:    /* ldmxcsr */
6929           if (!i386_mxcsr_regnum_p (gdbarch, I387_MXCSR_REGNUM(tdep)))
6930             goto no_support;
6931           record_full_arch_list_add_reg (ir.regcache, I387_MXCSR_REGNUM(tdep));
6932           break;
6933
6934         case 3:    /* stmxcsr */
6935           ir.ot = OT_LONG;
6936           if (i386_record_lea_modrm (&ir))
6937             return -1;
6938           break;
6939
6940         case 5:    /* lfence */
6941         case 6:    /* mfence */
6942         case 7:    /* sfence clflush */
6943           break;
6944
6945         default:
6946           opcode = (opcode << 8) | ir.modrm;
6947           goto no_support;
6948           break;
6949         }
6950       break;
6951
6952     case 0x0fc3:    /* movnti */
6953       ir.ot = (ir.dflag == 2) ? OT_QUAD : OT_LONG;
6954       if (i386_record_modrm (&ir))
6955         return -1;
6956       if (ir.mod == 3)
6957         goto no_support;
6958       ir.reg |= rex_r;
6959       if (i386_record_lea_modrm (&ir))
6960         return -1;
6961       break;
6962
6963     /* Add prefix to opcode.  */
6964     case 0x0f10:
6965     case 0x0f11:
6966     case 0x0f12:
6967     case 0x0f13:
6968     case 0x0f14:
6969     case 0x0f15:
6970     case 0x0f16:
6971     case 0x0f17:
6972     case 0x0f28:
6973     case 0x0f29:
6974     case 0x0f2a:
6975     case 0x0f2b:
6976     case 0x0f2c:
6977     case 0x0f2d:
6978     case 0x0f2e:
6979     case 0x0f2f:
6980     case 0x0f38:
6981     case 0x0f39:
6982     case 0x0f3a:
6983     case 0x0f50:
6984     case 0x0f51:
6985     case 0x0f52:
6986     case 0x0f53:
6987     case 0x0f54:
6988     case 0x0f55:
6989     case 0x0f56:
6990     case 0x0f57:
6991     case 0x0f58:
6992     case 0x0f59:
6993     case 0x0f5a:
6994     case 0x0f5b:
6995     case 0x0f5c:
6996     case 0x0f5d:
6997     case 0x0f5e:
6998     case 0x0f5f:
6999     case 0x0f60:
7000     case 0x0f61:
7001     case 0x0f62:
7002     case 0x0f63:
7003     case 0x0f64:
7004     case 0x0f65:
7005     case 0x0f66:
7006     case 0x0f67:
7007     case 0x0f68:
7008     case 0x0f69:
7009     case 0x0f6a:
7010     case 0x0f6b:
7011     case 0x0f6c:
7012     case 0x0f6d:
7013     case 0x0f6e:
7014     case 0x0f6f:
7015     case 0x0f70:
7016     case 0x0f71:
7017     case 0x0f72:
7018     case 0x0f73:
7019     case 0x0f74:
7020     case 0x0f75:
7021     case 0x0f76:
7022     case 0x0f7c:
7023     case 0x0f7d:
7024     case 0x0f7e:
7025     case 0x0f7f:
7026     case 0x0fb8:
7027     case 0x0fc2:
7028     case 0x0fc4:
7029     case 0x0fc5:
7030     case 0x0fc6:
7031     case 0x0fd0:
7032     case 0x0fd1:
7033     case 0x0fd2:
7034     case 0x0fd3:
7035     case 0x0fd4:
7036     case 0x0fd5:
7037     case 0x0fd6:
7038     case 0x0fd7:
7039     case 0x0fd8:
7040     case 0x0fd9:
7041     case 0x0fda:
7042     case 0x0fdb:
7043     case 0x0fdc:
7044     case 0x0fdd:
7045     case 0x0fde:
7046     case 0x0fdf:
7047     case 0x0fe0:
7048     case 0x0fe1:
7049     case 0x0fe2:
7050     case 0x0fe3:
7051     case 0x0fe4:
7052     case 0x0fe5:
7053     case 0x0fe6:
7054     case 0x0fe7:
7055     case 0x0fe8:
7056     case 0x0fe9:
7057     case 0x0fea:
7058     case 0x0feb:
7059     case 0x0fec:
7060     case 0x0fed:
7061     case 0x0fee:
7062     case 0x0fef:
7063     case 0x0ff0:
7064     case 0x0ff1:
7065     case 0x0ff2:
7066     case 0x0ff3:
7067     case 0x0ff4:
7068     case 0x0ff5:
7069     case 0x0ff6:
7070     case 0x0ff7:
7071     case 0x0ff8:
7072     case 0x0ff9:
7073     case 0x0ffa:
7074     case 0x0ffb:
7075     case 0x0ffc:
7076     case 0x0ffd:
7077     case 0x0ffe:
7078       /* Mask out PREFIX_ADDR.  */
7079       switch ((prefixes & ~PREFIX_ADDR))
7080         {
7081         case PREFIX_REPNZ:
7082           opcode |= 0xf20000;
7083           break;
7084         case PREFIX_DATA:
7085           opcode |= 0x660000;
7086           break;
7087         case PREFIX_REPZ:
7088           opcode |= 0xf30000;
7089           break;
7090         }
7091 reswitch_prefix_add:
7092       switch (opcode)
7093         {
7094         case 0x0f38:
7095         case 0x660f38:
7096         case 0xf20f38:
7097         case 0x0f3a:
7098         case 0x660f3a:
7099           if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
7100             return -1;
7101           ir.addr++;
7102           opcode = (uint32_t) opcode8 | opcode << 8;
7103           goto reswitch_prefix_add;
7104           break;
7105
7106         case 0x0f10:        /* movups */
7107         case 0x660f10:      /* movupd */
7108         case 0xf30f10:      /* movss */
7109         case 0xf20f10:      /* movsd */
7110         case 0x0f12:        /* movlps */
7111         case 0x660f12:      /* movlpd */
7112         case 0xf30f12:      /* movsldup */
7113         case 0xf20f12:      /* movddup */
7114         case 0x0f14:        /* unpcklps */
7115         case 0x660f14:      /* unpcklpd */
7116         case 0x0f15:        /* unpckhps */
7117         case 0x660f15:      /* unpckhpd */
7118         case 0x0f16:        /* movhps */
7119         case 0x660f16:      /* movhpd */
7120         case 0xf30f16:      /* movshdup */
7121         case 0x0f28:        /* movaps */
7122         case 0x660f28:      /* movapd */
7123         case 0x0f2a:        /* cvtpi2ps */
7124         case 0x660f2a:      /* cvtpi2pd */
7125         case 0xf30f2a:      /* cvtsi2ss */
7126         case 0xf20f2a:      /* cvtsi2sd */
7127         case 0x0f2c:        /* cvttps2pi */
7128         case 0x660f2c:      /* cvttpd2pi */
7129         case 0x0f2d:        /* cvtps2pi */
7130         case 0x660f2d:      /* cvtpd2pi */
7131         case 0x660f3800:    /* pshufb */
7132         case 0x660f3801:    /* phaddw */
7133         case 0x660f3802:    /* phaddd */
7134         case 0x660f3803:    /* phaddsw */
7135         case 0x660f3804:    /* pmaddubsw */
7136         case 0x660f3805:    /* phsubw */
7137         case 0x660f3806:    /* phsubd */
7138         case 0x660f3807:    /* phsubsw */
7139         case 0x660f3808:    /* psignb */
7140         case 0x660f3809:    /* psignw */
7141         case 0x660f380a:    /* psignd */
7142         case 0x660f380b:    /* pmulhrsw */
7143         case 0x660f3810:    /* pblendvb */
7144         case 0x660f3814:    /* blendvps */
7145         case 0x660f3815:    /* blendvpd */
7146         case 0x660f381c:    /* pabsb */
7147         case 0x660f381d:    /* pabsw */
7148         case 0x660f381e:    /* pabsd */
7149         case 0x660f3820:    /* pmovsxbw */
7150         case 0x660f3821:    /* pmovsxbd */
7151         case 0x660f3822:    /* pmovsxbq */
7152         case 0x660f3823:    /* pmovsxwd */
7153         case 0x660f3824:    /* pmovsxwq */
7154         case 0x660f3825:    /* pmovsxdq */
7155         case 0x660f3828:    /* pmuldq */
7156         case 0x660f3829:    /* pcmpeqq */
7157         case 0x660f382a:    /* movntdqa */
7158         case 0x660f3a08:    /* roundps */
7159         case 0x660f3a09:    /* roundpd */
7160         case 0x660f3a0a:    /* roundss */
7161         case 0x660f3a0b:    /* roundsd */
7162         case 0x660f3a0c:    /* blendps */
7163         case 0x660f3a0d:    /* blendpd */
7164         case 0x660f3a0e:    /* pblendw */
7165         case 0x660f3a0f:    /* palignr */
7166         case 0x660f3a20:    /* pinsrb */
7167         case 0x660f3a21:    /* insertps */
7168         case 0x660f3a22:    /* pinsrd pinsrq */
7169         case 0x660f3a40:    /* dpps */
7170         case 0x660f3a41:    /* dppd */
7171         case 0x660f3a42:    /* mpsadbw */
7172         case 0x660f3a60:    /* pcmpestrm */
7173         case 0x660f3a61:    /* pcmpestri */
7174         case 0x660f3a62:    /* pcmpistrm */
7175         case 0x660f3a63:    /* pcmpistri */
7176         case 0x0f51:        /* sqrtps */
7177         case 0x660f51:      /* sqrtpd */
7178         case 0xf20f51:      /* sqrtsd */
7179         case 0xf30f51:      /* sqrtss */
7180         case 0x0f52:        /* rsqrtps */
7181         case 0xf30f52:      /* rsqrtss */
7182         case 0x0f53:        /* rcpps */
7183         case 0xf30f53:      /* rcpss */
7184         case 0x0f54:        /* andps */
7185         case 0x660f54:      /* andpd */
7186         case 0x0f55:        /* andnps */
7187         case 0x660f55:      /* andnpd */
7188         case 0x0f56:        /* orps */
7189         case 0x660f56:      /* orpd */
7190         case 0x0f57:        /* xorps */
7191         case 0x660f57:      /* xorpd */
7192         case 0x0f58:        /* addps */
7193         case 0x660f58:      /* addpd */
7194         case 0xf20f58:      /* addsd */
7195         case 0xf30f58:      /* addss */
7196         case 0x0f59:        /* mulps */
7197         case 0x660f59:      /* mulpd */
7198         case 0xf20f59:      /* mulsd */
7199         case 0xf30f59:      /* mulss */
7200         case 0x0f5a:        /* cvtps2pd */
7201         case 0x660f5a:      /* cvtpd2ps */
7202         case 0xf20f5a:      /* cvtsd2ss */
7203         case 0xf30f5a:      /* cvtss2sd */
7204         case 0x0f5b:        /* cvtdq2ps */
7205         case 0x660f5b:      /* cvtps2dq */
7206         case 0xf30f5b:      /* cvttps2dq */
7207         case 0x0f5c:        /* subps */
7208         case 0x660f5c:      /* subpd */
7209         case 0xf20f5c:      /* subsd */
7210         case 0xf30f5c:      /* subss */
7211         case 0x0f5d:        /* minps */
7212         case 0x660f5d:      /* minpd */
7213         case 0xf20f5d:      /* minsd */
7214         case 0xf30f5d:      /* minss */
7215         case 0x0f5e:        /* divps */
7216         case 0x660f5e:      /* divpd */
7217         case 0xf20f5e:      /* divsd */
7218         case 0xf30f5e:      /* divss */
7219         case 0x0f5f:        /* maxps */
7220         case 0x660f5f:      /* maxpd */
7221         case 0xf20f5f:      /* maxsd */
7222         case 0xf30f5f:      /* maxss */
7223         case 0x660f60:      /* punpcklbw */
7224         case 0x660f61:      /* punpcklwd */
7225         case 0x660f62:      /* punpckldq */
7226         case 0x660f63:      /* packsswb */
7227         case 0x660f64:      /* pcmpgtb */
7228         case 0x660f65:      /* pcmpgtw */
7229         case 0x660f66:      /* pcmpgtd */
7230         case 0x660f67:      /* packuswb */
7231         case 0x660f68:      /* punpckhbw */
7232         case 0x660f69:      /* punpckhwd */
7233         case 0x660f6a:      /* punpckhdq */
7234         case 0x660f6b:      /* packssdw */
7235         case 0x660f6c:      /* punpcklqdq */
7236         case 0x660f6d:      /* punpckhqdq */
7237         case 0x660f6e:      /* movd */
7238         case 0x660f6f:      /* movdqa */
7239         case 0xf30f6f:      /* movdqu */
7240         case 0x660f70:      /* pshufd */
7241         case 0xf20f70:      /* pshuflw */
7242         case 0xf30f70:      /* pshufhw */
7243         case 0x660f74:      /* pcmpeqb */
7244         case 0x660f75:      /* pcmpeqw */
7245         case 0x660f76:      /* pcmpeqd */
7246         case 0x660f7c:      /* haddpd */
7247         case 0xf20f7c:      /* haddps */
7248         case 0x660f7d:      /* hsubpd */
7249         case 0xf20f7d:      /* hsubps */
7250         case 0xf30f7e:      /* movq */
7251         case 0x0fc2:        /* cmpps */
7252         case 0x660fc2:      /* cmppd */
7253         case 0xf20fc2:      /* cmpsd */
7254         case 0xf30fc2:      /* cmpss */
7255         case 0x660fc4:      /* pinsrw */
7256         case 0x0fc6:        /* shufps */
7257         case 0x660fc6:      /* shufpd */
7258         case 0x660fd0:      /* addsubpd */
7259         case 0xf20fd0:      /* addsubps */
7260         case 0x660fd1:      /* psrlw */
7261         case 0x660fd2:      /* psrld */
7262         case 0x660fd3:      /* psrlq */
7263         case 0x660fd4:      /* paddq */
7264         case 0x660fd5:      /* pmullw */
7265         case 0xf30fd6:      /* movq2dq */
7266         case 0x660fd8:      /* psubusb */
7267         case 0x660fd9:      /* psubusw */
7268         case 0x660fda:      /* pminub */
7269         case 0x660fdb:      /* pand */
7270         case 0x660fdc:      /* paddusb */
7271         case 0x660fdd:      /* paddusw */
7272         case 0x660fde:      /* pmaxub */
7273         case 0x660fdf:      /* pandn */
7274         case 0x660fe0:      /* pavgb */
7275         case 0x660fe1:      /* psraw */
7276         case 0x660fe2:      /* psrad */
7277         case 0x660fe3:      /* pavgw */
7278         case 0x660fe4:      /* pmulhuw */
7279         case 0x660fe5:      /* pmulhw */
7280         case 0x660fe6:      /* cvttpd2dq */
7281         case 0xf20fe6:      /* cvtpd2dq */
7282         case 0xf30fe6:      /* cvtdq2pd */
7283         case 0x660fe8:      /* psubsb */
7284         case 0x660fe9:      /* psubsw */
7285         case 0x660fea:      /* pminsw */
7286         case 0x660feb:      /* por */
7287         case 0x660fec:      /* paddsb */
7288         case 0x660fed:      /* paddsw */
7289         case 0x660fee:      /* pmaxsw */
7290         case 0x660fef:      /* pxor */
7291         case 0xf20ff0:      /* lddqu */
7292         case 0x660ff1:      /* psllw */
7293         case 0x660ff2:      /* pslld */
7294         case 0x660ff3:      /* psllq */
7295         case 0x660ff4:      /* pmuludq */
7296         case 0x660ff5:      /* pmaddwd */
7297         case 0x660ff6:      /* psadbw */
7298         case 0x660ff8:      /* psubb */
7299         case 0x660ff9:      /* psubw */
7300         case 0x660ffa:      /* psubd */
7301         case 0x660ffb:      /* psubq */
7302         case 0x660ffc:      /* paddb */
7303         case 0x660ffd:      /* paddw */
7304         case 0x660ffe:      /* paddd */
7305           if (i386_record_modrm (&ir))
7306             return -1;
7307           ir.reg |= rex_r;
7308           if (!i386_xmm_regnum_p (gdbarch, I387_XMM0_REGNUM (tdep) + ir.reg))
7309             goto no_support;
7310           record_full_arch_list_add_reg (ir.regcache,
7311                                          I387_XMM0_REGNUM (tdep) + ir.reg);
7312           if ((opcode & 0xfffffffc) == 0x660f3a60)
7313             I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7314           break;
7315
7316         case 0x0f11:        /* movups */
7317         case 0x660f11:      /* movupd */
7318         case 0xf30f11:      /* movss */
7319         case 0xf20f11:      /* movsd */
7320         case 0x0f13:        /* movlps */
7321         case 0x660f13:      /* movlpd */
7322         case 0x0f17:        /* movhps */
7323         case 0x660f17:      /* movhpd */
7324         case 0x0f29:        /* movaps */
7325         case 0x660f29:      /* movapd */
7326         case 0x660f3a14:    /* pextrb */
7327         case 0x660f3a15:    /* pextrw */
7328         case 0x660f3a16:    /* pextrd pextrq */
7329         case 0x660f3a17:    /* extractps */
7330         case 0x660f7f:      /* movdqa */
7331         case 0xf30f7f:      /* movdqu */
7332           if (i386_record_modrm (&ir))
7333             return -1;
7334           if (ir.mod == 3)
7335             {
7336               if (opcode == 0x0f13 || opcode == 0x660f13
7337                   || opcode == 0x0f17 || opcode == 0x660f17)
7338                 goto no_support;
7339               ir.rm |= ir.rex_b;
7340               if (!i386_xmm_regnum_p (gdbarch,
7341                                       I387_XMM0_REGNUM (tdep) + ir.rm))
7342                 goto no_support;
7343               record_full_arch_list_add_reg (ir.regcache,
7344                                              I387_XMM0_REGNUM (tdep) + ir.rm);
7345             }
7346           else
7347             {
7348               switch (opcode)
7349                 {
7350                   case 0x660f3a14:
7351                     ir.ot = OT_BYTE;
7352                     break;
7353                   case 0x660f3a15:
7354                     ir.ot = OT_WORD;
7355                     break;
7356                   case 0x660f3a16:
7357                     ir.ot = OT_LONG;
7358                     break;
7359                   case 0x660f3a17:
7360                     ir.ot = OT_QUAD;
7361                     break;
7362                   default:
7363                     ir.ot = OT_DQUAD;
7364                     break;
7365                 }
7366               if (i386_record_lea_modrm (&ir))
7367                 return -1;
7368             }
7369           break;
7370
7371         case 0x0f2b:      /* movntps */
7372         case 0x660f2b:    /* movntpd */
7373         case 0x0fe7:      /* movntq */
7374         case 0x660fe7:    /* movntdq */
7375           if (ir.mod == 3)
7376             goto no_support;
7377           if (opcode == 0x0fe7)
7378             ir.ot = OT_QUAD;
7379           else
7380             ir.ot = OT_DQUAD;
7381           if (i386_record_lea_modrm (&ir))
7382             return -1;
7383           break;
7384
7385         case 0xf30f2c:      /* cvttss2si */
7386         case 0xf20f2c:      /* cvttsd2si */
7387         case 0xf30f2d:      /* cvtss2si */
7388         case 0xf20f2d:      /* cvtsd2si */
7389         case 0xf20f38f0:    /* crc32 */
7390         case 0xf20f38f1:    /* crc32 */
7391         case 0x0f50:        /* movmskps */
7392         case 0x660f50:      /* movmskpd */
7393         case 0x0fc5:        /* pextrw */
7394         case 0x660fc5:      /* pextrw */
7395         case 0x0fd7:        /* pmovmskb */
7396         case 0x660fd7:      /* pmovmskb */
7397           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
7398           break;
7399
7400         case 0x0f3800:    /* pshufb */
7401         case 0x0f3801:    /* phaddw */
7402         case 0x0f3802:    /* phaddd */
7403         case 0x0f3803:    /* phaddsw */
7404         case 0x0f3804:    /* pmaddubsw */
7405         case 0x0f3805:    /* phsubw */
7406         case 0x0f3806:    /* phsubd */
7407         case 0x0f3807:    /* phsubsw */
7408         case 0x0f3808:    /* psignb */
7409         case 0x0f3809:    /* psignw */
7410         case 0x0f380a:    /* psignd */
7411         case 0x0f380b:    /* pmulhrsw */
7412         case 0x0f381c:    /* pabsb */
7413         case 0x0f381d:    /* pabsw */
7414         case 0x0f381e:    /* pabsd */
7415         case 0x0f382b:    /* packusdw */
7416         case 0x0f3830:    /* pmovzxbw */
7417         case 0x0f3831:    /* pmovzxbd */
7418         case 0x0f3832:    /* pmovzxbq */
7419         case 0x0f3833:    /* pmovzxwd */
7420         case 0x0f3834:    /* pmovzxwq */
7421         case 0x0f3835:    /* pmovzxdq */
7422         case 0x0f3837:    /* pcmpgtq */
7423         case 0x0f3838:    /* pminsb */
7424         case 0x0f3839:    /* pminsd */
7425         case 0x0f383a:    /* pminuw */
7426         case 0x0f383b:    /* pminud */
7427         case 0x0f383c:    /* pmaxsb */
7428         case 0x0f383d:    /* pmaxsd */
7429         case 0x0f383e:    /* pmaxuw */
7430         case 0x0f383f:    /* pmaxud */
7431         case 0x0f3840:    /* pmulld */
7432         case 0x0f3841:    /* phminposuw */
7433         case 0x0f3a0f:    /* palignr */
7434         case 0x0f60:      /* punpcklbw */
7435         case 0x0f61:      /* punpcklwd */
7436         case 0x0f62:      /* punpckldq */
7437         case 0x0f63:      /* packsswb */
7438         case 0x0f64:      /* pcmpgtb */
7439         case 0x0f65:      /* pcmpgtw */
7440         case 0x0f66:      /* pcmpgtd */
7441         case 0x0f67:      /* packuswb */
7442         case 0x0f68:      /* punpckhbw */
7443         case 0x0f69:      /* punpckhwd */
7444         case 0x0f6a:      /* punpckhdq */
7445         case 0x0f6b:      /* packssdw */
7446         case 0x0f6e:      /* movd */
7447         case 0x0f6f:      /* movq */
7448         case 0x0f70:      /* pshufw */
7449         case 0x0f74:      /* pcmpeqb */
7450         case 0x0f75:      /* pcmpeqw */
7451         case 0x0f76:      /* pcmpeqd */
7452         case 0x0fc4:      /* pinsrw */
7453         case 0x0fd1:      /* psrlw */
7454         case 0x0fd2:      /* psrld */
7455         case 0x0fd3:      /* psrlq */
7456         case 0x0fd4:      /* paddq */
7457         case 0x0fd5:      /* pmullw */
7458         case 0xf20fd6:    /* movdq2q */
7459         case 0x0fd8:      /* psubusb */
7460         case 0x0fd9:      /* psubusw */
7461         case 0x0fda:      /* pminub */
7462         case 0x0fdb:      /* pand */
7463         case 0x0fdc:      /* paddusb */
7464         case 0x0fdd:      /* paddusw */
7465         case 0x0fde:      /* pmaxub */
7466         case 0x0fdf:      /* pandn */
7467         case 0x0fe0:      /* pavgb */
7468         case 0x0fe1:      /* psraw */
7469         case 0x0fe2:      /* psrad */
7470         case 0x0fe3:      /* pavgw */
7471         case 0x0fe4:      /* pmulhuw */
7472         case 0x0fe5:      /* pmulhw */
7473         case 0x0fe8:      /* psubsb */
7474         case 0x0fe9:      /* psubsw */
7475         case 0x0fea:      /* pminsw */
7476         case 0x0feb:      /* por */
7477         case 0x0fec:      /* paddsb */
7478         case 0x0fed:      /* paddsw */
7479         case 0x0fee:      /* pmaxsw */
7480         case 0x0fef:      /* pxor */
7481         case 0x0ff1:      /* psllw */
7482         case 0x0ff2:      /* pslld */
7483         case 0x0ff3:      /* psllq */
7484         case 0x0ff4:      /* pmuludq */
7485         case 0x0ff5:      /* pmaddwd */
7486         case 0x0ff6:      /* psadbw */
7487         case 0x0ff8:      /* psubb */
7488         case 0x0ff9:      /* psubw */
7489         case 0x0ffa:      /* psubd */
7490         case 0x0ffb:      /* psubq */
7491         case 0x0ffc:      /* paddb */
7492         case 0x0ffd:      /* paddw */
7493         case 0x0ffe:      /* paddd */
7494           if (i386_record_modrm (&ir))
7495             return -1;
7496           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.reg))
7497             goto no_support;
7498           record_full_arch_list_add_reg (ir.regcache,
7499                                          I387_MM0_REGNUM (tdep) + ir.reg);
7500           break;
7501
7502         case 0x0f71:    /* psllw */
7503         case 0x0f72:    /* pslld */
7504         case 0x0f73:    /* psllq */
7505           if (i386_record_modrm (&ir))
7506             return -1;
7507           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.rm))
7508             goto no_support;
7509           record_full_arch_list_add_reg (ir.regcache,
7510                                          I387_MM0_REGNUM (tdep) + ir.rm);
7511           break;
7512
7513         case 0x660f71:    /* psllw */
7514         case 0x660f72:    /* pslld */
7515         case 0x660f73:    /* psllq */
7516           if (i386_record_modrm (&ir))
7517             return -1;
7518           ir.rm |= ir.rex_b;
7519           if (!i386_xmm_regnum_p (gdbarch, I387_XMM0_REGNUM (tdep) + ir.rm))
7520             goto no_support;
7521           record_full_arch_list_add_reg (ir.regcache,
7522                                          I387_XMM0_REGNUM (tdep) + ir.rm);
7523           break;
7524
7525         case 0x0f7e:      /* movd */
7526         case 0x660f7e:    /* movd */
7527           if (i386_record_modrm (&ir))
7528             return -1;
7529           if (ir.mod == 3)
7530             I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
7531           else
7532             {
7533               if (ir.dflag == 2)
7534                 ir.ot = OT_QUAD;
7535               else
7536                 ir.ot = OT_LONG;
7537               if (i386_record_lea_modrm (&ir))
7538                 return -1;
7539             }
7540           break;
7541
7542         case 0x0f7f:    /* movq */
7543           if (i386_record_modrm (&ir))
7544             return -1;
7545           if (ir.mod == 3)
7546             {
7547               if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.rm))
7548                 goto no_support;
7549               record_full_arch_list_add_reg (ir.regcache,
7550                                              I387_MM0_REGNUM (tdep) + ir.rm);
7551             }
7552           else
7553             {
7554               ir.ot = OT_QUAD;
7555               if (i386_record_lea_modrm (&ir))
7556                 return -1;
7557             }
7558           break;
7559
7560         case 0xf30fb8:    /* popcnt */
7561           if (i386_record_modrm (&ir))
7562             return -1;
7563           I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
7564           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7565           break;
7566
7567         case 0x660fd6:    /* movq */
7568           if (i386_record_modrm (&ir))
7569             return -1;
7570           if (ir.mod == 3)
7571             {
7572               ir.rm |= ir.rex_b;
7573               if (!i386_xmm_regnum_p (gdbarch,
7574                                       I387_XMM0_REGNUM (tdep) + ir.rm))
7575                 goto no_support;
7576               record_full_arch_list_add_reg (ir.regcache,
7577                                              I387_XMM0_REGNUM (tdep) + ir.rm);
7578             }
7579           else
7580             {
7581               ir.ot = OT_QUAD;
7582               if (i386_record_lea_modrm (&ir))
7583                 return -1;
7584             }
7585           break;
7586
7587         case 0x660f3817:    /* ptest */
7588         case 0x0f2e:        /* ucomiss */
7589         case 0x660f2e:      /* ucomisd */
7590         case 0x0f2f:        /* comiss */
7591         case 0x660f2f:      /* comisd */
7592           I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
7593           break;
7594
7595         case 0x0ff7:    /* maskmovq */
7596           regcache_raw_read_unsigned (ir.regcache,
7597                                       ir.regmap[X86_RECORD_REDI_REGNUM],
7598                                       &addr);
7599           if (record_full_arch_list_add_mem (addr, 64))
7600             return -1;
7601           break;
7602
7603         case 0x660ff7:    /* maskmovdqu */
7604           regcache_raw_read_unsigned (ir.regcache,
7605                                       ir.regmap[X86_RECORD_REDI_REGNUM],
7606                                       &addr);
7607           if (record_full_arch_list_add_mem (addr, 128))
7608             return -1;
7609           break;
7610
7611         default:
7612           goto no_support;
7613           break;
7614         }
7615       break;
7616
7617     default:
7618       goto no_support;
7619       break;
7620     }
7621
7622   /* In the future, maybe still need to deal with need_dasm.  */
7623   I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REIP_REGNUM);
7624   if (record_full_arch_list_add_end ())
7625     return -1;
7626
7627   return 0;
7628
7629  no_support:
7630   printf_unfiltered (_("Process record does not support instruction 0x%02x "
7631                        "at address %s.\n"),
7632                      (unsigned int) (opcode),
7633                      paddress (gdbarch, ir.orig_addr));
7634   return -1;
7635 }
7636
7637 static const int i386_record_regmap[] =
7638 {
7639   I386_EAX_REGNUM, I386_ECX_REGNUM, I386_EDX_REGNUM, I386_EBX_REGNUM,
7640   I386_ESP_REGNUM, I386_EBP_REGNUM, I386_ESI_REGNUM, I386_EDI_REGNUM,
7641   0, 0, 0, 0, 0, 0, 0, 0,
7642   I386_EIP_REGNUM, I386_EFLAGS_REGNUM, I386_CS_REGNUM, I386_SS_REGNUM,
7643   I386_DS_REGNUM, I386_ES_REGNUM, I386_FS_REGNUM, I386_GS_REGNUM
7644 };
7645
7646 /* Check that the given address appears suitable for a fast
7647    tracepoint, which on x86-64 means that we need an instruction of at
7648    least 5 bytes, so that we can overwrite it with a 4-byte-offset
7649    jump and not have to worry about program jumps to an address in the
7650    middle of the tracepoint jump.  On x86, it may be possible to use
7651    4-byte jumps with a 2-byte offset to a trampoline located in the
7652    bottom 64 KiB of memory.  Returns 1 if OK, and writes a size
7653    of instruction to replace, and 0 if not, plus an explanatory
7654    string.  */
7655
7656 static int
7657 i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
7658                                CORE_ADDR addr, int *isize, char **msg)
7659 {
7660   int len, jumplen;
7661   static struct ui_file *gdb_null = NULL;
7662
7663   /*  Ask the target for the minimum instruction length supported.  */
7664   jumplen = target_get_min_fast_tracepoint_insn_len ();
7665
7666   if (jumplen < 0)
7667     {
7668       /* If the target does not support the get_min_fast_tracepoint_insn_len
7669          operation, assume that fast tracepoints will always be implemented
7670          using 4-byte relative jumps on both x86 and x86-64.  */
7671       jumplen = 5;
7672     }
7673   else if (jumplen == 0)
7674     {
7675       /* If the target does support get_min_fast_tracepoint_insn_len but
7676          returns zero, then the IPA has not loaded yet.  In this case,
7677          we optimistically assume that truncated 2-byte relative jumps
7678          will be available on x86, and compensate later if this assumption
7679          turns out to be incorrect.  On x86-64 architectures, 4-byte relative
7680          jumps will always be used.  */
7681       jumplen = (register_size (gdbarch, 0) == 8) ? 5 : 4;
7682     }
7683
7684   /* Dummy file descriptor for the disassembler.  */
7685   if (!gdb_null)
7686     gdb_null = ui_file_new ();
7687
7688   /* Check for fit.  */
7689   len = gdb_print_insn (gdbarch, addr, gdb_null, NULL);
7690   if (isize)
7691     *isize = len;
7692
7693   if (len < jumplen)
7694     {
7695       /* Return a bit of target-specific detail to add to the caller's
7696          generic failure message.  */
7697       if (msg)
7698         *msg = xstrprintf (_("; instruction is only %d bytes long, "
7699                              "need at least %d bytes for the jump"),
7700                            len, jumplen);
7701       return 0;
7702     }
7703   else
7704     {
7705       if (msg)
7706         *msg = NULL;
7707       return 1;
7708     }
7709 }
7710
7711 static int
7712 i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
7713                        struct tdesc_arch_data *tdesc_data)
7714 {
7715   const struct target_desc *tdesc = tdep->tdesc;
7716   const struct tdesc_feature *feature_core;
7717   const struct tdesc_feature *feature_sse, *feature_avx, *feature_mpx;
7718   int i, num_regs, valid_p;
7719
7720   if (! tdesc_has_registers (tdesc))
7721     return 0;
7722
7723   /* Get core registers.  */
7724   feature_core = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.core");
7725   if (feature_core == NULL)
7726     return 0;
7727
7728   /* Get SSE registers.  */
7729   feature_sse = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.sse");
7730
7731   /* Try AVX registers.  */
7732   feature_avx = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx");
7733
7734   /* Try MPX registers.  */
7735   feature_mpx = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.mpx");
7736
7737   valid_p = 1;
7738
7739   /* The XCR0 bits.  */
7740   if (feature_avx)
7741     {
7742       /* AVX register description requires SSE register description.  */
7743       if (!feature_sse)
7744         return 0;
7745
7746       tdep->xcr0 = I386_XSTATE_AVX_MASK;
7747
7748       /* It may have been set by OSABI initialization function.  */
7749       if (tdep->num_ymm_regs == 0)
7750         {
7751           tdep->ymmh_register_names = i386_ymmh_names;
7752           tdep->num_ymm_regs = 8;
7753           tdep->ymm0h_regnum = I386_YMM0H_REGNUM;
7754         }
7755
7756       for (i = 0; i < tdep->num_ymm_regs; i++)
7757         valid_p &= tdesc_numbered_register (feature_avx, tdesc_data,
7758                                             tdep->ymm0h_regnum + i,
7759                                             tdep->ymmh_register_names[i]);
7760     }
7761   else if (feature_sse)
7762     tdep->xcr0 = I386_XSTATE_SSE_MASK;
7763   else
7764     {
7765       tdep->xcr0 = I386_XSTATE_X87_MASK;
7766       tdep->num_xmm_regs = 0;
7767     }
7768
7769   num_regs = tdep->num_core_regs;
7770   for (i = 0; i < num_regs; i++)
7771     valid_p &= tdesc_numbered_register (feature_core, tdesc_data, i,
7772                                         tdep->register_names[i]);
7773
7774   if (feature_sse)
7775     {
7776       /* Need to include %mxcsr, so add one.  */
7777       num_regs += tdep->num_xmm_regs + 1;
7778       for (; i < num_regs; i++)
7779         valid_p &= tdesc_numbered_register (feature_sse, tdesc_data, i,
7780                                             tdep->register_names[i]);
7781     }
7782
7783   if (feature_mpx)
7784     {
7785       tdep->xcr0 = I386_XSTATE_MPX_MASK;
7786
7787       if (tdep->bnd0r_regnum < 0)
7788         {
7789           tdep->mpx_register_names = i386_mpx_names;
7790           tdep->bnd0r_regnum = I386_BND0R_REGNUM;
7791           tdep->bndcfgu_regnum = I386_BNDCFGU_REGNUM;
7792         }
7793
7794       for (i = 0; i < I387_NUM_MPX_REGS; i++)
7795         valid_p &= tdesc_numbered_register (feature_mpx, tdesc_data,
7796             I387_BND0R_REGNUM (tdep) + i,
7797             tdep->mpx_register_names[i]);
7798     }
7799
7800   return valid_p;
7801 }
7802
7803 \f
7804 static struct gdbarch *
7805 i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
7806 {
7807   struct gdbarch_tdep *tdep;
7808   struct gdbarch *gdbarch;
7809   struct tdesc_arch_data *tdesc_data;
7810   const struct target_desc *tdesc;
7811   int mm0_regnum;
7812   int ymm0_regnum;
7813   int bnd0_regnum;
7814   int num_bnd_cooked;
7815
7816   /* If there is already a candidate, use it.  */
7817   arches = gdbarch_list_lookup_by_info (arches, &info);
7818   if (arches != NULL)
7819     return arches->gdbarch;
7820
7821   /* Allocate space for the new architecture.  */
7822   tdep = XCNEW (struct gdbarch_tdep);
7823   gdbarch = gdbarch_alloc (&info, tdep);
7824
7825   /* General-purpose registers.  */
7826   tdep->gregset = NULL;
7827   tdep->gregset_reg_offset = NULL;
7828   tdep->gregset_num_regs = I386_NUM_GREGS;
7829   tdep->sizeof_gregset = 0;
7830
7831   /* Floating-point registers.  */
7832   tdep->fpregset = NULL;
7833   tdep->sizeof_fpregset = I387_SIZEOF_FSAVE;
7834
7835   tdep->xstateregset = NULL;
7836
7837   /* The default settings include the FPU registers, the MMX registers
7838      and the SSE registers.  This can be overridden for a specific ABI
7839      by adjusting the members `st0_regnum', `mm0_regnum' and
7840      `num_xmm_regs' of `struct gdbarch_tdep', otherwise the registers
7841      will show up in the output of "info all-registers".  */
7842
7843   tdep->st0_regnum = I386_ST0_REGNUM;
7844
7845   /* I386_NUM_XREGS includes %mxcsr, so substract one.  */
7846   tdep->num_xmm_regs = I386_NUM_XREGS - 1;
7847
7848   tdep->jb_pc_offset = -1;
7849   tdep->struct_return = pcc_struct_return;
7850   tdep->sigtramp_start = 0;
7851   tdep->sigtramp_end = 0;
7852   tdep->sigtramp_p = i386_sigtramp_p;
7853   tdep->sigcontext_addr = NULL;
7854   tdep->sc_reg_offset = NULL;
7855   tdep->sc_pc_offset = -1;
7856   tdep->sc_sp_offset = -1;
7857
7858   tdep->xsave_xcr0_offset = -1;
7859
7860   tdep->record_regmap = i386_record_regmap;
7861
7862   set_gdbarch_long_long_align_bit (gdbarch, 32);
7863
7864   /* The format used for `long double' on almost all i386 targets is
7865      the i387 extended floating-point format.  In fact, of all targets
7866      in the GCC 2.95 tree, only OSF/1 does it different, and insists
7867      on having a `long double' that's not `long' at all.  */
7868   set_gdbarch_long_double_format (gdbarch, floatformats_i387_ext);
7869
7870   /* Although the i387 extended floating-point has only 80 significant
7871      bits, a `long double' actually takes up 96, probably to enforce
7872      alignment.  */
7873   set_gdbarch_long_double_bit (gdbarch, 96);
7874
7875   /* Register numbers of various important registers.  */
7876   set_gdbarch_sp_regnum (gdbarch, I386_ESP_REGNUM); /* %esp */
7877   set_gdbarch_pc_regnum (gdbarch, I386_EIP_REGNUM); /* %eip */
7878   set_gdbarch_ps_regnum (gdbarch, I386_EFLAGS_REGNUM); /* %eflags */
7879   set_gdbarch_fp0_regnum (gdbarch, I386_ST0_REGNUM); /* %st(0) */
7880
7881   /* NOTE: kettenis/20040418: GCC does have two possible register
7882      numbering schemes on the i386: dbx and SVR4.  These schemes
7883      differ in how they number %ebp, %esp, %eflags, and the
7884      floating-point registers, and are implemented by the arrays
7885      dbx_register_map[] and svr4_dbx_register_map in
7886      gcc/config/i386.c.  GCC also defines a third numbering scheme in
7887      gcc/config/i386.c, which it designates as the "default" register
7888      map used in 64bit mode.  This last register numbering scheme is
7889      implemented in dbx64_register_map, and is used for AMD64; see
7890      amd64-tdep.c.
7891
7892      Currently, each GCC i386 target always uses the same register
7893      numbering scheme across all its supported debugging formats
7894      i.e. SDB (COFF), stabs and DWARF 2.  This is because
7895      gcc/sdbout.c, gcc/dbxout.c and gcc/dwarf2out.c all use the
7896      DBX_REGISTER_NUMBER macro which is defined by each target's
7897      respective config header in a manner independent of the requested
7898      output debugging format.
7899
7900      This does not match the arrangement below, which presumes that
7901      the SDB and stabs numbering schemes differ from the DWARF and
7902      DWARF 2 ones.  The reason for this arrangement is that it is
7903      likely to get the numbering scheme for the target's
7904      default/native debug format right.  For targets where GCC is the
7905      native compiler (FreeBSD, NetBSD, OpenBSD, GNU/Linux) or for
7906      targets where the native toolchain uses a different numbering
7907      scheme for a particular debug format (stabs-in-ELF on Solaris)
7908      the defaults below will have to be overridden, like
7909      i386_elf_init_abi() does.  */
7910
7911   /* Use the dbx register numbering scheme for stabs and COFF.  */
7912   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_dbx_reg_to_regnum);
7913   set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_dbx_reg_to_regnum);
7914
7915   /* Use the SVR4 register numbering scheme for DWARF 2.  */
7916   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
7917
7918   /* We don't set gdbarch_stab_reg_to_regnum, since ECOFF doesn't seem to
7919      be in use on any of the supported i386 targets.  */
7920
7921   set_gdbarch_print_float_info (gdbarch, i387_print_float_info);
7922
7923   set_gdbarch_get_longjmp_target (gdbarch, i386_get_longjmp_target);
7924
7925   /* Call dummy code.  */
7926   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
7927   set_gdbarch_push_dummy_code (gdbarch, i386_push_dummy_code);
7928   set_gdbarch_push_dummy_call (gdbarch, i386_push_dummy_call);
7929   set_gdbarch_frame_align (gdbarch, i386_frame_align);
7930
7931   set_gdbarch_convert_register_p (gdbarch, i386_convert_register_p);
7932   set_gdbarch_register_to_value (gdbarch,  i386_register_to_value);
7933   set_gdbarch_value_to_register (gdbarch, i386_value_to_register);
7934
7935   set_gdbarch_return_value (gdbarch, i386_return_value);
7936
7937   set_gdbarch_skip_prologue (gdbarch, i386_skip_prologue);
7938
7939   /* Stack grows downward.  */
7940   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
7941
7942   set_gdbarch_breakpoint_from_pc (gdbarch, i386_breakpoint_from_pc);
7943   set_gdbarch_decr_pc_after_break (gdbarch, 1);
7944   set_gdbarch_max_insn_length (gdbarch, I386_MAX_INSN_LEN);
7945
7946   set_gdbarch_frame_args_skip (gdbarch, 8);
7947
7948   set_gdbarch_print_insn (gdbarch, i386_print_insn);
7949
7950   set_gdbarch_dummy_id (gdbarch, i386_dummy_id);
7951
7952   set_gdbarch_unwind_pc (gdbarch, i386_unwind_pc);
7953
7954   /* Add the i386 register groups.  */
7955   i386_add_reggroups (gdbarch);
7956   tdep->register_reggroup_p = i386_register_reggroup_p;
7957
7958   /* Helper for function argument information.  */
7959   set_gdbarch_fetch_pointer_argument (gdbarch, i386_fetch_pointer_argument);
7960
7961   /* Hook the function epilogue frame unwinder.  This unwinder is
7962      appended to the list first, so that it supercedes the DWARF
7963      unwinder in function epilogues (where the DWARF unwinder
7964      currently fails).  */
7965   frame_unwind_append_unwinder (gdbarch, &i386_epilogue_frame_unwind);
7966
7967   /* Hook in the DWARF CFI frame unwinder.  This unwinder is appended
7968      to the list before the prologue-based unwinders, so that DWARF
7969      CFI info will be used if it is available.  */
7970   dwarf2_append_unwinders (gdbarch);
7971
7972   frame_base_set_default (gdbarch, &i386_frame_base);
7973
7974   /* Pseudo registers may be changed by amd64_init_abi.  */
7975   set_gdbarch_pseudo_register_read_value (gdbarch,
7976                                           i386_pseudo_register_read_value);
7977   set_gdbarch_pseudo_register_write (gdbarch, i386_pseudo_register_write);
7978
7979   set_tdesc_pseudo_register_type (gdbarch, i386_pseudo_register_type);
7980   set_tdesc_pseudo_register_name (gdbarch, i386_pseudo_register_name);
7981
7982   /* Override the normal target description method to make the AVX
7983      upper halves anonymous.  */
7984   set_gdbarch_register_name (gdbarch, i386_register_name);
7985
7986   /* Even though the default ABI only includes general-purpose registers,
7987      floating-point registers and the SSE registers, we have to leave a
7988      gap for the upper AVX registers and the MPX registers.  */
7989   set_gdbarch_num_regs (gdbarch, I386_MPX_NUM_REGS);
7990
7991   /* Get the x86 target description from INFO.  */
7992   tdesc = info.target_desc;
7993   if (! tdesc_has_registers (tdesc))
7994     tdesc = tdesc_i386;
7995   tdep->tdesc = tdesc;
7996
7997   tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS;
7998   tdep->register_names = i386_register_names;
7999
8000   /* No upper YMM registers.  */
8001   tdep->ymmh_register_names = NULL;
8002   tdep->ymm0h_regnum = -1;
8003
8004   tdep->num_byte_regs = 8;
8005   tdep->num_word_regs = 8;
8006   tdep->num_dword_regs = 0;
8007   tdep->num_mmx_regs = 8;
8008   tdep->num_ymm_regs = 0;
8009
8010   /* No MPX registers.  */
8011   tdep->bnd0r_regnum = -1;
8012   tdep->bndcfgu_regnum = -1;
8013
8014   tdesc_data = tdesc_data_alloc ();
8015
8016   set_gdbarch_relocate_instruction (gdbarch, i386_relocate_instruction);
8017
8018   set_gdbarch_gen_return_address (gdbarch, i386_gen_return_address);
8019
8020   /* Hook in ABI-specific overrides, if they have been registered.  */
8021   info.tdep_info = (void *) tdesc_data;
8022   gdbarch_init_osabi (info, gdbarch);
8023
8024   if (!i386_validate_tdesc_p (tdep, tdesc_data))
8025     {
8026       tdesc_data_cleanup (tdesc_data);
8027       xfree (tdep);
8028       gdbarch_free (gdbarch);
8029       return NULL;
8030     }
8031
8032   num_bnd_cooked = (tdep->bnd0r_regnum > 0 ? I387_NUM_BND_REGS : 0);
8033
8034   /* Wire in pseudo registers.  Number of pseudo registers may be
8035      changed.  */
8036   set_gdbarch_num_pseudo_regs (gdbarch, (tdep->num_byte_regs
8037                                          + tdep->num_word_regs
8038                                          + tdep->num_dword_regs
8039                                          + tdep->num_mmx_regs
8040                                          + tdep->num_ymm_regs
8041                                          + num_bnd_cooked));
8042
8043   /* Target description may be changed.  */
8044   tdesc = tdep->tdesc;
8045
8046   tdesc_use_registers (gdbarch, tdesc, tdesc_data);
8047
8048   /* Override gdbarch_register_reggroup_p set in tdesc_use_registers.  */
8049   set_gdbarch_register_reggroup_p (gdbarch, tdep->register_reggroup_p);
8050
8051   /* Make %al the first pseudo-register.  */
8052   tdep->al_regnum = gdbarch_num_regs (gdbarch);
8053   tdep->ax_regnum = tdep->al_regnum + tdep->num_byte_regs;
8054
8055   ymm0_regnum = tdep->ax_regnum + tdep->num_word_regs;
8056   if (tdep->num_dword_regs)
8057     {
8058       /* Support dword pseudo-register if it hasn't been disabled.  */
8059       tdep->eax_regnum = ymm0_regnum;
8060       ymm0_regnum += tdep->num_dword_regs;
8061     }
8062   else
8063     tdep->eax_regnum = -1;
8064
8065   mm0_regnum = ymm0_regnum;
8066   if (tdep->num_ymm_regs)
8067     {
8068       /* Support YMM pseudo-register if it is available.  */
8069       tdep->ymm0_regnum = ymm0_regnum;
8070       mm0_regnum += tdep->num_ymm_regs;
8071     }
8072   else
8073     tdep->ymm0_regnum = -1;
8074
8075   bnd0_regnum = mm0_regnum;
8076   if (tdep->num_mmx_regs != 0)
8077     {
8078       /* Support MMX pseudo-register if MMX hasn't been disabled.  */
8079       tdep->mm0_regnum = mm0_regnum;
8080       bnd0_regnum += tdep->num_mmx_regs;
8081     }
8082   else
8083     tdep->mm0_regnum = -1;
8084
8085   if (tdep->bnd0r_regnum > 0)
8086       tdep->bnd0_regnum = bnd0_regnum;
8087   else
8088     tdep-> bnd0_regnum = -1;
8089
8090   /* Hook in the legacy prologue-based unwinders last (fallback).  */
8091   frame_unwind_append_unwinder (gdbarch, &i386_stack_tramp_frame_unwind);
8092   frame_unwind_append_unwinder (gdbarch, &i386_sigtramp_frame_unwind);
8093   frame_unwind_append_unwinder (gdbarch, &i386_frame_unwind);
8094
8095   /* If we have a register mapping, enable the generic core file
8096      support, unless it has already been enabled.  */
8097   if (tdep->gregset_reg_offset
8098       && !gdbarch_regset_from_core_section_p (gdbarch))
8099     set_gdbarch_regset_from_core_section (gdbarch,
8100                                           i386_regset_from_core_section);
8101
8102   set_gdbarch_skip_permanent_breakpoint (gdbarch,
8103                                          i386_skip_permanent_breakpoint);
8104
8105   set_gdbarch_fast_tracepoint_valid_at (gdbarch,
8106                                         i386_fast_tracepoint_valid_at);
8107
8108   return gdbarch;
8109 }
8110
8111 static enum gdb_osabi
8112 i386_coff_osabi_sniffer (bfd *abfd)
8113 {
8114   if (strcmp (bfd_get_target (abfd), "coff-go32-exe") == 0
8115       || strcmp (bfd_get_target (abfd), "coff-go32") == 0)
8116     return GDB_OSABI_GO32;
8117
8118   return GDB_OSABI_UNKNOWN;
8119 }
8120 \f
8121
8122 /* Provide a prototype to silence -Wmissing-prototypes.  */
8123 void _initialize_i386_tdep (void);
8124
8125 void
8126 _initialize_i386_tdep (void)
8127 {
8128   register_gdbarch_init (bfd_arch_i386, i386_gdbarch_init);
8129
8130   /* Add the variable that controls the disassembly flavor.  */
8131   add_setshow_enum_cmd ("disassembly-flavor", no_class, valid_flavors,
8132                         &disassembly_flavor, _("\
8133 Set the disassembly flavor."), _("\
8134 Show the disassembly flavor."), _("\
8135 The valid values are \"att\" and \"intel\", and the default value is \"att\"."),
8136                         NULL,
8137                         NULL, /* FIXME: i18n: */
8138                         &setlist, &showlist);
8139
8140   /* Add the variable that controls the convention for returning
8141      structs.  */
8142   add_setshow_enum_cmd ("struct-convention", no_class, valid_conventions,
8143                         &struct_convention, _("\
8144 Set the convention for returning small structs."), _("\
8145 Show the convention for returning small structs."), _("\
8146 Valid values are \"default\", \"pcc\" and \"reg\", and the default value\n\
8147 is \"default\"."),
8148                         NULL,
8149                         NULL, /* FIXME: i18n: */
8150                         &setlist, &showlist);
8151
8152   gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour,
8153                                   i386_coff_osabi_sniffer);
8154
8155   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_SVR4,
8156                           i386_svr4_init_abi);
8157   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_GO32,
8158                           i386_go32_init_abi);
8159
8160   /* Initialize the i386-specific register groups.  */
8161   i386_init_reggroups ();
8162
8163   /* Initialize the standard target descriptions.  */
8164   initialize_tdesc_i386 ();
8165   initialize_tdesc_i386_mmx ();
8166   initialize_tdesc_i386_avx ();
8167   initialize_tdesc_i386_mpx ();
8168
8169   /* Tell remote stub that we support XML target description.  */
8170   register_remote_support_xml ("i386");
8171 }