gdb/i386-tdep.c

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