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