gdb/i386-tdep.c

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