gdb/i386-tdep.c

   1 /* Intel 386 target-dependent stuff.
   2
   3    Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   5    2010 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "opcode/i386.h"
  24 #include "arch-utils.h"
  25 #include "command.h"
  26 #include "dummy-frame.h"
  27 #include "dwarf2-frame.h"
  28 #include "doublest.h"
  29 #include "frame.h"
  30 #include "frame-base.h"
  31 #include "frame-unwind.h"
  32 #include "inferior.h"
  33 #include "gdbcmd.h"
  34 #include "gdbcore.h"
  35 #include "gdbtypes.h"
  36 #include "objfiles.h"
  37 #include "osabi.h"
  38 #include "regcache.h"
  39 #include "reggroups.h"
  40 #include "regset.h"
  41 #include "symfile.h"
  42 #include "symtab.h"
  43 #include "target.h"
  44 #include "value.h"
  45 #include "dis-asm.h"
  46 #include "disasm.h"
  47
  48 #include "gdb_assert.h"
  49 #include "gdb_string.h"
  50
  51 #include "i386-tdep.h"
  52 #include "i387-tdep.h"
  53
  54 #include "record.h"
  55 #include <stdint.h>
  56
  57 #include "features/i386/i386.c"
  58
  59 /* Register names.  */
  60
  61 static const char *i386_register_names[] =
  62 {
  63   "eax",   "ecx",    "edx",   "ebx",
  64   "esp",   "ebp",    "esi",   "edi",
  65   "eip",   "eflags", "cs",    "ss",
  66   "ds",    "es",     "fs",    "gs",
  67   "st0",   "st1",    "st2",   "st3",
  68   "st4",   "st5",    "st6",   "st7",
  69   "fctrl", "fstat",  "ftag",  "fiseg",
  70   "fioff", "foseg",  "fooff", "fop",
  71   "xmm0",  "xmm1",   "xmm2",  "xmm3",
  72   "xmm4",  "xmm5",   "xmm6",  "xmm7",
  73   "mxcsr"
  74 };
  75
  76 /* Register names for MMX pseudo-registers.  */
  77
  78 static const char *i386_mmx_names[] =
  79 {
  80   "mm0", "mm1", "mm2", "mm3",
  81   "mm4", "mm5", "mm6", "mm7"
  82 };
  83
  84 /* Register names for byte pseudo-registers.  */
  85
  86 static const char *i386_byte_names[] =
  87 {
  88   "al", "cl", "dl", "bl",
  89   "ah", "ch", "dh", "bh"
  90 };
  91
  92 /* Register names for word pseudo-registers.  */
  93
  94 static const char *i386_word_names[] =
  95 {
  96   "ax", "cx", "dx", "bx",
  97   "sp", "bp", "si", "di"
  98 };
  99
 100 /* MMX register?  */
 101
 102 static int
 103 i386_mmx_regnum_p (struct gdbarch *gdbarch, int regnum)
 104 {
 105   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 106   int mm0_regnum = tdep->mm0_regnum;
 107
 108   if (mm0_regnum < 0)
 109     return 0;
 110
 111   regnum -= mm0_regnum;
 112   return regnum >= 0 && regnum < tdep->num_mmx_regs;
 113 }
 114
 115 /* Byte register?  */
 116
 117 int
 118 i386_byte_regnum_p (struct gdbarch *gdbarch, int regnum)
 119 {
 120   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 121
 122   regnum -= tdep->al_regnum;
 123   return regnum >= 0 && regnum < tdep->num_byte_regs;
 124 }
 125
 126 /* Word register?  */
 127
 128 int
 129 i386_word_regnum_p (struct gdbarch *gdbarch, int regnum)
 130 {
 131   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 132
 133   regnum -= tdep->ax_regnum;
 134   return regnum >= 0 && regnum < tdep->num_word_regs;
 135 }
 136
 137 /* Dword register?  */
 138
 139 int
 140 i386_dword_regnum_p (struct gdbarch *gdbarch, int regnum)
 141 {
 142   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 143   int eax_regnum = tdep->eax_regnum;
 144
 145   if (eax_regnum < 0)
 146     return 0;
 147
 148   regnum -= eax_regnum;
 149   return regnum >= 0 && regnum < tdep->num_dword_regs;
 150 }
 151
 152 /* SSE register?  */
 153
 154 static int
 155 i386_sse_regnum_p (struct gdbarch *gdbarch, int regnum)
 156 {
 157   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 158
 159   if (I387_NUM_XMM_REGS (tdep) == 0)
 160     return 0;
 161
 162   return (I387_XMM0_REGNUM (tdep) <= regnum
 163           && regnum < I387_MXCSR_REGNUM (tdep));
 164 }
 165
 166 static int
 167 i386_mxcsr_regnum_p (struct gdbarch *gdbarch, int regnum)
 168 {
 169   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 170
 171   if (I387_NUM_XMM_REGS (tdep) == 0)
 172     return 0;
 173
 174   return (regnum == I387_MXCSR_REGNUM (tdep));
 175 }
 176
 177 /* FP register?  */
 178
 179 int
 180 i386_fp_regnum_p (struct gdbarch *gdbarch, int regnum)
 181 {
 182   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 183
 184   if (I387_ST0_REGNUM (tdep) < 0)
 185     return 0;
 186
 187   return (I387_ST0_REGNUM (tdep) <= regnum
 188           && regnum < I387_FCTRL_REGNUM (tdep));
 189 }
 190
 191 int
 192 i386_fpc_regnum_p (struct gdbarch *gdbarch, int regnum)
 193 {
 194   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 195
 196   if (I387_ST0_REGNUM (tdep) < 0)
 197     return 0;
 198
 199   return (I387_FCTRL_REGNUM (tdep) <= regnum
 200           && regnum < I387_XMM0_REGNUM (tdep));
 201 }
 202
 203 /* Return the name of register REGNUM.  */
 204
 205 const char *
 206 i386_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
 207 {
 208   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 209   if (i386_mmx_regnum_p (gdbarch, regnum))
 210     return i386_mmx_names[regnum - I387_MM0_REGNUM (tdep)];
 211   else if (i386_byte_regnum_p (gdbarch, regnum))
 212     return i386_byte_names[regnum - tdep->al_regnum];
 213   else if (i386_word_regnum_p (gdbarch, regnum))
 214     return i386_word_names[regnum - tdep->ax_regnum];
 215
 216   internal_error (__FILE__, __LINE__, _("invalid regnum"));
 217 }
 218
 219 /* Convert a dbx register number REG to the appropriate register
 220    number used by GDB.  */
 221
 222 static int
 223 i386_dbx_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 224 {
 225   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 226
 227   /* This implements what GCC calls the "default" register map
 228      (dbx_register_map[]).  */
 229
 230   if (reg >= 0 && reg <= 7)
 231     {
 232       /* General-purpose registers.  The debug info calls %ebp
 233          register 4, and %esp register 5.  */
 234       if (reg == 4)
 235         return 5;
 236       else if (reg == 5)
 237         return 4;
 238       else return reg;
 239     }
 240   else if (reg >= 12 && reg <= 19)
 241     {
 242       /* Floating-point registers.  */
 243       return reg - 12 + I387_ST0_REGNUM (tdep);
 244     }
 245   else if (reg >= 21 && reg <= 28)
 246     {
 247       /* SSE registers.  */
 248       return reg - 21 + I387_XMM0_REGNUM (tdep);
 249     }
 250   else if (reg >= 29 && reg <= 36)
 251     {
 252       /* MMX registers.  */
 253       return reg - 29 + I387_MM0_REGNUM (tdep);
 254     }
 255
 256   /* This will hopefully provoke a warning.  */
 257   return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 258 }
 259
 260 /* Convert SVR4 register number REG to the appropriate register number
 261    used by GDB.  */
 262
 263 static int
 264 i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 265 {
 266   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 267
 268   /* This implements the GCC register map that tries to be compatible
 269      with the SVR4 C compiler for DWARF (svr4_dbx_register_map[]).  */
 270
 271   /* The SVR4 register numbering includes %eip and %eflags, and
 272      numbers the floating point registers differently.  */
 273   if (reg >= 0 && reg <= 9)
 274     {
 275       /* General-purpose registers.  */
 276       return reg;
 277     }
 278   else if (reg >= 11 && reg <= 18)
 279     {
 280       /* Floating-point registers.  */
 281       return reg - 11 + I387_ST0_REGNUM (tdep);
 282     }
 283   else if (reg >= 21 && reg <= 36)
 284     {
 285       /* The SSE and MMX registers have the same numbers as with dbx.  */
 286       return i386_dbx_reg_to_regnum (gdbarch, reg);
 287     }
 288
 289   switch (reg)
 290     {
 291     case 37: return I387_FCTRL_REGNUM (tdep);
 292     case 38: return I387_FSTAT_REGNUM (tdep);
 293     case 39: return I387_MXCSR_REGNUM (tdep);
 294     case 40: return I386_ES_REGNUM;
 295     case 41: return I386_CS_REGNUM;
 296     case 42: return I386_SS_REGNUM;
 297     case 43: return I386_DS_REGNUM;
 298     case 44: return I386_FS_REGNUM;
 299     case 45: return I386_GS_REGNUM;
 300     }
 301
 302   /* This will hopefully provoke a warning.  */
 303   return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 304 }
 305
 306 \f
 307
 308 /* This is the variable that is set with "set disassembly-flavor", and
 309    its legitimate values.  */
 310 static const char att_flavor[] = "att";
 311 static const char intel_flavor[] = "intel";
 312 static const char *valid_flavors[] =
 313 {
 314   att_flavor,
 315   intel_flavor,
 316   NULL
 317 };
 318 static const char *disassembly_flavor = att_flavor;
 319 \f
 320
 321 /* Use the program counter to determine the contents and size of a
 322    breakpoint instruction.  Return a pointer to a string of bytes that
 323    encode a breakpoint instruction, store the length of the string in
 324    *LEN and optionally adjust *PC to point to the correct memory
 325    location for inserting the breakpoint.
 326
 327    On the i386 we have a single breakpoint that fits in a single byte
 328    and can be inserted anywhere.
 329
 330    This function is 64-bit safe.  */
 331
 332 static const gdb_byte *
 333 i386_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
 334 {
 335   static gdb_byte break_insn[] = { 0xcc }; /* int 3 */
 336
 337   *len = sizeof (break_insn);
 338   return break_insn;
 339 }
 340 \f
 341 /* Displaced instruction handling.  */
 342
 343 /* Skip the legacy instruction prefixes in INSN.
 344    Not all prefixes are valid for any particular insn
 345    but we needn't care, the insn will fault if it's invalid.
 346    The result is a pointer to the first opcode byte,
 347    or NULL if we run off the end of the buffer.  */
 348
 349 static gdb_byte *
 350 i386_skip_prefixes (gdb_byte *insn, size_t max_len)
 351 {
 352   gdb_byte *end = insn + max_len;
 353
 354   while (insn < end)
 355     {
 356       switch (*insn)
 357         {
 358         case DATA_PREFIX_OPCODE:
 359         case ADDR_PREFIX_OPCODE:
 360         case CS_PREFIX_OPCODE:
 361         case DS_PREFIX_OPCODE:
 362         case ES_PREFIX_OPCODE:
 363         case FS_PREFIX_OPCODE:
 364         case GS_PREFIX_OPCODE:
 365         case SS_PREFIX_OPCODE:
 366         case LOCK_PREFIX_OPCODE:
 367         case REPE_PREFIX_OPCODE:
 368         case REPNE_PREFIX_OPCODE:
 369           ++insn;
 370           continue;
 371         default:
 372           return insn;
 373         }
 374     }
 375
 376   return NULL;
 377 }
 378
 379 static int
 380 i386_absolute_jmp_p (const gdb_byte *insn)
 381 {
 382   /* jmp far (absolute address in operand) */
 383   if (insn[0] == 0xea)
 384     return 1;
 385
 386   if (insn[0] == 0xff)
 387     {
 388       /* jump near, absolute indirect (/4) */
 389       if ((insn[1] & 0x38) == 0x20)
 390         return 1;
 391
 392       /* jump far, absolute indirect (/5) */
 393       if ((insn[1] & 0x38) == 0x28)
 394         return 1;
 395     }
 396
 397   return 0;
 398 }
 399
 400 static int
 401 i386_absolute_call_p (const gdb_byte *insn)
 402 {
 403   /* call far, absolute */
 404   if (insn[0] == 0x9a)
 405     return 1;
 406
 407   if (insn[0] == 0xff)
 408     {
 409       /* Call near, absolute indirect (/2) */
 410       if ((insn[1] & 0x38) == 0x10)
 411         return 1;
 412
 413       /* Call far, absolute indirect (/3) */
 414       if ((insn[1] & 0x38) == 0x18)
 415         return 1;
 416     }
 417
 418   return 0;
 419 }
 420
 421 static int
 422 i386_ret_p (const gdb_byte *insn)
 423 {
 424   switch (insn[0])
 425     {
 426     case 0xc2: /* ret near, pop N bytes */
 427     case 0xc3: /* ret near */
 428     case 0xca: /* ret far, pop N bytes */
 429     case 0xcb: /* ret far */
 430     case 0xcf: /* iret */
 431       return 1;
 432
 433     default:
 434       return 0;
 435     }
 436 }
 437
 438 static int
 439 i386_call_p (const gdb_byte *insn)
 440 {
 441   if (i386_absolute_call_p (insn))
 442     return 1;
 443
 444   /* call near, relative */
 445   if (insn[0] == 0xe8)
 446     return 1;
 447
 448   return 0;
 449 }
 450
 451 /* Return non-zero if INSN is a system call, and set *LENGTHP to its
 452    length in bytes.  Otherwise, return zero.  */
 453
 454 static int
 455 i386_syscall_p (const gdb_byte *insn, ULONGEST *lengthp)
 456 {
 457   if (insn[0] == 0xcd)
 458     {
 459       *lengthp = 2;
 460       return 1;
 461     }
 462
 463   return 0;
 464 }
 465
 466 /* Fix up the state of registers and memory after having single-stepped
 467    a displaced instruction.  */
 468
 469 void
 470 i386_displaced_step_fixup (struct gdbarch *gdbarch,
 471                            struct displaced_step_closure *closure,
 472                            CORE_ADDR from, CORE_ADDR to,
 473                            struct regcache *regs)
 474 {
 475   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 476
 477   /* The offset we applied to the instruction's address.
 478      This could well be negative (when viewed as a signed 32-bit
 479      value), but ULONGEST won't reflect that, so take care when
 480      applying it.  */
 481   ULONGEST insn_offset = to - from;
 482
 483   /* Since we use simple_displaced_step_copy_insn, our closure is a
 484      copy of the instruction.  */
 485   gdb_byte *insn = (gdb_byte *) closure;
 486   /* The start of the insn, needed in case we see some prefixes.  */
 487   gdb_byte *insn_start = insn;
 488
 489   if (debug_displaced)
 490     fprintf_unfiltered (gdb_stdlog,
 491                         "displaced: fixup (%s, %s), "
 492                         "insn = 0x%02x 0x%02x ...\n",
 493                         paddress (gdbarch, from), paddress (gdbarch, to),
 494                         insn[0], insn[1]);
 495
 496   /* The list of issues to contend with here is taken from
 497      resume_execution in arch/i386/kernel/kprobes.c, Linux 2.6.20.
 498      Yay for Free Software!  */
 499
 500   /* Relocate the %eip, if necessary.  */
 501
 502   /* The instruction recognizers we use assume any leading prefixes
 503      have been skipped.  */
 504   {
 505     /* This is the size of the buffer in closure.  */
 506     size_t max_insn_len = gdbarch_max_insn_length (gdbarch);
 507     gdb_byte *opcode = i386_skip_prefixes (insn, max_insn_len);
 508     /* If there are too many prefixes, just ignore the insn.
 509        It will fault when run.  */
 510     if (opcode != NULL)
 511       insn = opcode;
 512   }
 513
 514   /* Except in the case of absolute or indirect jump or call
 515      instructions, or a return instruction, the new eip is relative to
 516      the displaced instruction; make it relative.  Well, signal
 517      handler returns don't need relocation either, but we use the
 518      value of %eip to recognize those; see below.  */
 519   if (! i386_absolute_jmp_p (insn)
 520       && ! i386_absolute_call_p (insn)
 521       && ! i386_ret_p (insn))
 522     {
 523       ULONGEST orig_eip;
 524       ULONGEST insn_len;
 525
 526       regcache_cooked_read_unsigned (regs, I386_EIP_REGNUM, &orig_eip);
 527
 528       /* A signal trampoline system call changes the %eip, resuming
 529          execution of the main program after the signal handler has
 530          returned.  That makes them like 'return' instructions; we
 531          shouldn't relocate %eip.
 532
 533          But most system calls don't, and we do need to relocate %eip.
 534
 535          Our heuristic for distinguishing these cases: if stepping
 536          over the system call instruction left control directly after
 537          the instruction, the we relocate --- control almost certainly
 538          doesn't belong in the displaced copy.  Otherwise, we assume
 539          the instruction has put control where it belongs, and leave
 540          it unrelocated.  Goodness help us if there are PC-relative
 541          system calls.  */
 542       if (i386_syscall_p (insn, &insn_len)
 543           && orig_eip != to + (insn - insn_start) + insn_len)
 544         {
 545           if (debug_displaced)
 546             fprintf_unfiltered (gdb_stdlog,
 547                                 "displaced: syscall changed %%eip; "
 548                                 "not relocating\n");
 549         }
 550       else
 551         {
 552           ULONGEST eip = (orig_eip - insn_offset) & 0xffffffffUL;
 553
 554           /* If we just stepped over a breakpoint insn, we don't backup
 555              the pc on purpose; this is to match behaviour without
 556              stepping.  */
 557
 558           regcache_cooked_write_unsigned (regs, I386_EIP_REGNUM, eip);
 559
 560           if (debug_displaced)
 561             fprintf_unfiltered (gdb_stdlog,
 562                                 "displaced: "
 563                                 "relocated %%eip from %s to %s\n",
 564                                 paddress (gdbarch, orig_eip),
 565                                 paddress (gdbarch, eip));
 566         }
 567     }
 568
 569   /* If the instruction was PUSHFL, then the TF bit will be set in the
 570      pushed value, and should be cleared.  We'll leave this for later,
 571      since GDB already messes up the TF flag when stepping over a
 572      pushfl.  */
 573
 574   /* If the instruction was a call, the return address now atop the
 575      stack is the address following the copied instruction.  We need
 576      to make it the address following the original instruction.  */
 577   if (i386_call_p (insn))
 578     {
 579       ULONGEST esp;
 580       ULONGEST retaddr;
 581       const ULONGEST retaddr_len = 4;
 582
 583       regcache_cooked_read_unsigned (regs, I386_ESP_REGNUM, &esp);
 584       retaddr = read_memory_unsigned_integer (esp, retaddr_len, byte_order);
 585       retaddr = (retaddr - insn_offset) & 0xffffffffUL;
 586       write_memory_unsigned_integer (esp, retaddr_len, byte_order, retaddr);
 587
 588       if (debug_displaced)
 589         fprintf_unfiltered (gdb_stdlog,
 590                             "displaced: relocated return addr at %s to %s\n",
 591                             paddress (gdbarch, esp),
 592                             paddress (gdbarch, retaddr));
 593     }
 594 }
 595 \f
 596 #ifdef I386_REGNO_TO_SYMMETRY
 597 #error "The Sequent Symmetry is no longer supported."
 598 #endif
 599
 600 /* According to the System V ABI, the registers %ebp, %ebx, %edi, %esi
 601    and %esp "belong" to the calling function.  Therefore these
 602    registers should be saved if they're going to be modified.  */
 603
 604 /* The maximum number of saved registers.  This should include all
 605    registers mentioned above, and %eip.  */
 606 #define I386_NUM_SAVED_REGS     I386_NUM_GREGS
 607
 608 struct i386_frame_cache
 609 {
 610   /* Base address.  */
 611   CORE_ADDR base;
 612   LONGEST sp_offset;
 613   CORE_ADDR pc;
 614
 615   /* Saved registers.  */
 616   CORE_ADDR saved_regs[I386_NUM_SAVED_REGS];
 617   CORE_ADDR saved_sp;
 618   int saved_sp_reg;
 619   int pc_in_eax;
 620
 621   /* Stack space reserved for local variables.  */
 622   long locals;
 623 };
 624
 625 /* Allocate and initialize a frame cache.  */
 626
 627 static struct i386_frame_cache *
 628 i386_alloc_frame_cache (void)
 629 {
 630   struct i386_frame_cache *cache;
 631   int i;
 632
 633   cache = FRAME_OBSTACK_ZALLOC (struct i386_frame_cache);
 634
 635   /* Base address.  */
 636   cache->base = 0;
 637   cache->sp_offset = -4;
 638   cache->pc = 0;
 639
 640   /* Saved registers.  We initialize these to -1 since zero is a valid
 641      offset (that's where %ebp is supposed to be stored).  */
 642   for (i = 0; i < I386_NUM_SAVED_REGS; i++)
 643     cache->saved_regs[i] = -1;
 644   cache->saved_sp = 0;
 645   cache->saved_sp_reg = -1;
 646   cache->pc_in_eax = 0;
 647
 648   /* Frameless until proven otherwise.  */
 649   cache->locals = -1;
 650
 651   return cache;
 652 }
 653
 654 /* If the instruction at PC is a jump, return the address of its
 655    target.  Otherwise, return PC.  */
 656
 657 static CORE_ADDR
 658 i386_follow_jump (struct gdbarch *gdbarch, CORE_ADDR pc)
 659 {
 660   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 661   gdb_byte op;
 662   long delta = 0;
 663   int data16 = 0;
 664
 665   target_read_memory (pc, &op, 1);
 666   if (op == 0x66)
 667     {
 668       data16 = 1;
 669       op = read_memory_unsigned_integer (pc + 1, 1, byte_order);
 670     }
 671
 672   switch (op)
 673     {
 674     case 0xe9:
 675       /* Relative jump: if data16 == 0, disp32, else disp16.  */
 676       if (data16)
 677         {
 678           delta = read_memory_integer (pc + 2, 2, byte_order);
 679
 680           /* Include the size of the jmp instruction (including the
 681              0x66 prefix).  */
 682           delta += 4;
 683         }
 684       else
 685         {
 686           delta = read_memory_integer (pc + 1, 4, byte_order);
 687
 688           /* Include the size of the jmp instruction.  */
 689           delta += 5;
 690         }
 691       break;
 692     case 0xeb:
 693       /* Relative jump, disp8 (ignore data16).  */
 694       delta = read_memory_integer (pc + data16 + 1, 1, byte_order);
 695
 696       delta += data16 + 2;
 697       break;
 698     }
 699
 700   return pc + delta;
 701 }
 702
 703 /* Check whether PC points at a prologue for a function returning a
 704    structure or union.  If so, it updates CACHE and returns the
 705    address of the first instruction after the code sequence that
 706    removes the "hidden" argument from the stack or CURRENT_PC,
 707    whichever is smaller.  Otherwise, return PC.  */
 708
 709 static CORE_ADDR
 710 i386_analyze_struct_return (CORE_ADDR pc, CORE_ADDR current_pc,
 711                             struct i386_frame_cache *cache)
 712 {
 713   /* Functions that return a structure or union start with:
 714
 715         popl %eax             0x58
 716         xchgl %eax, (%esp)    0x87 0x04 0x24
 717      or xchgl %eax, 0(%esp)   0x87 0x44 0x24 0x00
 718
 719      (the System V compiler puts out the second `xchg' instruction,
 720      and the assembler doesn't try to optimize it, so the 'sib' form
 721      gets generated).  This sequence is used to get the address of the
 722      return buffer for a function that returns a structure.  */
 723   static gdb_byte proto1[3] = { 0x87, 0x04, 0x24 };
 724   static gdb_byte proto2[4] = { 0x87, 0x44, 0x24, 0x00 };
 725   gdb_byte buf[4];
 726   gdb_byte op;
 727
 728   if (current_pc <= pc)
 729     return pc;
 730
 731   target_read_memory (pc, &op, 1);
 732
 733   if (op != 0x58)               /* popl %eax */
 734     return pc;
 735
 736   target_read_memory (pc + 1, buf, 4);
 737   if (memcmp (buf, proto1, 3) != 0 && memcmp (buf, proto2, 4) != 0)
 738     return pc;
 739
 740   if (current_pc == pc)
 741     {
 742       cache->sp_offset += 4;
 743       return current_pc;
 744     }
 745
 746   if (current_pc == pc + 1)
 747     {
 748       cache->pc_in_eax = 1;
 749       return current_pc;
 750     }
 751
 752   if (buf[1] == proto1[1])
 753     return pc + 4;
 754   else
 755     return pc + 5;
 756 }
 757
 758 static CORE_ADDR
 759 i386_skip_probe (CORE_ADDR pc)
 760 {
 761   /* A function may start with
 762
 763         pushl constant
 764         call _probe
 765         addl $4, %esp
 766
 767      followed by
 768
 769         pushl %ebp
 770
 771      etc.  */
 772   gdb_byte buf[8];
 773   gdb_byte op;
 774
 775   target_read_memory (pc, &op, 1);
 776
 777   if (op == 0x68 || op == 0x6a)
 778     {
 779       int delta;
 780
 781       /* Skip past the `pushl' instruction; it has either a one-byte or a
 782          four-byte operand, depending on the opcode.  */
 783       if (op == 0x68)
 784         delta = 5;
 785       else
 786         delta = 2;
 787
 788       /* Read the following 8 bytes, which should be `call _probe' (6
 789          bytes) followed by `addl $4,%esp' (2 bytes).  */
 790       read_memory (pc + delta, buf, sizeof (buf));
 791       if (buf[0] == 0xe8 && buf[6] == 0xc4 && buf[7] == 0x4)
 792         pc += delta + sizeof (buf);
 793     }
 794
 795   return pc;
 796 }
 797
 798 /* GCC 4.1 and later, can put code in the prologue to realign the
 799    stack pointer.  Check whether PC points to such code, and update
 800    CACHE accordingly.  Return the first instruction after the code
 801    sequence or CURRENT_PC, whichever is smaller.  If we don't
 802    recognize the code, return PC.  */
 803
 804 static CORE_ADDR
 805 i386_analyze_stack_align (CORE_ADDR pc, CORE_ADDR current_pc,
 806                           struct i386_frame_cache *cache)
 807 {
 808   /* There are 2 code sequences to re-align stack before the frame
 809      gets set up:
 810
 811         1. Use a caller-saved saved register:
 812
 813                 leal  4(%esp), %reg
 814                 andl  $-XXX, %esp
 815                 pushl -4(%reg)
 816
 817         2. Use a callee-saved saved register:
 818
 819                 pushl %reg
 820                 leal  8(%esp), %reg
 821                 andl  $-XXX, %esp
 822                 pushl -4(%reg)
 823
 824      "andl $-XXX, %esp" can be either 3 bytes or 6 bytes:
 825
 826         0x83 0xe4 0xf0                  andl $-16, %esp
 827         0x81 0xe4 0x00 0xff 0xff 0xff   andl $-256, %esp
 828    */
 829
 830   gdb_byte buf[14];
 831   int reg;
 832   int offset, offset_and;
 833   static int regnums[8] = {
 834     I386_EAX_REGNUM,            /* %eax */
 835     I386_ECX_REGNUM,            /* %ecx */
 836     I386_EDX_REGNUM,            /* %edx */
 837     I386_EBX_REGNUM,            /* %ebx */
 838     I386_ESP_REGNUM,            /* %esp */
 839     I386_EBP_REGNUM,            /* %ebp */
 840     I386_ESI_REGNUM,            /* %esi */
 841     I386_EDI_REGNUM             /* %edi */
 842   };
 843
 844   if (target_read_memory (pc, buf, sizeof buf))
 845     return pc;
 846
 847   /* Check caller-saved saved register.  The first instruction has
 848      to be "leal 4(%esp), %reg".  */
 849   if (buf[0] == 0x8d && buf[2] == 0x24 && buf[3] == 0x4)
 850     {
 851       /* MOD must be binary 10 and R/M must be binary 100.  */
 852       if ((buf[1] & 0xc7) != 0x44)
 853         return pc;
 854
 855       /* REG has register number.  */
 856       reg = (buf[1] >> 3) & 7;
 857       offset = 4;
 858     }
 859   else
 860     {
 861       /* Check callee-saved saved register.  The first instruction
 862          has to be "pushl %reg".  */
 863       if ((buf[0] & 0xf8) != 0x50)
 864         return pc;
 865
 866       /* Get register.  */
 867       reg = buf[0] & 0x7;
 868
 869       /* The next instruction has to be "leal 8(%esp), %reg".  */
 870       if (buf[1] != 0x8d || buf[3] != 0x24 || buf[4] != 0x8)
 871         return pc;
 872
 873       /* MOD must be binary 10 and R/M must be binary 100.  */
 874       if ((buf[2] & 0xc7) != 0x44)
 875         return pc;
 876
 877       /* REG has register number.  Registers in pushl and leal have to
 878          be the same.  */
 879       if (reg != ((buf[2] >> 3) & 7))
 880         return pc;
 881
 882       offset = 5;
 883     }
 884
 885   /* Rigister can't be %esp nor %ebp.  */
 886   if (reg == 4 || reg == 5)
 887     return pc;
 888
 889   /* The next instruction has to be "andl $-XXX, %esp".  */
 890   if (buf[offset + 1] != 0xe4
 891       || (buf[offset] != 0x81 && buf[offset] != 0x83))
 892     return pc;
 893
 894   offset_and = offset;
 895   offset += buf[offset] == 0x81 ? 6 : 3;
 896
 897   /* The next instruction has to be "pushl -4(%reg)".  8bit -4 is
 898      0xfc.  REG must be binary 110 and MOD must be binary 01.  */
 899   if (buf[offset] != 0xff
 900       || buf[offset + 2] != 0xfc
 901       || (buf[offset + 1] & 0xf8) != 0x70)
 902     return pc;
 903
 904   /* R/M has register.  Registers in leal and pushl have to be the
 905      same.  */
 906   if (reg != (buf[offset + 1] & 7))
 907     return pc;
 908
 909   if (current_pc > pc + offset_and)
 910     cache->saved_sp_reg = regnums[reg];
 911
 912   return min (pc + offset + 3, current_pc);
 913 }
 914
 915 /* Maximum instruction length we need to handle.  */
 916 #define I386_MAX_MATCHED_INSN_LEN       6
 917
 918 /* Instruction description.  */
 919 struct i386_insn
 920 {
 921   size_t len;
 922   gdb_byte insn[I386_MAX_MATCHED_INSN_LEN];
 923   gdb_byte mask[I386_MAX_MATCHED_INSN_LEN];
 924 };
 925
 926 /* Search for the instruction at PC in the list SKIP_INSNS.  Return
 927    the first instruction description that matches.  Otherwise, return
 928    NULL.  */
 929
 930 static struct i386_insn *
 931 i386_match_insn (CORE_ADDR pc, struct i386_insn *skip_insns)
 932 {
 933   struct i386_insn *insn;
 934   gdb_byte op;
 935
 936   target_read_memory (pc, &op, 1);
 937
 938   for (insn = skip_insns; insn->len > 0; insn++)
 939     {
 940       if ((op & insn->mask[0]) == insn->insn[0])
 941         {
 942           gdb_byte buf[I386_MAX_MATCHED_INSN_LEN - 1];
 943           int insn_matched = 1;
 944           size_t i;
 945
 946           gdb_assert (insn->len > 1);
 947           gdb_assert (insn->len <= I386_MAX_MATCHED_INSN_LEN);
 948
 949           target_read_memory (pc + 1, buf, insn->len - 1);
 950           for (i = 1; i < insn->len; i++)
 951             {
 952               if ((buf[i - 1] & insn->mask[i]) != insn->insn[i])
 953                 insn_matched = 0;
 954             }
 955
 956           if (insn_matched)
 957             return insn;
 958         }
 959     }
 960
 961   return NULL;
 962 }
 963
 964 /* Some special instructions that might be migrated by GCC into the
 965    part of the prologue that sets up the new stack frame.  Because the
 966    stack frame hasn't been setup yet, no registers have been saved
 967    yet, and only the scratch registers %eax, %ecx and %edx can be
 968    touched.  */
 969
 970 struct i386_insn i386_frame_setup_skip_insns[] =
 971 {
 972   /* Check for `movb imm8, r' and `movl imm32, r'.
 973
 974      ??? Should we handle 16-bit operand-sizes here?  */
 975
 976   /* `movb imm8, %al' and `movb imm8, %ah' */
 977   /* `movb imm8, %cl' and `movb imm8, %ch' */
 978   { 2, { 0xb0, 0x00 }, { 0xfa, 0x00 } },
 979   /* `movb imm8, %dl' and `movb imm8, %dh' */
 980   { 2, { 0xb2, 0x00 }, { 0xfb, 0x00 } },
 981   /* `movl imm32, %eax' and `movl imm32, %ecx' */
 982   { 5, { 0xb8 }, { 0xfe } },
 983   /* `movl imm32, %edx' */
 984   { 5, { 0xba }, { 0xff } },
 985
 986   /* Check for `mov imm32, r32'.  Note that there is an alternative
 987      encoding for `mov m32, %eax'.
 988
 989      ??? Should we handle SIB adressing here?
 990      ??? Should we handle 16-bit operand-sizes here?  */
 991
 992   /* `movl m32, %eax' */
 993   { 5, { 0xa1 }, { 0xff } },
 994   /* `movl m32, %eax' and `mov; m32, %ecx' */
 995   { 6, { 0x89, 0x05 }, {0xff, 0xf7 } },
 996   /* `movl m32, %edx' */
 997   { 6, { 0x89, 0x15 }, {0xff, 0xff } },
 998
 999   /* Check for `xorl r32, r32' and the equivalent `subl r32, r32'.
1000      Because of the symmetry, there are actually two ways to encode
1001      these instructions; opcode bytes 0x29 and 0x2b for `subl' and
1002      opcode bytes 0x31 and 0x33 for `xorl'.  */
1003
1004   /* `subl %eax, %eax' */
1005   { 2, { 0x29, 0xc0 }, { 0xfd, 0xff } },
1006   /* `subl %ecx, %ecx' */
1007   { 2, { 0x29, 0xc9 }, { 0xfd, 0xff } },
1008   /* `subl %edx, %edx' */
1009   { 2, { 0x29, 0xd2 }, { 0xfd, 0xff } },
1010   /* `xorl %eax, %eax' */
1011   { 2, { 0x31, 0xc0 }, { 0xfd, 0xff } },
1012   /* `xorl %ecx, %ecx' */
1013   { 2, { 0x31, 0xc9 }, { 0xfd, 0xff } },
1014   /* `xorl %edx, %edx' */
1015   { 2, { 0x31, 0xd2 }, { 0xfd, 0xff } },
1016   { 0 }
1017 };
1018
1019
1020 /* Check whether PC points to a no-op instruction.  */
1021 static CORE_ADDR
1022 i386_skip_noop (CORE_ADDR pc)
1023 {
1024   gdb_byte op;
1025   int check = 1;
1026
1027   target_read_memory (pc, &op, 1);
1028
1029   while (check)
1030     {
1031       check = 0;
1032       /* Ignore `nop' instruction.  */
1033       if (op == 0x90)
1034         {
1035           pc += 1;
1036           target_read_memory (pc, &op, 1);
1037           check = 1;
1038         }
1039       /* Ignore no-op instruction `mov %edi, %edi'.
1040          Microsoft system dlls often start with
1041          a `mov %edi,%edi' instruction.
1042          The 5 bytes before the function start are
1043          filled with `nop' instructions.
1044          This pattern can be used for hot-patching:
1045          The `mov %edi, %edi' instruction can be replaced by a
1046          near jump to the location of the 5 `nop' instructions
1047          which can be replaced by a 32-bit jump to anywhere
1048          in the 32-bit address space.  */
1049
1050       else if (op == 0x8b)
1051         {
1052           target_read_memory (pc + 1, &op, 1);
1053           if (op == 0xff)
1054             {
1055               pc += 2;
1056               target_read_memory (pc, &op, 1);
1057               check = 1;
1058             }
1059         }
1060     }
1061   return pc;
1062 }
1063
1064 /* Check whether PC points at a code that sets up a new stack frame.
1065    If so, it updates CACHE and returns the address of the first
1066    instruction after the sequence that sets up the frame or LIMIT,
1067    whichever is smaller.  If we don't recognize the code, return PC.  */
1068
1069 static CORE_ADDR
1070 i386_analyze_frame_setup (struct gdbarch *gdbarch,
1071                           CORE_ADDR pc, CORE_ADDR limit,
1072                           struct i386_frame_cache *cache)
1073 {
1074   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1075   struct i386_insn *insn;
1076   gdb_byte op;
1077   int skip = 0;
1078
1079   if (limit <= pc)
1080     return limit;
1081
1082   target_read_memory (pc, &op, 1);
1083
1084   if (op == 0x55)               /* pushl %ebp */
1085     {
1086       /* Take into account that we've executed the `pushl %ebp' that
1087          starts this instruction sequence.  */
1088       cache->saved_regs[I386_EBP_REGNUM] = 0;
1089       cache->sp_offset += 4;
1090       pc++;
1091
1092       /* If that's all, return now.  */
1093       if (limit <= pc)
1094         return limit;
1095
1096       /* Check for some special instructions that might be migrated by
1097          GCC into the prologue and skip them.  At this point in the
1098          prologue, code should only touch the scratch registers %eax,
1099          %ecx and %edx, so while the number of posibilities is sheer,
1100          it is limited.
1101
1102          Make sure we only skip these instructions if we later see the
1103          `movl %esp, %ebp' that actually sets up the frame.  */
1104       while (pc + skip < limit)
1105         {
1106           insn = i386_match_insn (pc + skip, i386_frame_setup_skip_insns);
1107           if (insn == NULL)
1108             break;
1109
1110           skip += insn->len;
1111         }
1112
1113       /* If that's all, return now.  */
1114       if (limit <= pc + skip)
1115         return limit;
1116
1117       target_read_memory (pc + skip, &op, 1);
1118
1119       /* Check for `movl %esp, %ebp' -- can be written in two ways.  */
1120       switch (op)
1121         {
1122         case 0x8b:
1123           if (read_memory_unsigned_integer (pc + skip + 1, 1, byte_order)
1124               != 0xec)
1125             return pc;
1126           break;
1127         case 0x89:
1128           if (read_memory_unsigned_integer (pc + skip + 1, 1, byte_order)
1129               != 0xe5)
1130             return pc;
1131           break;
1132         default:
1133           return pc;
1134         }
1135
1136       /* OK, we actually have a frame.  We just don't know how large
1137          it is yet.  Set its size to zero.  We'll adjust it if
1138          necessary.  We also now commit to skipping the special
1139          instructions mentioned before.  */
1140       cache->locals = 0;
1141       pc += (skip + 2);
1142
1143       /* If that's all, return now.  */
1144       if (limit <= pc)
1145         return limit;
1146
1147       /* Check for stack adjustment
1148
1149             subl $XXX, %esp
1150
1151          NOTE: You can't subtract a 16-bit immediate from a 32-bit
1152          reg, so we don't have to worry about a data16 prefix.  */
1153       target_read_memory (pc, &op, 1);
1154       if (op == 0x83)
1155         {
1156           /* `subl' with 8-bit immediate.  */
1157           if (read_memory_unsigned_integer (pc + 1, 1, byte_order) != 0xec)
1158             /* Some instruction starting with 0x83 other than `subl'.  */
1159             return pc;
1160
1161           /* `subl' with signed 8-bit immediate (though it wouldn't
1162              make sense to be negative).  */
1163           cache->locals = read_memory_integer (pc + 2, 1, byte_order);
1164           return pc + 3;
1165         }
1166       else if (op == 0x81)
1167         {
1168           /* Maybe it is `subl' with a 32-bit immediate.  */
1169           if (read_memory_unsigned_integer (pc + 1, 1, byte_order) != 0xec)
1170             /* Some instruction starting with 0x81 other than `subl'.  */
1171             return pc;
1172
1173           /* It is `subl' with a 32-bit immediate.  */
1174           cache->locals = read_memory_integer (pc + 2, 4, byte_order);
1175           return pc + 6;
1176         }
1177       else
1178         {
1179           /* Some instruction other than `subl'.  */
1180           return pc;
1181         }
1182     }
1183   else if (op == 0xc8)          /* enter */
1184     {
1185       cache->locals = read_memory_unsigned_integer (pc + 1, 2, byte_order);
1186       return pc + 4;
1187     }
1188
1189   return pc;
1190 }
1191
1192 /* Check whether PC points at code that saves registers on the stack.
1193    If so, it updates CACHE and returns the address of the first
1194    instruction after the register saves or CURRENT_PC, whichever is
1195    smaller.  Otherwise, return PC.  */
1196
1197 static CORE_ADDR
1198 i386_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
1199                              struct i386_frame_cache *cache)
1200 {
1201   CORE_ADDR offset = 0;
1202   gdb_byte op;
1203   int i;
1204
1205   if (cache->locals > 0)
1206     offset -= cache->locals;
1207   for (i = 0; i < 8 && pc < current_pc; i++)
1208     {
1209       target_read_memory (pc, &op, 1);
1210       if (op < 0x50 || op > 0x57)
1211         break;
1212
1213       offset -= 4;
1214       cache->saved_regs[op - 0x50] = offset;
1215       cache->sp_offset += 4;
1216       pc++;
1217     }
1218
1219   return pc;
1220 }
1221
1222 /* Do a full analysis of the prologue at PC and update CACHE
1223    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
1224    address where the analysis stopped.
1225
1226    We handle these cases:
1227
1228    The startup sequence can be at the start of the function, or the
1229    function can start with a branch to startup code at the end.
1230
1231    %ebp can be set up with either the 'enter' instruction, or "pushl
1232    %ebp, movl %esp, %ebp" (`enter' is too slow to be useful, but was
1233    once used in the System V compiler).
1234
1235    Local space is allocated just below the saved %ebp by either the
1236    'enter' instruction, or by "subl $<size>, %esp".  'enter' has a
1237    16-bit unsigned argument for space to allocate, and the 'addl'
1238    instruction could have either a signed byte, or 32-bit immediate.
1239
1240    Next, the registers used by this function are pushed.  With the
1241    System V compiler they will always be in the order: %edi, %esi,
1242    %ebx (and sometimes a harmless bug causes it to also save but not
1243    restore %eax); however, the code below is willing to see the pushes
1244    in any order, and will handle up to 8 of them.
1245
1246    If the setup sequence is at the end of the function, then the next
1247    instruction will be a branch back to the start.  */
1248
1249 static CORE_ADDR
1250 i386_analyze_prologue (struct gdbarch *gdbarch,
1251                        CORE_ADDR pc, CORE_ADDR current_pc,
1252                        struct i386_frame_cache *cache)
1253 {
1254   pc = i386_skip_noop (pc);
1255   pc = i386_follow_jump (gdbarch, pc);
1256   pc = i386_analyze_struct_return (pc, current_pc, cache);
1257   pc = i386_skip_probe (pc);
1258   pc = i386_analyze_stack_align (pc, current_pc, cache);
1259   pc = i386_analyze_frame_setup (gdbarch, pc, current_pc, cache);
1260   return i386_analyze_register_saves (pc, current_pc, cache);
1261 }
1262
1263 /* Return PC of first real instruction.  */
1264
1265 static CORE_ADDR
1266 i386_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
1267 {
1268   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1269
1270   static gdb_byte pic_pat[6] =
1271   {
1272     0xe8, 0, 0, 0, 0,           /* call 0x0 */
1273     0x5b,                       /* popl %ebx */
1274   };
1275   struct i386_frame_cache cache;
1276   CORE_ADDR pc;
1277   gdb_byte op;
1278   int i;
1279
1280   cache.locals = -1;
1281   pc = i386_analyze_prologue (gdbarch, start_pc, 0xffffffff, &cache);
1282   if (cache.locals < 0)
1283     return start_pc;
1284
1285   /* Found valid frame setup.  */
1286
1287   /* The native cc on SVR4 in -K PIC mode inserts the following code
1288      to get the address of the global offset table (GOT) into register
1289      %ebx:
1290
1291         call    0x0
1292         popl    %ebx
1293         movl    %ebx,x(%ebp)    (optional)
1294         addl    y,%ebx
1295
1296      This code is with the rest of the prologue (at the end of the
1297      function), so we have to skip it to get to the first real
1298      instruction at the start of the function.  */
1299
1300   for (i = 0; i < 6; i++)
1301     {
1302       target_read_memory (pc + i, &op, 1);
1303       if (pic_pat[i] != op)
1304         break;
1305     }
1306   if (i == 6)
1307     {
1308       int delta = 6;
1309
1310       target_read_memory (pc + delta, &op, 1);
1311
1312       if (op == 0x89)           /* movl %ebx, x(%ebp) */
1313         {
1314           op = read_memory_unsigned_integer (pc + delta + 1, 1, byte_order);
1315
1316           if (op == 0x5d)       /* One byte offset from %ebp.  */
1317             delta += 3;
1318           else if (op == 0x9d)  /* Four byte offset from %ebp.  */
1319             delta += 6;
1320           else                  /* Unexpected instruction.  */
1321             delta = 0;
1322
1323           target_read_memory (pc + delta, &op, 1);
1324         }
1325
1326       /* addl y,%ebx */
1327       if (delta > 0 && op == 0x81
1328           && read_memory_unsigned_integer (pc + delta + 1, 1, byte_order)
1329              == 0xc3)
1330         {
1331           pc += delta + 6;
1332         }
1333     }
1334
1335   /* If the function starts with a branch (to startup code at the end)
1336      the last instruction should bring us back to the first
1337      instruction of the real code.  */
1338   if (i386_follow_jump (gdbarch, start_pc) != start_pc)
1339     pc = i386_follow_jump (gdbarch, pc);
1340
1341   return pc;
1342 }
1343
1344 /* Check that the code pointed to by PC corresponds to a call to
1345    __main, skip it if so.  Return PC otherwise.  */
1346
1347 CORE_ADDR
1348 i386_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1349 {
1350   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1351   gdb_byte op;
1352
1353   target_read_memory (pc, &op, 1);
1354   if (op == 0xe8)
1355     {
1356       gdb_byte buf[4];
1357
1358       if (target_read_memory (pc + 1, buf, sizeof buf) == 0)
1359         {
1360           /* Make sure address is computed correctly as a 32bit
1361              integer even if CORE_ADDR is 64 bit wide.  */
1362           struct minimal_symbol *s;
1363           CORE_ADDR call_dest;
1364
1365           call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
1366           call_dest = call_dest & 0xffffffffU;
1367           s = lookup_minimal_symbol_by_pc (call_dest);
1368           if (s != NULL
1369               && SYMBOL_LINKAGE_NAME (s) != NULL
1370               && strcmp (SYMBOL_LINKAGE_NAME (s), "__main") == 0)
1371             pc += 5;
1372         }
1373     }
1374
1375   return pc;
1376 }
1377
1378 /* This function is 64-bit safe.  */
1379
1380 static CORE_ADDR
1381 i386_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1382 {
1383   gdb_byte buf[8];
1384
1385   frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
1386   return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
1387 }
1388 \f
1389
1390 /* Normal frames.  */
1391
1392 static struct i386_frame_cache *
1393 i386_frame_cache (struct frame_info *this_frame, void **this_cache)
1394 {
1395   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1396   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1397   struct i386_frame_cache *cache;
1398   gdb_byte buf[4];
1399   int i;
1400
1401   if (*this_cache)
1402     return *this_cache;
1403
1404   cache = i386_alloc_frame_cache ();
1405   *this_cache = cache;
1406
1407   /* In principle, for normal frames, %ebp holds the frame pointer,
1408      which holds the base address for the current stack frame.
1409      However, for functions that don't need it, the frame pointer is
1410      optional.  For these "frameless" functions the frame pointer is
1411      actually the frame pointer of the calling frame.  Signal
1412      trampolines are just a special case of a "frameless" function.
1413      They (usually) share their frame pointer with the frame that was
1414      in progress when the signal occurred.  */
1415
1416   get_frame_register (this_frame, I386_EBP_REGNUM, buf);
1417   cache->base = extract_unsigned_integer (buf, 4, byte_order);
1418   if (cache->base == 0)
1419     return cache;
1420
1421   /* For normal frames, %eip is stored at 4(%ebp).  */
1422   cache->saved_regs[I386_EIP_REGNUM] = 4;
1423
1424   cache->pc = get_frame_func (this_frame);
1425   if (cache->pc != 0)
1426     i386_analyze_prologue (gdbarch, cache->pc, get_frame_pc (this_frame),
1427                            cache);
1428
1429   if (cache->saved_sp_reg != -1)
1430     {
1431       /* Saved stack pointer has been saved.  */
1432       get_frame_register (this_frame, cache->saved_sp_reg, buf);
1433       cache->saved_sp = extract_unsigned_integer (buf, 4, byte_order);
1434     }
1435
1436   if (cache->locals < 0)
1437     {
1438       /* We didn't find a valid frame, which means that CACHE->base
1439          currently holds the frame pointer for our calling frame.  If
1440          we're at the start of a function, or somewhere half-way its
1441          prologue, the function's frame probably hasn't been fully
1442          setup yet.  Try to reconstruct the base address for the stack
1443          frame by looking at the stack pointer.  For truly "frameless"
1444          functions this might work too.  */
1445
1446       if (cache->saved_sp_reg != -1)
1447         {
1448           /* We're halfway aligning the stack.  */
1449           cache->base = ((cache->saved_sp - 4) & 0xfffffff0) - 4;
1450           cache->saved_regs[I386_EIP_REGNUM] = cache->saved_sp - 4;
1451
1452           /* This will be added back below.  */
1453           cache->saved_regs[I386_EIP_REGNUM] -= cache->base;
1454         }
1455       else if (cache->pc != 0
1456                || target_read_memory (get_frame_pc (this_frame), buf, 1))
1457         {
1458           /* We're in a known function, but did not find a frame
1459              setup.  Assume that the function does not use %ebp.
1460              Alternatively, we may have jumped to an invalid
1461              address; in that case there is definitely no new
1462              frame in %ebp.  */
1463           get_frame_register (this_frame, I386_ESP_REGNUM, buf);
1464           cache->base = extract_unsigned_integer (buf, 4, byte_order)
1465                         + cache->sp_offset;
1466         }
1467       else
1468         /* We're in an unknown function.  We could not find the start
1469            of the function to analyze the prologue; our best option is
1470            to assume a typical frame layout with the caller's %ebp
1471            saved.  */
1472         cache->saved_regs[I386_EBP_REGNUM] = 0;
1473     }
1474
1475   /* Now that we have the base address for the stack frame we can
1476      calculate the value of %esp in the calling frame.  */
1477   if (cache->saved_sp == 0)
1478     cache->saved_sp = cache->base + 8;
1479
1480   /* Adjust all the saved registers such that they contain addresses
1481      instead of offsets.  */
1482   for (i = 0; i < I386_NUM_SAVED_REGS; i++)
1483     if (cache->saved_regs[i] != -1)
1484       cache->saved_regs[i] += cache->base;
1485
1486   return cache;
1487 }
1488
1489 static void
1490 i386_frame_this_id (struct frame_info *this_frame, void **this_cache,
1491                     struct frame_id *this_id)
1492 {
1493   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
1494
1495   /* This marks the outermost frame.  */
1496   if (cache->base == 0)
1497     return;
1498
1499   /* See the end of i386_push_dummy_call.  */
1500   (*this_id) = frame_id_build (cache->base + 8, cache->pc);
1501 }
1502
1503 static struct value *
1504 i386_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1505                           int regnum)
1506 {
1507   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
1508
1509   gdb_assert (regnum >= 0);
1510
1511   /* The System V ABI says that:
1512
1513      "The flags register contains the system flags, such as the
1514      direction flag and the carry flag.  The direction flag must be
1515      set to the forward (that is, zero) direction before entry and
1516      upon exit from a function.  Other user flags have no specified
1517      role in the standard calling sequence and are not preserved."
1518
1519      To guarantee the "upon exit" part of that statement we fake a
1520      saved flags register that has its direction flag cleared.
1521
1522      Note that GCC doesn't seem to rely on the fact that the direction
1523      flag is cleared after a function return; it always explicitly
1524      clears the flag before operations where it matters.
1525
1526      FIXME: kettenis/20030316: I'm not quite sure whether this is the
1527      right thing to do.  The way we fake the flags register here makes
1528      it impossible to change it.  */
1529
1530   if (regnum == I386_EFLAGS_REGNUM)
1531     {
1532       ULONGEST val;
1533
1534       val = get_frame_register_unsigned (this_frame, regnum);
1535       val &= ~(1 << 10);
1536       return frame_unwind_got_constant (this_frame, regnum, val);
1537     }
1538
1539   if (regnum == I386_EIP_REGNUM && cache->pc_in_eax)
1540     return frame_unwind_got_register (this_frame, regnum, I386_EAX_REGNUM);
1541
1542   if (regnum == I386_ESP_REGNUM && cache->saved_sp)
1543     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
1544
1545   if (regnum < I386_NUM_SAVED_REGS && cache->saved_regs[regnum] != -1)
1546     return frame_unwind_got_memory (this_frame, regnum,
1547                                     cache->saved_regs[regnum]);
1548
1549   return frame_unwind_got_register (this_frame, regnum, regnum);
1550 }
1551
1552 static const struct frame_unwind i386_frame_unwind =
1553 {
1554   NORMAL_FRAME,
1555   i386_frame_this_id,
1556   i386_frame_prev_register,
1557   NULL,
1558   default_frame_sniffer
1559 };
1560
1561 /* Normal frames, but in a function epilogue.  */
1562
1563 /* The epilogue is defined here as the 'ret' instruction, which will
1564    follow any instruction such as 'leave' or 'pop %ebp' that destroys
1565    the function's stack frame.  */
1566
1567 static int
1568 i386_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1569 {
1570   gdb_byte insn;
1571
1572   if (target_read_memory (pc, &insn, 1))
1573     return 0;   /* Can't read memory at pc.  */
1574
1575   if (insn != 0xc3)     /* 'ret' instruction.  */
1576     return 0;
1577
1578   return 1;
1579 }
1580
1581 static int
1582 i386_epilogue_frame_sniffer (const struct frame_unwind *self,
1583                              struct frame_info *this_frame,
1584                              void **this_prologue_cache)
1585 {
1586   if (frame_relative_level (this_frame) == 0)
1587     return i386_in_function_epilogue_p (get_frame_arch (this_frame),
1588                                         get_frame_pc (this_frame));
1589   else
1590     return 0;
1591 }
1592
1593 static struct i386_frame_cache *
1594 i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
1595 {
1596   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1597   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1598   struct i386_frame_cache *cache;
1599   gdb_byte buf[4];
1600
1601   if (*this_cache)
1602     return *this_cache;
1603
1604   cache = i386_alloc_frame_cache ();
1605   *this_cache = cache;
1606
1607   /* Cache base will be %esp plus cache->sp_offset (-4).  */
1608   get_frame_register (this_frame, I386_ESP_REGNUM, buf);
1609   cache->base = extract_unsigned_integer (buf, 4,
1610                                           byte_order) + cache->sp_offset;
1611
1612   /* Cache pc will be the frame func.  */
1613   cache->pc = get_frame_pc (this_frame);
1614
1615   /* The saved %esp will be at cache->base plus 8.  */
1616   cache->saved_sp = cache->base + 8;
1617
1618   /* The saved %eip will be at cache->base plus 4.  */
1619   cache->saved_regs[I386_EIP_REGNUM] = cache->base + 4;
1620
1621   return cache;
1622 }
1623
1624 static void
1625 i386_epilogue_frame_this_id (struct frame_info *this_frame,
1626                              void **this_cache,
1627                              struct frame_id *this_id)
1628 {
1629   struct i386_frame_cache *cache = i386_epilogue_frame_cache (this_frame,
1630                                                               this_cache);
1631
1632   (*this_id) = frame_id_build (cache->base + 8, cache->pc);
1633 }
1634
1635 static const struct frame_unwind i386_epilogue_frame_unwind =
1636 {
1637   NORMAL_FRAME,
1638   i386_epilogue_frame_this_id,
1639   i386_frame_prev_register,
1640   NULL,
1641   i386_epilogue_frame_sniffer
1642 };
1643 \f
1644
1645 /* Signal trampolines.  */
1646
1647 static struct i386_frame_cache *
1648 i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
1649 {
1650   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1651   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1652   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1653   struct i386_frame_cache *cache;
1654   CORE_ADDR addr;
1655   gdb_byte buf[4];
1656
1657   if (*this_cache)
1658     return *this_cache;
1659
1660   cache = i386_alloc_frame_cache ();
1661
1662   get_frame_register (this_frame, I386_ESP_REGNUM, buf);
1663   cache->base = extract_unsigned_integer (buf, 4, byte_order) - 4;
1664
1665   addr = tdep->sigcontext_addr (this_frame);
1666   if (tdep->sc_reg_offset)
1667     {
1668       int i;
1669
1670       gdb_assert (tdep->sc_num_regs <= I386_NUM_SAVED_REGS);
1671
1672       for (i = 0; i < tdep->sc_num_regs; i++)
1673         if (tdep->sc_reg_offset[i] != -1)
1674           cache->saved_regs[i] = addr + tdep->sc_reg_offset[i];
1675     }
1676   else
1677     {
1678       cache->saved_regs[I386_EIP_REGNUM] = addr + tdep->sc_pc_offset;
1679       cache->saved_regs[I386_ESP_REGNUM] = addr + tdep->sc_sp_offset;
1680     }
1681
1682   *this_cache = cache;
1683   return cache;
1684 }
1685
1686 static void
1687 i386_sigtramp_frame_this_id (struct frame_info *this_frame, void **this_cache,
1688                              struct frame_id *this_id)
1689 {
1690   struct i386_frame_cache *cache =
1691     i386_sigtramp_frame_cache (this_frame, this_cache);
1692
1693   /* See the end of i386_push_dummy_call.  */
1694   (*this_id) = frame_id_build (cache->base + 8, get_frame_pc (this_frame));
1695 }
1696
1697 static struct value *
1698 i386_sigtramp_frame_prev_register (struct frame_info *this_frame,
1699                                    void **this_cache, int regnum)
1700 {
1701   /* Make sure we've initialized the cache.  */
1702   i386_sigtramp_frame_cache (this_frame, this_cache);
1703
1704   return i386_frame_prev_register (this_frame, this_cache, regnum);
1705 }
1706
1707 static int
1708 i386_sigtramp_frame_sniffer (const struct frame_unwind *self,
1709                              struct frame_info *this_frame,
1710                              void **this_prologue_cache)
1711 {
1712   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
1713
1714   /* We shouldn't even bother if we don't have a sigcontext_addr
1715      handler.  */
1716   if (tdep->sigcontext_addr == NULL)
1717     return 0;
1718
1719   if (tdep->sigtramp_p != NULL)
1720     {
1721       if (tdep->sigtramp_p (this_frame))
1722         return 1;
1723     }
1724
1725   if (tdep->sigtramp_start != 0)
1726     {
1727       CORE_ADDR pc = get_frame_pc (this_frame);
1728
1729       gdb_assert (tdep->sigtramp_end != 0);
1730       if (pc >= tdep->sigtramp_start && pc < tdep->sigtramp_end)
1731         return 1;
1732     }
1733
1734   return 0;
1735 }
1736
1737 static const struct frame_unwind i386_sigtramp_frame_unwind =
1738 {
1739   SIGTRAMP_FRAME,
1740   i386_sigtramp_frame_this_id,
1741   i386_sigtramp_frame_prev_register,
1742   NULL,
1743   i386_sigtramp_frame_sniffer
1744 };
1745 \f
1746
1747 static CORE_ADDR
1748 i386_frame_base_address (struct frame_info *this_frame, void **this_cache)
1749 {
1750   struct i386_frame_cache *cache = i386_frame_cache (this_frame, this_cache);
1751
1752   return cache->base;
1753 }
1754
1755 static const struct frame_base i386_frame_base =
1756 {
1757   &i386_frame_unwind,
1758   i386_frame_base_address,
1759   i386_frame_base_address,
1760   i386_frame_base_address
1761 };
1762
1763 static struct frame_id
1764 i386_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1765 {
1766   CORE_ADDR fp;
1767
1768   fp = get_frame_register_unsigned (this_frame, I386_EBP_REGNUM);
1769
1770   /* See the end of i386_push_dummy_call.  */
1771   return frame_id_build (fp + 8, get_frame_pc (this_frame));
1772 }
1773 \f
1774
1775 /* Figure out where the longjmp will land.  Slurp the args out of the
1776    stack.  We expect the first arg to be a pointer to the jmp_buf
1777    structure from which we extract the address that we will land at.
1778    This address is copied into PC.  This routine returns non-zero on
1779    success.  */
1780
1781 static int
1782 i386_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1783 {
1784   gdb_byte buf[4];
1785   CORE_ADDR sp, jb_addr;
1786   struct gdbarch *gdbarch = get_frame_arch (frame);
1787   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1788   int jb_pc_offset = gdbarch_tdep (gdbarch)->jb_pc_offset;
1789
1790   /* If JB_PC_OFFSET is -1, we have no way to find out where the
1791      longjmp will land.  */
1792   if (jb_pc_offset == -1)
1793     return 0;
1794
1795   get_frame_register (frame, I386_ESP_REGNUM, buf);
1796   sp = extract_unsigned_integer (buf, 4, byte_order);
1797   if (target_read_memory (sp + 4, buf, 4))
1798     return 0;
1799
1800   jb_addr = extract_unsigned_integer (buf, 4, byte_order);
1801   if (target_read_memory (jb_addr + jb_pc_offset, buf, 4))
1802     return 0;
1803
1804   *pc = extract_unsigned_integer (buf, 4, byte_order);
1805   return 1;
1806 }
1807 \f
1808
1809 /* Check whether TYPE must be 16-byte-aligned when passed as a
1810    function argument.  16-byte vectors, _Decimal128 and structures or
1811    unions containing such types must be 16-byte-aligned; other
1812    arguments are 4-byte-aligned.  */
1813
1814 static int
1815 i386_16_byte_align_p (struct type *type)
1816 {
1817   type = check_typedef (type);
1818   if ((TYPE_CODE (type) == TYPE_CODE_DECFLOAT
1819        || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)))
1820       && TYPE_LENGTH (type) == 16)
1821     return 1;
1822   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1823     return i386_16_byte_align_p (TYPE_TARGET_TYPE (type));
1824   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1825       || TYPE_CODE (type) == TYPE_CODE_UNION)
1826     {
1827       int i;
1828       for (i = 0; i < TYPE_NFIELDS (type); i++)
1829         {
1830           if (i386_16_byte_align_p (TYPE_FIELD_TYPE (type, i)))
1831             return 1;
1832         }
1833     }
1834   return 0;
1835 }
1836
1837 static CORE_ADDR
1838 i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1839                       struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
1840                       struct value **args, CORE_ADDR sp, int struct_return,
1841                       CORE_ADDR struct_addr)
1842 {
1843   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1844   gdb_byte buf[4];
1845   int i;
1846   int write_pass;
1847   int args_space = 0;
1848
1849   /* Determine the total space required for arguments and struct
1850      return address in a first pass (allowing for 16-byte-aligned
1851      arguments), then push arguments in a second pass.  */
1852
1853   for (write_pass = 0; write_pass < 2; write_pass++)
1854     {
1855       int args_space_used = 0;
1856       int have_16_byte_aligned_arg = 0;
1857
1858       if (struct_return)
1859         {
1860           if (write_pass)
1861             {
1862               /* Push value address.  */
1863               store_unsigned_integer (buf, 4, byte_order, struct_addr);
1864               write_memory (sp, buf, 4);
1865               args_space_used += 4;
1866             }
1867           else
1868             args_space += 4;
1869         }
1870
1871       for (i = 0; i < nargs; i++)
1872         {
1873           int len = TYPE_LENGTH (value_enclosing_type (args[i]));
1874
1875           if (write_pass)
1876             {
1877               if (i386_16_byte_align_p (value_enclosing_type (args[i])))
1878                 args_space_used = align_up (args_space_used, 16);
1879
1880               write_memory (sp + args_space_used,
1881                             value_contents_all (args[i]), len);
1882               /* The System V ABI says that:
1883
1884               "An argument's size is increased, if necessary, to make it a
1885               multiple of [32-bit] words.  This may require tail padding,
1886               depending on the size of the argument."
1887
1888               This makes sure the stack stays word-aligned.  */
1889               args_space_used += align_up (len, 4);
1890             }
1891           else
1892             {
1893               if (i386_16_byte_align_p (value_enclosing_type (args[i])))
1894                 {
1895                   args_space = align_up (args_space, 16);
1896                   have_16_byte_aligned_arg = 1;
1897                 }
1898               args_space += align_up (len, 4);
1899             }
1900         }
1901
1902       if (!write_pass)
1903         {
1904           if (have_16_byte_aligned_arg)
1905             args_space = align_up (args_space, 16);
1906           sp -= args_space;
1907         }
1908     }
1909
1910   /* Store return address.  */
1911   sp -= 4;
1912   store_unsigned_integer (buf, 4, byte_order, bp_addr);
1913   write_memory (sp, buf, 4);
1914
1915   /* Finally, update the stack pointer...  */
1916   store_unsigned_integer (buf, 4, byte_order, sp);
1917   regcache_cooked_write (regcache, I386_ESP_REGNUM, buf);
1918
1919   /* ...and fake a frame pointer.  */
1920   regcache_cooked_write (regcache, I386_EBP_REGNUM, buf);
1921
1922   /* MarkK wrote: This "+ 8" is all over the place:
1923      (i386_frame_this_id, i386_sigtramp_frame_this_id,
1924      i386_dummy_id).  It's there, since all frame unwinders for
1925      a given target have to agree (within a certain margin) on the
1926      definition of the stack address of a frame.  Otherwise frame id
1927      comparison might not work correctly.  Since DWARF2/GCC uses the
1928      stack address *before* the function call as a frame's CFA.  On
1929      the i386, when %ebp is used as a frame pointer, the offset
1930      between the contents %ebp and the CFA as defined by GCC.  */
1931   return sp + 8;
1932 }
1933
1934 /* These registers are used for returning integers (and on some
1935    targets also for returning `struct' and `union' values when their
1936    size and alignment match an integer type).  */
1937 #define LOW_RETURN_REGNUM       I386_EAX_REGNUM /* %eax */
1938 #define HIGH_RETURN_REGNUM      I386_EDX_REGNUM /* %edx */
1939
1940 /* Read, for architecture GDBARCH, a function return value of TYPE
1941    from REGCACHE, and copy that into VALBUF.  */
1942
1943 static void
1944 i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
1945                            struct regcache *regcache, gdb_byte *valbuf)
1946 {
1947   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1948   int len = TYPE_LENGTH (type);
1949   gdb_byte buf[I386_MAX_REGISTER_SIZE];
1950
1951   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1952     {
1953       if (tdep->st0_regnum < 0)
1954         {
1955           warning (_("Cannot find floating-point return value."));
1956           memset (valbuf, 0, len);
1957           return;
1958         }
1959
1960       /* Floating-point return values can be found in %st(0).  Convert
1961          its contents to the desired type.  This is probably not
1962          exactly how it would happen on the target itself, but it is
1963          the best we can do.  */
1964       regcache_raw_read (regcache, I386_ST0_REGNUM, buf);
1965       convert_typed_floating (buf, i387_ext_type (gdbarch), valbuf, type);
1966     }
1967   else
1968     {
1969       int low_size = register_size (gdbarch, LOW_RETURN_REGNUM);
1970       int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM);
1971
1972       if (len <= low_size)
1973         {
1974           regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
1975           memcpy (valbuf, buf, len);
1976         }
1977       else if (len <= (low_size + high_size))
1978         {
1979           regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf);
1980           memcpy (valbuf, buf, low_size);
1981           regcache_raw_read (regcache, HIGH_RETURN_REGNUM, buf);
1982           memcpy (valbuf + low_size, buf, len - low_size);
1983         }
1984       else
1985         internal_error (__FILE__, __LINE__,
1986                         _("Cannot extract return value of %d bytes long."), len);
1987     }
1988 }
1989
1990 /* Write, for architecture GDBARCH, a function return value of TYPE
1991    from VALBUF into REGCACHE.  */
1992
1993 static void
1994 i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
1995                          struct regcache *regcache, const gdb_byte *valbuf)
1996 {
1997   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1998   int len = TYPE_LENGTH (type);
1999
2000   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2001     {
2002       ULONGEST fstat;
2003       gdb_byte buf[I386_MAX_REGISTER_SIZE];
2004
2005       if (tdep->st0_regnum < 0)
2006         {
2007           warning (_("Cannot set floating-point return value."));
2008           return;
2009         }
2010
2011       /* Returning floating-point values is a bit tricky.  Apart from
2012          storing the return value in %st(0), we have to simulate the
2013          state of the FPU at function return point.  */
2014
2015       /* Convert the value found in VALBUF to the extended
2016          floating-point format used by the FPU.  This is probably
2017          not exactly how it would happen on the target itself, but
2018          it is the best we can do.  */
2019       convert_typed_floating (valbuf, type, buf, i387_ext_type (gdbarch));
2020       regcache_raw_write (regcache, I386_ST0_REGNUM, buf);
2021
2022       /* Set the top of the floating-point register stack to 7.  The
2023          actual value doesn't really matter, but 7 is what a normal
2024          function return would end up with if the program started out
2025          with a freshly initialized FPU.  */
2026       regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
2027       fstat |= (7 << 11);
2028       regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM (tdep), fstat);
2029
2030       /* Mark %st(1) through %st(7) as empty.  Since we set the top of
2031          the floating-point register stack to 7, the appropriate value
2032          for the tag word is 0x3fff.  */
2033       regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM (tdep), 0x3fff);
2034     }
2035   else
2036     {
2037       int low_size = register_size (gdbarch, LOW_RETURN_REGNUM);
2038       int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM);
2039
2040       if (len <= low_size)
2041         regcache_raw_write_part (regcache, LOW_RETURN_REGNUM, 0, len, valbuf);
2042       else if (len <= (low_size + high_size))
2043         {
2044           regcache_raw_write (regcache, LOW_RETURN_REGNUM, valbuf);
2045           regcache_raw_write_part (regcache, HIGH_RETURN_REGNUM, 0,
2046                                    len - low_size, valbuf + low_size);
2047         }
2048       else
2049         internal_error (__FILE__, __LINE__,
2050                         _("Cannot store return value of %d bytes long."), len);
2051     }
2052 }
2053 \f
2054
2055 /* This is the variable that is set with "set struct-convention", and
2056    its legitimate values.  */
2057 static const char default_struct_convention[] = "default";
2058 static const char pcc_struct_convention[] = "pcc";
2059 static const char reg_struct_convention[] = "reg";
2060 static const char *valid_conventions[] =
2061 {
2062   default_struct_convention,
2063   pcc_struct_convention,
2064   reg_struct_convention,
2065   NULL
2066 };
2067 static const char *struct_convention = default_struct_convention;
2068
2069 /* Return non-zero if TYPE, which is assumed to be a structure,
2070    a union type, or an array type, should be returned in registers
2071    for architecture GDBARCH.  */
2072
2073 static int
2074 i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
2075 {
2076   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2077   enum type_code code = TYPE_CODE (type);
2078   int len = TYPE_LENGTH (type);
2079
2080   gdb_assert (code == TYPE_CODE_STRUCT
2081               || code == TYPE_CODE_UNION
2082               || code == TYPE_CODE_ARRAY);
2083
2084   if (struct_convention == pcc_struct_convention
2085       || (struct_convention == default_struct_convention
2086           && tdep->struct_return == pcc_struct_return))
2087     return 0;
2088
2089   /* Structures consisting of a single `float', `double' or 'long
2090      double' member are returned in %st(0).  */
2091   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2092     {
2093       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
2094       if (TYPE_CODE (type) == TYPE_CODE_FLT)
2095         return (len == 4 || len == 8 || len == 12);
2096     }
2097
2098   return (len == 1 || len == 2 || len == 4 || len == 8);
2099 }
2100
2101 /* Determine, for architecture GDBARCH, how a return value of TYPE
2102    should be returned.  If it is supposed to be returned in registers,
2103    and READBUF is non-zero, read the appropriate value from REGCACHE,
2104    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
2105    from WRITEBUF into REGCACHE.  */
2106
2107 static enum return_value_convention
2108 i386_return_value (struct gdbarch *gdbarch, struct type *func_type,
2109                    struct type *type, struct regcache *regcache,
2110                    gdb_byte *readbuf, const gdb_byte *writebuf)
2111 {
2112   enum type_code code = TYPE_CODE (type);
2113
2114   if (((code == TYPE_CODE_STRUCT
2115         || code == TYPE_CODE_UNION
2116         || code == TYPE_CODE_ARRAY)
2117        && !i386_reg_struct_return_p (gdbarch, type))
2118       /* 128-bit decimal float uses the struct return convention.  */
2119       || (code == TYPE_CODE_DECFLOAT && TYPE_LENGTH (type) == 16))
2120     {
2121       /* The System V ABI says that:
2122
2123          "A function that returns a structure or union also sets %eax
2124          to the value of the original address of the caller's area
2125          before it returns.  Thus when the caller receives control
2126          again, the address of the returned object resides in register
2127          %eax and can be used to access the object."
2128
2129          So the ABI guarantees that we can always find the return
2130          value just after the function has returned.  */
2131
2132       /* Note that the ABI doesn't mention functions returning arrays,
2133          which is something possible in certain languages such as Ada.
2134          In this case, the value is returned as if it was wrapped in
2135          a record, so the convention applied to records also applies
2136          to arrays.  */
2137
2138       if (readbuf)
2139         {
2140           ULONGEST addr;
2141
2142           regcache_raw_read_unsigned (regcache, I386_EAX_REGNUM, &addr);
2143           read_memory (addr, readbuf, TYPE_LENGTH (type));
2144         }
2145
2146       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
2147     }
2148
2149   /* This special case is for structures consisting of a single
2150      `float', `double' or 'long double' member.  These structures are
2151      returned in %st(0).  For these structures, we call ourselves
2152      recursively, changing TYPE into the type of the first member of
2153      the structure.  Since that should work for all structures that
2154      have only one member, we don't bother to check the member's type
2155      here.  */
2156   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
2157     {
2158       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
2159       return i386_return_value (gdbarch, func_type, type, regcache,
2160                                 readbuf, writebuf);
2161     }
2162
2163   if (readbuf)
2164     i386_extract_return_value (gdbarch, type, regcache, readbuf);
2165   if (writebuf)
2166     i386_store_return_value (gdbarch, type, regcache, writebuf);
2167
2168   return RETURN_VALUE_REGISTER_CONVENTION;
2169 }
2170 \f
2171
2172 struct type *
2173 i387_ext_type (struct gdbarch *gdbarch)
2174 {
2175   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2176
2177   if (!tdep->i387_ext_type)
2178     {
2179       tdep->i387_ext_type = tdesc_find_type (gdbarch, "i387_ext");
2180       gdb_assert (tdep->i387_ext_type != NULL);
2181     }
2182
2183   return tdep->i387_ext_type;
2184 }
2185
2186 /* Construct vector type for MMX registers.  */
2187 static struct type *
2188 i386_mmx_type (struct gdbarch *gdbarch)
2189 {
2190   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2191
2192   if (!tdep->i386_mmx_type)
2193     {
2194       const struct builtin_type *bt = builtin_type (gdbarch);
2195
2196       /* The type we're building is this: */
2197 #if 0
2198       union __gdb_builtin_type_vec64i
2199       {
2200         int64_t uint64;
2201         int32_t v2_int32[2];
2202         int16_t v4_int16[4];
2203         int8_t v8_int8[8];
2204       };
2205 #endif
2206
2207       struct type *t;
2208
2209       t = arch_composite_type (gdbarch,
2210                                "__gdb_builtin_type_vec64i", TYPE_CODE_UNION);
2211
2212       append_composite_type_field (t, "uint64", bt->builtin_int64);
2213       append_composite_type_field (t, "v2_int32",
2214                                    init_vector_type (bt->builtin_int32, 2));
2215       append_composite_type_field (t, "v4_int16",
2216                                    init_vector_type (bt->builtin_int16, 4));
2217       append_composite_type_field (t, "v8_int8",
2218                                    init_vector_type (bt->builtin_int8, 8));
2219
2220       TYPE_VECTOR (t) = 1;
2221       TYPE_NAME (t) = "builtin_type_vec64i";
2222       tdep->i386_mmx_type = t;
2223     }
2224
2225   return tdep->i386_mmx_type;
2226 }
2227
2228 /* Return the GDB type object for the "standard" data type of data in
2229    register REGNUM. */
2230
2231 static struct type *
2232 i386_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
2233 {
2234   if (i386_mmx_regnum_p (gdbarch, regnum))
2235     return i386_mmx_type (gdbarch);
2236   else
2237     {
2238       const struct builtin_type *bt = builtin_type (gdbarch);
2239       if (i386_byte_regnum_p (gdbarch, regnum))
2240         return bt->builtin_int8;
2241       else if (i386_word_regnum_p (gdbarch, regnum))
2242         return bt->builtin_int16;
2243       else if (i386_dword_regnum_p (gdbarch, regnum))
2244         return bt->builtin_int32;
2245     }
2246
2247   internal_error (__FILE__, __LINE__, _("invalid regnum"));
2248 }
2249
2250 /* Map a cooked register onto a raw register or memory.  For the i386,
2251    the MMX registers need to be mapped onto floating point registers.  */
2252
2253 static int
2254 i386_mmx_regnum_to_fp_regnum (struct regcache *regcache, int regnum)
2255 {
2256   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
2257   int mmxreg, fpreg;
2258   ULONGEST fstat;
2259   int tos;
2260
2261   mmxreg = regnum - tdep->mm0_regnum;
2262   regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat);
2263   tos = (fstat >> 11) & 0x7;
2264   fpreg = (mmxreg + tos) % 8;
2265
2266   return (I387_ST0_REGNUM (tdep) + fpreg);
2267 }
2268
2269 void
2270 i386_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2271                            int regnum, gdb_byte *buf)
2272 {
2273   gdb_byte raw_buf[MAX_REGISTER_SIZE];
2274
2275   if (i386_mmx_regnum_p (gdbarch, regnum))
2276     {
2277       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
2278
2279       /* Extract (always little endian).  */
2280       regcache_raw_read (regcache, fpnum, raw_buf);
2281       memcpy (buf, raw_buf, register_size (gdbarch, regnum));
2282     }
2283   else
2284     {
2285       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2286
2287       if (i386_word_regnum_p (gdbarch, regnum))
2288         {
2289           int gpnum = regnum - tdep->ax_regnum;
2290
2291           /* Extract (always little endian).  */
2292           regcache_raw_read (regcache, gpnum, raw_buf);
2293           memcpy (buf, raw_buf, 2);
2294         }
2295       else if (i386_byte_regnum_p (gdbarch, regnum))
2296         {
2297           /* Check byte pseudo registers last since this function will
2298              be called from amd64_pseudo_register_read, which handles
2299              byte pseudo registers differently.  */
2300           int gpnum = regnum - tdep->al_regnum;
2301
2302           /* Extract (always little endian).  We read both lower and
2303              upper registers.  */
2304           regcache_raw_read (regcache, gpnum % 4, raw_buf);
2305           if (gpnum >= 4)
2306             memcpy (buf, raw_buf + 1, 1);
2307           else
2308             memcpy (buf, raw_buf, 1);
2309         }
2310       else
2311         internal_error (__FILE__, __LINE__, _("invalid regnum"));
2312     }
2313 }
2314
2315 void
2316 i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2317                             int regnum, const gdb_byte *buf)
2318 {
2319   gdb_byte raw_buf[MAX_REGISTER_SIZE];
2320
2321   if (i386_mmx_regnum_p (gdbarch, regnum))
2322     {
2323       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
2324
2325       /* Read ...  */
2326       regcache_raw_read (regcache, fpnum, raw_buf);
2327       /* ... Modify ... (always little endian).  */
2328       memcpy (raw_buf, buf, register_size (gdbarch, regnum));
2329       /* ... Write.  */
2330       regcache_raw_write (regcache, fpnum, raw_buf);
2331     }
2332   else
2333     {
2334       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2335
2336       if (i386_word_regnum_p (gdbarch, regnum))
2337         {
2338           int gpnum = regnum - tdep->ax_regnum;
2339
2340           /* Read ...  */
2341           regcache_raw_read (regcache, gpnum, raw_buf);
2342           /* ... Modify ... (always little endian).  */
2343           memcpy (raw_buf, buf, 2);
2344           /* ... Write.  */
2345           regcache_raw_write (regcache, gpnum, raw_buf);
2346         }
2347       else if (i386_byte_regnum_p (gdbarch, regnum))
2348         {
2349           /* Check byte pseudo registers last since this function will
2350              be called from amd64_pseudo_register_read, which handles
2351              byte pseudo registers differently.  */
2352           int gpnum = regnum - tdep->al_regnum;
2353
2354           /* Read ...  We read both lower and upper registers.  */
2355           regcache_raw_read (regcache, gpnum % 4, raw_buf);
2356           /* ... Modify ... (always little endian).  */
2357           if (gpnum >= 4)
2358             memcpy (raw_buf + 1, buf, 1);
2359           else
2360             memcpy (raw_buf, buf, 1);
2361           /* ... Write.  */
2362           regcache_raw_write (regcache, gpnum % 4, raw_buf);
2363         }
2364       else
2365         internal_error (__FILE__, __LINE__, _("invalid regnum"));
2366     }
2367 }
2368 \f
2369
2370 /* Return the register number of the register allocated by GCC after
2371    REGNUM, or -1 if there is no such register.  */
2372
2373 static int
2374 i386_next_regnum (int regnum)
2375 {
2376   /* GCC allocates the registers in the order:
2377
2378      %eax, %edx, %ecx, %ebx, %esi, %edi, %ebp, %esp, ...
2379
2380      Since storing a variable in %esp doesn't make any sense we return
2381      -1 for %ebp and for %esp itself.  */
2382   static int next_regnum[] =
2383   {
2384     I386_EDX_REGNUM,            /* Slot for %eax.  */
2385     I386_EBX_REGNUM,            /* Slot for %ecx.  */
2386     I386_ECX_REGNUM,            /* Slot for %edx.  */
2387     I386_ESI_REGNUM,            /* Slot for %ebx.  */
2388     -1, -1,                     /* Slots for %esp and %ebp.  */
2389     I386_EDI_REGNUM,            /* Slot for %esi.  */
2390     I386_EBP_REGNUM             /* Slot for %edi.  */
2391   };
2392
2393   if (regnum >= 0 && regnum < sizeof (next_regnum) / sizeof (next_regnum[0]))
2394     return next_regnum[regnum];
2395
2396   return -1;
2397 }
2398
2399 /* Return nonzero if a value of type TYPE stored in register REGNUM
2400    needs any special handling.  */
2401
2402 static int
2403 i386_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
2404 {
2405   int len = TYPE_LENGTH (type);
2406
2407   /* Values may be spread across multiple registers.  Most debugging
2408      formats aren't expressive enough to specify the locations, so
2409      some heuristics is involved.  Right now we only handle types that
2410      have a length that is a multiple of the word size, since GCC
2411      doesn't seem to put any other types into registers.  */
2412   if (len > 4 && len % 4 == 0)
2413     {
2414       int last_regnum = regnum;
2415
2416       while (len > 4)
2417         {
2418           last_regnum = i386_next_regnum (last_regnum);
2419           len -= 4;
2420         }
2421
2422       if (last_regnum != -1)
2423         return 1;
2424     }
2425
2426   return i387_convert_register_p (gdbarch, regnum, type);
2427 }
2428
2429 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
2430    return its contents in TO.  */
2431
2432 static void
2433 i386_register_to_value (struct frame_info *frame, int regnum,
2434                         struct type *type, gdb_byte *to)
2435 {
2436   struct gdbarch *gdbarch = get_frame_arch (frame);
2437   int len = TYPE_LENGTH (type);
2438
2439   /* FIXME: kettenis/20030609: What should we do if REGNUM isn't
2440      available in FRAME (i.e. if it wasn't saved)?  */
2441
2442   if (i386_fp_regnum_p (gdbarch, regnum))
2443     {
2444       i387_register_to_value (frame, regnum, type, to);
2445       return;
2446     }
2447
2448   /* Read a value spread across multiple registers.  */
2449
2450   gdb_assert (len > 4 && len % 4 == 0);
2451
2452   while (len > 0)
2453     {
2454       gdb_assert (regnum != -1);
2455       gdb_assert (register_size (gdbarch, regnum) == 4);
2456
2457       get_frame_register (frame, regnum, to);
2458       regnum = i386_next_regnum (regnum);
2459       len -= 4;
2460       to += 4;
2461     }
2462 }
2463
2464 /* Write the contents FROM of a value of type TYPE into register
2465    REGNUM in frame FRAME.  */
2466
2467 static void
2468 i386_value_to_register (struct frame_info *frame, int regnum,
2469                         struct type *type, const gdb_byte *from)
2470 {
2471   int len = TYPE_LENGTH (type);
2472
2473   if (i386_fp_regnum_p (get_frame_arch (frame), regnum))
2474     {
2475       i387_value_to_register (frame, regnum, type, from);
2476       return;
2477     }
2478
2479   /* Write a value spread across multiple registers.  */
2480
2481   gdb_assert (len > 4 && len % 4 == 0);
2482
2483   while (len > 0)
2484     {
2485       gdb_assert (regnum != -1);
2486       gdb_assert (register_size (get_frame_arch (frame), regnum) == 4);
2487
2488       put_frame_register (frame, regnum, from);
2489       regnum = i386_next_regnum (regnum);
2490       len -= 4;
2491       from += 4;
2492     }
2493 }
2494 \f
2495 /* Supply register REGNUM from the buffer specified by GREGS and LEN
2496    in the general-purpose register set REGSET to register cache
2497    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
2498
2499 void
2500 i386_supply_gregset (const struct regset *regset, struct regcache *regcache,
2501                      int regnum, const void *gregs, size_t len)
2502 {
2503   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
2504   const gdb_byte *regs = gregs;
2505   int i;
2506
2507   gdb_assert (len == tdep->sizeof_gregset);
2508
2509   for (i = 0; i < tdep->gregset_num_regs; i++)
2510     {
2511       if ((regnum == i || regnum == -1)
2512           && tdep->gregset_reg_offset[i] != -1)
2513         regcache_raw_supply (regcache, i, regs + tdep->gregset_reg_offset[i]);
2514     }
2515 }
2516
2517 /* Collect register REGNUM from the register cache REGCACHE and store
2518    it in the buffer specified by GREGS and LEN as described by the
2519    general-purpose register set REGSET.  If REGNUM is -1, do this for
2520    all registers in REGSET.  */
2521
2522 void
2523 i386_collect_gregset (const struct regset *regset,
2524                       const struct regcache *regcache,
2525                       int regnum, void *gregs, size_t len)
2526 {
2527   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
2528   gdb_byte *regs = gregs;
2529   int i;
2530
2531   gdb_assert (len == tdep->sizeof_gregset);
2532
2533   for (i = 0; i < tdep->gregset_num_regs; i++)
2534     {
2535       if ((regnum == i || regnum == -1)
2536           && tdep->gregset_reg_offset[i] != -1)
2537         regcache_raw_collect (regcache, i, regs + tdep->gregset_reg_offset[i]);
2538     }
2539 }
2540
2541 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
2542    in the floating-point register set REGSET to register cache
2543    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
2544
2545 static void
2546 i386_supply_fpregset (const struct regset *regset, struct regcache *regcache,
2547                       int regnum, const void *fpregs, size_t len)
2548 {
2549   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
2550
2551   if (len == I387_SIZEOF_FXSAVE)
2552     {
2553       i387_supply_fxsave (regcache, regnum, fpregs);
2554       return;
2555     }
2556
2557   gdb_assert (len == tdep->sizeof_fpregset);
2558   i387_supply_fsave (regcache, regnum, fpregs);
2559 }
2560
2561 /* Collect register REGNUM from the register cache REGCACHE and store
2562    it in the buffer specified by FPREGS and LEN as described by the
2563    floating-point register set REGSET.  If REGNUM is -1, do this for
2564    all registers in REGSET.  */
2565
2566 static void
2567 i386_collect_fpregset (const struct regset *regset,
2568                        const struct regcache *regcache,
2569                        int regnum, void *fpregs, size_t len)
2570 {
2571   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
2572
2573   if (len == I387_SIZEOF_FXSAVE)
2574     {
2575       i387_collect_fxsave (regcache, regnum, fpregs);
2576       return;
2577     }
2578
2579   gdb_assert (len == tdep->sizeof_fpregset);
2580   i387_collect_fsave (regcache, regnum, fpregs);
2581 }
2582
2583 /* Return the appropriate register set for the core section identified
2584    by SECT_NAME and SECT_SIZE.  */
2585
2586 const struct regset *
2587 i386_regset_from_core_section (struct gdbarch *gdbarch,
2588                                const char *sect_name, size_t sect_size)
2589 {
2590   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2591
2592   if (strcmp (sect_name, ".reg") == 0 && sect_size == tdep->sizeof_gregset)
2593     {
2594       if (tdep->gregset == NULL)
2595         tdep->gregset = regset_alloc (gdbarch, i386_supply_gregset,
2596                                       i386_collect_gregset);
2597       return tdep->gregset;
2598     }
2599
2600   if ((strcmp (sect_name, ".reg2") == 0 && sect_size == tdep->sizeof_fpregset)
2601       || (strcmp (sect_name, ".reg-xfp") == 0
2602           && sect_size == I387_SIZEOF_FXSAVE))
2603     {
2604       if (tdep->fpregset == NULL)
2605         tdep->fpregset = regset_alloc (gdbarch, i386_supply_fpregset,
2606                                        i386_collect_fpregset);
2607       return tdep->fpregset;
2608     }
2609
2610   return NULL;
2611 }
2612 \f
2613
2614 /* Stuff for WIN32 PE style DLL's but is pretty generic really.  */
2615
2616 CORE_ADDR
2617 i386_pe_skip_trampoline_code (struct frame_info *frame,
2618                               CORE_ADDR pc, char *name)
2619 {
2620   struct gdbarch *gdbarch = get_frame_arch (frame);
2621   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2622
2623   /* jmp *(dest) */
2624   if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
2625     {
2626       unsigned long indirect =
2627         read_memory_unsigned_integer (pc + 2, 4, byte_order);
2628       struct minimal_symbol *indsym =
2629         indirect ? lookup_minimal_symbol_by_pc (indirect) : 0;
2630       char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : 0;
2631
2632       if (symname)
2633         {
2634           if (strncmp (symname, "__imp_", 6) == 0
2635               || strncmp (symname, "_imp_", 5) == 0)
2636             return name ? 1 :
2637                    read_memory_unsigned_integer (indirect, 4, byte_order);
2638         }
2639     }
2640   return 0;                     /* Not a trampoline.  */
2641 }
2642 \f
2643
2644 /* Return whether the THIS_FRAME corresponds to a sigtramp
2645    routine.  */
2646
2647 int
2648 i386_sigtramp_p (struct frame_info *this_frame)
2649 {
2650   CORE_ADDR pc = get_frame_pc (this_frame);
2651   char *name;
2652
2653   find_pc_partial_function (pc, &name, NULL, NULL);
2654   return (name && strcmp ("_sigtramp", name) == 0);
2655 }
2656 \f
2657
2658 /* We have two flavours of disassembly.  The machinery on this page
2659    deals with switching between those.  */
2660
2661 static int
2662 i386_print_insn (bfd_vma pc, struct disassemble_info *info)
2663 {
2664   gdb_assert (disassembly_flavor == att_flavor
2665               || disassembly_flavor == intel_flavor);
2666
2667   /* FIXME: kettenis/20020915: Until disassembler_options is properly
2668      constified, cast to prevent a compiler warning.  */
2669   info->disassembler_options = (char *) disassembly_flavor;
2670
2671   return print_insn_i386 (pc, info);
2672 }
2673 \f
2674
2675 /* There are a few i386 architecture variants that differ only
2676    slightly from the generic i386 target.  For now, we don't give them
2677    their own source file, but include them here.  As a consequence,
2678    they'll always be included.  */
2679
2680 /* System V Release 4 (SVR4).  */
2681
2682 /* Return whether THIS_FRAME corresponds to a SVR4 sigtramp
2683    routine.  */
2684
2685 static int
2686 i386_svr4_sigtramp_p (struct frame_info *this_frame)
2687 {
2688   CORE_ADDR pc = get_frame_pc (this_frame);
2689   char *name;
2690
2691   /* UnixWare uses _sigacthandler.  The origin of the other symbols is
2692      currently unknown.  */
2693   find_pc_partial_function (pc, &name, NULL, NULL);
2694   return (name && (strcmp ("_sigreturn", name) == 0
2695                    || strcmp ("_sigacthandler", name) == 0
2696                    || strcmp ("sigvechandler", name) == 0));
2697 }
2698
2699 /* Assuming THIS_FRAME is for a SVR4 sigtramp routine, return the
2700    address of the associated sigcontext (ucontext) structure.  */
2701
2702 static CORE_ADDR
2703 i386_svr4_sigcontext_addr (struct frame_info *this_frame)
2704 {
2705   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2706   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2707   gdb_byte buf[4];
2708   CORE_ADDR sp;
2709
2710   get_frame_register (this_frame, I386_ESP_REGNUM, buf);
2711   sp = extract_unsigned_integer (buf, 4, byte_order);
2712
2713   return read_memory_unsigned_integer (sp + 8, 4, byte_order);
2714 }
2715 \f
2716
2717 /* Generic ELF.  */
2718
2719 void
2720 i386_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2721 {
2722   /* We typically use stabs-in-ELF with the SVR4 register numbering.  */
2723   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
2724 }
2725
2726 /* System V Release 4 (SVR4).  */
2727
2728 void
2729 i386_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2730 {
2731   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2732
2733   /* System V Release 4 uses ELF.  */
2734   i386_elf_init_abi (info, gdbarch);
2735
2736   /* System V Release 4 has shared libraries.  */
2737   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
2738
2739   tdep->sigtramp_p = i386_svr4_sigtramp_p;
2740   tdep->sigcontext_addr = i386_svr4_sigcontext_addr;
2741   tdep->sc_pc_offset = 36 + 14 * 4;
2742   tdep->sc_sp_offset = 36 + 17 * 4;
2743
2744   tdep->jb_pc_offset = 20;
2745 }
2746
2747 /* DJGPP.  */
2748
2749 static void
2750 i386_go32_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2751 {
2752   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2753
2754   /* DJGPP doesn't have any special frames for signal handlers.  */
2755   tdep->sigtramp_p = NULL;
2756
2757   tdep->jb_pc_offset = 36;
2758
2759   /* DJGPP does not support the SSE registers.  */
2760   tdep->num_xmm_regs = 0;
2761   set_gdbarch_num_regs (gdbarch, I386_NUM_GREGS + I387_NUM_REGS);
2762
2763   /* Native compiler is GCC, which uses the SVR4 register numbering
2764      even in COFF and STABS.  See the comment in i386_gdbarch_init,
2765      before the calls to set_gdbarch_stab_reg_to_regnum and
2766      set_gdbarch_sdb_reg_to_regnum.  */
2767   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
2768   set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
2769 }
2770 \f
2771
2772 /* i386 register groups.  In addition to the normal groups, add "mmx"
2773    and "sse".  */
2774
2775 static struct reggroup *i386_sse_reggroup;
2776 static struct reggroup *i386_mmx_reggroup;
2777
2778 static void
2779 i386_init_reggroups (void)
2780 {
2781   i386_sse_reggroup = reggroup_new ("sse", USER_REGGROUP);
2782   i386_mmx_reggroup = reggroup_new ("mmx", USER_REGGROUP);
2783 }
2784
2785 static void
2786 i386_add_reggroups (struct gdbarch *gdbarch)
2787 {
2788   reggroup_add (gdbarch, i386_sse_reggroup);
2789   reggroup_add (gdbarch, i386_mmx_reggroup);
2790   reggroup_add (gdbarch, general_reggroup);
2791   reggroup_add (gdbarch, float_reggroup);
2792   reggroup_add (gdbarch, all_reggroup);
2793   reggroup_add (gdbarch, save_reggroup);
2794   reggroup_add (gdbarch, restore_reggroup);
2795   reggroup_add (gdbarch, vector_reggroup);
2796   reggroup_add (gdbarch, system_reggroup);
2797 }
2798
2799 int
2800 i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
2801                           struct reggroup *group)
2802 {
2803   int sse_regnum_p, fp_regnum_p, mmx_regnum_p, byte_regnum_p,
2804       word_regnum_p, dword_regnum_p;
2805
2806   /* Don't include pseudo registers, except for MMX, in any register
2807      groups.  */
2808   byte_regnum_p = i386_byte_regnum_p (gdbarch, regnum);
2809   if (byte_regnum_p)
2810     return 0;
2811
2812   word_regnum_p = i386_word_regnum_p (gdbarch, regnum);
2813   if (word_regnum_p)
2814     return 0;
2815
2816   dword_regnum_p = i386_dword_regnum_p (gdbarch, regnum);
2817   if (dword_regnum_p)
2818     return 0;
2819
2820   mmx_regnum_p = i386_mmx_regnum_p (gdbarch, regnum);
2821   if (group == i386_mmx_reggroup)
2822     return mmx_regnum_p;
2823
2824   sse_regnum_p = (i386_sse_regnum_p (gdbarch, regnum)
2825                   || i386_mxcsr_regnum_p (gdbarch, regnum));
2826   if (group == i386_sse_reggroup)
2827     return sse_regnum_p;
2828   if (group == vector_reggroup)
2829     return mmx_regnum_p || sse_regnum_p;
2830
2831   fp_regnum_p = (i386_fp_regnum_p (gdbarch, regnum)
2832                  || i386_fpc_regnum_p (gdbarch, regnum));
2833   if (group == float_reggroup)
2834     return fp_regnum_p;
2835
2836   if (group == general_reggroup)
2837     return (!fp_regnum_p
2838             && !mmx_regnum_p
2839             && !sse_regnum_p
2840             && !byte_regnum_p
2841             && !word_regnum_p
2842             && !dword_regnum_p);
2843
2844   return default_register_reggroup_p (gdbarch, regnum, group);
2845 }
2846 \f
2847
2848 /* Get the ARGIth function argument for the current function.  */
2849
2850 static CORE_ADDR
2851 i386_fetch_pointer_argument (struct frame_info *frame, int argi,
2852                              struct type *type)
2853 {
2854   struct gdbarch *gdbarch = get_frame_arch (frame);
2855   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2856   CORE_ADDR sp = get_frame_register_unsigned  (frame, I386_ESP_REGNUM);
2857   return read_memory_unsigned_integer (sp + (4 * (argi + 1)), 4, byte_order);
2858 }
2859
2860 static void
2861 i386_skip_permanent_breakpoint (struct regcache *regcache)
2862 {
2863   CORE_ADDR current_pc = regcache_read_pc (regcache);
2864
2865  /* On i386, breakpoint is exactly 1 byte long, so we just
2866     adjust the PC in the regcache.  */
2867   current_pc += 1;
2868   regcache_write_pc (regcache, current_pc);
2869 }
2870
2871
2872 #define PREFIX_REPZ     0x01
2873 #define PREFIX_REPNZ    0x02
2874 #define PREFIX_LOCK     0x04
2875 #define PREFIX_DATA     0x08
2876 #define PREFIX_ADDR     0x10
2877
2878 /* operand size */
2879 enum
2880 {
2881   OT_BYTE = 0,
2882   OT_WORD,
2883   OT_LONG,
2884   OT_QUAD,
2885 };
2886
2887 /* i386 arith/logic operations */
2888 enum
2889 {
2890   OP_ADDL,
2891   OP_ORL,
2892   OP_ADCL,
2893   OP_SBBL,
2894   OP_ANDL,
2895   OP_SUBL,
2896   OP_XORL,
2897   OP_CMPL,
2898 };
2899
2900 struct i386_record_s
2901 {
2902   struct gdbarch *gdbarch;
2903   struct regcache *regcache;
2904   CORE_ADDR orig_addr;
2905   CORE_ADDR addr;
2906   int aflag;
2907   int dflag;
2908   int override;
2909   uint8_t modrm;
2910   uint8_t mod, reg, rm;
2911   int ot;
2912   uint8_t rex_x;
2913   uint8_t rex_b;
2914   int rip_offset;
2915   int popl_esp_hack;
2916   const int *regmap;
2917 };
2918
2919 /* Parse "modrm" part in current memory address that irp->addr point to
2920    Return -1 if something wrong. */
2921
2922 static int
2923 i386_record_modrm (struct i386_record_s *irp)
2924 {
2925   struct gdbarch *gdbarch = irp->gdbarch;
2926
2927   if (target_read_memory (irp->addr, &irp->modrm, 1))
2928     {
2929       if (record_debug)
2930         printf_unfiltered (_("Process record: error reading memory at "
2931                              "addr %s len = 1.\n"),
2932                            paddress (gdbarch, irp->addr));
2933       return -1;
2934     }
2935   irp->addr++;
2936   irp->mod = (irp->modrm >> 6) & 3;
2937   irp->reg = (irp->modrm >> 3) & 7;
2938   irp->rm = irp->modrm & 7;
2939
2940   return 0;
2941 }
2942
2943 /* Get the memory address that current instruction  write to and set it to
2944    the argument "addr".
2945    Return -1 if something wrong. */
2946
2947 static int
2948 i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
2949 {
2950   struct gdbarch *gdbarch = irp->gdbarch;
2951   uint8_t tmpu8;
2952   int16_t tmpi16;
2953   int32_t tmpi32;
2954   ULONGEST tmpulongest;
2955
2956   *addr = 0;
2957   if (irp->aflag)
2958     {
2959       /* 32 bits */
2960       int havesib = 0;
2961       uint8_t scale = 0;
2962       uint8_t index = 0;
2963       uint8_t base = irp->rm;
2964
2965       if (base == 4)
2966         {
2967           havesib = 1;
2968           if (target_read_memory (irp->addr, &tmpu8, 1))
2969             {
2970               if (record_debug)
2971                 printf_unfiltered (_("Process record: error reading memory "
2972                                      "at addr %s len = 1.\n"),
2973                                    paddress (gdbarch, irp->addr));
2974               return -1;
2975             }
2976           irp->addr++;
2977           scale = (tmpu8 >> 6) & 3;
2978           index = ((tmpu8 >> 3) & 7) | irp->rex_x;
2979           base = (tmpu8 & 7);
2980         }
2981       base |= irp->rex_b;
2982
2983       switch (irp->mod)
2984         {
2985         case 0:
2986           if ((base & 7) == 5)
2987             {
2988               base = 0xff;
2989               if (target_read_memory (irp->addr, (gdb_byte *) &tmpi32, 4))
2990                 {
2991                   if (record_debug)
2992                     printf_unfiltered (_("Process record: error reading "
2993                                          "memory at addr %s len = 4.\n"),
2994                                        paddress (gdbarch, irp->addr));
2995                   return -1;
2996                 }
2997               irp->addr += 4;
2998               *addr = tmpi32;
2999               if (irp->regmap[X86_RECORD_R8_REGNUM] && !havesib)
3000                 *addr += irp->addr + irp->rip_offset;
3001             }
3002           else
3003             {
3004               *addr = 0;
3005             }
3006           break;
3007         case 1:
3008           if (target_read_memory (irp->addr, &tmpu8, 1))
3009             {
3010               if (record_debug)
3011                 printf_unfiltered (_("Process record: error reading memory "
3012                                      "at addr %s len = 1.\n"),
3013                                    paddress (gdbarch, irp->addr));
3014               return -1;
3015             }
3016           irp->addr++;
3017           *addr = (int8_t) tmpu8;
3018           break;
3019         case 2:
3020           if (target_read_memory (irp->addr, (gdb_byte *) &tmpi32, 4))
3021             {
3022               if (record_debug)
3023                 printf_unfiltered (_("Process record: error reading memory "
3024                                      "at addr %s len = 4.\n"),
3025                                    paddress (gdbarch, irp->addr));
3026               return -1;
3027             }
3028           *addr = tmpi32;
3029           irp->addr += 4;
3030           break;
3031         }
3032
3033       tmpulongest = 0;
3034       if (base != 0xff)
3035         {
3036           if (base == 4 && irp->popl_esp_hack)
3037             *addr += irp->popl_esp_hack;
3038           regcache_raw_read_unsigned (irp->regcache, irp->regmap[base],
3039                                       &tmpulongest);
3040         }
3041       if (irp->aflag == 2)
3042         {
3043           *addr += tmpulongest;
3044         }
3045       else
3046         *addr = (uint32_t) (tmpulongest + *addr);
3047
3048       if (havesib && (index != 4 || scale != 0))
3049         {
3050           regcache_raw_read_unsigned (irp->regcache, irp->regmap[index],
3051                                       &tmpulongest);
3052           if (irp->aflag == 2)
3053             *addr += tmpulongest << scale;
3054           else
3055             *addr = (uint32_t) (*addr + (tmpulongest << scale));
3056         }
3057     }
3058   else
3059     {
3060       /* 16 bits */
3061       switch (irp->mod)
3062         {
3063         case 0:
3064           if (irp->rm == 6)
3065             {
3066               if (target_read_memory
3067                   (irp->addr, (gdb_byte *) &tmpi16, 2))
3068                 {
3069                   if (record_debug)
3070                     printf_unfiltered (_("Process record: error reading "
3071                                          "memory at addr %s len = 2.\n"),
3072                                        paddress (gdbarch, irp->addr));
3073                   return -1;
3074                 }
3075               irp->addr += 2;
3076               *addr = tmpi16;
3077               irp->rm = 0;
3078               goto no_rm;
3079             }
3080           else
3081             {
3082               *addr = 0;
3083             }
3084           break;
3085         case 1:
3086           if (target_read_memory (irp->addr, &tmpu8, 1))
3087             {
3088               if (record_debug)
3089                 printf_unfiltered (_("Process record: error reading memory "
3090                                      "at addr %s len = 1.\n"),
3091                                    paddress (gdbarch, irp->addr));
3092               return -1;
3093             }
3094           irp->addr++;
3095           *addr = (int8_t) tmpu8;
3096           break;
3097         case 2:
3098           if (target_read_memory (irp->addr, (gdb_byte *) &tmpi16, 2))
3099             {
3100               if (record_debug)
3101                 printf_unfiltered (_("Process record: error reading memory "
3102                                      "at addr %s len = 2.\n"),
3103                                    paddress (gdbarch, irp->addr));
3104               return -1;
3105             }
3106           irp->addr += 2;
3107           *addr = tmpi16;
3108           break;
3109         }
3110
3111       switch (irp->rm)
3112         {
3113         case 0:
3114           regcache_raw_read_unsigned (irp->regcache,
3115                                       irp->regmap[X86_RECORD_REBX_REGNUM],
3116                                       &tmpulongest);
3117           *addr = (uint32_t) (*addr + tmpulongest);
3118           regcache_raw_read_unsigned (irp->regcache,
3119                                       irp->regmap[X86_RECORD_RESI_REGNUM],
3120                                       &tmpulongest);
3121           *addr = (uint32_t) (*addr + tmpulongest);
3122           break;
3123         case 1:
3124           regcache_raw_read_unsigned (irp->regcache,
3125                                       irp->regmap[X86_RECORD_REBX_REGNUM],
3126                                       &tmpulongest);
3127           *addr = (uint32_t) (*addr + tmpulongest);
3128           regcache_raw_read_unsigned (irp->regcache,
3129                                       irp->regmap[X86_RECORD_REDI_REGNUM],
3130                                       &tmpulongest);
3131           *addr = (uint32_t) (*addr + tmpulongest);
3132           break;
3133         case 2:
3134           regcache_raw_read_unsigned (irp->regcache,
3135                                       irp->regmap[X86_RECORD_REBP_REGNUM],
3136                                       &tmpulongest);
3137           *addr = (uint32_t) (*addr + tmpulongest);
3138           regcache_raw_read_unsigned (irp->regcache,
3139                                       irp->regmap[X86_RECORD_RESI_REGNUM],
3140                                       &tmpulongest);
3141           *addr = (uint32_t) (*addr + tmpulongest);
3142           break;
3143         case 3:
3144           regcache_raw_read_unsigned (irp->regcache,
3145                                       irp->regmap[X86_RECORD_REBP_REGNUM],
3146                                       &tmpulongest);
3147           *addr = (uint32_t) (*addr + tmpulongest);
3148           regcache_raw_read_unsigned (irp->regcache,
3149                                       irp->regmap[X86_RECORD_REDI_REGNUM],
3150                                       &tmpulongest);
3151           *addr = (uint32_t) (*addr + tmpulongest);
3152           break;
3153         case 4:
3154           regcache_raw_read_unsigned (irp->regcache,
3155                                       irp->regmap[X86_RECORD_RESI_REGNUM],
3156                                       &tmpulongest);
3157           *addr = (uint32_t) (*addr + tmpulongest);
3158           break;
3159         case 5:
3160           regcache_raw_read_unsigned (irp->regcache,
3161                                       irp->regmap[X86_RECORD_REDI_REGNUM],
3162                                       &tmpulongest);
3163           *addr = (uint32_t) (*addr + tmpulongest);
3164           break;
3165         case 6:
3166           regcache_raw_read_unsigned (irp->regcache,
3167                                       irp->regmap[X86_RECORD_REBP_REGNUM],
3168                                       &tmpulongest);
3169           *addr = (uint32_t) (*addr + tmpulongest);
3170           break;
3171         case 7:
3172           regcache_raw_read_unsigned (irp->regcache,
3173                                       irp->regmap[X86_RECORD_REBX_REGNUM],
3174                                       &tmpulongest);
3175           *addr = (uint32_t) (*addr + tmpulongest);
3176           break;
3177         }
3178       *addr &= 0xffff;
3179     }
3180
3181  no_rm:
3182   return 0;
3183 }
3184
3185 /* Record the value of the memory that willbe changed in current instruction
3186    to "record_arch_list".
3187    Return -1 if something wrong. */
3188
3189 static int
3190 i386_record_lea_modrm (struct i386_record_s *irp)
3191 {
3192   struct gdbarch *gdbarch = irp->gdbarch;
3193   uint64_t addr;
3194
3195   if (irp->override >= 0)
3196     {
3197       warning (_("Process record ignores the memory change "
3198                  "of instruction at address %s because it "
3199                  "can't get the value of the segment register."),
3200                paddress (gdbarch, irp->orig_addr));
3201       return 0;
3202     }
3203
3204   if (i386_record_lea_modrm_addr (irp, &addr))
3205     return -1;
3206
3207   if (record_arch_list_add_mem (addr, 1 << irp->ot))
3208     return -1;
3209
3210   return 0;
3211 }
3212
3213 /* Record the push operation to "record_arch_list".
3214    Return -1 if something wrong. */
3215
3216 static int
3217 i386_record_push (struct i386_record_s *irp, int size)
3218 {
3219   ULONGEST tmpulongest;
3220
3221   if (record_arch_list_add_reg (irp->regcache,
3222                                 irp->regmap[X86_RECORD_RESP_REGNUM]))
3223     return -1;
3224   regcache_raw_read_unsigned (irp->regcache,
3225                               irp->regmap[X86_RECORD_RESP_REGNUM],
3226                               &tmpulongest);
3227   if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest - size, size))
3228     return -1;
3229
3230   return 0;
3231 }
3232
3233
3234 /* Defines contents to record.  */
3235 #define I386_SAVE_FPU_REGS              0xfffd
3236 #define I386_SAVE_FPU_ENV               0xfffe
3237 #define I386_SAVE_FPU_ENV_REG_STACK     0xffff
3238
3239 /* Record the value of floating point registers which will be changed by the
3240    current instruction to "record_arch_list".  Return -1 if something is wrong.
3241 */
3242
3243 static int i386_record_floats (struct gdbarch *gdbarch,
3244                                struct i386_record_s *ir,
3245                                uint32_t iregnum)
3246 {
3247   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3248   int i;
3249
3250   /* Oza: Because of floating point insn push/pop of fpu stack is going to
3251      happen.  Currently we store st0-st7 registers, but we need not store all
3252      registers all the time, in future we use ftag register and record only
3253      those who are not marked as an empty.  */
3254
3255   if (I386_SAVE_FPU_REGS == iregnum)
3256     {
3257       for (i = I387_ST0_REGNUM (tdep); i <= I387_ST0_REGNUM (tdep) + 7; i++)
3258         {
3259           if (record_arch_list_add_reg (ir->regcache, i))
3260             return -1;
3261         }
3262     }
3263   else if (I386_SAVE_FPU_ENV == iregnum)
3264     {
3265       for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
3266               {
3267               if (record_arch_list_add_reg (ir->regcache, i))
3268                 return -1;
3269               }
3270     }
3271   else if (I386_SAVE_FPU_ENV_REG_STACK == iregnum)
3272     {
3273       for (i = I387_ST0_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
3274       {
3275         if (record_arch_list_add_reg (ir->regcache, i))
3276           return -1;
3277       }
3278     }
3279   else if ((iregnum >= I387_ST0_REGNUM (tdep)) &&
3280            (iregnum <= I387_FOP_REGNUM (tdep)))
3281     {
3282       if (record_arch_list_add_reg (ir->regcache,iregnum))
3283         return -1;
3284     }
3285   else
3286     {
3287       /* Parameter error.  */
3288       return -1;
3289     }
3290   if(I386_SAVE_FPU_ENV != iregnum)
3291     {
3292     for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
3293       {
3294       if (record_arch_list_add_reg (ir->regcache, i))
3295         return -1;
3296       }
3297     }
3298   return 0;
3299 }
3300
3301 /* Parse the current instruction and record the values of the registers and
3302    memory that will be changed in current instruction to "record_arch_list".
3303    Return -1 if something wrong. */
3304
3305 #define I386_RECORD_ARCH_LIST_ADD_REG(regnum) \
3306     record_arch_list_add_reg (ir.regcache, ir.regmap[(regnum)])
3307
3308 int
3309 i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
3310                      CORE_ADDR addr)
3311 {
3312   int prefixes = 0;
3313   uint8_t tmpu8;
3314   uint16_t tmpu16;
3315   uint32_t tmpu32;
3316   ULONGEST tmpulongest;
3317   uint32_t opcode;
3318   struct i386_record_s ir;
3319   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3320   int rex = 0;
3321   uint8_t rex_w = -1;
3322   uint8_t rex_r = 0;
3323
3324   memset (&ir, 0, sizeof (struct i386_record_s));
3325   ir.regcache = regcache;
3326   ir.addr = addr;
3327   ir.orig_addr = addr;
3328   ir.aflag = 1;
3329   ir.dflag = 1;
3330   ir.override = -1;
3331   ir.popl_esp_hack = 0;
3332   ir.regmap = gdbarch_tdep (gdbarch)->record_regmap;
3333   ir.gdbarch = gdbarch;
3334
3335   if (record_debug > 1)
3336     fprintf_unfiltered (gdb_stdlog, "Process record: i386_process_record "
3337                                     "addr = %s\n",
3338                         paddress (gdbarch, ir.addr));
3339
3340   /* prefixes */
3341   while (1)
3342     {
3343       if (target_read_memory (ir.addr, &tmpu8, 1))
3344         {
3345           if (record_debug)
3346             printf_unfiltered (_("Process record: error reading memory at "
3347                                  "addr %s len = 1.\n"),
3348                                paddress (gdbarch, ir.addr));
3349           return -1;
3350         }
3351       ir.addr++;
3352       switch (tmpu8)    /* Instruction prefixes */
3353         {
3354         case REPE_PREFIX_OPCODE:
3355           prefixes |= PREFIX_REPZ;
3356           break;
3357         case REPNE_PREFIX_OPCODE:
3358           prefixes |= PREFIX_REPNZ;
3359           break;
3360         case LOCK_PREFIX_OPCODE:
3361           prefixes |= PREFIX_LOCK;
3362           break;
3363         case CS_PREFIX_OPCODE:
3364           ir.override = X86_RECORD_CS_REGNUM;
3365           break;
3366         case SS_PREFIX_OPCODE:
3367           ir.override = X86_RECORD_SS_REGNUM;
3368           break;
3369         case DS_PREFIX_OPCODE:
3370           ir.override = X86_RECORD_DS_REGNUM;
3371           break;
3372         case ES_PREFIX_OPCODE:
3373           ir.override = X86_RECORD_ES_REGNUM;
3374           break;
3375         case FS_PREFIX_OPCODE:
3376           ir.override = X86_RECORD_FS_REGNUM;
3377           break;
3378         case GS_PREFIX_OPCODE:
3379           ir.override = X86_RECORD_GS_REGNUM;
3380           break;
3381         case DATA_PREFIX_OPCODE:
3382           prefixes |= PREFIX_DATA;
3383           break;
3384         case ADDR_PREFIX_OPCODE:
3385           prefixes |= PREFIX_ADDR;
3386           break;
3387         case 0x40:      /* i386 inc %eax */
3388         case 0x41:      /* i386 inc %ecx */
3389         case 0x42:      /* i386 inc %edx */
3390         case 0x43:      /* i386 inc %ebx */
3391         case 0x44:      /* i386 inc %esp */
3392         case 0x45:      /* i386 inc %ebp */
3393         case 0x46:      /* i386 inc %esi */
3394         case 0x47:      /* i386 inc %edi */
3395         case 0x48:      /* i386 dec %eax */
3396         case 0x49:      /* i386 dec %ecx */
3397         case 0x4a:      /* i386 dec %edx */
3398         case 0x4b:      /* i386 dec %ebx */
3399         case 0x4c:      /* i386 dec %esp */
3400         case 0x4d:      /* i386 dec %ebp */
3401         case 0x4e:      /* i386 dec %esi */
3402         case 0x4f:      /* i386 dec %edi */
3403           if (ir.regmap[X86_RECORD_R8_REGNUM])  /* 64 bit target */
3404             {
3405                /* REX */
3406                rex = 1;
3407                rex_w = (tmpu8 >> 3) & 1;
3408                rex_r = (tmpu8 & 0x4) << 1;
3409                ir.rex_x = (tmpu8 & 0x2) << 2;
3410                ir.rex_b = (tmpu8 & 0x1) << 3;
3411             }
3412           else                                  /* 32 bit target */
3413             goto out_prefixes;
3414           break;
3415         default:
3416           goto out_prefixes;
3417           break;
3418         }
3419     }
3420  out_prefixes:
3421   if (ir.regmap[X86_RECORD_R8_REGNUM] && rex_w == 1)
3422     {
3423       ir.dflag = 2;
3424     }
3425   else
3426     {
3427       if (prefixes & PREFIX_DATA)
3428         ir.dflag ^= 1;
3429     }
3430   if (prefixes & PREFIX_ADDR)
3431     ir.aflag ^= 1;
3432   else if (ir.regmap[X86_RECORD_R8_REGNUM])
3433     ir.aflag = 2;
3434
3435   /* now check op code */
3436   opcode = (uint32_t) tmpu8;
3437  reswitch:
3438   switch (opcode)
3439     {
3440     case 0x0f:
3441       if (target_read_memory (ir.addr, &tmpu8, 1))
3442         {
3443           if (record_debug)
3444             printf_unfiltered (_("Process record: error reading memory at "
3445                                  "addr %s len = 1.\n"),
3446                                paddress (gdbarch, ir.addr));
3447           return -1;
3448         }
3449       ir.addr++;
3450       opcode = (uint16_t) tmpu8 | 0x0f00;
3451       goto reswitch;
3452       break;
3453
3454     case 0x00:    /* arith & logic */
3455     case 0x01:
3456     case 0x02:
3457     case 0x03:
3458     case 0x04:
3459     case 0x05:
3460     case 0x08:
3461     case 0x09:
3462     case 0x0a:
3463     case 0x0b:
3464     case 0x0c:
3465     case 0x0d:
3466     case 0x10:
3467     case 0x11:
3468     case 0x12:
3469     case 0x13:
3470     case 0x14:
3471     case 0x15:
3472     case 0x18:
3473     case 0x19:
3474     case 0x1a:
3475     case 0x1b:
3476     case 0x1c:
3477     case 0x1d:
3478     case 0x20:
3479     case 0x21:
3480     case 0x22:
3481     case 0x23:
3482     case 0x24:
3483     case 0x25:
3484     case 0x28:
3485     case 0x29:
3486     case 0x2a:
3487     case 0x2b:
3488     case 0x2c:
3489     case 0x2d:
3490     case 0x30:
3491     case 0x31:
3492     case 0x32:
3493     case 0x33:
3494     case 0x34:
3495     case 0x35:
3496     case 0x38:
3497     case 0x39:
3498     case 0x3a:
3499     case 0x3b:
3500     case 0x3c:
3501     case 0x3d:
3502       if (((opcode >> 3) & 7) != OP_CMPL)
3503         {
3504           if ((opcode & 1) == 0)
3505             ir.ot = OT_BYTE;
3506           else
3507             ir.ot = ir.dflag + OT_WORD;
3508
3509           switch ((opcode >> 1) & 3)
3510             {
3511             case 0:    /* OP Ev, Gv */
3512               if (i386_record_modrm (&ir))
3513                 return -1;
3514               if (ir.mod != 3)
3515                 {
3516                   if (i386_record_lea_modrm (&ir))
3517                     return -1;
3518                 }
3519               else
3520                 {
3521                   ir.rm |= ir.rex_b;
3522                   if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3523                     ir.rm &= 0x3;
3524                   I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
3525                 }
3526               break;
3527             case 1:    /* OP Gv, Ev */
3528               if (i386_record_modrm (&ir))
3529                 return -1;
3530               ir.reg |= rex_r;
3531               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3532                 ir.reg &= 0x3;
3533               I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
3534               break;
3535             case 2:    /* OP A, Iv */
3536               I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
3537               break;
3538             }
3539         }
3540       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3541       break;
3542
3543     case 0x80:    /* GRP1 */
3544     case 0x81:
3545     case 0x82:
3546     case 0x83:
3547       if (i386_record_modrm (&ir))
3548         return -1;
3549
3550       if (ir.reg != OP_CMPL)
3551         {
3552           if ((opcode & 1) == 0)
3553             ir.ot = OT_BYTE;
3554           else
3555             ir.ot = ir.dflag + OT_WORD;
3556
3557           if (ir.mod != 3)
3558             {
3559               if (opcode == 0x83)
3560                 ir.rip_offset = 1;
3561               else
3562                 ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
3563               if (i386_record_lea_modrm (&ir))
3564                 return -1;
3565             }
3566           else
3567             I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
3568         }
3569       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3570       break;
3571
3572     case 0x40:      /* inc */
3573     case 0x41:
3574     case 0x42:
3575     case 0x43:
3576     case 0x44:
3577     case 0x45:
3578     case 0x46:
3579     case 0x47:
3580
3581     case 0x48:      /* dec */
3582     case 0x49:
3583     case 0x4a:
3584     case 0x4b:
3585     case 0x4c:
3586     case 0x4d:
3587     case 0x4e:
3588     case 0x4f:
3589
3590       I386_RECORD_ARCH_LIST_ADD_REG (opcode & 7);
3591       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3592       break;
3593
3594     case 0xf6:    /* GRP3 */
3595     case 0xf7:
3596       if ((opcode & 1) == 0)
3597         ir.ot = OT_BYTE;
3598       else
3599         ir.ot = ir.dflag + OT_WORD;
3600       if (i386_record_modrm (&ir))
3601         return -1;
3602
3603       if (ir.mod != 3 && ir.reg == 0)
3604         ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
3605
3606       switch (ir.reg)
3607         {
3608         case 0:    /* test */
3609           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3610           break;
3611         case 2:    /* not */
3612         case 3:    /* neg */
3613           if (ir.mod != 3)
3614             {
3615               if (i386_record_lea_modrm (&ir))
3616                 return -1;
3617             }
3618           else
3619             {
3620               ir.rm |= ir.rex_b;
3621               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3622                 ir.rm &= 0x3;
3623               I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
3624             }
3625           if (ir.reg == 3)  /* neg */
3626             I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3627           break;
3628         case 4:    /* mul  */
3629         case 5:    /* imul */
3630         case 6:    /* div  */
3631         case 7:    /* idiv */
3632           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
3633           if (ir.ot != OT_BYTE)
3634             I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
3635           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3636           break;
3637         default:
3638           ir.addr -= 2;
3639           opcode = opcode << 8 | ir.modrm;
3640           goto no_support;
3641           break;
3642         }
3643       break;
3644
3645     case 0xfe:    /* GRP4 */
3646     case 0xff:    /* GRP5 */
3647       if (i386_record_modrm (&ir))
3648         return -1;
3649       if (ir.reg >= 2 && opcode == 0xfe)
3650         {
3651           ir.addr -= 2;
3652           opcode = opcode << 8 | ir.modrm;
3653           goto no_support;
3654         }
3655       switch (ir.reg)
3656         {
3657         case 0:    /* inc */
3658         case 1:    /* dec */
3659           if ((opcode & 1) == 0)
3660             ir.ot = OT_BYTE;
3661           else
3662             ir.ot = ir.dflag + OT_WORD;
3663           if (ir.mod != 3)
3664             {
3665               if (i386_record_lea_modrm (&ir))
3666                 return -1;
3667             }
3668           else
3669             {
3670               ir.rm |= ir.rex_b;
3671               if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3672                 ir.rm &= 0x3;
3673               I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
3674             }
3675           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3676           break;
3677         case 2:    /* call */
3678           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
3679             ir.dflag = 2;
3680           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
3681             return -1;
3682           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3683           break;
3684         case 3:    /* lcall */
3685           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
3686           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
3687             return -1;
3688           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3689           break;
3690         case 4:    /* jmp  */
3691         case 5:    /* ljmp */
3692           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3693           break;
3694         case 6:    /* push */
3695           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
3696             ir.dflag = 2;
3697           if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
3698             return -1;
3699           break;
3700         default:
3701           ir.addr -= 2;
3702           opcode = opcode << 8 | ir.modrm;
3703           goto no_support;
3704           break;
3705         }
3706       break;
3707
3708     case 0x84:    /* test */
3709     case 0x85:
3710     case 0xa8:
3711     case 0xa9:
3712       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3713       break;
3714
3715     case 0x98:    /* CWDE/CBW */
3716       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
3717       break;
3718
3719     case 0x99:    /* CDQ/CWD */
3720       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
3721       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
3722       break;
3723
3724     case 0x0faf:  /* imul */
3725     case 0x69:
3726     case 0x6b:
3727       ir.ot = ir.dflag + OT_WORD;
3728       if (i386_record_modrm (&ir))
3729         return -1;
3730       if (opcode == 0x69)
3731         ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
3732       else if (opcode == 0x6b)
3733         ir.rip_offset = 1;
3734       ir.reg |= rex_r;
3735       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3736         ir.reg &= 0x3;
3737       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
3738       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3739       break;
3740
3741     case 0x0fc0:  /* xadd */
3742     case 0x0fc1:
3743       if ((opcode & 1) == 0)
3744         ir.ot = OT_BYTE;
3745       else
3746         ir.ot = ir.dflag + OT_WORD;
3747       if (i386_record_modrm (&ir))
3748         return -1;
3749       ir.reg |= rex_r;
3750       if (ir.mod == 3)
3751         {
3752           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3753             ir.reg &= 0x3;
3754           I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
3755           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3756             ir.rm &= 0x3;
3757           I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
3758         }
3759       else
3760         {
3761           if (i386_record_lea_modrm (&ir))
3762             return -1;
3763           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3764             ir.reg &= 0x3;
3765           I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
3766         }
3767       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3768       break;
3769
3770     case 0x0fb0:  /* cmpxchg */
3771     case 0x0fb1:
3772       if ((opcode & 1) == 0)
3773         ir.ot = OT_BYTE;
3774       else
3775         ir.ot = ir.dflag + OT_WORD;
3776       if (i386_record_modrm (&ir))
3777         return -1;
3778       if (ir.mod == 3)
3779         {
3780           ir.reg |= rex_r;
3781           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
3782           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3783             ir.reg &= 0x3;
3784           I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
3785         }
3786       else
3787         {
3788           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
3789           if (i386_record_lea_modrm (&ir))
3790             return -1;
3791         }
3792       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3793       break;
3794
3795     case 0x0fc7:    /* cmpxchg8b */
3796       if (i386_record_modrm (&ir))
3797         return -1;
3798       if (ir.mod == 3)
3799         {
3800           ir.addr -= 2;
3801           opcode = opcode << 8 | ir.modrm;
3802           goto no_support;
3803         }
3804       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
3805       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
3806       if (i386_record_lea_modrm (&ir))
3807         return -1;
3808       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3809       break;
3810
3811     case 0x50:    /* push */
3812     case 0x51:
3813     case 0x52:
3814     case 0x53:
3815     case 0x54:
3816     case 0x55:
3817     case 0x56:
3818     case 0x57:
3819     case 0x68:
3820     case 0x6a:
3821       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
3822         ir.dflag = 2;
3823       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
3824         return -1;
3825       break;
3826
3827     case 0x06:    /* push es */
3828     case 0x0e:    /* push cs */
3829     case 0x16:    /* push ss */
3830     case 0x1e:    /* push ds */
3831       if (ir.regmap[X86_RECORD_R8_REGNUM])
3832         {
3833           ir.addr -= 1;
3834           goto no_support;
3835         }
3836       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
3837         return -1;
3838       break;
3839
3840     case 0x0fa0:    /* push fs */
3841     case 0x0fa8:    /* push gs */
3842       if (ir.regmap[X86_RECORD_R8_REGNUM])
3843         {
3844           ir.addr -= 2;
3845           goto no_support;
3846         }
3847       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
3848         return -1;
3849       break;
3850
3851     case 0x60:    /* pusha */
3852       if (ir.regmap[X86_RECORD_R8_REGNUM])
3853         {
3854           ir.addr -= 1;
3855           goto no_support;
3856         }
3857       if (i386_record_push (&ir, 1 << (ir.dflag + 4)))
3858         return -1;
3859       break;
3860
3861     case 0x58:    /* pop */
3862     case 0x59:
3863     case 0x5a:
3864     case 0x5b:
3865     case 0x5c:
3866     case 0x5d:
3867     case 0x5e:
3868     case 0x5f:
3869       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3870       I386_RECORD_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
3871       break;
3872
3873     case 0x61:    /* popa */
3874       if (ir.regmap[X86_RECORD_R8_REGNUM])
3875         {
3876           ir.addr -= 1;
3877           goto no_support;
3878         }
3879       for (tmpu8 = X86_RECORD_REAX_REGNUM; tmpu8 <= X86_RECORD_REDI_REGNUM;
3880            tmpu8++)
3881         I386_RECORD_ARCH_LIST_ADD_REG (tmpu8);
3882       break;
3883
3884     case 0x8f:    /* pop */
3885       if (ir.regmap[X86_RECORD_R8_REGNUM])
3886         ir.ot = ir.dflag ? OT_QUAD : OT_WORD;
3887       else
3888         ir.ot = ir.dflag + OT_WORD;
3889       if (i386_record_modrm (&ir))
3890         return -1;
3891       if (ir.mod == 3)
3892         I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
3893       else
3894         {
3895           ir.popl_esp_hack = 1 << ir.ot;
3896           if (i386_record_lea_modrm (&ir))
3897             return -1;
3898         }
3899       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3900       break;
3901
3902     case 0xc8:    /* enter */
3903       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
3904       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
3905         ir.dflag = 2;
3906       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
3907         return -1;
3908       break;
3909
3910     case 0xc9:    /* leave */
3911       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3912       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
3913       break;
3914
3915     case 0x07:    /* pop es */
3916       if (ir.regmap[X86_RECORD_R8_REGNUM])
3917         {
3918           ir.addr -= 1;
3919           goto no_support;
3920         }
3921       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3922       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_ES_REGNUM);
3923       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3924       break;
3925
3926     case 0x17:    /* pop ss */
3927       if (ir.regmap[X86_RECORD_R8_REGNUM])
3928         {
3929           ir.addr -= 1;
3930           goto no_support;
3931         }
3932       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3933       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_SS_REGNUM);
3934       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3935       break;
3936
3937     case 0x1f:    /* pop ds */
3938       if (ir.regmap[X86_RECORD_R8_REGNUM])
3939         {
3940           ir.addr -= 1;
3941           goto no_support;
3942         }
3943       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3944       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_DS_REGNUM);
3945       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3946       break;
3947
3948     case 0x0fa1:    /* pop fs */
3949       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3950       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_FS_REGNUM);
3951       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3952       break;
3953
3954     case 0x0fa9:    /* pop gs */
3955       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
3956       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
3957       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
3958       break;
3959
3960     case 0x88:    /* mov */
3961     case 0x89:
3962     case 0xc6:
3963     case 0xc7:
3964       if ((opcode & 1) == 0)
3965         ir.ot = OT_BYTE;
3966       else
3967         ir.ot = ir.dflag + OT_WORD;
3968
3969       if (i386_record_modrm (&ir))
3970         return -1;
3971
3972       if (ir.mod != 3)
3973         {
3974           if (opcode == 0xc6 || opcode == 0xc7)
3975             ir.rip_offset = (ir.ot > OT_LONG) ? 4 : (1 << ir.ot);
3976           if (i386_record_lea_modrm (&ir))
3977             return -1;
3978         }
3979       else
3980         {
3981           if (opcode == 0xc6 || opcode == 0xc7)
3982             ir.rm |= ir.rex_b;
3983           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3984             ir.rm &= 0x3;
3985           I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
3986         }
3987       break;
3988
3989     case 0x8a:    /* mov */
3990     case 0x8b:
3991       if ((opcode & 1) == 0)
3992         ir.ot = OT_BYTE;
3993       else
3994         ir.ot = ir.dflag + OT_WORD;
3995       if (i386_record_modrm (&ir))
3996         return -1;
3997       ir.reg |= rex_r;
3998       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
3999         ir.reg &= 0x3;
4000       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
4001       break;
4002
4003     case 0x8c:    /* mov seg */
4004       if (i386_record_modrm (&ir))
4005         return -1;
4006       if (ir.reg > 5)
4007         {
4008           ir.addr -= 2;
4009           opcode = opcode << 8 | ir.modrm;
4010           goto no_support;
4011         }
4012
4013       if (ir.mod == 3)
4014         I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
4015       else
4016         {
4017           ir.ot = OT_WORD;
4018           if (i386_record_lea_modrm (&ir))
4019             return -1;
4020         }
4021       break;
4022
4023     case 0x8e:    /* mov seg */
4024       if (i386_record_modrm (&ir))
4025         return -1;
4026       switch (ir.reg)
4027         {
4028         case 0:
4029           tmpu8 = X86_RECORD_ES_REGNUM;
4030           break;
4031         case 2:
4032           tmpu8 = X86_RECORD_SS_REGNUM;
4033           break;
4034         case 3:
4035           tmpu8 = X86_RECORD_DS_REGNUM;
4036           break;
4037         case 4:
4038           tmpu8 = X86_RECORD_FS_REGNUM;
4039           break;
4040         case 5:
4041           tmpu8 = X86_RECORD_GS_REGNUM;
4042           break;
4043         default:
4044           ir.addr -= 2;
4045           opcode = opcode << 8 | ir.modrm;
4046           goto no_support;
4047           break;
4048         }
4049       I386_RECORD_ARCH_LIST_ADD_REG (tmpu8);
4050       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4051       break;
4052
4053     case 0x0fb6:    /* movzbS */
4054     case 0x0fb7:    /* movzwS */
4055     case 0x0fbe:    /* movsbS */
4056     case 0x0fbf:    /* movswS */
4057       if (i386_record_modrm (&ir))
4058         return -1;
4059       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
4060       break;
4061
4062     case 0x8d:      /* lea */
4063       if (i386_record_modrm (&ir))
4064         return -1;
4065       if (ir.mod == 3)
4066         {
4067           ir.addr -= 2;
4068           opcode = opcode << 8 | ir.modrm;
4069           goto no_support;
4070         }
4071       ir.ot = ir.dflag;
4072       ir.reg |= rex_r;
4073       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4074         ir.reg &= 0x3;
4075       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
4076       break;
4077
4078     case 0xa0:    /* mov EAX */
4079     case 0xa1:
4080
4081     case 0xd7:    /* xlat */
4082       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4083       break;
4084
4085     case 0xa2:    /* mov EAX */
4086     case 0xa3:
4087       if (ir.override >= 0)
4088         {
4089           warning (_("Process record ignores the memory change "
4090                      "of instruction at address %s because "
4091                      "it can't get the value of the segment "
4092                      "register."),
4093                    paddress (gdbarch, ir.orig_addr));
4094         }
4095       else
4096         {
4097           if ((opcode & 1) == 0)
4098             ir.ot = OT_BYTE;
4099           else
4100             ir.ot = ir.dflag + OT_WORD;
4101           if (ir.aflag == 2)
4102             {
4103               if (target_read_memory (ir.addr, (gdb_byte *) &addr, 8))
4104                 {
4105                   if (record_debug)
4106                     printf_unfiltered (_("Process record: error reading "
4107                                          "memory at addr 0x%s len = 8.\n"),
4108                                        paddress (gdbarch, ir.addr));
4109                   return -1;
4110                 }
4111               ir.addr += 8;
4112             }
4113           else if (ir.aflag)
4114             {
4115               if (target_read_memory (ir.addr, (gdb_byte *) &tmpu32, 4))
4116                 {
4117                   if (record_debug)
4118                     printf_unfiltered (_("Process record: error reading "
4119                                          "memory at addr 0x%s len = 4.\n"),
4120                                        paddress (gdbarch, ir.addr));
4121                   return -1;
4122                 }
4123               ir.addr += 4;
4124               addr = tmpu32;
4125             }
4126           else
4127             {
4128               if (target_read_memory (ir.addr, (gdb_byte *) &tmpu16, 2))
4129                 {
4130                   if (record_debug)
4131                     printf_unfiltered (_("Process record: error reading "
4132                                          "memory at addr 0x%s len = 2.\n"),
4133                                        paddress (gdbarch, ir.addr));
4134                   return -1;
4135                 }
4136               ir.addr += 2;
4137               addr = tmpu16;
4138             }
4139           if (record_arch_list_add_mem (addr, 1 << ir.ot))
4140             return -1;
4141         }
4142       break;
4143
4144     case 0xb0:    /* mov R, Ib */
4145     case 0xb1:
4146     case 0xb2:
4147     case 0xb3:
4148     case 0xb4:
4149     case 0xb5:
4150     case 0xb6:
4151     case 0xb7:
4152       I386_RECORD_ARCH_LIST_ADD_REG ((ir.regmap[X86_RECORD_R8_REGNUM])
4153                                         ? ((opcode & 0x7) | ir.rex_b)
4154                                         : ((opcode & 0x7) & 0x3));
4155       break;
4156
4157     case 0xb8:    /* mov R, Iv */
4158     case 0xb9:
4159     case 0xba:
4160     case 0xbb:
4161     case 0xbc:
4162     case 0xbd:
4163     case 0xbe:
4164     case 0xbf:
4165       I386_RECORD_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
4166       break;
4167
4168     case 0x91:    /* xchg R, EAX */
4169     case 0x92:
4170     case 0x93:
4171     case 0x94:
4172     case 0x95:
4173     case 0x96:
4174     case 0x97:
4175       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4176       I386_RECORD_ARCH_LIST_ADD_REG (opcode & 0x7);
4177       break;
4178
4179     case 0x86:    /* xchg Ev, Gv */
4180     case 0x87:
4181       if ((opcode & 1) == 0)
4182         ir.ot = OT_BYTE;
4183       else
4184         ir.ot = ir.dflag + OT_WORD;
4185       if (i386_record_modrm (&ir))
4186         return -1;
4187       if (ir.mod == 3)
4188         {
4189           ir.rm |= ir.rex_b;
4190           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4191             ir.rm &= 0x3;
4192           I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
4193         }
4194       else
4195         {
4196           if (i386_record_lea_modrm (&ir))
4197             return -1;
4198         }
4199       ir.reg |= rex_r;
4200       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4201         ir.reg &= 0x3;
4202       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
4203       break;
4204
4205     case 0xc4:    /* les Gv */
4206     case 0xc5:    /* lds Gv */
4207       if (ir.regmap[X86_RECORD_R8_REGNUM])
4208         {
4209           ir.addr -= 1;
4210           goto no_support;
4211         }
4212     case 0x0fb2:    /* lss Gv */
4213     case 0x0fb4:    /* lfs Gv */
4214     case 0x0fb5:    /* lgs Gv */
4215       if (i386_record_modrm (&ir))
4216         return -1;
4217       if (ir.mod == 3)
4218         {
4219           if (opcode > 0xff)
4220             ir.addr -= 3;
4221           else
4222             ir.addr -= 2;
4223           opcode = opcode << 8 | ir.modrm;
4224           goto no_support;
4225         }
4226       switch (opcode)
4227         {
4228         case 0xc4:    /* les Gv */
4229           tmpu8 = X86_RECORD_ES_REGNUM;
4230           break;
4231         case 0xc5:    /* lds Gv */
4232           tmpu8 = X86_RECORD_DS_REGNUM;
4233           break;
4234         case 0x0fb2:  /* lss Gv */
4235           tmpu8 = X86_RECORD_SS_REGNUM;
4236           break;
4237         case 0x0fb4:  /* lfs Gv */
4238           tmpu8 = X86_RECORD_FS_REGNUM;
4239           break;
4240         case 0x0fb5:  /* lgs Gv */
4241           tmpu8 = X86_RECORD_GS_REGNUM;
4242           break;
4243         }
4244       I386_RECORD_ARCH_LIST_ADD_REG (tmpu8);
4245       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
4246       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4247       break;
4248
4249     case 0xc0:    /* shifts */
4250     case 0xc1:
4251     case 0xd0:
4252     case 0xd1:
4253     case 0xd2:
4254     case 0xd3:
4255       if ((opcode & 1) == 0)
4256         ir.ot = OT_BYTE;
4257       else
4258         ir.ot = ir.dflag + OT_WORD;
4259       if (i386_record_modrm (&ir))
4260         return -1;
4261       if (ir.mod != 3 && (opcode == 0xd2 || opcode == 0xd3))
4262         {
4263           if (i386_record_lea_modrm (&ir))
4264             return -1;
4265         }
4266       else
4267         {
4268           ir.rm |= ir.rex_b;
4269           if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
4270             ir.rm &= 0x3;
4271           I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
4272         }
4273       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4274       break;
4275
4276     case 0x0fa4:
4277     case 0x0fa5:
4278     case 0x0fac:
4279     case 0x0fad:
4280       if (i386_record_modrm (&ir))
4281         return -1;
4282       if (ir.mod == 3)
4283         {
4284           if (record_arch_list_add_reg (ir.regcache, ir.rm))
4285             return -1;
4286         }
4287       else
4288         {
4289           if (i386_record_lea_modrm (&ir))
4290             return -1;
4291         }
4292       break;
4293
4294     case 0xd8:    /* Floats.  */
4295     case 0xd9:
4296     case 0xda:
4297     case 0xdb:
4298     case 0xdc:
4299     case 0xdd:
4300     case 0xde:
4301     case 0xdf:
4302       if (i386_record_modrm (&ir))
4303         return -1;
4304       ir.reg |= ((opcode & 7) << 3);
4305       if (ir.mod != 3)
4306         {
4307           /* Memory. */
4308           uint64_t tmpu64;
4309
4310           if (i386_record_lea_modrm_addr (&ir, &tmpu64))
4311             return -1;
4312           switch (ir.reg)
4313             {
4314             case 0x02:
4315             case 0x12:
4316             case 0x22:
4317             case 0x32:
4318               /* For fcom, ficom nothing to do.  */
4319               break;
4320             case 0x03:
4321             case 0x13:
4322             case 0x23:
4323             case 0x33:
4324               /* For fcomp, ficomp pop FPU stack, store all.  */
4325               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
4326                 return -1;
4327               break;
4328             case 0x00:
4329             case 0x01:
4330             case 0x04:
4331             case 0x05:
4332             case 0x06:
4333             case 0x07:
4334             case 0x10:
4335             case 0x11:
4336             case 0x14:
4337             case 0x15:
4338             case 0x16:
4339             case 0x17:
4340             case 0x20:
4341             case 0x21:
4342             case 0x24:
4343             case 0x25:
4344             case 0x26:
4345             case 0x27:
4346             case 0x30:
4347             case 0x31:
4348             case 0x34:
4349             case 0x35:
4350             case 0x36:
4351             case 0x37:
4352               /* For fadd, fmul, fsub, fsubr, fdiv, fdivr, fiadd, fimul,
4353                  fisub, fisubr, fidiv, fidivr, modR/M.reg is an extension
4354                  of code,  always affects st(0) register.  */
4355               if (i386_record_floats (gdbarch, &ir, I387_ST0_REGNUM (tdep)))
4356                 return -1;
4357               break;
4358             case 0x08:
4359             case 0x0a:
4360             case 0x0b:
4361             case 0x18:
4362             case 0x19:
4363             case 0x1a:
4364             case 0x1b:
4365             case 0x1d:
4366             case 0x28:
4367             case 0x29:
4368             case 0x2a:
4369             case 0x2b:
4370             case 0x38:
4371             case 0x39:
4372             case 0x3a:
4373             case 0x3b:
4374             case 0x3c:
4375             case 0x3d:
4376               switch (ir.reg & 7)
4377                 {
4378                 case 0:
4379                   /* Handling fld, fild.  */
4380                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
4381                     return -1;
4382                   break;
4383                 case 1:
4384                   switch (ir.reg >> 4)
4385                     {
4386                     case 0:
4387                       if (record_arch_list_add_mem (tmpu64, 4))
4388                         return -1;
4389                       break;
4390                     case 2:
4391                       if (record_arch_list_add_mem (tmpu64, 8))
4392                         return -1;
4393                       break;
4394                     case 3:
4395                       break;
4396                     default:
4397                       if (record_arch_list_add_mem (tmpu64, 2))
4398                         return -1;
4399                       break;
4400                     }
4401                   break;
4402                 default:
4403                   switch (ir.reg >> 4)
4404                     {
4405                     case 0:
4406                       if (record_arch_list_add_mem (tmpu64, 4))
4407                         return -1;
4408                       if (3 == (ir.reg & 7))
4409                         {
4410                           /* For fstp m32fp.  */
4411                           if (i386_record_floats (gdbarch, &ir,
4412                                                   I386_SAVE_FPU_REGS))
4413                             return -1;
4414                         }
4415                       break;
4416                     case 1:
4417                       if (record_arch_list_add_mem (tmpu64, 4))
4418                         return -1;
4419                       if ((3 == (ir.reg & 7))
4420                           || (5 == (ir.reg & 7))
4421                           || (7 == (ir.reg & 7)))
4422                         {
4423                           /* For fstp insn.  */
4424                           if (i386_record_floats (gdbarch, &ir,
4425                                                   I386_SAVE_FPU_REGS))
4426                             return -1;
4427                         }
4428                       break;
4429                     case 2:
4430                       if (record_arch_list_add_mem (tmpu64, 8))
4431                         return -1;
4432                       if (3 == (ir.reg & 7))
4433                         {
4434                           /* For fstp m64fp.  */
4435                           if (i386_record_floats (gdbarch, &ir,
4436                                                   I386_SAVE_FPU_REGS))
4437                             return -1;
4438                         }
4439                       break;
4440                     case 3:
4441                       if ((3 <= (ir.reg & 7)) && (6 <= (ir.reg & 7)))
4442                         {
4443                           /* For fistp, fbld, fild, fbstp.  */
4444                           if (i386_record_floats (gdbarch, &ir,
4445                                                   I386_SAVE_FPU_REGS))
4446                             return -1;
4447                         }
4448                       /* Fall through */
4449                     default:
4450                       if (record_arch_list_add_mem (tmpu64, 2))
4451                         return -1;
4452                       break;
4453                     }
4454                   break;
4455                 }
4456               break;
4457             case 0x0c:
4458               /* Insn fldenv.  */
4459               if (i386_record_floats (gdbarch, &ir,
4460                                       I386_SAVE_FPU_ENV_REG_STACK))
4461                 return -1;
4462               break;
4463             case 0x0d:
4464               /* Insn fldcw.  */
4465               if (i386_record_floats (gdbarch, &ir, I387_FCTRL_REGNUM (tdep)))
4466                 return -1;
4467               break;
4468             case 0x2c:
4469               /* Insn frstor.  */
4470               if (i386_record_floats (gdbarch, &ir,
4471                                       I386_SAVE_FPU_ENV_REG_STACK))
4472                 return -1;
4473               break;
4474             case 0x0e:
4475               if (ir.dflag)
4476                 {
4477                   if (record_arch_list_add_mem (tmpu64, 28))
4478                     return -1;
4479                 }
4480               else
4481                 {
4482                   if (record_arch_list_add_mem (tmpu64, 14))
4483                     return -1;
4484                 }
4485               break;
4486             case 0x0f:
4487             case 0x2f:
4488               if (record_arch_list_add_mem (tmpu64, 2))
4489                 return -1;
4490               /* Insn fstp, fbstp.  */
4491               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
4492                 return -1;
4493               break;
4494             case 0x1f:
4495             case 0x3e:
4496               if (record_arch_list_add_mem (tmpu64, 10))
4497                 return -1;
4498               break;
4499             case 0x2e:
4500               if (ir.dflag)
4501                 {
4502                   if (record_arch_list_add_mem (tmpu64, 28))
4503                     return -1;
4504                   tmpu64 += 28;
4505                 }
4506               else
4507                 {
4508                   if (record_arch_list_add_mem (tmpu64, 14))
4509                     return -1;
4510                   tmpu64 += 14;
4511                 }
4512               if (record_arch_list_add_mem (tmpu64, 80))
4513                 return -1;
4514               /* Insn fsave.  */
4515               if (i386_record_floats (gdbarch, &ir,
4516                                       I386_SAVE_FPU_ENV_REG_STACK))
4517                 return -1;
4518               break;
4519             case 0x3f:
4520               if (record_arch_list_add_mem (tmpu64, 8))
4521                 return -1;
4522               /* Insn fistp.  */
4523               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
4524                 return -1;
4525               break;
4526             default:
4527               ir.addr -= 2;
4528               opcode = opcode << 8 | ir.modrm;
4529               goto no_support;
4530               break;
4531             }
4532         }
4533       /* Opcode is an extension of modR/M byte.  */
4534       else
4535         {
4536           switch (opcode)
4537             {
4538             case 0xd8:
4539               if (i386_record_floats (gdbarch, &ir, I387_ST0_REGNUM (tdep)))
4540                 return -1;
4541               break;
4542             case 0xd9:
4543               if (0x0c == (ir.modrm >> 4))
4544                 {
4545                   if ((ir.modrm & 0x0f) <= 7)
4546                     {
4547                       if (i386_record_floats (gdbarch, &ir,
4548                                               I386_SAVE_FPU_REGS))
4549                         return -1;
4550                     }
4551                   else
4552                     {
4553                       if (i386_record_floats (gdbarch, &ir,
4554                                               I387_ST0_REGNUM (tdep)))
4555                         return -1;
4556                       /* If only st(0) is changing, then we have already
4557                          recorded.  */
4558                       if ((ir.modrm & 0x0f) - 0x08)
4559                         {
4560                           if (i386_record_floats (gdbarch, &ir,
4561                                                   I387_ST0_REGNUM (tdep) +
4562                                                   ((ir.modrm & 0x0f) - 0x08)))
4563                             return -1;
4564                         }
4565                     }
4566                 }
4567               else
4568                 {
4569                   switch (ir.modrm)
4570                     {
4571                     case 0xe0:
4572                     case 0xe1:
4573                     case 0xf0:
4574                     case 0xf5:
4575                     case 0xf8:
4576                     case 0xfa:
4577                     case 0xfc:
4578                     case 0xfe:
4579                     case 0xff:
4580                       if (i386_record_floats (gdbarch, &ir,
4581                                               I387_ST0_REGNUM (tdep)))
4582                         return -1;
4583                       break;
4584                     case 0xf1:
4585                     case 0xf2:
4586                     case 0xf3:
4587                     case 0xf4:
4588                     case 0xf6:
4589                     case 0xf7:
4590                     case 0xe8:
4591                     case 0xe9:
4592                     case 0xea:
4593                     case 0xeb:
4594                     case 0xec:
4595                     case 0xed:
4596                     case 0xee:
4597                     case 0xf9:
4598                     case 0xfb:
4599                       if (i386_record_floats (gdbarch, &ir,
4600                                               I386_SAVE_FPU_REGS))
4601                         return -1;
4602                       break;
4603                     case 0xfd:
4604                       if (i386_record_floats (gdbarch, &ir,
4605                                               I387_ST0_REGNUM (tdep)))
4606                         return -1;
4607                       if (i386_record_floats (gdbarch, &ir,
4608                                               I387_ST0_REGNUM (tdep) + 1))
4609                         return -1;
4610                       break;
4611                     }
4612                 }
4613               break;
4614             case 0xda:
4615               if (0xe9 == ir.modrm)
4616                 {
4617                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
4618                     return -1;
4619                 }
4620               else if ((0x0c == ir.modrm >> 4) || (0x0d == ir.modrm >> 4))
4621                 {
4622                   if (i386_record_floats (gdbarch, &ir,
4623                                           I387_ST0_REGNUM (tdep)))
4624                     return -1;
4625                   if (((ir.modrm & 0x0f) > 0) && ((ir.modrm & 0x0f) <= 7))
4626                     {
4627                       if (i386_record_floats (gdbarch, &ir,
4628                                               I387_ST0_REGNUM (tdep) +
4629                                               (ir.modrm & 0x0f)))
4630                         return -1;
4631                     }
4632                   else if ((ir.modrm & 0x0f) - 0x08)
4633                     {
4634                       if (i386_record_floats (gdbarch, &ir,
4635                                               I387_ST0_REGNUM (tdep) +
4636                                               ((ir.modrm & 0x0f) - 0x08)))
4637                         return -1;
4638                     }
4639                 }
4640               break;
4641             case 0xdb:
4642               if (0xe3 == ir.modrm)
4643                 {
4644                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_ENV))
4645                     return -1;
4646                 }
4647               else if ((0x0c == ir.modrm >> 4) || (0x0d == ir.modrm >> 4))
4648                 {
4649                   if (i386_record_floats (gdbarch, &ir,
4650                                           I387_ST0_REGNUM (tdep)))
4651                     return -1;
4652                   if (((ir.modrm & 0x0f) > 0) && ((ir.modrm & 0x0f) <= 7))
4653                     {
4654                       if (i386_record_floats (gdbarch, &ir,
4655                                               I387_ST0_REGNUM (tdep) +
4656                                               (ir.modrm & 0x0f)))
4657                         return -1;
4658                     }
4659                   else if ((ir.modrm & 0x0f) - 0x08)
4660                     {
4661                       if (i386_record_floats (gdbarch, &ir,
4662                                               I387_ST0_REGNUM (tdep) +
4663                                               ((ir.modrm & 0x0f) - 0x08)))
4664                         return -1;
4665                     }
4666                 }
4667               break;
4668             case 0xdc:
4669               if ((0x0c == ir.modrm >> 4)
4670                   || (0x0d == ir.modrm >> 4)
4671                   || (0x0f == ir.modrm >> 4))
4672                 {
4673                   if ((ir.modrm & 0x0f) <= 7)
4674                     {
4675                       if (i386_record_floats (gdbarch, &ir,
4676                                               I387_ST0_REGNUM (tdep) +
4677                                               (ir.modrm & 0x0f)))
4678                         return -1;
4679                     }
4680                   else
4681                     {
4682                       if (i386_record_floats (gdbarch, &ir,
4683                                               I387_ST0_REGNUM (tdep) +
4684                                               ((ir.modrm & 0x0f) - 0x08)))
4685                         return -1;
4686                     }
4687                 }
4688               break;
4689             case 0xdd:
4690               if (0x0c == ir.modrm >> 4)
4691                 {
4692                   if (i386_record_floats (gdbarch, &ir,
4693                                           I387_FTAG_REGNUM (tdep)))
4694                     return -1;
4695                 }
4696               else if ((0x0d == ir.modrm >> 4) || (0x0e == ir.modrm >> 4))
4697                 {
4698                   if ((ir.modrm & 0x0f) <= 7)
4699                     {
4700                       if (i386_record_floats (gdbarch, &ir,
4701                                               I387_ST0_REGNUM (tdep) +
4702                                               (ir.modrm & 0x0f)))
4703                         return -1;
4704                     }
4705                   else
4706                     {
4707                       if (i386_record_floats (gdbarch, &ir,
4708                                               I386_SAVE_FPU_REGS))
4709                         return -1;
4710                     }
4711                 }
4712               break;
4713             case 0xde:
4714               if ((0x0c == ir.modrm >> 4)
4715                   || (0x0e == ir.modrm >> 4)
4716                   || (0x0f == ir.modrm >> 4)
4717                   || (0xd9 == ir.modrm))
4718                 {
4719                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
4720                     return -1;
4721                 }
4722               break;
4723             case 0xdf:
4724               if (0xe0 == ir.modrm)
4725                 {
4726                   if (record_arch_list_add_reg (ir.regcache, I386_EAX_REGNUM))
4727                     return -1;
4728                 }
4729               else if ((0x0f == ir.modrm >> 4) || (0x0e == ir.modrm >> 4))
4730                 {
4731                   if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
4732                     return -1;
4733                 }
4734               break;
4735             }
4736         }
4737       break;
4738       /* string ops */
4739     case 0xa4:    /* movsS */
4740     case 0xa5:
4741     case 0xaa:    /* stosS */
4742     case 0xab:
4743     case 0x6c:    /* insS */
4744     case 0x6d:
4745       regcache_raw_read_unsigned (ir.regcache,
4746                                   ir.regmap[X86_RECORD_RECX_REGNUM],
4747                                   &tmpulongest);
4748       if (tmpulongest)
4749         {
4750           ULONGEST es, ds;
4751
4752           if ((opcode & 1) == 0)
4753             ir.ot = OT_BYTE;
4754           else
4755             ir.ot = ir.dflag + OT_WORD;
4756           regcache_raw_read_unsigned (ir.regcache,
4757                                       ir.regmap[X86_RECORD_REDI_REGNUM],
4758                                       &tmpulongest);
4759
4760           regcache_raw_read_unsigned (ir.regcache,
4761                                       ir.regmap[X86_RECORD_ES_REGNUM],
4762                                       &es);
4763           regcache_raw_read_unsigned (ir.regcache,
4764                                       ir.regmap[X86_RECORD_DS_REGNUM],
4765                                       &ds);
4766           if (ir.aflag && (es != ds))
4767             {
4768               /* addr += ((uint32_t) read_register (I386_ES_REGNUM)) << 4; */
4769               warning (_("Process record ignores the memory "
4770                          "change of instruction at address %s "
4771                          "because it can't get the value of the "
4772                          "ES segment register."),
4773                        paddress (gdbarch, ir.orig_addr));
4774             }
4775           else
4776             {
4777               if (record_arch_list_add_mem (tmpulongest, 1 << ir.ot))
4778                 return -1;
4779             }
4780
4781           if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
4782             I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
4783           if (opcode == 0xa4 || opcode == 0xa5)
4784             I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
4785           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
4786           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4787         }
4788       break;
4789
4790     case 0xa6:    /* cmpsS */
4791     case 0xa7:
4792       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
4793       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
4794       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
4795         I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
4796       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4797       break;
4798
4799     case 0xac:    /* lodsS */
4800     case 0xad:
4801       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4802       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
4803       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
4804         I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
4805       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4806       break;
4807
4808     case 0xae:    /* scasS */
4809     case 0xaf:
4810       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
4811       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
4812         I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
4813       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4814       break;
4815
4816     case 0x6e:    /* outsS */
4817     case 0x6f:
4818       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
4819       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
4820         I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
4821       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4822       break;
4823
4824     case 0xe4:    /* port I/O */
4825     case 0xe5:
4826     case 0xec:
4827     case 0xed:
4828       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4829       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4830       break;
4831
4832     case 0xe6:
4833     case 0xe7:
4834     case 0xee:
4835     case 0xef:
4836       break;
4837
4838       /* control */
4839     case 0xc2:    /* ret im */
4840     case 0xc3:    /* ret */
4841       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
4842       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4843       break;
4844
4845     case 0xca:    /* lret im */
4846     case 0xcb:    /* lret */
4847     case 0xcf:    /* iret */
4848       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
4849       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
4850       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4851       break;
4852
4853     case 0xe8:    /* call im */
4854       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
4855         ir.dflag = 2;
4856       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
4857         return -1;
4858       break;
4859
4860     case 0x9a:    /* lcall im */
4861       if (ir.regmap[X86_RECORD_R8_REGNUM])
4862         {
4863           ir.addr -= 1;
4864           goto no_support;
4865         }
4866       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
4867       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
4868         return -1;
4869       break;
4870
4871     case 0xe9:    /* jmp im */
4872     case 0xea:    /* ljmp im */
4873     case 0xeb:    /* jmp Jb */
4874     case 0x70:    /* jcc Jb */
4875     case 0x71:
4876     case 0x72:
4877     case 0x73:
4878     case 0x74:
4879     case 0x75:
4880     case 0x76:
4881     case 0x77:
4882     case 0x78:
4883     case 0x79:
4884     case 0x7a:
4885     case 0x7b:
4886     case 0x7c:
4887     case 0x7d:
4888     case 0x7e:
4889     case 0x7f:
4890     case 0x0f80:  /* jcc Jv */
4891     case 0x0f81:
4892     case 0x0f82:
4893     case 0x0f83:
4894     case 0x0f84:
4895     case 0x0f85:
4896     case 0x0f86:
4897     case 0x0f87:
4898     case 0x0f88:
4899     case 0x0f89:
4900     case 0x0f8a:
4901     case 0x0f8b:
4902     case 0x0f8c:
4903     case 0x0f8d:
4904     case 0x0f8e:
4905     case 0x0f8f:
4906       break;
4907
4908     case 0x0f90:  /* setcc Gv */
4909     case 0x0f91:
4910     case 0x0f92:
4911     case 0x0f93:
4912     case 0x0f94:
4913     case 0x0f95:
4914     case 0x0f96:
4915     case 0x0f97:
4916     case 0x0f98:
4917     case 0x0f99:
4918     case 0x0f9a:
4919     case 0x0f9b:
4920     case 0x0f9c:
4921     case 0x0f9d:
4922     case 0x0f9e:
4923     case 0x0f9f:
4924       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4925       ir.ot = OT_BYTE;
4926       if (i386_record_modrm (&ir))
4927         return -1;
4928       if (ir.mod == 3)
4929         I386_RECORD_ARCH_LIST_ADD_REG (ir.rex_b ? (ir.rm | ir.rex_b)
4930                                                 : (ir.rm & 0x3));
4931       else
4932         {
4933           if (i386_record_lea_modrm (&ir))
4934             return -1;
4935         }
4936       break;
4937
4938     case 0x0f40:    /* cmov Gv, Ev */
4939     case 0x0f41:
4940     case 0x0f42:
4941     case 0x0f43:
4942     case 0x0f44:
4943     case 0x0f45:
4944     case 0x0f46:
4945     case 0x0f47:
4946     case 0x0f48:
4947     case 0x0f49:
4948     case 0x0f4a:
4949     case 0x0f4b:
4950     case 0x0f4c:
4951     case 0x0f4d:
4952     case 0x0f4e:
4953     case 0x0f4f:
4954       if (i386_record_modrm (&ir))
4955         return -1;
4956       ir.reg |= rex_r;
4957       if (ir.dflag == OT_BYTE)
4958         ir.reg &= 0x3;
4959       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
4960       break;
4961
4962       /* flags */
4963     case 0x9c:    /* pushf */
4964       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4965       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
4966         ir.dflag = 2;
4967       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
4968         return -1;
4969       break;
4970
4971     case 0x9d:    /* popf */
4972       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
4973       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4974       break;
4975
4976     case 0x9e:    /* sahf */
4977       if (ir.regmap[X86_RECORD_R8_REGNUM])
4978         {
4979           ir.addr -= 1;
4980           goto no_support;
4981         }
4982     case 0xf5:    /* cmc */
4983     case 0xf8:    /* clc */
4984     case 0xf9:    /* stc */
4985     case 0xfc:    /* cld */
4986     case 0xfd:    /* std */
4987       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4988       break;
4989
4990     case 0x9f:    /* lahf */
4991       if (ir.regmap[X86_RECORD_R8_REGNUM])
4992         {
4993           ir.addr -= 1;
4994           goto no_support;
4995         }
4996       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
4997       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
4998       break;
4999
5000       /* bit operations */
5001     case 0x0fba:    /* bt/bts/btr/btc Gv, im */
5002       ir.ot = ir.dflag + OT_WORD;
5003       if (i386_record_modrm (&ir))
5004         return -1;
5005       if (ir.reg < 4)
5006         {
5007           ir.addr -= 2;
5008           opcode = opcode << 8 | ir.modrm;
5009           goto no_support;
5010         }
5011       if (ir.reg != 4)
5012         {
5013           if (ir.mod == 3)
5014             I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5015           else
5016             {
5017               if (i386_record_lea_modrm (&ir))
5018                 return -1;
5019             }
5020         }
5021       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5022       break;
5023
5024     case 0x0fa3:    /* bt Gv, Ev */
5025       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5026       break;
5027
5028     case 0x0fab:    /* bts */
5029     case 0x0fb3:    /* btr */
5030     case 0x0fbb:    /* btc */
5031       ir.ot = ir.dflag + OT_WORD;
5032       if (i386_record_modrm (&ir))
5033         return -1;
5034       if (ir.mod == 3)
5035         I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5036       else
5037         {
5038           uint64_t tmpu64;
5039           if (i386_record_lea_modrm_addr (&ir, &tmpu64))
5040             return -1;
5041           regcache_raw_read_unsigned (ir.regcache,
5042                                       ir.regmap[ir.reg | rex_r],
5043                                       &tmpulongest);
5044           switch (ir.dflag)
5045             {
5046             case 0:
5047               tmpu64 += ((int16_t) tmpulongest >> 4) << 4;
5048               break;
5049             case 1:
5050               tmpu64 += ((int32_t) tmpulongest >> 5) << 5;
5051               break;
5052             case 2:
5053               tmpu64 += ((int64_t) tmpulongest >> 6) << 6;
5054               break;
5055             }
5056           if (record_arch_list_add_mem (tmpu64, 1 << ir.ot))
5057             return -1;
5058           if (i386_record_lea_modrm (&ir))
5059             return -1;
5060         }
5061       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5062       break;
5063
5064     case 0x0fbc:    /* bsf */
5065     case 0x0fbd:    /* bsr */
5066       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
5067       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5068       break;
5069
5070       /* bcd */
5071     case 0x27:    /* daa */
5072     case 0x2f:    /* das */
5073     case 0x37:    /* aaa */
5074     case 0x3f:    /* aas */
5075     case 0xd4:    /* aam */
5076     case 0xd5:    /* aad */
5077       if (ir.regmap[X86_RECORD_R8_REGNUM])
5078         {
5079           ir.addr -= 1;
5080           goto no_support;
5081         }
5082       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5083       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5084       break;
5085
5086       /* misc */
5087     case 0x90:    /* nop */
5088       if (prefixes & PREFIX_LOCK)
5089         {
5090           ir.addr -= 1;
5091           goto no_support;
5092         }
5093       break;
5094
5095     case 0x9b:    /* fwait */
5096       if (target_read_memory (ir.addr, &tmpu8, 1))
5097         {
5098           if (record_debug)
5099             printf_unfiltered (_("Process record: error reading memory at "
5100                                  "addr 0x%s len = 1.\n"),
5101                                paddress (gdbarch, ir.addr));
5102           return -1;
5103         }
5104       opcode = (uint32_t) tmpu8;
5105       ir.addr++;
5106       goto reswitch;
5107       break;
5108
5109       /* XXX */
5110     case 0xcc:    /* int3 */
5111       printf_unfiltered (_("Process record doesn't support instruction "
5112                            "int3.\n"));
5113       ir.addr -= 1;
5114       goto no_support;
5115       break;
5116
5117       /* XXX */
5118     case 0xcd:    /* int */
5119       {
5120         int ret;
5121         if (target_read_memory (ir.addr, &tmpu8, 1))
5122           {
5123             if (record_debug)
5124               printf_unfiltered (_("Process record: error reading memory "
5125                                    "at addr %s len = 1.\n"),
5126                                  paddress (gdbarch, ir.addr));
5127             return -1;
5128           }
5129         ir.addr++;
5130         if (tmpu8 != 0x80
5131             || gdbarch_tdep (gdbarch)->i386_intx80_record == NULL)
5132           {
5133             printf_unfiltered (_("Process record doesn't support "
5134                                  "instruction int 0x%02x.\n"),
5135                                tmpu8);
5136             ir.addr -= 2;
5137             goto no_support;
5138           }
5139         ret = gdbarch_tdep (gdbarch)->i386_intx80_record (ir.regcache);
5140         if (ret)
5141           return ret;
5142       }
5143       break;
5144
5145       /* XXX */
5146     case 0xce:    /* into */
5147       printf_unfiltered (_("Process record doesn't support "
5148                            "instruction into.\n"));
5149       ir.addr -= 1;
5150       goto no_support;
5151       break;
5152
5153     case 0xfa:    /* cli */
5154     case 0xfb:    /* sti */
5155       break;
5156
5157     case 0x62:    /* bound */
5158       printf_unfiltered (_("Process record doesn't support "
5159                            "instruction bound.\n"));
5160       ir.addr -= 1;
5161       goto no_support;
5162       break;
5163
5164     case 0x0fc8:    /* bswap reg */
5165     case 0x0fc9:
5166     case 0x0fca:
5167     case 0x0fcb:
5168     case 0x0fcc:
5169     case 0x0fcd:
5170     case 0x0fce:
5171     case 0x0fcf:
5172       I386_RECORD_ARCH_LIST_ADD_REG ((opcode & 7) | ir.rex_b);
5173       break;
5174
5175     case 0xd6:    /* salc */
5176       if (ir.regmap[X86_RECORD_R8_REGNUM])
5177         {
5178           ir.addr -= 1;
5179           goto no_support;
5180         }
5181       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5182       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5183       break;
5184
5185     case 0xe0:    /* loopnz */
5186     case 0xe1:    /* loopz */
5187     case 0xe2:    /* loop */
5188     case 0xe3:    /* jecxz */
5189       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
5190       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5191       break;
5192
5193     case 0x0f30:    /* wrmsr */
5194       printf_unfiltered (_("Process record doesn't support "
5195                            "instruction wrmsr.\n"));
5196       ir.addr -= 2;
5197       goto no_support;
5198       break;
5199
5200     case 0x0f32:    /* rdmsr */
5201       printf_unfiltered (_("Process record doesn't support "
5202                            "instruction rdmsr.\n"));
5203       ir.addr -= 2;
5204       goto no_support;
5205       break;
5206
5207     case 0x0f31:    /* rdtsc */
5208       printf_unfiltered (_("Process record doesn't support "
5209                            "instruction rdtsc.\n"));
5210       ir.addr -= 2;
5211       goto no_support;
5212       break;
5213
5214     case 0x0f34:    /* sysenter */
5215       {
5216         int ret;
5217         if (ir.regmap[X86_RECORD_R8_REGNUM])
5218           {
5219             ir.addr -= 2;
5220             goto no_support;
5221           }
5222         if (gdbarch_tdep (gdbarch)->i386_sysenter_record == NULL)
5223           {
5224             printf_unfiltered (_("Process record doesn't support "
5225                                  "instruction sysenter.\n"));
5226             ir.addr -= 2;
5227             goto no_support;
5228           }
5229         ret = gdbarch_tdep (gdbarch)->i386_sysenter_record (ir.regcache);
5230         if (ret)
5231           return ret;
5232       }
5233       break;
5234
5235     case 0x0f35:    /* sysexit */
5236       printf_unfiltered (_("Process record doesn't support "
5237                            "instruction sysexit.\n"));
5238       ir.addr -= 2;
5239       goto no_support;
5240       break;
5241
5242     case 0x0f05:    /* syscall */
5243       {
5244         int ret;
5245         if (gdbarch_tdep (gdbarch)->i386_syscall_record == NULL)
5246           {
5247             printf_unfiltered (_("Process record doesn't support "
5248                                  "instruction syscall.\n"));
5249             ir.addr -= 2;
5250             goto no_support;
5251           }
5252         ret = gdbarch_tdep (gdbarch)->i386_syscall_record (ir.regcache);
5253         if (ret)
5254           return ret;
5255       }
5256       break;
5257
5258     case 0x0f07:    /* sysret */
5259       printf_unfiltered (_("Process record doesn't support "
5260                            "instruction sysret.\n"));
5261       ir.addr -= 2;
5262       goto no_support;
5263       break;
5264
5265     case 0x0fa2:    /* cpuid */
5266       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5267       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
5268       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
5269       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
5270       break;
5271
5272     case 0xf4:    /* hlt */
5273       printf_unfiltered (_("Process record doesn't support "
5274                            "instruction hlt.\n"));
5275       ir.addr -= 1;
5276       goto no_support;
5277       break;
5278
5279     case 0x0f00:
5280       if (i386_record_modrm (&ir))
5281         return -1;
5282       switch (ir.reg)
5283         {
5284         case 0:  /* sldt */
5285         case 1:  /* str  */
5286           if (ir.mod == 3)
5287             I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5288           else
5289             {
5290               ir.ot = OT_WORD;
5291               if (i386_record_lea_modrm (&ir))
5292                 return -1;
5293             }
5294           break;
5295         case 2:  /* lldt */
5296         case 3:  /* ltr */
5297           break;
5298         case 4:  /* verr */
5299         case 5:  /* verw */
5300           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5301           break;
5302         default:
5303           ir.addr -= 3;
5304           opcode = opcode << 8 | ir.modrm;
5305           goto no_support;
5306           break;
5307         }
5308       break;
5309
5310     case 0x0f01:
5311       if (i386_record_modrm (&ir))
5312         return -1;
5313       switch (ir.reg)
5314         {
5315         case 0:  /* sgdt */
5316           {
5317             uint64_t tmpu64;
5318
5319             if (ir.mod == 3)
5320               {
5321                 ir.addr -= 3;
5322                 opcode = opcode << 8 | ir.modrm;
5323                 goto no_support;
5324               }
5325             if (ir.override >= 0)
5326               {
5327                 warning (_("Process record ignores the memory "
5328                            "change of instruction at "
5329                            "address %s because it can't get "
5330                            "the value of the segment "
5331                            "register."),
5332                          paddress (gdbarch, ir.orig_addr));
5333               }
5334             else
5335               {
5336                 if (i386_record_lea_modrm_addr (&ir, &tmpu64))
5337                   return -1;
5338                 if (record_arch_list_add_mem (tmpu64, 2))
5339                   return -1;
5340                 tmpu64 += 2;
5341                 if (ir.regmap[X86_RECORD_R8_REGNUM])
5342                   {
5343                     if (record_arch_list_add_mem (tmpu64, 8))
5344                       return -1;
5345                   }
5346                 else
5347                   {
5348                     if (record_arch_list_add_mem (tmpu64, 4))
5349                       return -1;
5350                   }
5351               }
5352           }
5353           break;
5354         case 1:
5355           if (ir.mod == 3)
5356             {
5357               switch (ir.rm)
5358                 {
5359                 case 0:  /* monitor */
5360                   break;
5361                 case 1:  /* mwait */
5362                   I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5363                   break;
5364                 default:
5365                   ir.addr -= 3;
5366                   opcode = opcode << 8 | ir.modrm;
5367                   goto no_support;
5368                   break;
5369                 }
5370             }
5371           else
5372             {
5373               /* sidt */
5374               if (ir.override >= 0)
5375                 {
5376                   warning (_("Process record ignores the memory "
5377                              "change of instruction at "
5378                              "address %s because it can't get "
5379                              "the value of the segment "
5380                              "register."),
5381                            paddress (gdbarch, ir.orig_addr));
5382                 }
5383               else
5384                 {
5385                   uint64_t tmpu64;
5386
5387                   if (i386_record_lea_modrm_addr (&ir, &tmpu64))
5388                     return -1;
5389                   if (record_arch_list_add_mem (tmpu64, 2))
5390                     return -1;
5391                   tmpu64 += 2;
5392                   if (ir.regmap[X86_RECORD_R8_REGNUM])
5393                     {
5394                       if (record_arch_list_add_mem (tmpu64, 8))
5395                         return -1;
5396                     }
5397                   else
5398                     {
5399                       if (record_arch_list_add_mem (tmpu64, 4))
5400                         return -1;
5401                     }
5402                 }
5403             }
5404           break;
5405         case 2:  /* lgdt */
5406           if (ir.mod == 3)
5407             {
5408               /* xgetbv */
5409               if (ir.rm == 0)
5410                 {
5411                   I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
5412                   I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
5413                   break;
5414                 }
5415               /* xsetbv */
5416               else if (ir.rm == 1)
5417                 break;
5418             }
5419         case 3:  /* lidt */
5420           if (ir.mod == 3)
5421             {
5422               ir.addr -= 3;
5423               opcode = opcode << 8 | ir.modrm;
5424               goto no_support;
5425             }
5426           break;
5427         case 4:  /* smsw */
5428           if (ir.mod == 3)
5429             {
5430               if (record_arch_list_add_reg (ir.regcache, ir.rm | ir.rex_b))
5431                 return -1;
5432             }
5433           else
5434             {
5435               ir.ot = OT_WORD;
5436               if (i386_record_lea_modrm (&ir))
5437                 return -1;
5438             }
5439           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5440           break;
5441         case 6:  /* lmsw */
5442           I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5443           break;
5444         case 7:  /* invlpg */
5445           if (ir.mod == 3)
5446             {
5447               if (ir.rm == 0 && ir.regmap[X86_RECORD_R8_REGNUM])
5448                 I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
5449               else
5450                 {
5451                   ir.addr -= 3;
5452                   opcode = opcode << 8 | ir.modrm;
5453                   goto no_support;
5454                 }
5455             }
5456           else
5457             I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5458           break;
5459         default:
5460           ir.addr -= 3;
5461           opcode = opcode << 8 | ir.modrm;
5462           goto no_support;
5463           break;
5464         }
5465       break;
5466
5467     case 0x0f08:    /* invd */
5468     case 0x0f09:    /* wbinvd */
5469       break;
5470
5471     case 0x63:    /* arpl */
5472       if (i386_record_modrm (&ir))
5473         return -1;
5474       if (ir.mod == 3 || ir.regmap[X86_RECORD_R8_REGNUM])
5475         {
5476           I386_RECORD_ARCH_LIST_ADD_REG (ir.regmap[X86_RECORD_R8_REGNUM]
5477                                            ? (ir.reg | rex_r) : ir.rm);
5478         }
5479       else
5480         {
5481           ir.ot = ir.dflag ? OT_LONG : OT_WORD;
5482           if (i386_record_lea_modrm (&ir))
5483             return -1;
5484         }
5485       if (!ir.regmap[X86_RECORD_R8_REGNUM])
5486         I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5487       break;
5488
5489     case 0x0f02:    /* lar */
5490     case 0x0f03:    /* lsl */
5491       if (i386_record_modrm (&ir))
5492         return -1;
5493       I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
5494       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5495       break;
5496
5497     case 0x0f18:
5498       if (i386_record_modrm (&ir))
5499         return -1;
5500       if (ir.mod == 3 && ir.reg == 3)
5501         {
5502           ir.addr -= 3;
5503           opcode = opcode << 8 | ir.modrm;
5504           goto no_support;
5505         }
5506       break;
5507
5508     case 0x0f19:
5509     case 0x0f1a:
5510     case 0x0f1b:
5511     case 0x0f1c:
5512     case 0x0f1d:
5513     case 0x0f1e:
5514     case 0x0f1f:
5515       /* nop (multi byte) */
5516       break;
5517
5518     case 0x0f20:    /* mov reg, crN */
5519     case 0x0f22:    /* mov crN, reg */
5520       if (i386_record_modrm (&ir))
5521         return -1;
5522       if ((ir.modrm & 0xc0) != 0xc0)
5523         {
5524           ir.addr -= 3;
5525           opcode = opcode << 8 | ir.modrm;
5526           goto no_support;
5527         }
5528       switch (ir.reg)
5529         {
5530         case 0:
5531         case 2:
5532         case 3:
5533         case 4:
5534         case 8:
5535           if (opcode & 2)
5536             I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5537           else
5538             I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5539           break;
5540         default:
5541           ir.addr -= 3;
5542           opcode = opcode << 8 | ir.modrm;
5543           goto no_support;
5544           break;
5545         }
5546       break;
5547
5548     case 0x0f21:    /* mov reg, drN */
5549     case 0x0f23:    /* mov drN, reg */
5550       if (i386_record_modrm (&ir))
5551         return -1;
5552       if ((ir.modrm & 0xc0) != 0xc0 || ir.reg == 4
5553           || ir.reg == 5 || ir.reg >= 8)
5554         {
5555           ir.addr -= 3;
5556           opcode = opcode << 8 | ir.modrm;
5557           goto no_support;
5558         }
5559       if (opcode & 2)
5560         I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5561       else
5562         I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
5563       break;
5564
5565     case 0x0f06:    /* clts */
5566       I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
5567       break;
5568
5569       /* MMX/SSE/SSE2/PNI support */
5570       /* XXX */
5571
5572     default:
5573       if (opcode > 0xff)
5574         ir.addr -= 2;
5575       else
5576         ir.addr -= 1;
5577       goto no_support;
5578       break;
5579     }
5580
5581   /* In the future, maybe still need to deal with need_dasm.  */
5582   I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REIP_REGNUM);
5583   if (record_arch_list_add_end ())
5584     return -1;
5585
5586   return 0;
5587
5588  no_support:
5589   printf_unfiltered (_("Process record doesn't support instruction 0x%02x "
5590                        "at address %s.\n"),
5591                      (unsigned int) (opcode), paddress (gdbarch, ir.addr));
5592   return -1;
5593 }
5594
5595 static const int i386_record_regmap[] =
5596 {
5597   I386_EAX_REGNUM, I386_ECX_REGNUM, I386_EDX_REGNUM, I386_EBX_REGNUM,
5598   I386_ESP_REGNUM, I386_EBP_REGNUM, I386_ESI_REGNUM, I386_EDI_REGNUM,
5599   0, 0, 0, 0, 0, 0, 0, 0,
5600   I386_EIP_REGNUM, I386_EFLAGS_REGNUM, I386_CS_REGNUM, I386_SS_REGNUM,
5601   I386_DS_REGNUM, I386_ES_REGNUM, I386_FS_REGNUM, I386_GS_REGNUM
5602 };
5603
5604 /* Check that the given address appears suitable for a fast
5605    tracepoint, which on x86 means that we need an instruction of at
5606    least 5 bytes, so that we can overwrite it with a 4-byte-offset
5607    jump and not have to worry about program jumps to an address in the
5608    middle of the tracepoint jump.  Returns 1 if OK, and writes a size
5609    of instruction to replace, and 0 if not, plus an explanatory
5610    string.  */
5611
5612 static int
5613 i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
5614                                CORE_ADDR addr, int *isize, char **msg)
5615 {
5616   int len, jumplen;
5617   static struct ui_file *gdb_null = NULL;
5618
5619   /* This is based on the target agent using a 4-byte relative jump.
5620      Alternate future possibilities include 8-byte offset for x86-84,
5621      or 3-byte jumps if the program has trampoline space close by.  */
5622   jumplen = 5;
5623
5624   /* Dummy file descriptor for the disassembler.  */
5625   if (!gdb_null)
5626     gdb_null = ui_file_new ();
5627
5628   /* Check for fit.  */
5629   len = gdb_print_insn (gdbarch, addr, gdb_null, NULL);
5630   if (len < jumplen)
5631     {
5632       /* Return a bit of target-specific detail to add to the caller's
5633          generic failure message.  */
5634       if (msg)
5635         *msg = xstrprintf (_("; instruction is only %d bytes long, need at least %d bytes for the jump"),
5636                            len, jumplen);
5637       return 0;
5638     }
5639
5640   if (isize)
5641     *isize = len;
5642   if (msg)
5643     *msg = NULL;
5644   return 1;
5645 }
5646
5647 static int
5648 i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
5649                        struct tdesc_arch_data *tdesc_data)
5650 {
5651   const struct target_desc *tdesc = tdep->tdesc;
5652   const struct tdesc_feature *feature_core, *feature_vector;
5653   int i, num_regs, valid_p;
5654
5655   if (! tdesc_has_registers (tdesc))
5656     return 0;
5657
5658   /* Get core registers.  */
5659   feature_core = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.core");
5660
5661   /* Get SSE registers.  */
5662   feature_vector = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.sse");
5663
5664   if (feature_core == NULL || feature_vector == NULL)
5665     return 0;
5666
5667   valid_p = 1;
5668
5669   num_regs = tdep->num_core_regs;
5670   for (i = 0; i < num_regs; i++)
5671     valid_p &= tdesc_numbered_register (feature_core, tdesc_data, i,
5672                                         tdep->register_names[i]);
5673
5674   /* Need to include %mxcsr, so add one.  */
5675   num_regs += tdep->num_xmm_regs + 1;
5676   for (; i < num_regs; i++)
5677     valid_p &= tdesc_numbered_register (feature_vector, tdesc_data, i,
5678                                         tdep->register_names[i]);
5679
5680   return valid_p;
5681 }
5682
5683 \f
5684 static struct gdbarch *
5685 i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
5686 {
5687   struct gdbarch_tdep *tdep;
5688   struct gdbarch *gdbarch;
5689   struct tdesc_arch_data *tdesc_data;
5690   const struct target_desc *tdesc;
5691   int mm0_regnum;
5692
5693   /* If there is already a candidate, use it.  */
5694   arches = gdbarch_list_lookup_by_info (arches, &info);
5695   if (arches != NULL)
5696     return arches->gdbarch;
5697
5698   /* Allocate space for the new architecture.  */
5699   tdep = XCALLOC (1, struct gdbarch_tdep);
5700   gdbarch = gdbarch_alloc (&info, tdep);
5701
5702   /* General-purpose registers.  */
5703   tdep->gregset = NULL;
5704   tdep->gregset_reg_offset = NULL;
5705   tdep->gregset_num_regs = I386_NUM_GREGS;
5706   tdep->sizeof_gregset = 0;
5707
5708   /* Floating-point registers.  */
5709   tdep->fpregset = NULL;
5710   tdep->sizeof_fpregset = I387_SIZEOF_FSAVE;
5711
5712   /* The default settings include the FPU registers, the MMX registers
5713      and the SSE registers.  This can be overridden for a specific ABI
5714      by adjusting the members `st0_regnum', `mm0_regnum' and
5715      `num_xmm_regs' of `struct gdbarch_tdep', otherwise the registers
5716      will show up in the output of "info all-registers".  Ideally we
5717      should try to autodetect whether they are available, such that we
5718      can prevent "info all-registers" from displaying registers that
5719      aren't available.
5720
5721      NOTE: kevinb/2003-07-13: ... if it's a choice between printing
5722      [the SSE registers] always (even when they don't exist) or never
5723      showing them to the user (even when they do exist), I prefer the
5724      former over the latter.  */
5725
5726   tdep->st0_regnum = I386_ST0_REGNUM;
5727
5728   /* I386_NUM_XREGS includes %mxcsr, so substract one.  */
5729   tdep->num_xmm_regs = I386_NUM_XREGS - 1;
5730
5731   tdep->jb_pc_offset = -1;
5732   tdep->struct_return = pcc_struct_return;
5733   tdep->sigtramp_start = 0;
5734   tdep->sigtramp_end = 0;
5735   tdep->sigtramp_p = i386_sigtramp_p;
5736   tdep->sigcontext_addr = NULL;
5737   tdep->sc_reg_offset = NULL;
5738   tdep->sc_pc_offset = -1;
5739   tdep->sc_sp_offset = -1;
5740
5741   tdep->record_regmap = i386_record_regmap;
5742
5743   /* The format used for `long double' on almost all i386 targets is
5744      the i387 extended floating-point format.  In fact, of all targets
5745      in the GCC 2.95 tree, only OSF/1 does it different, and insists
5746      on having a `long double' that's not `long' at all.  */
5747   set_gdbarch_long_double_format (gdbarch, floatformats_i387_ext);
5748
5749   /* Although the i387 extended floating-point has only 80 significant
5750      bits, a `long double' actually takes up 96, probably to enforce
5751      alignment.  */
5752   set_gdbarch_long_double_bit (gdbarch, 96);
5753
5754   /* Register numbers of various important registers.  */
5755   set_gdbarch_sp_regnum (gdbarch, I386_ESP_REGNUM); /* %esp */
5756   set_gdbarch_pc_regnum (gdbarch, I386_EIP_REGNUM); /* %eip */
5757   set_gdbarch_ps_regnum (gdbarch, I386_EFLAGS_REGNUM); /* %eflags */
5758   set_gdbarch_fp0_regnum (gdbarch, I386_ST0_REGNUM); /* %st(0) */
5759
5760   /* NOTE: kettenis/20040418: GCC does have two possible register
5761      numbering schemes on the i386: dbx and SVR4.  These schemes
5762      differ in how they number %ebp, %esp, %eflags, and the
5763      floating-point registers, and are implemented by the arrays
5764      dbx_register_map[] and svr4_dbx_register_map in
5765      gcc/config/i386.c.  GCC also defines a third numbering scheme in
5766      gcc/config/i386.c, which it designates as the "default" register
5767      map used in 64bit mode.  This last register numbering scheme is
5768      implemented in dbx64_register_map, and is used for AMD64; see
5769      amd64-tdep.c.
5770
5771      Currently, each GCC i386 target always uses the same register
5772      numbering scheme across all its supported debugging formats
5773      i.e. SDB (COFF), stabs and DWARF 2.  This is because
5774      gcc/sdbout.c, gcc/dbxout.c and gcc/dwarf2out.c all use the
5775      DBX_REGISTER_NUMBER macro which is defined by each target's
5776      respective config header in a manner independent of the requested
5777      output debugging format.
5778
5779      This does not match the arrangement below, which presumes that
5780      the SDB and stabs numbering schemes differ from the DWARF and
5781      DWARF 2 ones.  The reason for this arrangement is that it is
5782      likely to get the numbering scheme for the target's
5783      default/native debug format right.  For targets where GCC is the
5784      native compiler (FreeBSD, NetBSD, OpenBSD, GNU/Linux) or for
5785      targets where the native toolchain uses a different numbering
5786      scheme for a particular debug format (stabs-in-ELF on Solaris)
5787      the defaults below will have to be overridden, like
5788      i386_elf_init_abi() does.  */
5789
5790   /* Use the dbx register numbering scheme for stabs and COFF.  */
5791   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_dbx_reg_to_regnum);
5792   set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_dbx_reg_to_regnum);
5793
5794   /* Use the SVR4 register numbering scheme for DWARF 2.  */
5795   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
5796
5797   /* We don't set gdbarch_stab_reg_to_regnum, since ECOFF doesn't seem to
5798      be in use on any of the supported i386 targets.  */
5799
5800   set_gdbarch_print_float_info (gdbarch, i387_print_float_info);
5801
5802   set_gdbarch_get_longjmp_target (gdbarch, i386_get_longjmp_target);
5803
5804   /* Call dummy code.  */
5805   set_gdbarch_push_dummy_call (gdbarch, i386_push_dummy_call);
5806
5807   set_gdbarch_convert_register_p (gdbarch, i386_convert_register_p);
5808   set_gdbarch_register_to_value (gdbarch,  i386_register_to_value);
5809   set_gdbarch_value_to_register (gdbarch, i386_value_to_register);
5810
5811   set_gdbarch_return_value (gdbarch, i386_return_value);
5812
5813   set_gdbarch_skip_prologue (gdbarch, i386_skip_prologue);
5814
5815   /* Stack grows downward.  */
5816   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
5817
5818   set_gdbarch_breakpoint_from_pc (gdbarch, i386_breakpoint_from_pc);
5819   set_gdbarch_decr_pc_after_break (gdbarch, 1);
5820   set_gdbarch_max_insn_length (gdbarch, I386_MAX_INSN_LEN);
5821
5822   set_gdbarch_frame_args_skip (gdbarch, 8);
5823
5824   set_gdbarch_print_insn (gdbarch, i386_print_insn);
5825
5826   set_gdbarch_dummy_id (gdbarch, i386_dummy_id);
5827
5828   set_gdbarch_unwind_pc (gdbarch, i386_unwind_pc);
5829
5830   /* Add the i386 register groups.  */
5831   i386_add_reggroups (gdbarch);
5832   tdep->register_reggroup_p = i386_register_reggroup_p;
5833
5834   /* Helper for function argument information.  */
5835   set_gdbarch_fetch_pointer_argument (gdbarch, i386_fetch_pointer_argument);
5836
5837   /* Hook the function epilogue frame unwinder.  This unwinder is
5838      appended to the list first, so that it supercedes the Dwarf
5839      unwinder in function epilogues (where the Dwarf unwinder
5840      currently fails).  */
5841   frame_unwind_append_unwinder (gdbarch, &i386_epilogue_frame_unwind);
5842
5843   /* Hook in the DWARF CFI frame unwinder.  This unwinder is appended
5844      to the list before the prologue-based unwinders, so that Dwarf
5845      CFI info will be used if it is available.  */
5846   dwarf2_append_unwinders (gdbarch);
5847
5848   frame_base_set_default (gdbarch, &i386_frame_base);
5849
5850   /* Pseudo registers may be changed by amd64_init_abi.  */
5851   set_gdbarch_pseudo_register_read (gdbarch, i386_pseudo_register_read);
5852   set_gdbarch_pseudo_register_write (gdbarch, i386_pseudo_register_write);
5853
5854   set_tdesc_pseudo_register_type (gdbarch, i386_pseudo_register_type);
5855   set_tdesc_pseudo_register_name (gdbarch, i386_pseudo_register_name);
5856
5857   /* The default ABI includes general-purpose registers,
5858      floating-point registers, and the SSE registers.  */
5859   set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS);
5860
5861   /* Get the x86 target description from INFO.  */
5862   tdesc = info.target_desc;
5863   if (! tdesc_has_registers (tdesc))
5864     tdesc = tdesc_i386;
5865   tdep->tdesc = tdesc;
5866
5867   tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS;
5868   tdep->register_names = i386_register_names;
5869
5870   tdep->num_byte_regs = 8;
5871   tdep->num_word_regs = 8;
5872   tdep->num_dword_regs = 0;
5873   tdep->num_mmx_regs = 8;
5874
5875   tdesc_data = tdesc_data_alloc ();
5876
5877   /* Hook in ABI-specific overrides, if they have been registered.  */
5878   info.tdep_info = (void *) tdesc_data;
5879   gdbarch_init_osabi (info, gdbarch);
5880
5881   /* Wire in pseudo registers.  Number of pseudo registers may be
5882      changed.  */
5883   set_gdbarch_num_pseudo_regs (gdbarch, (tdep->num_byte_regs
5884                                          + tdep->num_word_regs
5885                                          + tdep->num_dword_regs
5886                                          + tdep->num_mmx_regs));
5887
5888   /* Target description may be changed.  */
5889   tdesc = tdep->tdesc;
5890
5891   if (!i386_validate_tdesc_p (tdep, tdesc_data))
5892     {
5893       tdesc_data_cleanup (tdesc_data);
5894       xfree (tdep);
5895       gdbarch_free (gdbarch);
5896       return NULL;
5897     }
5898
5899   tdesc_use_registers (gdbarch, tdesc, tdesc_data);
5900
5901   /* Override gdbarch_register_reggroup_p set in tdesc_use_registers.  */
5902   set_gdbarch_register_reggroup_p (gdbarch, tdep->register_reggroup_p);
5903
5904   /* Make %al the first pseudo-register.  */
5905   tdep->al_regnum = gdbarch_num_regs (gdbarch);
5906   tdep->ax_regnum = tdep->al_regnum + tdep->num_byte_regs;
5907
5908   mm0_regnum = tdep->ax_regnum + tdep->num_word_regs;
5909   if (tdep->num_dword_regs)
5910     {
5911       /* Support dword pseudo-registesr if it hasn't been disabled,  */
5912       tdep->eax_regnum = mm0_regnum;
5913       mm0_regnum = tdep->eax_regnum + tdep->num_dword_regs;
5914     }
5915   else
5916     tdep->eax_regnum = -1;
5917
5918   if (tdep->num_mmx_regs != 0)
5919     {
5920       /* Support MMX pseudo-registesr if MMX hasn't been disabled,  */
5921       tdep->mm0_regnum = mm0_regnum;
5922     }
5923   else
5924     tdep->mm0_regnum = -1;
5925
5926   /* Hook in the legacy prologue-based unwinders last (fallback).  */
5927   frame_unwind_append_unwinder (gdbarch, &i386_sigtramp_frame_unwind);
5928   frame_unwind_append_unwinder (gdbarch, &i386_frame_unwind);
5929
5930   /* If we have a register mapping, enable the generic core file
5931      support, unless it has already been enabled.  */
5932   if (tdep->gregset_reg_offset
5933       && !gdbarch_regset_from_core_section_p (gdbarch))
5934     set_gdbarch_regset_from_core_section (gdbarch,
5935                                           i386_regset_from_core_section);
5936
5937   set_gdbarch_skip_permanent_breakpoint (gdbarch,
5938                                          i386_skip_permanent_breakpoint);
5939
5940   set_gdbarch_fast_tracepoint_valid_at (gdbarch,
5941                                         i386_fast_tracepoint_valid_at);
5942
5943   return gdbarch;
5944 }
5945
5946 static enum gdb_osabi
5947 i386_coff_osabi_sniffer (bfd *abfd)
5948 {
5949   if (strcmp (bfd_get_target (abfd), "coff-go32-exe") == 0
5950       || strcmp (bfd_get_target (abfd), "coff-go32") == 0)
5951     return GDB_OSABI_GO32;
5952
5953   return GDB_OSABI_UNKNOWN;
5954 }
5955 \f
5956
5957 /* Provide a prototype to silence -Wmissing-prototypes.  */
5958 void _initialize_i386_tdep (void);
5959
5960 void
5961 _initialize_i386_tdep (void)
5962 {
5963   register_gdbarch_init (bfd_arch_i386, i386_gdbarch_init);
5964
5965   /* Add the variable that controls the disassembly flavor.  */
5966   add_setshow_enum_cmd ("disassembly-flavor", no_class, valid_flavors,
5967                         &disassembly_flavor, _("\
5968 Set the disassembly flavor."), _("\
5969 Show the disassembly flavor."), _("\
5970 The valid values are \"att\" and \"intel\", and the default value is \"att\"."),
5971                         NULL,
5972                         NULL, /* FIXME: i18n: */
5973                         &setlist, &showlist);
5974
5975   /* Add the variable that controls the convention for returning
5976      structs.  */
5977   add_setshow_enum_cmd ("struct-convention", no_class, valid_conventions,
5978                         &struct_convention, _("\
5979 Set the convention for returning small structs."), _("\
5980 Show the convention for returning small structs."), _("\
5981 Valid values are \"default\", \"pcc\" and \"reg\", and the default value\n\
5982 is \"default\"."),
5983                         NULL,
5984                         NULL, /* FIXME: i18n: */
5985                         &setlist, &showlist);
5986
5987   gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour,
5988                                   i386_coff_osabi_sniffer);
5989
5990   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_SVR4,
5991                           i386_svr4_init_abi);
5992   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_GO32,
5993                           i386_go32_init_abi);
5994
5995   /* Initialize the i386-specific register groups.  */
5996   i386_init_reggroups ();
5997
5998   /* Initialize the standard target descriptions.  */
5999   initialize_tdesc_i386 ();
6000 }