Add return address collection for tracepoints.
[external/binutils.git] / gdb / amd64-tdep.c
1 /* Target-dependent code for AMD64.
2
3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4    2011 Free Software Foundation, Inc.
5
6    Contributed by Jiri Smid, SuSE Labs.
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 #include "defs.h"
24 #include "opcode/i386.h"
25 #include "dis-asm.h"
26 #include "arch-utils.h"
27 #include "block.h"
28 #include "dummy-frame.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 "objfiles.h"
36 #include "regcache.h"
37 #include "regset.h"
38 #include "symfile.h"
39 #include "disasm.h"
40 #include "gdb_assert.h"
41 #include "exceptions.h"
42 #include "amd64-tdep.h"
43 #include "i387-tdep.h"
44
45 #include "features/i386/amd64.c"
46 #include "features/i386/amd64-avx.c"
47
48 #include "ax.h"
49 #include "ax-gdb.h"
50
51 /* Note that the AMD64 architecture was previously known as x86-64.
52    The latter is (forever) engraved into the canonical system name as
53    returned by config.guess, and used as the name for the AMD64 port
54    of GNU/Linux.  The BSD's have renamed their ports to amd64; they
55    don't like to shout.  For GDB we prefer the amd64_-prefix over the
56    x86_64_-prefix since it's so much easier to type.  */
57
58 /* Register information.  */
59
60 static const char *amd64_register_names[] = 
61 {
62   "rax", "rbx", "rcx", "rdx", "rsi", "rdi", "rbp", "rsp",
63
64   /* %r8 is indeed register number 8.  */
65   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
66   "rip", "eflags", "cs", "ss", "ds", "es", "fs", "gs",
67
68   /* %st0 is register number 24.  */
69   "st0", "st1", "st2", "st3", "st4", "st5", "st6", "st7",
70   "fctrl", "fstat", "ftag", "fiseg", "fioff", "foseg", "fooff", "fop",
71
72   /* %xmm0 is register number 40.  */
73   "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
74   "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
75   "mxcsr",
76 };
77
78 static const char *amd64_ymm_names[] = 
79 {
80   "ymm0", "ymm1", "ymm2", "ymm3",
81   "ymm4", "ymm5", "ymm6", "ymm7",
82   "ymm8", "ymm9", "ymm10", "ymm11",
83   "ymm12", "ymm13", "ymm14", "ymm15"
84 };
85
86 static const char *amd64_ymmh_names[] = 
87 {
88   "ymm0h", "ymm1h", "ymm2h", "ymm3h",
89   "ymm4h", "ymm5h", "ymm6h", "ymm7h",
90   "ymm8h", "ymm9h", "ymm10h", "ymm11h",
91   "ymm12h", "ymm13h", "ymm14h", "ymm15h"
92 };
93
94 /* The registers used to pass integer arguments during a function call.  */
95 static int amd64_dummy_call_integer_regs[] =
96 {
97   AMD64_RDI_REGNUM,             /* %rdi */
98   AMD64_RSI_REGNUM,             /* %rsi */
99   AMD64_RDX_REGNUM,             /* %rdx */
100   AMD64_RCX_REGNUM,             /* %rcx */
101   8,                            /* %r8 */
102   9                             /* %r9 */
103 };
104
105 /* DWARF Register Number Mapping as defined in the System V psABI,
106    section 3.6.  */
107
108 static int amd64_dwarf_regmap[] =
109 {
110   /* General Purpose Registers RAX, RDX, RCX, RBX, RSI, RDI.  */
111   AMD64_RAX_REGNUM, AMD64_RDX_REGNUM,
112   AMD64_RCX_REGNUM, AMD64_RBX_REGNUM,
113   AMD64_RSI_REGNUM, AMD64_RDI_REGNUM,
114
115   /* Frame Pointer Register RBP.  */
116   AMD64_RBP_REGNUM,
117
118   /* Stack Pointer Register RSP.  */
119   AMD64_RSP_REGNUM,
120
121   /* Extended Integer Registers 8 - 15.  */
122   8, 9, 10, 11, 12, 13, 14, 15,
123
124   /* Return Address RA.  Mapped to RIP.  */
125   AMD64_RIP_REGNUM,
126
127   /* SSE Registers 0 - 7.  */
128   AMD64_XMM0_REGNUM + 0, AMD64_XMM1_REGNUM,
129   AMD64_XMM0_REGNUM + 2, AMD64_XMM0_REGNUM + 3,
130   AMD64_XMM0_REGNUM + 4, AMD64_XMM0_REGNUM + 5,
131   AMD64_XMM0_REGNUM + 6, AMD64_XMM0_REGNUM + 7,
132
133   /* Extended SSE Registers 8 - 15.  */
134   AMD64_XMM0_REGNUM + 8, AMD64_XMM0_REGNUM + 9,
135   AMD64_XMM0_REGNUM + 10, AMD64_XMM0_REGNUM + 11,
136   AMD64_XMM0_REGNUM + 12, AMD64_XMM0_REGNUM + 13,
137   AMD64_XMM0_REGNUM + 14, AMD64_XMM0_REGNUM + 15,
138
139   /* Floating Point Registers 0-7.  */
140   AMD64_ST0_REGNUM + 0, AMD64_ST0_REGNUM + 1,
141   AMD64_ST0_REGNUM + 2, AMD64_ST0_REGNUM + 3,
142   AMD64_ST0_REGNUM + 4, AMD64_ST0_REGNUM + 5,
143   AMD64_ST0_REGNUM + 6, AMD64_ST0_REGNUM + 7,
144   
145   /* Control and Status Flags Register.  */
146   AMD64_EFLAGS_REGNUM,
147
148   /* Selector Registers.  */
149   AMD64_ES_REGNUM,
150   AMD64_CS_REGNUM,
151   AMD64_SS_REGNUM,
152   AMD64_DS_REGNUM,
153   AMD64_FS_REGNUM,
154   AMD64_GS_REGNUM,
155   -1,
156   -1,
157
158   /* Segment Base Address Registers.  */
159   -1,
160   -1,
161   -1,
162   -1,
163
164   /* Special Selector Registers.  */
165   -1,
166   -1,
167
168   /* Floating Point Control Registers.  */
169   AMD64_MXCSR_REGNUM,
170   AMD64_FCTRL_REGNUM,
171   AMD64_FSTAT_REGNUM
172 };
173
174 static const int amd64_dwarf_regmap_len =
175   (sizeof (amd64_dwarf_regmap) / sizeof (amd64_dwarf_regmap[0]));
176
177 /* Convert DWARF register number REG to the appropriate register
178    number used by GDB.  */
179
180 static int
181 amd64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
182 {
183   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
184   int ymm0_regnum = tdep->ymm0_regnum;
185   int regnum = -1;
186
187   if (reg >= 0 && reg < amd64_dwarf_regmap_len)
188     regnum = amd64_dwarf_regmap[reg];
189
190   if (regnum == -1)
191     warning (_("Unmapped DWARF Register #%d encountered."), reg);
192   else if (ymm0_regnum >= 0
193            && i386_xmm_regnum_p (gdbarch, regnum))
194     regnum += ymm0_regnum - I387_XMM0_REGNUM (tdep);
195
196   return regnum;
197 }
198
199 /* Map architectural register numbers to gdb register numbers.  */
200
201 static const int amd64_arch_regmap[16] =
202 {
203   AMD64_RAX_REGNUM,     /* %rax */
204   AMD64_RCX_REGNUM,     /* %rcx */
205   AMD64_RDX_REGNUM,     /* %rdx */
206   AMD64_RBX_REGNUM,     /* %rbx */
207   AMD64_RSP_REGNUM,     /* %rsp */
208   AMD64_RBP_REGNUM,     /* %rbp */
209   AMD64_RSI_REGNUM,     /* %rsi */
210   AMD64_RDI_REGNUM,     /* %rdi */
211   AMD64_R8_REGNUM,      /* %r8 */
212   AMD64_R9_REGNUM,      /* %r9 */
213   AMD64_R10_REGNUM,     /* %r10 */
214   AMD64_R11_REGNUM,     /* %r11 */
215   AMD64_R12_REGNUM,     /* %r12 */
216   AMD64_R13_REGNUM,     /* %r13 */
217   AMD64_R14_REGNUM,     /* %r14 */
218   AMD64_R15_REGNUM      /* %r15 */
219 };
220
221 static const int amd64_arch_regmap_len =
222   (sizeof (amd64_arch_regmap) / sizeof (amd64_arch_regmap[0]));
223
224 /* Convert architectural register number REG to the appropriate register
225    number used by GDB.  */
226
227 static int
228 amd64_arch_reg_to_regnum (int reg)
229 {
230   gdb_assert (reg >= 0 && reg < amd64_arch_regmap_len);
231
232   return amd64_arch_regmap[reg];
233 }
234
235 /* Register names for byte pseudo-registers.  */
236
237 static const char *amd64_byte_names[] =
238 {
239   "al", "bl", "cl", "dl", "sil", "dil", "bpl", "spl",
240   "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l",
241   "ah", "bh", "ch", "dh"
242 };
243
244 /* Number of lower byte registers.  */
245 #define AMD64_NUM_LOWER_BYTE_REGS 16
246
247 /* Register names for word pseudo-registers.  */
248
249 static const char *amd64_word_names[] =
250 {
251   "ax", "bx", "cx", "dx", "si", "di", "bp", "", 
252   "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
253 };
254
255 /* Register names for dword pseudo-registers.  */
256
257 static const char *amd64_dword_names[] =
258 {
259   "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp", 
260   "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
261 };
262
263 /* Return the name of register REGNUM.  */
264
265 static const char *
266 amd64_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
267 {
268   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
269   if (i386_byte_regnum_p (gdbarch, regnum))
270     return amd64_byte_names[regnum - tdep->al_regnum];
271   else if (i386_ymm_regnum_p (gdbarch, regnum))
272     return amd64_ymm_names[regnum - tdep->ymm0_regnum];
273   else if (i386_word_regnum_p (gdbarch, regnum))
274     return amd64_word_names[regnum - tdep->ax_regnum];
275   else if (i386_dword_regnum_p (gdbarch, regnum))
276     return amd64_dword_names[regnum - tdep->eax_regnum];
277   else
278     return i386_pseudo_register_name (gdbarch, regnum);
279 }
280
281 static struct value *
282 amd64_pseudo_register_read_value (struct gdbarch *gdbarch,
283                                   struct regcache *regcache,
284                                   int regnum)
285 {
286   gdb_byte raw_buf[MAX_REGISTER_SIZE];
287   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
288   enum register_status status;
289   struct value *result_value;
290   gdb_byte *buf;
291
292   result_value = allocate_value (register_type (gdbarch, regnum));
293   VALUE_LVAL (result_value) = lval_register;
294   VALUE_REGNUM (result_value) = regnum;
295   buf = value_contents_raw (result_value);
296
297   if (i386_byte_regnum_p (gdbarch, regnum))
298     {
299       int gpnum = regnum - tdep->al_regnum;
300
301       /* Extract (always little endian).  */
302       if (gpnum >= AMD64_NUM_LOWER_BYTE_REGS)
303         {
304           /* Special handling for AH, BH, CH, DH.  */
305           status = regcache_raw_read (regcache,
306                                       gpnum - AMD64_NUM_LOWER_BYTE_REGS,
307                                       raw_buf);
308           if (status == REG_VALID)
309             memcpy (buf, raw_buf + 1, 1);
310           else
311             mark_value_bytes_unavailable (result_value, 0,
312                                           TYPE_LENGTH (value_type (result_value)));
313         }
314       else
315         {
316           status = regcache_raw_read (regcache, gpnum, raw_buf);
317           if (status == REG_VALID)
318             memcpy (buf, raw_buf, 1);
319           else
320             mark_value_bytes_unavailable (result_value, 0,
321                                           TYPE_LENGTH (value_type (result_value)));
322         }
323     }
324   else if (i386_dword_regnum_p (gdbarch, regnum))
325     {
326       int gpnum = regnum - tdep->eax_regnum;
327       /* Extract (always little endian).  */
328       status = regcache_raw_read (regcache, gpnum, raw_buf);
329       if (status == REG_VALID)
330         memcpy (buf, raw_buf, 4);
331       else
332         mark_value_bytes_unavailable (result_value, 0,
333                                       TYPE_LENGTH (value_type (result_value)));
334     }
335   else
336     i386_pseudo_register_read_into_value (gdbarch, regcache, regnum,
337                                           result_value);
338
339   return result_value;
340 }
341
342 static void
343 amd64_pseudo_register_write (struct gdbarch *gdbarch,
344                              struct regcache *regcache,
345                              int regnum, const gdb_byte *buf)
346 {
347   gdb_byte raw_buf[MAX_REGISTER_SIZE];
348   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
349
350   if (i386_byte_regnum_p (gdbarch, regnum))
351     {
352       int gpnum = regnum - tdep->al_regnum;
353
354       if (gpnum >= AMD64_NUM_LOWER_BYTE_REGS)
355         {
356           /* Read ... AH, BH, CH, DH.  */
357           regcache_raw_read (regcache,
358                              gpnum - AMD64_NUM_LOWER_BYTE_REGS, raw_buf);
359           /* ... Modify ... (always little endian).  */
360           memcpy (raw_buf + 1, buf, 1);
361           /* ... Write.  */
362           regcache_raw_write (regcache,
363                               gpnum - AMD64_NUM_LOWER_BYTE_REGS, raw_buf);
364         }
365       else
366         {
367           /* Read ...  */
368           regcache_raw_read (regcache, gpnum, raw_buf);
369           /* ... Modify ... (always little endian).  */
370           memcpy (raw_buf, buf, 1);
371           /* ... Write.  */
372           regcache_raw_write (regcache, gpnum, raw_buf);
373         }
374     }
375   else if (i386_dword_regnum_p (gdbarch, regnum))
376     {
377       int gpnum = regnum - tdep->eax_regnum;
378
379       /* Read ...  */
380       regcache_raw_read (regcache, gpnum, raw_buf);
381       /* ... Modify ... (always little endian).  */
382       memcpy (raw_buf, buf, 4);
383       /* ... Write.  */
384       regcache_raw_write (regcache, gpnum, raw_buf);
385     }
386   else
387     i386_pseudo_register_write (gdbarch, regcache, regnum, buf);
388 }
389
390 \f
391
392 /* Return the union class of CLASS1 and CLASS2.  See the psABI for
393    details.  */
394
395 static enum amd64_reg_class
396 amd64_merge_classes (enum amd64_reg_class class1, enum amd64_reg_class class2)
397 {
398   /* Rule (a): If both classes are equal, this is the resulting class.  */
399   if (class1 == class2)
400     return class1;
401
402   /* Rule (b): If one of the classes is NO_CLASS, the resulting class
403      is the other class.  */
404   if (class1 == AMD64_NO_CLASS)
405     return class2;
406   if (class2 == AMD64_NO_CLASS)
407     return class1;
408
409   /* Rule (c): If one of the classes is MEMORY, the result is MEMORY.  */
410   if (class1 == AMD64_MEMORY || class2 == AMD64_MEMORY)
411     return AMD64_MEMORY;
412
413   /* Rule (d): If one of the classes is INTEGER, the result is INTEGER.  */
414   if (class1 == AMD64_INTEGER || class2 == AMD64_INTEGER)
415     return AMD64_INTEGER;
416
417   /* Rule (e): If one of the classes is X87, X87UP, COMPLEX_X87 class,
418      MEMORY is used as class.  */
419   if (class1 == AMD64_X87 || class1 == AMD64_X87UP
420       || class1 == AMD64_COMPLEX_X87 || class2 == AMD64_X87
421       || class2 == AMD64_X87UP || class2 == AMD64_COMPLEX_X87)
422     return AMD64_MEMORY;
423
424   /* Rule (f): Otherwise class SSE is used.  */
425   return AMD64_SSE;
426 }
427
428 /* Return non-zero if TYPE is a non-POD structure or union type.  */
429
430 static int
431 amd64_non_pod_p (struct type *type)
432 {
433   /* ??? A class with a base class certainly isn't POD, but does this
434      catch all non-POD structure types?  */
435   if (TYPE_CODE (type) == TYPE_CODE_STRUCT && TYPE_N_BASECLASSES (type) > 0)
436     return 1;
437
438   return 0;
439 }
440
441 /* Classify TYPE according to the rules for aggregate (structures and
442    arrays) and union types, and store the result in CLASS.  */
443
444 static void
445 amd64_classify_aggregate (struct type *type, enum amd64_reg_class class[2])
446 {
447   int len = TYPE_LENGTH (type);
448
449   /* 1. If the size of an object is larger than two eightbytes, or in
450         C++, is a non-POD structure or union type, or contains
451         unaligned fields, it has class memory.  */
452   if (len > 16 || amd64_non_pod_p (type))
453     {
454       class[0] = class[1] = AMD64_MEMORY;
455       return;
456     }
457
458   /* 2. Both eightbytes get initialized to class NO_CLASS.  */
459   class[0] = class[1] = AMD64_NO_CLASS;
460
461   /* 3. Each field of an object is classified recursively so that
462         always two fields are considered. The resulting class is
463         calculated according to the classes of the fields in the
464         eightbyte: */
465
466   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
467     {
468       struct type *subtype = check_typedef (TYPE_TARGET_TYPE (type));
469
470       /* All fields in an array have the same type.  */
471       amd64_classify (subtype, class);
472       if (len > 8 && class[1] == AMD64_NO_CLASS)
473         class[1] = class[0];
474     }
475   else
476     {
477       int i;
478
479       /* Structure or union.  */
480       gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
481                   || TYPE_CODE (type) == TYPE_CODE_UNION);
482
483       for (i = 0; i < TYPE_NFIELDS (type); i++)
484         {
485           struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
486           int pos = TYPE_FIELD_BITPOS (type, i) / 64;
487           enum amd64_reg_class subclass[2];
488           int bitsize = TYPE_FIELD_BITSIZE (type, i);
489           int endpos;
490
491           if (bitsize == 0)
492             bitsize = TYPE_LENGTH (subtype) * 8;
493           endpos = (TYPE_FIELD_BITPOS (type, i) + bitsize - 1) / 64;
494
495           /* Ignore static fields.  */
496           if (field_is_static (&TYPE_FIELD (type, i)))
497             continue;
498
499           gdb_assert (pos == 0 || pos == 1);
500
501           amd64_classify (subtype, subclass);
502           class[pos] = amd64_merge_classes (class[pos], subclass[0]);
503           if (bitsize <= 64 && pos == 0 && endpos == 1)
504             /* This is a bit of an odd case:  We have a field that would
505                normally fit in one of the two eightbytes, except that
506                it is placed in a way that this field straddles them.
507                This has been seen with a structure containing an array.
508
509                The ABI is a bit unclear in this case, but we assume that
510                this field's class (stored in subclass[0]) must also be merged
511                into class[1].  In other words, our field has a piece stored
512                in the second eight-byte, and thus its class applies to
513                the second eight-byte as well.
514
515                In the case where the field length exceeds 8 bytes,
516                it should not be necessary to merge the field class
517                into class[1].  As LEN > 8, subclass[1] is necessarily
518                different from AMD64_NO_CLASS.  If subclass[1] is equal
519                to subclass[0], then the normal class[1]/subclass[1]
520                merging will take care of everything.  For subclass[1]
521                to be different from subclass[0], I can only see the case
522                where we have a SSE/SSEUP or X87/X87UP pair, which both
523                use up all 16 bytes of the aggregate, and are already
524                handled just fine (because each portion sits on its own
525                8-byte).  */
526             class[1] = amd64_merge_classes (class[1], subclass[0]);
527           if (pos == 0)
528             class[1] = amd64_merge_classes (class[1], subclass[1]);
529         }
530     }
531
532   /* 4. Then a post merger cleanup is done:  */
533
534   /* Rule (a): If one of the classes is MEMORY, the whole argument is
535      passed in memory.  */
536   if (class[0] == AMD64_MEMORY || class[1] == AMD64_MEMORY)
537     class[0] = class[1] = AMD64_MEMORY;
538
539   /* Rule (b): If SSEUP is not preceded by SSE, it is converted to
540      SSE.  */
541   if (class[0] == AMD64_SSEUP)
542     class[0] = AMD64_SSE;
543   if (class[1] == AMD64_SSEUP && class[0] != AMD64_SSE)
544     class[1] = AMD64_SSE;
545 }
546
547 /* Classify TYPE, and store the result in CLASS.  */
548
549 void
550 amd64_classify (struct type *type, enum amd64_reg_class class[2])
551 {
552   enum type_code code = TYPE_CODE (type);
553   int len = TYPE_LENGTH (type);
554
555   class[0] = class[1] = AMD64_NO_CLASS;
556
557   /* Arguments of types (signed and unsigned) _Bool, char, short, int,
558      long, long long, and pointers are in the INTEGER class.  Similarly,
559      range types, used by languages such as Ada, are also in the INTEGER
560      class.  */
561   if ((code == TYPE_CODE_INT || code == TYPE_CODE_ENUM
562        || code == TYPE_CODE_BOOL || code == TYPE_CODE_RANGE
563        || code == TYPE_CODE_CHAR
564        || code == TYPE_CODE_PTR || code == TYPE_CODE_REF)
565       && (len == 1 || len == 2 || len == 4 || len == 8))
566     class[0] = AMD64_INTEGER;
567
568   /* Arguments of types float, double, _Decimal32, _Decimal64 and __m64
569      are in class SSE.  */
570   else if ((code == TYPE_CODE_FLT || code == TYPE_CODE_DECFLOAT)
571            && (len == 4 || len == 8))
572     /* FIXME: __m64 .  */
573     class[0] = AMD64_SSE;
574
575   /* Arguments of types __float128, _Decimal128 and __m128 are split into
576      two halves.  The least significant ones belong to class SSE, the most
577      significant one to class SSEUP.  */
578   else if (code == TYPE_CODE_DECFLOAT && len == 16)
579     /* FIXME: __float128, __m128.  */
580     class[0] = AMD64_SSE, class[1] = AMD64_SSEUP;
581
582   /* The 64-bit mantissa of arguments of type long double belongs to
583      class X87, the 16-bit exponent plus 6 bytes of padding belongs to
584      class X87UP.  */
585   else if (code == TYPE_CODE_FLT && len == 16)
586     /* Class X87 and X87UP.  */
587     class[0] = AMD64_X87, class[1] = AMD64_X87UP;
588
589   /* Aggregates.  */
590   else if (code == TYPE_CODE_ARRAY || code == TYPE_CODE_STRUCT
591            || code == TYPE_CODE_UNION)
592     amd64_classify_aggregate (type, class);
593 }
594
595 static enum return_value_convention
596 amd64_return_value (struct gdbarch *gdbarch, struct type *func_type,
597                     struct type *type, struct regcache *regcache,
598                     gdb_byte *readbuf, const gdb_byte *writebuf)
599 {
600   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
601   enum amd64_reg_class class[2];
602   int len = TYPE_LENGTH (type);
603   static int integer_regnum[] = { AMD64_RAX_REGNUM, AMD64_RDX_REGNUM };
604   static int sse_regnum[] = { AMD64_XMM0_REGNUM, AMD64_XMM1_REGNUM };
605   int integer_reg = 0;
606   int sse_reg = 0;
607   int i;
608
609   gdb_assert (!(readbuf && writebuf));
610   gdb_assert (tdep->classify);
611
612   /* 1. Classify the return type with the classification algorithm.  */
613   tdep->classify (type, class);
614
615   /* 2. If the type has class MEMORY, then the caller provides space
616      for the return value and passes the address of this storage in
617      %rdi as if it were the first argument to the function.  In effect,
618      this address becomes a hidden first argument.
619
620      On return %rax will contain the address that has been passed in
621      by the caller in %rdi.  */
622   if (class[0] == AMD64_MEMORY)
623     {
624       /* As indicated by the comment above, the ABI guarantees that we
625          can always find the return value just after the function has
626          returned.  */
627
628       if (readbuf)
629         {
630           ULONGEST addr;
631
632           regcache_raw_read_unsigned (regcache, AMD64_RAX_REGNUM, &addr);
633           read_memory (addr, readbuf, TYPE_LENGTH (type));
634         }
635
636       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
637     }
638
639   gdb_assert (class[1] != AMD64_MEMORY);
640   gdb_assert (len <= 16);
641
642   for (i = 0; len > 0; i++, len -= 8)
643     {
644       int regnum = -1;
645       int offset = 0;
646
647       switch (class[i])
648         {
649         case AMD64_INTEGER:
650           /* 3. If the class is INTEGER, the next available register
651              of the sequence %rax, %rdx is used.  */
652           regnum = integer_regnum[integer_reg++];
653           break;
654
655         case AMD64_SSE:
656           /* 4. If the class is SSE, the next available SSE register
657              of the sequence %xmm0, %xmm1 is used.  */
658           regnum = sse_regnum[sse_reg++];
659           break;
660
661         case AMD64_SSEUP:
662           /* 5. If the class is SSEUP, the eightbyte is passed in the
663              upper half of the last used SSE register.  */
664           gdb_assert (sse_reg > 0);
665           regnum = sse_regnum[sse_reg - 1];
666           offset = 8;
667           break;
668
669         case AMD64_X87:
670           /* 6. If the class is X87, the value is returned on the X87
671              stack in %st0 as 80-bit x87 number.  */
672           regnum = AMD64_ST0_REGNUM;
673           if (writebuf)
674             i387_return_value (gdbarch, regcache);
675           break;
676
677         case AMD64_X87UP:
678           /* 7. If the class is X87UP, the value is returned together
679              with the previous X87 value in %st0.  */
680           gdb_assert (i > 0 && class[0] == AMD64_X87);
681           regnum = AMD64_ST0_REGNUM;
682           offset = 8;
683           len = 2;
684           break;
685
686         case AMD64_NO_CLASS:
687           continue;
688
689         default:
690           gdb_assert (!"Unexpected register class.");
691         }
692
693       gdb_assert (regnum != -1);
694
695       if (readbuf)
696         regcache_raw_read_part (regcache, regnum, offset, min (len, 8),
697                                 readbuf + i * 8);
698       if (writebuf)
699         regcache_raw_write_part (regcache, regnum, offset, min (len, 8),
700                                  writebuf + i * 8);
701     }
702
703   return RETURN_VALUE_REGISTER_CONVENTION;
704 }
705 \f
706
707 static CORE_ADDR
708 amd64_push_arguments (struct regcache *regcache, int nargs,
709                       struct value **args, CORE_ADDR sp, int struct_return)
710 {
711   struct gdbarch *gdbarch = get_regcache_arch (regcache);
712   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
713   int *integer_regs = tdep->call_dummy_integer_regs;
714   int num_integer_regs = tdep->call_dummy_num_integer_regs;
715
716   static int sse_regnum[] =
717   {
718     /* %xmm0 ... %xmm7 */
719     AMD64_XMM0_REGNUM + 0, AMD64_XMM1_REGNUM,
720     AMD64_XMM0_REGNUM + 2, AMD64_XMM0_REGNUM + 3,
721     AMD64_XMM0_REGNUM + 4, AMD64_XMM0_REGNUM + 5,
722     AMD64_XMM0_REGNUM + 6, AMD64_XMM0_REGNUM + 7,
723   };
724   struct value **stack_args = alloca (nargs * sizeof (struct value *));
725   /* An array that mirrors the stack_args array.  For all arguments
726      that are passed by MEMORY, if that argument's address also needs
727      to be stored in a register, the ARG_ADDR_REGNO array will contain
728      that register number (or a negative value otherwise).  */
729   int *arg_addr_regno = alloca (nargs * sizeof (int));
730   int num_stack_args = 0;
731   int num_elements = 0;
732   int element = 0;
733   int integer_reg = 0;
734   int sse_reg = 0;
735   int i;
736
737   gdb_assert (tdep->classify);
738
739   /* Reserve a register for the "hidden" argument.  */
740   if (struct_return)
741     integer_reg++;
742
743   for (i = 0; i < nargs; i++)
744     {
745       struct type *type = value_type (args[i]);
746       int len = TYPE_LENGTH (type);
747       enum amd64_reg_class class[2];
748       int needed_integer_regs = 0;
749       int needed_sse_regs = 0;
750       int j;
751
752       /* Classify argument.  */
753       tdep->classify (type, class);
754
755       /* Calculate the number of integer and SSE registers needed for
756          this argument.  */
757       for (j = 0; j < 2; j++)
758         {
759           if (class[j] == AMD64_INTEGER)
760             needed_integer_regs++;
761           else if (class[j] == AMD64_SSE)
762             needed_sse_regs++;
763         }
764
765       /* Check whether enough registers are available, and if the
766          argument should be passed in registers at all.  */
767       if (integer_reg + needed_integer_regs > num_integer_regs
768           || sse_reg + needed_sse_regs > ARRAY_SIZE (sse_regnum)
769           || (needed_integer_regs == 0 && needed_sse_regs == 0))
770         {
771           /* The argument will be passed on the stack.  */
772           num_elements += ((len + 7) / 8);
773           stack_args[num_stack_args] = args[i];
774           /* If this is an AMD64_MEMORY argument whose address must also
775              be passed in one of the integer registers, reserve that
776              register and associate this value to that register so that
777              we can store the argument address as soon as we know it.  */
778           if (class[0] == AMD64_MEMORY
779               && tdep->memory_args_by_pointer
780               && integer_reg < tdep->call_dummy_num_integer_regs)
781             arg_addr_regno[num_stack_args] =
782               tdep->call_dummy_integer_regs[integer_reg++];
783           else
784             arg_addr_regno[num_stack_args] = -1;
785           num_stack_args++;
786         }
787       else
788         {
789           /* The argument will be passed in registers.  */
790           const gdb_byte *valbuf = value_contents (args[i]);
791           gdb_byte buf[8];
792
793           gdb_assert (len <= 16);
794
795           for (j = 0; len > 0; j++, len -= 8)
796             {
797               int regnum = -1;
798               int offset = 0;
799
800               switch (class[j])
801                 {
802                 case AMD64_INTEGER:
803                   regnum = integer_regs[integer_reg++];
804                   break;
805
806                 case AMD64_SSE:
807                   regnum = sse_regnum[sse_reg++];
808                   break;
809
810                 case AMD64_SSEUP:
811                   gdb_assert (sse_reg > 0);
812                   regnum = sse_regnum[sse_reg - 1];
813                   offset = 8;
814                   break;
815
816                 default:
817                   gdb_assert (!"Unexpected register class.");
818                 }
819
820               gdb_assert (regnum != -1);
821               memset (buf, 0, sizeof buf);
822               memcpy (buf, valbuf + j * 8, min (len, 8));
823               regcache_raw_write_part (regcache, regnum, offset, 8, buf);
824             }
825         }
826     }
827
828   /* Allocate space for the arguments on the stack.  */
829   sp -= num_elements * 8;
830
831   /* The psABI says that "The end of the input argument area shall be
832      aligned on a 16 byte boundary."  */
833   sp &= ~0xf;
834
835   /* Write out the arguments to the stack.  */
836   for (i = 0; i < num_stack_args; i++)
837     {
838       struct type *type = value_type (stack_args[i]);
839       const gdb_byte *valbuf = value_contents (stack_args[i]);
840       int len = TYPE_LENGTH (type);
841       CORE_ADDR arg_addr = sp + element * 8;
842
843       write_memory (arg_addr, valbuf, len);
844       if (arg_addr_regno[i] >= 0)
845         {
846           /* We also need to store the address of that argument in
847              the given register.  */
848           gdb_byte buf[8];
849           enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
850
851           store_unsigned_integer (buf, 8, byte_order, arg_addr);
852           regcache_cooked_write (regcache, arg_addr_regno[i], buf);
853         }
854       element += ((len + 7) / 8);
855     }
856
857   /* The psABI says that "For calls that may call functions that use
858      varargs or stdargs (prototype-less calls or calls to functions
859      containing ellipsis (...) in the declaration) %al is used as
860      hidden argument to specify the number of SSE registers used.  */
861   regcache_raw_write_unsigned (regcache, AMD64_RAX_REGNUM, sse_reg);
862   return sp; 
863 }
864
865 static CORE_ADDR
866 amd64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
867                        struct regcache *regcache, CORE_ADDR bp_addr,
868                        int nargs, struct value **args,  CORE_ADDR sp,
869                        int struct_return, CORE_ADDR struct_addr)
870 {
871   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
872   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
873   gdb_byte buf[8];
874
875   /* Pass arguments.  */
876   sp = amd64_push_arguments (regcache, nargs, args, sp, struct_return);
877
878   /* Pass "hidden" argument".  */
879   if (struct_return)
880     {
881       struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
882       /* The "hidden" argument is passed throught the first argument
883          register.  */
884       const int arg_regnum = tdep->call_dummy_integer_regs[0];
885
886       store_unsigned_integer (buf, 8, byte_order, struct_addr);
887       regcache_cooked_write (regcache, arg_regnum, buf);
888     }
889
890   /* Reserve some memory on the stack for the integer-parameter registers,
891      if required by the ABI.  */
892   if (tdep->integer_param_regs_saved_in_caller_frame)
893     sp -= tdep->call_dummy_num_integer_regs * 8;
894
895   /* Store return address.  */
896   sp -= 8;
897   store_unsigned_integer (buf, 8, byte_order, bp_addr);
898   write_memory (sp, buf, 8);
899
900   /* Finally, update the stack pointer...  */
901   store_unsigned_integer (buf, 8, byte_order, sp);
902   regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf);
903
904   /* ...and fake a frame pointer.  */
905   regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf);
906
907   return sp + 16;
908 }
909 \f
910 /* Displaced instruction handling.  */
911
912 /* A partially decoded instruction.
913    This contains enough details for displaced stepping purposes.  */
914
915 struct amd64_insn
916 {
917   /* The number of opcode bytes.  */
918   int opcode_len;
919   /* The offset of the rex prefix or -1 if not present.  */
920   int rex_offset;
921   /* The offset to the first opcode byte.  */
922   int opcode_offset;
923   /* The offset to the modrm byte or -1 if not present.  */
924   int modrm_offset;
925
926   /* The raw instruction.  */
927   gdb_byte *raw_insn;
928 };
929
930 struct displaced_step_closure
931 {
932   /* For rip-relative insns, saved copy of the reg we use instead of %rip.  */
933   int tmp_used;
934   int tmp_regno;
935   ULONGEST tmp_save;
936
937   /* Details of the instruction.  */
938   struct amd64_insn insn_details;
939
940   /* Amount of space allocated to insn_buf.  */
941   int max_len;
942
943   /* The possibly modified insn.
944      This is a variable-length field.  */
945   gdb_byte insn_buf[1];
946 };
947
948 /* WARNING: Keep onebyte_has_modrm, twobyte_has_modrm in sync with
949    ../opcodes/i386-dis.c (until libopcodes exports them, or an alternative,
950    at which point delete these in favor of libopcodes' versions).  */
951
952 static const unsigned char onebyte_has_modrm[256] = {
953   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
954   /*       -------------------------------        */
955   /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
956   /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
957   /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
958   /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
959   /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
960   /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
961   /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
962   /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
963   /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
964   /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
965   /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
966   /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
967   /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
968   /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
969   /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
970   /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1  /* f0 */
971   /*       -------------------------------        */
972   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
973 };
974
975 static const unsigned char twobyte_has_modrm[256] = {
976   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
977   /*       -------------------------------        */
978   /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
979   /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
980   /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
981   /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
982   /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
983   /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
984   /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
985   /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
986   /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
987   /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
988   /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
989   /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
990   /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
991   /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
992   /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
993   /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0  /* ff */
994   /*       -------------------------------        */
995   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
996 };
997
998 static int amd64_syscall_p (const struct amd64_insn *insn, int *lengthp);
999
1000 static int
1001 rex_prefix_p (gdb_byte pfx)
1002 {
1003   return REX_PREFIX_P (pfx);
1004 }
1005
1006 /* Skip the legacy instruction prefixes in INSN.
1007    We assume INSN is properly sentineled so we don't have to worry
1008    about falling off the end of the buffer.  */
1009
1010 static gdb_byte *
1011 amd64_skip_prefixes (gdb_byte *insn)
1012 {
1013   while (1)
1014     {
1015       switch (*insn)
1016         {
1017         case DATA_PREFIX_OPCODE:
1018         case ADDR_PREFIX_OPCODE:
1019         case CS_PREFIX_OPCODE:
1020         case DS_PREFIX_OPCODE:
1021         case ES_PREFIX_OPCODE:
1022         case FS_PREFIX_OPCODE:
1023         case GS_PREFIX_OPCODE:
1024         case SS_PREFIX_OPCODE:
1025         case LOCK_PREFIX_OPCODE:
1026         case REPE_PREFIX_OPCODE:
1027         case REPNE_PREFIX_OPCODE:
1028           ++insn;
1029           continue;
1030         default:
1031           break;
1032         }
1033       break;
1034     }
1035
1036   return insn;
1037 }
1038
1039 /* Return an integer register (other than RSP) that is unused as an input
1040    operand in INSN.
1041    In order to not require adding a rex prefix if the insn doesn't already
1042    have one, the result is restricted to RAX ... RDI, sans RSP.
1043    The register numbering of the result follows architecture ordering,
1044    e.g. RDI = 7.  */
1045
1046 static int
1047 amd64_get_unused_input_int_reg (const struct amd64_insn *details)
1048 {
1049   /* 1 bit for each reg */
1050   int used_regs_mask = 0;
1051
1052   /* There can be at most 3 int regs used as inputs in an insn, and we have
1053      7 to choose from (RAX ... RDI, sans RSP).
1054      This allows us to take a conservative approach and keep things simple.
1055      E.g. By avoiding RAX, we don't have to specifically watch for opcodes
1056      that implicitly specify RAX.  */
1057
1058   /* Avoid RAX.  */
1059   used_regs_mask |= 1 << EAX_REG_NUM;
1060   /* Similarily avoid RDX, implicit operand in divides.  */
1061   used_regs_mask |= 1 << EDX_REG_NUM;
1062   /* Avoid RSP.  */
1063   used_regs_mask |= 1 << ESP_REG_NUM;
1064
1065   /* If the opcode is one byte long and there's no ModRM byte,
1066      assume the opcode specifies a register.  */
1067   if (details->opcode_len == 1 && details->modrm_offset == -1)
1068     used_regs_mask |= 1 << (details->raw_insn[details->opcode_offset] & 7);
1069
1070   /* Mark used regs in the modrm/sib bytes.  */
1071   if (details->modrm_offset != -1)
1072     {
1073       int modrm = details->raw_insn[details->modrm_offset];
1074       int mod = MODRM_MOD_FIELD (modrm);
1075       int reg = MODRM_REG_FIELD (modrm);
1076       int rm = MODRM_RM_FIELD (modrm);
1077       int have_sib = mod != 3 && rm == 4;
1078
1079       /* Assume the reg field of the modrm byte specifies a register.  */
1080       used_regs_mask |= 1 << reg;
1081
1082       if (have_sib)
1083         {
1084           int base = SIB_BASE_FIELD (details->raw_insn[details->modrm_offset + 1]);
1085           int index = SIB_INDEX_FIELD (details->raw_insn[details->modrm_offset + 1]);
1086           used_regs_mask |= 1 << base;
1087           used_regs_mask |= 1 << index;
1088         }
1089       else
1090         {
1091           used_regs_mask |= 1 << rm;
1092         }
1093     }
1094
1095   gdb_assert (used_regs_mask < 256);
1096   gdb_assert (used_regs_mask != 255);
1097
1098   /* Finally, find a free reg.  */
1099   {
1100     int i;
1101
1102     for (i = 0; i < 8; ++i)
1103       {
1104         if (! (used_regs_mask & (1 << i)))
1105           return i;
1106       }
1107
1108     /* We shouldn't get here.  */
1109     internal_error (__FILE__, __LINE__, _("unable to find free reg"));
1110   }
1111 }
1112
1113 /* Extract the details of INSN that we need.  */
1114
1115 static void
1116 amd64_get_insn_details (gdb_byte *insn, struct amd64_insn *details)
1117 {
1118   gdb_byte *start = insn;
1119   int need_modrm;
1120
1121   details->raw_insn = insn;
1122
1123   details->opcode_len = -1;
1124   details->rex_offset = -1;
1125   details->opcode_offset = -1;
1126   details->modrm_offset = -1;
1127
1128   /* Skip legacy instruction prefixes.  */
1129   insn = amd64_skip_prefixes (insn);
1130
1131   /* Skip REX instruction prefix.  */
1132   if (rex_prefix_p (*insn))
1133     {
1134       details->rex_offset = insn - start;
1135       ++insn;
1136     }
1137
1138   details->opcode_offset = insn - start;
1139
1140   if (*insn == TWO_BYTE_OPCODE_ESCAPE)
1141     {
1142       /* Two or three-byte opcode.  */
1143       ++insn;
1144       need_modrm = twobyte_has_modrm[*insn];
1145
1146       /* Check for three-byte opcode.  */
1147       switch (*insn)
1148         {
1149         case 0x24:
1150         case 0x25:
1151         case 0x38:
1152         case 0x3a:
1153         case 0x7a:
1154         case 0x7b:
1155           ++insn;
1156           details->opcode_len = 3;
1157           break;
1158         default:
1159           details->opcode_len = 2;
1160           break;
1161         }
1162     }
1163   else
1164     {
1165       /* One-byte opcode.  */
1166       need_modrm = onebyte_has_modrm[*insn];
1167       details->opcode_len = 1;
1168     }
1169
1170   if (need_modrm)
1171     {
1172       ++insn;
1173       details->modrm_offset = insn - start;
1174     }
1175 }
1176
1177 /* Update %rip-relative addressing in INSN.
1178
1179    %rip-relative addressing only uses a 32-bit displacement.
1180    32 bits is not enough to be guaranteed to cover the distance between where
1181    the real instruction is and where its copy is.
1182    Convert the insn to use base+disp addressing.
1183    We set base = pc + insn_length so we can leave disp unchanged.  */
1184
1185 static void
1186 fixup_riprel (struct gdbarch *gdbarch, struct displaced_step_closure *dsc,
1187               CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
1188 {
1189   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1190   const struct amd64_insn *insn_details = &dsc->insn_details;
1191   int modrm_offset = insn_details->modrm_offset;
1192   gdb_byte *insn = insn_details->raw_insn + modrm_offset;
1193   CORE_ADDR rip_base;
1194   int32_t disp;
1195   int insn_length;
1196   int arch_tmp_regno, tmp_regno;
1197   ULONGEST orig_value;
1198
1199   /* %rip+disp32 addressing mode, displacement follows ModRM byte.  */
1200   ++insn;
1201
1202   /* Compute the rip-relative address.  */
1203   disp = extract_signed_integer (insn, sizeof (int32_t), byte_order);
1204   insn_length = gdb_buffered_insn_length (gdbarch, dsc->insn_buf,
1205                                           dsc->max_len, from);
1206   rip_base = from + insn_length;
1207
1208   /* We need a register to hold the address.
1209      Pick one not used in the insn.
1210      NOTE: arch_tmp_regno uses architecture ordering, e.g. RDI = 7.  */
1211   arch_tmp_regno = amd64_get_unused_input_int_reg (insn_details);
1212   tmp_regno = amd64_arch_reg_to_regnum (arch_tmp_regno);
1213
1214   /* REX.B should be unset as we were using rip-relative addressing,
1215      but ensure it's unset anyway, tmp_regno is not r8-r15.  */
1216   if (insn_details->rex_offset != -1)
1217     dsc->insn_buf[insn_details->rex_offset] &= ~REX_B;
1218
1219   regcache_cooked_read_unsigned (regs, tmp_regno, &orig_value);
1220   dsc->tmp_regno = tmp_regno;
1221   dsc->tmp_save = orig_value;
1222   dsc->tmp_used = 1;
1223
1224   /* Convert the ModRM field to be base+disp.  */
1225   dsc->insn_buf[modrm_offset] &= ~0xc7;
1226   dsc->insn_buf[modrm_offset] |= 0x80 + arch_tmp_regno;
1227
1228   regcache_cooked_write_unsigned (regs, tmp_regno, rip_base);
1229
1230   if (debug_displaced)
1231     fprintf_unfiltered (gdb_stdlog, "displaced: %%rip-relative addressing used.\n"
1232                         "displaced: using temp reg %d, old value %s, new value %s\n",
1233                         dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save),
1234                         paddress (gdbarch, rip_base));
1235 }
1236
1237 static void
1238 fixup_displaced_copy (struct gdbarch *gdbarch,
1239                       struct displaced_step_closure *dsc,
1240                       CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
1241 {
1242   const struct amd64_insn *details = &dsc->insn_details;
1243
1244   if (details->modrm_offset != -1)
1245     {
1246       gdb_byte modrm = details->raw_insn[details->modrm_offset];
1247
1248       if ((modrm & 0xc7) == 0x05)
1249         {
1250           /* The insn uses rip-relative addressing.
1251              Deal with it.  */
1252           fixup_riprel (gdbarch, dsc, from, to, regs);
1253         }
1254     }
1255 }
1256
1257 struct displaced_step_closure *
1258 amd64_displaced_step_copy_insn (struct gdbarch *gdbarch,
1259                                 CORE_ADDR from, CORE_ADDR to,
1260                                 struct regcache *regs)
1261 {
1262   int len = gdbarch_max_insn_length (gdbarch);
1263   /* Extra space for sentinels so fixup_{riprel,displaced_copy don't have to
1264      continually watch for running off the end of the buffer.  */
1265   int fixup_sentinel_space = len;
1266   struct displaced_step_closure *dsc =
1267     xmalloc (sizeof (*dsc) + len + fixup_sentinel_space);
1268   gdb_byte *buf = &dsc->insn_buf[0];
1269   struct amd64_insn *details = &dsc->insn_details;
1270
1271   dsc->tmp_used = 0;
1272   dsc->max_len = len + fixup_sentinel_space;
1273
1274   read_memory (from, buf, len);
1275
1276   /* Set up the sentinel space so we don't have to worry about running
1277      off the end of the buffer.  An excessive number of leading prefixes
1278      could otherwise cause this.  */
1279   memset (buf + len, 0, fixup_sentinel_space);
1280
1281   amd64_get_insn_details (buf, details);
1282
1283   /* GDB may get control back after the insn after the syscall.
1284      Presumably this is a kernel bug.
1285      If this is a syscall, make sure there's a nop afterwards.  */
1286   {
1287     int syscall_length;
1288
1289     if (amd64_syscall_p (details, &syscall_length))
1290       buf[details->opcode_offset + syscall_length] = NOP_OPCODE;
1291   }
1292
1293   /* Modify the insn to cope with the address where it will be executed from.
1294      In particular, handle any rip-relative addressing.  */
1295   fixup_displaced_copy (gdbarch, dsc, from, to, regs);
1296
1297   write_memory (to, buf, len);
1298
1299   if (debug_displaced)
1300     {
1301       fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
1302                           paddress (gdbarch, from), paddress (gdbarch, to));
1303       displaced_step_dump_bytes (gdb_stdlog, buf, len);
1304     }
1305
1306   return dsc;
1307 }
1308
1309 static int
1310 amd64_absolute_jmp_p (const struct amd64_insn *details)
1311 {
1312   const gdb_byte *insn = &details->raw_insn[details->opcode_offset];
1313
1314   if (insn[0] == 0xff)
1315     {
1316       /* jump near, absolute indirect (/4) */
1317       if ((insn[1] & 0x38) == 0x20)
1318         return 1;
1319
1320       /* jump far, absolute indirect (/5) */
1321       if ((insn[1] & 0x38) == 0x28)
1322         return 1;
1323     }
1324
1325   return 0;
1326 }
1327
1328 static int
1329 amd64_absolute_call_p (const struct amd64_insn *details)
1330 {
1331   const gdb_byte *insn = &details->raw_insn[details->opcode_offset];
1332
1333   if (insn[0] == 0xff)
1334     {
1335       /* Call near, absolute indirect (/2) */
1336       if ((insn[1] & 0x38) == 0x10)
1337         return 1;
1338
1339       /* Call far, absolute indirect (/3) */
1340       if ((insn[1] & 0x38) == 0x18)
1341         return 1;
1342     }
1343
1344   return 0;
1345 }
1346
1347 static int
1348 amd64_ret_p (const struct amd64_insn *details)
1349 {
1350   /* NOTE: gcc can emit "repz ; ret".  */
1351   const gdb_byte *insn = &details->raw_insn[details->opcode_offset];
1352
1353   switch (insn[0])
1354     {
1355     case 0xc2: /* ret near, pop N bytes */
1356     case 0xc3: /* ret near */
1357     case 0xca: /* ret far, pop N bytes */
1358     case 0xcb: /* ret far */
1359     case 0xcf: /* iret */
1360       return 1;
1361
1362     default:
1363       return 0;
1364     }
1365 }
1366
1367 static int
1368 amd64_call_p (const struct amd64_insn *details)
1369 {
1370   const gdb_byte *insn = &details->raw_insn[details->opcode_offset];
1371
1372   if (amd64_absolute_call_p (details))
1373     return 1;
1374
1375   /* call near, relative */
1376   if (insn[0] == 0xe8)
1377     return 1;
1378
1379   return 0;
1380 }
1381
1382 /* Return non-zero if INSN is a system call, and set *LENGTHP to its
1383    length in bytes.  Otherwise, return zero.  */
1384
1385 static int
1386 amd64_syscall_p (const struct amd64_insn *details, int *lengthp)
1387 {
1388   const gdb_byte *insn = &details->raw_insn[details->opcode_offset];
1389
1390   if (insn[0] == 0x0f && insn[1] == 0x05)
1391     {
1392       *lengthp = 2;
1393       return 1;
1394     }
1395
1396   return 0;
1397 }
1398
1399 /* Fix up the state of registers and memory after having single-stepped
1400    a displaced instruction.  */
1401
1402 void
1403 amd64_displaced_step_fixup (struct gdbarch *gdbarch,
1404                             struct displaced_step_closure *dsc,
1405                             CORE_ADDR from, CORE_ADDR to,
1406                             struct regcache *regs)
1407 {
1408   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1409   /* The offset we applied to the instruction's address.  */
1410   ULONGEST insn_offset = to - from;
1411   gdb_byte *insn = dsc->insn_buf;
1412   const struct amd64_insn *insn_details = &dsc->insn_details;
1413
1414   if (debug_displaced)
1415     fprintf_unfiltered (gdb_stdlog,
1416                         "displaced: fixup (%s, %s), "
1417                         "insn = 0x%02x 0x%02x ...\n",
1418                         paddress (gdbarch, from), paddress (gdbarch, to),
1419                         insn[0], insn[1]);
1420
1421   /* If we used a tmp reg, restore it.  */
1422
1423   if (dsc->tmp_used)
1424     {
1425       if (debug_displaced)
1426         fprintf_unfiltered (gdb_stdlog, "displaced: restoring reg %d to %s\n",
1427                             dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save));
1428       regcache_cooked_write_unsigned (regs, dsc->tmp_regno, dsc->tmp_save);
1429     }
1430
1431   /* The list of issues to contend with here is taken from
1432      resume_execution in arch/x86/kernel/kprobes.c, Linux 2.6.28.
1433      Yay for Free Software!  */
1434
1435   /* Relocate the %rip back to the program's instruction stream,
1436      if necessary.  */
1437
1438   /* Except in the case of absolute or indirect jump or call
1439      instructions, or a return instruction, the new rip is relative to
1440      the displaced instruction; make it relative to the original insn.
1441      Well, signal handler returns don't need relocation either, but we use the
1442      value of %rip to recognize those; see below.  */
1443   if (! amd64_absolute_jmp_p (insn_details)
1444       && ! amd64_absolute_call_p (insn_details)
1445       && ! amd64_ret_p (insn_details))
1446     {
1447       ULONGEST orig_rip;
1448       int insn_len;
1449
1450       regcache_cooked_read_unsigned (regs, AMD64_RIP_REGNUM, &orig_rip);
1451
1452       /* A signal trampoline system call changes the %rip, resuming
1453          execution of the main program after the signal handler has
1454          returned.  That makes them like 'return' instructions; we
1455          shouldn't relocate %rip.
1456
1457          But most system calls don't, and we do need to relocate %rip.
1458
1459          Our heuristic for distinguishing these cases: if stepping
1460          over the system call instruction left control directly after
1461          the instruction, the we relocate --- control almost certainly
1462          doesn't belong in the displaced copy.  Otherwise, we assume
1463          the instruction has put control where it belongs, and leave
1464          it unrelocated.  Goodness help us if there are PC-relative
1465          system calls.  */
1466       if (amd64_syscall_p (insn_details, &insn_len)
1467           && orig_rip != to + insn_len
1468           /* GDB can get control back after the insn after the syscall.
1469              Presumably this is a kernel bug.
1470              Fixup ensures its a nop, we add one to the length for it.  */
1471           && orig_rip != to + insn_len + 1)
1472         {
1473           if (debug_displaced)
1474             fprintf_unfiltered (gdb_stdlog,
1475                                 "displaced: syscall changed %%rip; "
1476                                 "not relocating\n");
1477         }
1478       else
1479         {
1480           ULONGEST rip = orig_rip - insn_offset;
1481
1482           /* If we just stepped over a breakpoint insn, we don't backup
1483              the pc on purpose; this is to match behaviour without
1484              stepping.  */
1485
1486           regcache_cooked_write_unsigned (regs, AMD64_RIP_REGNUM, rip);
1487
1488           if (debug_displaced)
1489             fprintf_unfiltered (gdb_stdlog,
1490                                 "displaced: "
1491                                 "relocated %%rip from %s to %s\n",
1492                                 paddress (gdbarch, orig_rip),
1493                                 paddress (gdbarch, rip));
1494         }
1495     }
1496
1497   /* If the instruction was PUSHFL, then the TF bit will be set in the
1498      pushed value, and should be cleared.  We'll leave this for later,
1499      since GDB already messes up the TF flag when stepping over a
1500      pushfl.  */
1501
1502   /* If the instruction was a call, the return address now atop the
1503      stack is the address following the copied instruction.  We need
1504      to make it the address following the original instruction.  */
1505   if (amd64_call_p (insn_details))
1506     {
1507       ULONGEST rsp;
1508       ULONGEST retaddr;
1509       const ULONGEST retaddr_len = 8;
1510
1511       regcache_cooked_read_unsigned (regs, AMD64_RSP_REGNUM, &rsp);
1512       retaddr = read_memory_unsigned_integer (rsp, retaddr_len, byte_order);
1513       retaddr = (retaddr - insn_offset) & 0xffffffffUL;
1514       write_memory_unsigned_integer (rsp, retaddr_len, byte_order, retaddr);
1515
1516       if (debug_displaced)
1517         fprintf_unfiltered (gdb_stdlog,
1518                             "displaced: relocated return addr at %s "
1519                             "to %s\n",
1520                             paddress (gdbarch, rsp),
1521                             paddress (gdbarch, retaddr));
1522     }
1523 }
1524
1525 /* If the instruction INSN uses RIP-relative addressing, return the
1526    offset into the raw INSN where the displacement to be adjusted is
1527    found.  Returns 0 if the instruction doesn't use RIP-relative
1528    addressing.  */
1529
1530 static int
1531 rip_relative_offset (struct amd64_insn *insn)
1532 {
1533   if (insn->modrm_offset != -1)
1534     {
1535       gdb_byte modrm = insn->raw_insn[insn->modrm_offset];
1536
1537       if ((modrm & 0xc7) == 0x05)
1538         {
1539           /* The displacement is found right after the ModRM byte.  */
1540           return insn->modrm_offset + 1;
1541         }
1542     }
1543
1544   return 0;
1545 }
1546
1547 static void
1548 append_insns (CORE_ADDR *to, ULONGEST len, const gdb_byte *buf)
1549 {
1550   target_write_memory (*to, buf, len);
1551   *to += len;
1552 }
1553
1554 void
1555 amd64_relocate_instruction (struct gdbarch *gdbarch,
1556                             CORE_ADDR *to, CORE_ADDR oldloc)
1557 {
1558   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1559   int len = gdbarch_max_insn_length (gdbarch);
1560   /* Extra space for sentinels.  */
1561   int fixup_sentinel_space = len;
1562   gdb_byte *buf = xmalloc (len + fixup_sentinel_space);
1563   struct amd64_insn insn_details;
1564   int offset = 0;
1565   LONGEST rel32, newrel;
1566   gdb_byte *insn;
1567   int insn_length;
1568
1569   read_memory (oldloc, buf, len);
1570
1571   /* Set up the sentinel space so we don't have to worry about running
1572      off the end of the buffer.  An excessive number of leading prefixes
1573      could otherwise cause this.  */
1574   memset (buf + len, 0, fixup_sentinel_space);
1575
1576   insn = buf;
1577   amd64_get_insn_details (insn, &insn_details);
1578
1579   insn_length = gdb_buffered_insn_length (gdbarch, insn, len, oldloc);
1580
1581   /* Skip legacy instruction prefixes.  */
1582   insn = amd64_skip_prefixes (insn);
1583
1584   /* Adjust calls with 32-bit relative addresses as push/jump, with
1585      the address pushed being the location where the original call in
1586      the user program would return to.  */
1587   if (insn[0] == 0xe8)
1588     {
1589       gdb_byte push_buf[16];
1590       unsigned int ret_addr;
1591
1592       /* Where "ret" in the original code will return to.  */
1593       ret_addr = oldloc + insn_length;
1594       push_buf[0] = 0x68; /* pushq $...  */
1595       memcpy (&push_buf[1], &ret_addr, 4);
1596       /* Push the push.  */
1597       append_insns (to, 5, push_buf);
1598
1599       /* Convert the relative call to a relative jump.  */
1600       insn[0] = 0xe9;
1601
1602       /* Adjust the destination offset.  */
1603       rel32 = extract_signed_integer (insn + 1, 4, byte_order);
1604       newrel = (oldloc - *to) + rel32;
1605       store_signed_integer (insn + 1, 4, byte_order, newrel);
1606
1607       if (debug_displaced)
1608         fprintf_unfiltered (gdb_stdlog,
1609                             "Adjusted insn rel32=%s at %s to"
1610                             " rel32=%s at %s\n",
1611                             hex_string (rel32), paddress (gdbarch, oldloc),
1612                             hex_string (newrel), paddress (gdbarch, *to));
1613
1614       /* Write the adjusted jump into its displaced location.  */
1615       append_insns (to, 5, insn);
1616       return;
1617     }
1618
1619   offset = rip_relative_offset (&insn_details);
1620   if (!offset)
1621     {
1622       /* Adjust jumps with 32-bit relative addresses.  Calls are
1623          already handled above.  */
1624       if (insn[0] == 0xe9)
1625         offset = 1;
1626       /* Adjust conditional jumps.  */
1627       else if (insn[0] == 0x0f && (insn[1] & 0xf0) == 0x80)
1628         offset = 2;
1629     }
1630
1631   if (offset)
1632     {
1633       rel32 = extract_signed_integer (insn + offset, 4, byte_order);
1634       newrel = (oldloc - *to) + rel32;
1635       store_signed_integer (insn + offset, 4, byte_order, newrel);
1636       if (debug_displaced)
1637         fprintf_unfiltered (gdb_stdlog,
1638                             "Adjusted insn rel32=%s at %s to"
1639                             " rel32=%s at %s\n",
1640                             hex_string (rel32), paddress (gdbarch, oldloc),
1641                             hex_string (newrel), paddress (gdbarch, *to));
1642     }
1643
1644   /* Write the adjusted instruction into its displaced location.  */
1645   append_insns (to, insn_length, buf);
1646 }
1647
1648 \f
1649 /* The maximum number of saved registers.  This should include %rip.  */
1650 #define AMD64_NUM_SAVED_REGS    AMD64_NUM_GREGS
1651
1652 struct amd64_frame_cache
1653 {
1654   /* Base address.  */
1655   CORE_ADDR base;
1656   int base_p;
1657   CORE_ADDR sp_offset;
1658   CORE_ADDR pc;
1659
1660   /* Saved registers.  */
1661   CORE_ADDR saved_regs[AMD64_NUM_SAVED_REGS];
1662   CORE_ADDR saved_sp;
1663   int saved_sp_reg;
1664
1665   /* Do we have a frame?  */
1666   int frameless_p;
1667 };
1668
1669 /* Initialize a frame cache.  */
1670
1671 static void
1672 amd64_init_frame_cache (struct amd64_frame_cache *cache)
1673 {
1674   int i;
1675
1676   /* Base address.  */
1677   cache->base = 0;
1678   cache->base_p = 0;
1679   cache->sp_offset = -8;
1680   cache->pc = 0;
1681
1682   /* Saved registers.  We initialize these to -1 since zero is a valid
1683      offset (that's where %rbp is supposed to be stored).
1684      The values start out as being offsets, and are later converted to
1685      addresses (at which point -1 is interpreted as an address, still meaning
1686      "invalid").  */
1687   for (i = 0; i < AMD64_NUM_SAVED_REGS; i++)
1688     cache->saved_regs[i] = -1;
1689   cache->saved_sp = 0;
1690   cache->saved_sp_reg = -1;
1691
1692   /* Frameless until proven otherwise.  */
1693   cache->frameless_p = 1;
1694 }
1695
1696 /* Allocate and initialize a frame cache.  */
1697
1698 static struct amd64_frame_cache *
1699 amd64_alloc_frame_cache (void)
1700 {
1701   struct amd64_frame_cache *cache;
1702
1703   cache = FRAME_OBSTACK_ZALLOC (struct amd64_frame_cache);
1704   amd64_init_frame_cache (cache);
1705   return cache;
1706 }
1707
1708 /* GCC 4.4 and later, can put code in the prologue to realign the
1709    stack pointer.  Check whether PC points to such code, and update
1710    CACHE accordingly.  Return the first instruction after the code
1711    sequence or CURRENT_PC, whichever is smaller.  If we don't
1712    recognize the code, return PC.  */
1713
1714 static CORE_ADDR
1715 amd64_analyze_stack_align (CORE_ADDR pc, CORE_ADDR current_pc,
1716                            struct amd64_frame_cache *cache)
1717 {
1718   /* There are 2 code sequences to re-align stack before the frame
1719      gets set up:
1720
1721         1. Use a caller-saved saved register:
1722
1723                 leaq  8(%rsp), %reg
1724                 andq  $-XXX, %rsp
1725                 pushq -8(%reg)
1726
1727         2. Use a callee-saved saved register:
1728
1729                 pushq %reg
1730                 leaq  16(%rsp), %reg
1731                 andq  $-XXX, %rsp
1732                 pushq -8(%reg)
1733
1734      "andq $-XXX, %rsp" can be either 4 bytes or 7 bytes:
1735      
1736         0x48 0x83 0xe4 0xf0                     andq $-16, %rsp
1737         0x48 0x81 0xe4 0x00 0xff 0xff 0xff      andq $-256, %rsp
1738    */
1739
1740   gdb_byte buf[18];
1741   int reg, r;
1742   int offset, offset_and;
1743
1744   if (target_read_memory (pc, buf, sizeof buf))
1745     return pc;
1746
1747   /* Check caller-saved saved register.  The first instruction has
1748      to be "leaq 8(%rsp), %reg".  */
1749   if ((buf[0] & 0xfb) == 0x48
1750       && buf[1] == 0x8d
1751       && buf[3] == 0x24
1752       && buf[4] == 0x8)
1753     {
1754       /* MOD must be binary 10 and R/M must be binary 100.  */
1755       if ((buf[2] & 0xc7) != 0x44)
1756         return pc;
1757
1758       /* REG has register number.  */
1759       reg = (buf[2] >> 3) & 7;
1760
1761       /* Check the REX.R bit.  */
1762       if (buf[0] == 0x4c)
1763         reg += 8;
1764
1765       offset = 5;
1766     }
1767   else
1768     {
1769       /* Check callee-saved saved register.  The first instruction
1770          has to be "pushq %reg".  */
1771       reg = 0;
1772       if ((buf[0] & 0xf8) == 0x50)
1773         offset = 0;
1774       else if ((buf[0] & 0xf6) == 0x40
1775                && (buf[1] & 0xf8) == 0x50)
1776         {
1777           /* Check the REX.B bit.  */
1778           if ((buf[0] & 1) != 0)
1779             reg = 8;
1780
1781           offset = 1;
1782         }
1783       else
1784         return pc;
1785
1786       /* Get register.  */
1787       reg += buf[offset] & 0x7;
1788
1789       offset++;
1790
1791       /* The next instruction has to be "leaq 16(%rsp), %reg".  */
1792       if ((buf[offset] & 0xfb) != 0x48
1793           || buf[offset + 1] != 0x8d
1794           || buf[offset + 3] != 0x24
1795           || buf[offset + 4] != 0x10)
1796         return pc;
1797
1798       /* MOD must be binary 10 and R/M must be binary 100.  */
1799       if ((buf[offset + 2] & 0xc7) != 0x44)
1800         return pc;
1801       
1802       /* REG has register number.  */
1803       r = (buf[offset + 2] >> 3) & 7;
1804
1805       /* Check the REX.R bit.  */
1806       if (buf[offset] == 0x4c)
1807         r += 8;
1808
1809       /* Registers in pushq and leaq have to be the same.  */
1810       if (reg != r)
1811         return pc;
1812
1813       offset += 5;
1814     }
1815
1816   /* Rigister can't be %rsp nor %rbp.  */
1817   if (reg == 4 || reg == 5)
1818     return pc;
1819
1820   /* The next instruction has to be "andq $-XXX, %rsp".  */
1821   if (buf[offset] != 0x48
1822       || buf[offset + 2] != 0xe4
1823       || (buf[offset + 1] != 0x81 && buf[offset + 1] != 0x83))
1824     return pc;
1825
1826   offset_and = offset;
1827   offset += buf[offset + 1] == 0x81 ? 7 : 4;
1828
1829   /* The next instruction has to be "pushq -8(%reg)".  */
1830   r = 0;
1831   if (buf[offset] == 0xff)
1832     offset++;
1833   else if ((buf[offset] & 0xf6) == 0x40
1834            && buf[offset + 1] == 0xff)
1835     {
1836       /* Check the REX.B bit.  */
1837       if ((buf[offset] & 0x1) != 0)
1838         r = 8;
1839       offset += 2;
1840     }
1841   else
1842     return pc;
1843
1844   /* 8bit -8 is 0xf8.  REG must be binary 110 and MOD must be binary
1845      01.  */
1846   if (buf[offset + 1] != 0xf8
1847       || (buf[offset] & 0xf8) != 0x70)
1848     return pc;
1849
1850   /* R/M has register.  */
1851   r += buf[offset] & 7;
1852
1853   /* Registers in leaq and pushq have to be the same.  */
1854   if (reg != r)
1855     return pc;
1856
1857   if (current_pc > pc + offset_and)
1858     cache->saved_sp_reg = amd64_arch_reg_to_regnum (reg);
1859
1860   return min (pc + offset + 2, current_pc);
1861 }
1862
1863 /* Do a limited analysis of the prologue at PC and update CACHE
1864    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
1865    address where the analysis stopped.
1866
1867    We will handle only functions beginning with:
1868
1869       pushq %rbp        0x55
1870       movq %rsp, %rbp   0x48 0x89 0xe5
1871
1872    Any function that doesn't start with this sequence will be assumed
1873    to have no prologue and thus no valid frame pointer in %rbp.  */
1874
1875 static CORE_ADDR
1876 amd64_analyze_prologue (struct gdbarch *gdbarch,
1877                         CORE_ADDR pc, CORE_ADDR current_pc,
1878                         struct amd64_frame_cache *cache)
1879 {
1880   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1881   static gdb_byte proto[3] = { 0x48, 0x89, 0xe5 }; /* movq %rsp, %rbp */
1882   gdb_byte buf[3];
1883   gdb_byte op;
1884
1885   if (current_pc <= pc)
1886     return current_pc;
1887
1888   pc = amd64_analyze_stack_align (pc, current_pc, cache);
1889
1890   op = read_memory_unsigned_integer (pc, 1, byte_order);
1891
1892   if (op == 0x55)               /* pushq %rbp */
1893     {
1894       /* Take into account that we've executed the `pushq %rbp' that
1895          starts this instruction sequence.  */
1896       cache->saved_regs[AMD64_RBP_REGNUM] = 0;
1897       cache->sp_offset += 8;
1898
1899       /* If that's all, return now.  */
1900       if (current_pc <= pc + 1)
1901         return current_pc;
1902
1903       /* Check for `movq %rsp, %rbp'.  */
1904       read_memory (pc + 1, buf, 3);
1905       if (memcmp (buf, proto, 3) != 0)
1906         return pc + 1;
1907
1908       /* OK, we actually have a frame.  */
1909       cache->frameless_p = 0;
1910       return pc + 4;
1911     }
1912
1913   return pc;
1914 }
1915
1916 /* Work around false termination of prologue - GCC PR debug/48827.
1917
1918    START_PC is the first instruction of a function, PC is its minimal already
1919    determined advanced address.  Function returns PC if it has nothing to do.
1920
1921    84 c0                test   %al,%al
1922    74 23                je     after
1923    <-- here is 0 lines advance - the false prologue end marker.
1924    0f 29 85 70 ff ff ff movaps %xmm0,-0x90(%rbp)
1925    0f 29 4d 80          movaps %xmm1,-0x80(%rbp)
1926    0f 29 55 90          movaps %xmm2,-0x70(%rbp)
1927    0f 29 5d a0          movaps %xmm3,-0x60(%rbp)
1928    0f 29 65 b0          movaps %xmm4,-0x50(%rbp)
1929    0f 29 6d c0          movaps %xmm5,-0x40(%rbp)
1930    0f 29 75 d0          movaps %xmm6,-0x30(%rbp)
1931    0f 29 7d e0          movaps %xmm7,-0x20(%rbp)
1932    after:  */
1933
1934 static CORE_ADDR
1935 amd64_skip_xmm_prologue (CORE_ADDR pc, CORE_ADDR start_pc)
1936 {
1937   struct symtab_and_line start_pc_sal, next_sal;
1938   gdb_byte buf[4 + 8 * 7];
1939   int offset, xmmreg;
1940
1941   if (pc == start_pc)
1942     return pc;
1943
1944   start_pc_sal = find_pc_sect_line (start_pc, NULL, 0);
1945   if (start_pc_sal.symtab == NULL
1946       || producer_is_gcc_ge_4 (start_pc_sal.symtab->producer) < 6
1947       || start_pc_sal.pc != start_pc || pc >= start_pc_sal.end)
1948     return pc;
1949
1950   next_sal = find_pc_sect_line (start_pc_sal.end, NULL, 0);
1951   if (next_sal.line != start_pc_sal.line)
1952     return pc;
1953
1954   /* START_PC can be from overlayed memory, ignored here.  */
1955   if (target_read_memory (next_sal.pc - 4, buf, sizeof (buf)) != 0)
1956     return pc;
1957
1958   /* test %al,%al */
1959   if (buf[0] != 0x84 || buf[1] != 0xc0)
1960     return pc;
1961   /* je AFTER */
1962   if (buf[2] != 0x74)
1963     return pc;
1964
1965   offset = 4;
1966   for (xmmreg = 0; xmmreg < 8; xmmreg++)
1967     {
1968       /* 0x0f 0x29 0b??000101 movaps %xmmreg?,-0x??(%rbp) */
1969       if (buf[offset] != 0x0f || buf[offset + 1] != 0x29
1970           || (buf[offset + 2] & 0x3f) != (xmmreg << 3 | 0x5))
1971         return pc;
1972
1973       /* 0b01?????? */
1974       if ((buf[offset + 2] & 0xc0) == 0x40)
1975         {
1976           /* 8-bit displacement.  */
1977           offset += 4;
1978         }
1979       /* 0b10?????? */
1980       else if ((buf[offset + 2] & 0xc0) == 0x80)
1981         {
1982           /* 32-bit displacement.  */
1983           offset += 7;
1984         }
1985       else
1986         return pc;
1987     }
1988
1989   /* je AFTER */
1990   if (offset - 4 != buf[3])
1991     return pc;
1992
1993   return next_sal.end;
1994 }
1995
1996 /* Return PC of first real instruction.  */
1997
1998 static CORE_ADDR
1999 amd64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
2000 {
2001   struct amd64_frame_cache cache;
2002   CORE_ADDR pc;
2003
2004   amd64_init_frame_cache (&cache);
2005   pc = amd64_analyze_prologue (gdbarch, start_pc, 0xffffffffffffffffLL,
2006                                &cache);
2007   if (cache.frameless_p)
2008     return start_pc;
2009
2010   return amd64_skip_xmm_prologue (pc, start_pc);
2011 }
2012 \f
2013
2014 /* Normal frames.  */
2015
2016 static void
2017 amd64_frame_cache_1 (struct frame_info *this_frame,
2018                      struct amd64_frame_cache *cache)
2019 {
2020   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2021   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2022   gdb_byte buf[8];
2023   int i;
2024
2025   cache->pc = get_frame_func (this_frame);
2026   if (cache->pc != 0)
2027     amd64_analyze_prologue (gdbarch, cache->pc, get_frame_pc (this_frame),
2028                             cache);
2029
2030   if (cache->frameless_p)
2031     {
2032       /* We didn't find a valid frame.  If we're at the start of a
2033          function, or somewhere half-way its prologue, the function's
2034          frame probably hasn't been fully setup yet.  Try to
2035          reconstruct the base address for the stack frame by looking
2036          at the stack pointer.  For truly "frameless" functions this
2037          might work too.  */
2038
2039       if (cache->saved_sp_reg != -1)
2040         {
2041           /* Stack pointer has been saved.  */
2042           get_frame_register (this_frame, cache->saved_sp_reg, buf);
2043           cache->saved_sp = extract_unsigned_integer (buf, 8, byte_order);
2044
2045           /* We're halfway aligning the stack.  */
2046           cache->base = ((cache->saved_sp - 8) & 0xfffffffffffffff0LL) - 8;
2047           cache->saved_regs[AMD64_RIP_REGNUM] = cache->saved_sp - 8;
2048
2049           /* This will be added back below.  */
2050           cache->saved_regs[AMD64_RIP_REGNUM] -= cache->base;
2051         }
2052       else
2053         {
2054           get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
2055           cache->base = extract_unsigned_integer (buf, 8, byte_order)
2056                         + cache->sp_offset;
2057         }
2058     }
2059   else
2060     {
2061       get_frame_register (this_frame, AMD64_RBP_REGNUM, buf);
2062       cache->base = extract_unsigned_integer (buf, 8, byte_order);
2063     }
2064
2065   /* Now that we have the base address for the stack frame we can
2066      calculate the value of %rsp in the calling frame.  */
2067   cache->saved_sp = cache->base + 16;
2068
2069   /* For normal frames, %rip is stored at 8(%rbp).  If we don't have a
2070      frame we find it at the same offset from the reconstructed base
2071      address.  If we're halfway aligning the stack, %rip is handled
2072      differently (see above).  */
2073   if (!cache->frameless_p || cache->saved_sp_reg == -1)
2074     cache->saved_regs[AMD64_RIP_REGNUM] = 8;
2075
2076   /* Adjust all the saved registers such that they contain addresses
2077      instead of offsets.  */
2078   for (i = 0; i < AMD64_NUM_SAVED_REGS; i++)
2079     if (cache->saved_regs[i] != -1)
2080       cache->saved_regs[i] += cache->base;
2081
2082   cache->base_p = 1;
2083 }
2084
2085 static struct amd64_frame_cache *
2086 amd64_frame_cache (struct frame_info *this_frame, void **this_cache)
2087 {
2088   volatile struct gdb_exception ex;
2089   struct amd64_frame_cache *cache;
2090
2091   if (*this_cache)
2092     return *this_cache;
2093
2094   cache = amd64_alloc_frame_cache ();
2095   *this_cache = cache;
2096
2097   TRY_CATCH (ex, RETURN_MASK_ERROR)
2098     {
2099       amd64_frame_cache_1 (this_frame, cache);
2100     }
2101   if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
2102     throw_exception (ex);
2103
2104   return cache;
2105 }
2106
2107 static enum unwind_stop_reason
2108 amd64_frame_unwind_stop_reason (struct frame_info *this_frame,
2109                                 void **this_cache)
2110 {
2111   struct amd64_frame_cache *cache =
2112     amd64_frame_cache (this_frame, this_cache);
2113
2114   if (!cache->base_p)
2115     return UNWIND_UNAVAILABLE;
2116
2117   /* This marks the outermost frame.  */
2118   if (cache->base == 0)
2119     return UNWIND_OUTERMOST;
2120
2121   return UNWIND_NO_REASON;
2122 }
2123
2124 static void
2125 amd64_frame_this_id (struct frame_info *this_frame, void **this_cache,
2126                      struct frame_id *this_id)
2127 {
2128   struct amd64_frame_cache *cache =
2129     amd64_frame_cache (this_frame, this_cache);
2130
2131   if (!cache->base_p)
2132     return;
2133
2134   /* This marks the outermost frame.  */
2135   if (cache->base == 0)
2136     return;
2137
2138   (*this_id) = frame_id_build (cache->base + 16, cache->pc);
2139 }
2140
2141 static struct value *
2142 amd64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
2143                            int regnum)
2144 {
2145   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2146   struct amd64_frame_cache *cache =
2147     amd64_frame_cache (this_frame, this_cache);
2148
2149   gdb_assert (regnum >= 0);
2150
2151   if (regnum == gdbarch_sp_regnum (gdbarch) && cache->saved_sp)
2152     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
2153
2154   if (regnum < AMD64_NUM_SAVED_REGS && cache->saved_regs[regnum] != -1)
2155     return frame_unwind_got_memory (this_frame, regnum,
2156                                     cache->saved_regs[regnum]);
2157
2158   return frame_unwind_got_register (this_frame, regnum, regnum);
2159 }
2160
2161 static const struct frame_unwind amd64_frame_unwind =
2162 {
2163   NORMAL_FRAME,
2164   amd64_frame_unwind_stop_reason,
2165   amd64_frame_this_id,
2166   amd64_frame_prev_register,
2167   NULL,
2168   default_frame_sniffer
2169 };
2170 \f
2171 /* Generate a bytecode expression to get the value of the saved PC.  */
2172
2173 static void
2174 amd64_gen_return_address (struct gdbarch *gdbarch,
2175                           struct agent_expr *ax, struct axs_value *value,
2176                           CORE_ADDR scope)
2177 {
2178   /* The following sequence assumes the traditional use of the base
2179      register.  */
2180   ax_reg (ax, AMD64_RBP_REGNUM);
2181   ax_const_l (ax, 8);
2182   ax_simple (ax, aop_add);
2183   value->type = register_type (gdbarch, AMD64_RIP_REGNUM);
2184   value->kind = axs_lvalue_memory;
2185 }
2186 \f
2187
2188 /* Signal trampolines.  */
2189
2190 /* FIXME: kettenis/20030419: Perhaps, we can unify the 32-bit and
2191    64-bit variants.  This would require using identical frame caches
2192    on both platforms.  */
2193
2194 static struct amd64_frame_cache *
2195 amd64_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
2196 {
2197   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2198   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2199   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2200   volatile struct gdb_exception ex;
2201   struct amd64_frame_cache *cache;
2202   CORE_ADDR addr;
2203   gdb_byte buf[8];
2204   int i;
2205
2206   if (*this_cache)
2207     return *this_cache;
2208
2209   cache = amd64_alloc_frame_cache ();
2210
2211   TRY_CATCH (ex, RETURN_MASK_ERROR)
2212     {
2213       get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
2214       cache->base = extract_unsigned_integer (buf, 8, byte_order) - 8;
2215
2216       addr = tdep->sigcontext_addr (this_frame);
2217       gdb_assert (tdep->sc_reg_offset);
2218       gdb_assert (tdep->sc_num_regs <= AMD64_NUM_SAVED_REGS);
2219       for (i = 0; i < tdep->sc_num_regs; i++)
2220         if (tdep->sc_reg_offset[i] != -1)
2221           cache->saved_regs[i] = addr + tdep->sc_reg_offset[i];
2222
2223       cache->base_p = 1;
2224     }
2225   if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
2226     throw_exception (ex);
2227
2228   *this_cache = cache;
2229   return cache;
2230 }
2231
2232 static enum unwind_stop_reason
2233 amd64_sigtramp_frame_unwind_stop_reason (struct frame_info *this_frame,
2234                                          void **this_cache)
2235 {
2236   struct amd64_frame_cache *cache =
2237     amd64_sigtramp_frame_cache (this_frame, this_cache);
2238
2239   if (!cache->base_p)
2240     return UNWIND_UNAVAILABLE;
2241
2242   return UNWIND_NO_REASON;
2243 }
2244
2245 static void
2246 amd64_sigtramp_frame_this_id (struct frame_info *this_frame,
2247                               void **this_cache, struct frame_id *this_id)
2248 {
2249   struct amd64_frame_cache *cache =
2250     amd64_sigtramp_frame_cache (this_frame, this_cache);
2251
2252   if (!cache->base_p)
2253     return;
2254
2255   (*this_id) = frame_id_build (cache->base + 16, get_frame_pc (this_frame));
2256 }
2257
2258 static struct value *
2259 amd64_sigtramp_frame_prev_register (struct frame_info *this_frame,
2260                                     void **this_cache, int regnum)
2261 {
2262   /* Make sure we've initialized the cache.  */
2263   amd64_sigtramp_frame_cache (this_frame, this_cache);
2264
2265   return amd64_frame_prev_register (this_frame, this_cache, regnum);
2266 }
2267
2268 static int
2269 amd64_sigtramp_frame_sniffer (const struct frame_unwind *self,
2270                               struct frame_info *this_frame,
2271                               void **this_cache)
2272 {
2273   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
2274
2275   /* We shouldn't even bother if we don't have a sigcontext_addr
2276      handler.  */
2277   if (tdep->sigcontext_addr == NULL)
2278     return 0;
2279
2280   if (tdep->sigtramp_p != NULL)
2281     {
2282       if (tdep->sigtramp_p (this_frame))
2283         return 1;
2284     }
2285
2286   if (tdep->sigtramp_start != 0)
2287     {
2288       CORE_ADDR pc = get_frame_pc (this_frame);
2289
2290       gdb_assert (tdep->sigtramp_end != 0);
2291       if (pc >= tdep->sigtramp_start && pc < tdep->sigtramp_end)
2292         return 1;
2293     }
2294
2295   return 0;
2296 }
2297
2298 static const struct frame_unwind amd64_sigtramp_frame_unwind =
2299 {
2300   SIGTRAMP_FRAME,
2301   amd64_sigtramp_frame_unwind_stop_reason,
2302   amd64_sigtramp_frame_this_id,
2303   amd64_sigtramp_frame_prev_register,
2304   NULL,
2305   amd64_sigtramp_frame_sniffer
2306 };
2307 \f
2308
2309 static CORE_ADDR
2310 amd64_frame_base_address (struct frame_info *this_frame, void **this_cache)
2311 {
2312   struct amd64_frame_cache *cache =
2313     amd64_frame_cache (this_frame, this_cache);
2314
2315   return cache->base;
2316 }
2317
2318 static const struct frame_base amd64_frame_base =
2319 {
2320   &amd64_frame_unwind,
2321   amd64_frame_base_address,
2322   amd64_frame_base_address,
2323   amd64_frame_base_address
2324 };
2325
2326 /* Normal frames, but in a function epilogue.  */
2327
2328 /* The epilogue is defined here as the 'ret' instruction, which will
2329    follow any instruction such as 'leave' or 'pop %ebp' that destroys
2330    the function's stack frame.  */
2331
2332 static int
2333 amd64_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2334 {
2335   gdb_byte insn;
2336   struct symtab *symtab;
2337
2338   symtab = find_pc_symtab (pc);
2339   if (symtab && symtab->epilogue_unwind_valid)
2340     return 0;
2341
2342   if (target_read_memory (pc, &insn, 1))
2343     return 0;   /* Can't read memory at pc.  */
2344
2345   if (insn != 0xc3)     /* 'ret' instruction.  */
2346     return 0;
2347
2348   return 1;
2349 }
2350
2351 static int
2352 amd64_epilogue_frame_sniffer (const struct frame_unwind *self,
2353                               struct frame_info *this_frame,
2354                               void **this_prologue_cache)
2355 {
2356   if (frame_relative_level (this_frame) == 0)
2357     return amd64_in_function_epilogue_p (get_frame_arch (this_frame),
2358                                          get_frame_pc (this_frame));
2359   else
2360     return 0;
2361 }
2362
2363 static struct amd64_frame_cache *
2364 amd64_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
2365 {
2366   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2367   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2368   volatile struct gdb_exception ex;
2369   struct amd64_frame_cache *cache;
2370   gdb_byte buf[8];
2371
2372   if (*this_cache)
2373     return *this_cache;
2374
2375   cache = amd64_alloc_frame_cache ();
2376   *this_cache = cache;
2377
2378   TRY_CATCH (ex, RETURN_MASK_ERROR)
2379     {
2380       /* Cache base will be %esp plus cache->sp_offset (-8).  */
2381       get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
2382       cache->base = extract_unsigned_integer (buf, 8,
2383                                               byte_order) + cache->sp_offset;
2384
2385       /* Cache pc will be the frame func.  */
2386       cache->pc = get_frame_pc (this_frame);
2387
2388       /* The saved %esp will be at cache->base plus 16.  */
2389       cache->saved_sp = cache->base + 16;
2390
2391       /* The saved %eip will be at cache->base plus 8.  */
2392       cache->saved_regs[AMD64_RIP_REGNUM] = cache->base + 8;
2393
2394       cache->base_p = 1;
2395     }
2396   if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
2397     throw_exception (ex);
2398
2399   return cache;
2400 }
2401
2402 static enum unwind_stop_reason
2403 amd64_epilogue_frame_unwind_stop_reason (struct frame_info *this_frame,
2404                                          void **this_cache)
2405 {
2406   struct amd64_frame_cache *cache
2407     = amd64_epilogue_frame_cache (this_frame, this_cache);
2408
2409   if (!cache->base_p)
2410     return UNWIND_UNAVAILABLE;
2411
2412   return UNWIND_NO_REASON;
2413 }
2414
2415 static void
2416 amd64_epilogue_frame_this_id (struct frame_info *this_frame,
2417                               void **this_cache,
2418                               struct frame_id *this_id)
2419 {
2420   struct amd64_frame_cache *cache = amd64_epilogue_frame_cache (this_frame,
2421                                                                this_cache);
2422
2423   if (!cache->base_p)
2424     return;
2425
2426   (*this_id) = frame_id_build (cache->base + 8, cache->pc);
2427 }
2428
2429 static const struct frame_unwind amd64_epilogue_frame_unwind =
2430 {
2431   NORMAL_FRAME,
2432   amd64_epilogue_frame_unwind_stop_reason,
2433   amd64_epilogue_frame_this_id,
2434   amd64_frame_prev_register,
2435   NULL, 
2436   amd64_epilogue_frame_sniffer
2437 };
2438
2439 static struct frame_id
2440 amd64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2441 {
2442   CORE_ADDR fp;
2443
2444   fp = get_frame_register_unsigned (this_frame, AMD64_RBP_REGNUM);
2445
2446   return frame_id_build (fp + 16, get_frame_pc (this_frame));
2447 }
2448
2449 /* 16 byte align the SP per frame requirements.  */
2450
2451 static CORE_ADDR
2452 amd64_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
2453 {
2454   return sp & -(CORE_ADDR)16;
2455 }
2456 \f
2457
2458 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
2459    in the floating-point register set REGSET to register cache
2460    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
2461
2462 static void
2463 amd64_supply_fpregset (const struct regset *regset, struct regcache *regcache,
2464                        int regnum, const void *fpregs, size_t len)
2465 {
2466   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
2467
2468   gdb_assert (len == tdep->sizeof_fpregset);
2469   amd64_supply_fxsave (regcache, regnum, fpregs);
2470 }
2471
2472 /* Collect register REGNUM from the register cache REGCACHE and store
2473    it in the buffer specified by FPREGS and LEN as described by the
2474    floating-point register set REGSET.  If REGNUM is -1, do this for
2475    all registers in REGSET.  */
2476
2477 static void
2478 amd64_collect_fpregset (const struct regset *regset,
2479                         const struct regcache *regcache,
2480                         int regnum, void *fpregs, size_t len)
2481 {
2482   const struct gdbarch_tdep *tdep = gdbarch_tdep (regset->arch);
2483
2484   gdb_assert (len == tdep->sizeof_fpregset);
2485   amd64_collect_fxsave (regcache, regnum, fpregs);
2486 }
2487
2488 /* Similar to amd64_supply_fpregset, but use XSAVE extended state.  */
2489
2490 static void
2491 amd64_supply_xstateregset (const struct regset *regset,
2492                            struct regcache *regcache, int regnum,
2493                            const void *xstateregs, size_t len)
2494 {
2495   amd64_supply_xsave (regcache, regnum, xstateregs);
2496 }
2497
2498 /* Similar to amd64_collect_fpregset, but use XSAVE extended state.  */
2499
2500 static void
2501 amd64_collect_xstateregset (const struct regset *regset,
2502                             const struct regcache *regcache,
2503                             int regnum, void *xstateregs, size_t len)
2504 {
2505   amd64_collect_xsave (regcache, regnum, xstateregs, 1);
2506 }
2507
2508 /* Return the appropriate register set for the core section identified
2509    by SECT_NAME and SECT_SIZE.  */
2510
2511 static const struct regset *
2512 amd64_regset_from_core_section (struct gdbarch *gdbarch,
2513                                 const char *sect_name, size_t sect_size)
2514 {
2515   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2516
2517   if (strcmp (sect_name, ".reg2") == 0 && sect_size == tdep->sizeof_fpregset)
2518     {
2519       if (tdep->fpregset == NULL)
2520         tdep->fpregset = regset_alloc (gdbarch, amd64_supply_fpregset,
2521                                        amd64_collect_fpregset);
2522
2523       return tdep->fpregset;
2524     }
2525
2526   if (strcmp (sect_name, ".reg-xstate") == 0)
2527     {
2528       if (tdep->xstateregset == NULL)
2529         tdep->xstateregset = regset_alloc (gdbarch,
2530                                            amd64_supply_xstateregset,
2531                                            amd64_collect_xstateregset);
2532
2533       return tdep->xstateregset;
2534     }
2535
2536   return i386_regset_from_core_section (gdbarch, sect_name, sect_size);
2537 }
2538 \f
2539
2540 /* Figure out where the longjmp will land.  Slurp the jmp_buf out of
2541    %rdi.  We expect its value to be a pointer to the jmp_buf structure
2542    from which we extract the address that we will land at.  This
2543    address is copied into PC.  This routine returns non-zero on
2544    success.  */
2545
2546 static int
2547 amd64_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
2548 {
2549   gdb_byte buf[8];
2550   CORE_ADDR jb_addr;
2551   struct gdbarch *gdbarch = get_frame_arch (frame);
2552   int jb_pc_offset = gdbarch_tdep (gdbarch)->jb_pc_offset;
2553   int len = TYPE_LENGTH (builtin_type (gdbarch)->builtin_func_ptr);
2554
2555   /* If JB_PC_OFFSET is -1, we have no way to find out where the
2556      longjmp will land.  */
2557   if (jb_pc_offset == -1)
2558     return 0;
2559
2560   get_frame_register (frame, AMD64_RDI_REGNUM, buf);
2561   jb_addr= extract_typed_address
2562             (buf, builtin_type (gdbarch)->builtin_data_ptr);
2563   if (target_read_memory (jb_addr + jb_pc_offset, buf, len))
2564     return 0;
2565
2566   *pc = extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
2567
2568   return 1;
2569 }
2570
2571 static const int amd64_record_regmap[] =
2572 {
2573   AMD64_RAX_REGNUM, AMD64_RCX_REGNUM, AMD64_RDX_REGNUM, AMD64_RBX_REGNUM,
2574   AMD64_RSP_REGNUM, AMD64_RBP_REGNUM, AMD64_RSI_REGNUM, AMD64_RDI_REGNUM,
2575   AMD64_R8_REGNUM, AMD64_R9_REGNUM, AMD64_R10_REGNUM, AMD64_R11_REGNUM,
2576   AMD64_R12_REGNUM, AMD64_R13_REGNUM, AMD64_R14_REGNUM, AMD64_R15_REGNUM,
2577   AMD64_RIP_REGNUM, AMD64_EFLAGS_REGNUM, AMD64_CS_REGNUM, AMD64_SS_REGNUM,
2578   AMD64_DS_REGNUM, AMD64_ES_REGNUM, AMD64_FS_REGNUM, AMD64_GS_REGNUM
2579 };
2580
2581 void
2582 amd64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
2583 {
2584   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2585   const struct target_desc *tdesc = info.target_desc;
2586
2587   /* AMD64 generally uses `fxsave' instead of `fsave' for saving its
2588      floating-point registers.  */
2589   tdep->sizeof_fpregset = I387_SIZEOF_FXSAVE;
2590
2591   if (! tdesc_has_registers (tdesc))
2592     tdesc = tdesc_amd64;
2593   tdep->tdesc = tdesc;
2594
2595   tdep->num_core_regs = AMD64_NUM_GREGS + I387_NUM_REGS;
2596   tdep->register_names = amd64_register_names;
2597
2598   if (tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx") != NULL)
2599     {
2600       tdep->ymmh_register_names = amd64_ymmh_names;
2601       tdep->num_ymm_regs = 16;
2602       tdep->ymm0h_regnum = AMD64_YMM0H_REGNUM;
2603     }
2604
2605   tdep->num_byte_regs = 20;
2606   tdep->num_word_regs = 16;
2607   tdep->num_dword_regs = 16;
2608   /* Avoid wiring in the MMX registers for now.  */
2609   tdep->num_mmx_regs = 0;
2610
2611   set_gdbarch_pseudo_register_read_value (gdbarch,
2612                                           amd64_pseudo_register_read_value);
2613   set_gdbarch_pseudo_register_write (gdbarch,
2614                                      amd64_pseudo_register_write);
2615
2616   set_tdesc_pseudo_register_name (gdbarch, amd64_pseudo_register_name);
2617
2618   /* AMD64 has an FPU and 16 SSE registers.  */
2619   tdep->st0_regnum = AMD64_ST0_REGNUM;
2620   tdep->num_xmm_regs = 16;
2621
2622   /* This is what all the fuss is about.  */
2623   set_gdbarch_long_bit (gdbarch, 64);
2624   set_gdbarch_long_long_bit (gdbarch, 64);
2625   set_gdbarch_ptr_bit (gdbarch, 64);
2626
2627   /* In contrast to the i386, on AMD64 a `long double' actually takes
2628      up 128 bits, even though it's still based on the i387 extended
2629      floating-point format which has only 80 significant bits.  */
2630   set_gdbarch_long_double_bit (gdbarch, 128);
2631
2632   set_gdbarch_num_regs (gdbarch, AMD64_NUM_REGS);
2633
2634   /* Register numbers of various important registers.  */
2635   set_gdbarch_sp_regnum (gdbarch, AMD64_RSP_REGNUM); /* %rsp */
2636   set_gdbarch_pc_regnum (gdbarch, AMD64_RIP_REGNUM); /* %rip */
2637   set_gdbarch_ps_regnum (gdbarch, AMD64_EFLAGS_REGNUM); /* %eflags */
2638   set_gdbarch_fp0_regnum (gdbarch, AMD64_ST0_REGNUM); /* %st(0) */
2639
2640   /* The "default" register numbering scheme for AMD64 is referred to
2641      as the "DWARF Register Number Mapping" in the System V psABI.
2642      The preferred debugging format for all known AMD64 targets is
2643      actually DWARF2, and GCC doesn't seem to support DWARF (that is
2644      DWARF-1), but we provide the same mapping just in case.  This
2645      mapping is also used for stabs, which GCC does support.  */
2646   set_gdbarch_stab_reg_to_regnum (gdbarch, amd64_dwarf_reg_to_regnum);
2647   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, amd64_dwarf_reg_to_regnum);
2648
2649   /* We don't override SDB_REG_RO_REGNUM, since COFF doesn't seem to
2650      be in use on any of the supported AMD64 targets.  */
2651
2652   /* Call dummy code.  */
2653   set_gdbarch_push_dummy_call (gdbarch, amd64_push_dummy_call);
2654   set_gdbarch_frame_align (gdbarch, amd64_frame_align);
2655   set_gdbarch_frame_red_zone_size (gdbarch, 128);
2656   tdep->call_dummy_num_integer_regs =
2657     ARRAY_SIZE (amd64_dummy_call_integer_regs);
2658   tdep->call_dummy_integer_regs = amd64_dummy_call_integer_regs;
2659   tdep->classify = amd64_classify;
2660
2661   set_gdbarch_convert_register_p (gdbarch, i387_convert_register_p);
2662   set_gdbarch_register_to_value (gdbarch, i387_register_to_value);
2663   set_gdbarch_value_to_register (gdbarch, i387_value_to_register);
2664
2665   set_gdbarch_return_value (gdbarch, amd64_return_value);
2666
2667   set_gdbarch_skip_prologue (gdbarch, amd64_skip_prologue);
2668
2669   tdep->record_regmap = amd64_record_regmap;
2670
2671   set_gdbarch_dummy_id (gdbarch, amd64_dummy_id);
2672
2673   /* Hook the function epilogue frame unwinder.  This unwinder is
2674      appended to the list first, so that it supercedes the other
2675      unwinders in function epilogues.  */
2676   frame_unwind_prepend_unwinder (gdbarch, &amd64_epilogue_frame_unwind);
2677
2678   /* Hook the prologue-based frame unwinders.  */
2679   frame_unwind_append_unwinder (gdbarch, &amd64_sigtramp_frame_unwind);
2680   frame_unwind_append_unwinder (gdbarch, &amd64_frame_unwind);
2681   frame_base_set_default (gdbarch, &amd64_frame_base);
2682
2683   /* If we have a register mapping, enable the generic core file support.  */
2684   if (tdep->gregset_reg_offset)
2685     set_gdbarch_regset_from_core_section (gdbarch,
2686                                           amd64_regset_from_core_section);
2687
2688   set_gdbarch_get_longjmp_target (gdbarch, amd64_get_longjmp_target);
2689
2690   set_gdbarch_relocate_instruction (gdbarch, amd64_relocate_instruction);
2691
2692   set_gdbarch_gen_return_address (gdbarch, amd64_gen_return_address);
2693 }
2694
2695 /* Provide a prototype to silence -Wmissing-prototypes.  */
2696 void _initialize_amd64_tdep (void);
2697
2698 void
2699 _initialize_amd64_tdep (void)
2700 {
2701   initialize_tdesc_amd64 ();
2702   initialize_tdesc_amd64_avx ();
2703 }
2704 \f
2705
2706 /* The 64-bit FXSAVE format differs from the 32-bit format in the
2707    sense that the instruction pointer and data pointer are simply
2708    64-bit offsets into the code segment and the data segment instead
2709    of a selector offset pair.  The functions below store the upper 32
2710    bits of these pointers (instead of just the 16-bits of the segment
2711    selector).  */
2712
2713 /* Fill register REGNUM in REGCACHE with the appropriate
2714    floating-point or SSE register value from *FXSAVE.  If REGNUM is
2715    -1, do this for all registers.  This function masks off any of the
2716    reserved bits in *FXSAVE.  */
2717
2718 void
2719 amd64_supply_fxsave (struct regcache *regcache, int regnum,
2720                      const void *fxsave)
2721 {
2722   struct gdbarch *gdbarch = get_regcache_arch (regcache);
2723   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2724
2725   i387_supply_fxsave (regcache, regnum, fxsave);
2726
2727   if (fxsave && gdbarch_ptr_bit (gdbarch) == 64)
2728     {
2729       const gdb_byte *regs = fxsave;
2730
2731       if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
2732         regcache_raw_supply (regcache, I387_FISEG_REGNUM (tdep), regs + 12);
2733       if (regnum == -1 || regnum == I387_FOSEG_REGNUM (tdep))
2734         regcache_raw_supply (regcache, I387_FOSEG_REGNUM (tdep), regs + 20);
2735     }
2736 }
2737
2738 /* Similar to amd64_supply_fxsave, but use XSAVE extended state.  */
2739
2740 void
2741 amd64_supply_xsave (struct regcache *regcache, int regnum,
2742                     const void *xsave)
2743 {
2744   struct gdbarch *gdbarch = get_regcache_arch (regcache);
2745   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2746
2747   i387_supply_xsave (regcache, regnum, xsave);
2748
2749   if (xsave && gdbarch_ptr_bit (gdbarch) == 64)
2750     {
2751       const gdb_byte *regs = xsave;
2752
2753       if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
2754         regcache_raw_supply (regcache, I387_FISEG_REGNUM (tdep),
2755                              regs + 12);
2756       if (regnum == -1 || regnum == I387_FOSEG_REGNUM (tdep))
2757         regcache_raw_supply (regcache, I387_FOSEG_REGNUM (tdep),
2758                              regs + 20);
2759     }
2760 }
2761
2762 /* Fill register REGNUM (if it is a floating-point or SSE register) in
2763    *FXSAVE with the value from REGCACHE.  If REGNUM is -1, do this for
2764    all registers.  This function doesn't touch any of the reserved
2765    bits in *FXSAVE.  */
2766
2767 void
2768 amd64_collect_fxsave (const struct regcache *regcache, int regnum,
2769                       void *fxsave)
2770 {
2771   struct gdbarch *gdbarch = get_regcache_arch (regcache);
2772   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2773   gdb_byte *regs = fxsave;
2774
2775   i387_collect_fxsave (regcache, regnum, fxsave);
2776
2777   if (gdbarch_ptr_bit (gdbarch) == 64)
2778     {
2779       if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
2780         regcache_raw_collect (regcache, I387_FISEG_REGNUM (tdep), regs + 12);
2781       if (regnum == -1 || regnum == I387_FOSEG_REGNUM (tdep))
2782         regcache_raw_collect (regcache, I387_FOSEG_REGNUM (tdep), regs + 20);
2783     }
2784 }
2785
2786 /* Similar to amd64_collect_fxsave, but use XSAVE extended state.  */
2787
2788 void
2789 amd64_collect_xsave (const struct regcache *regcache, int regnum,
2790                      void *xsave, int gcore)
2791 {
2792   struct gdbarch *gdbarch = get_regcache_arch (regcache);
2793   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2794   gdb_byte *regs = xsave;
2795
2796   i387_collect_xsave (regcache, regnum, xsave, gcore);
2797
2798   if (gdbarch_ptr_bit (gdbarch) == 64)
2799     {
2800       if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
2801         regcache_raw_collect (regcache, I387_FISEG_REGNUM (tdep),
2802                               regs + 12);
2803       if (regnum == -1 || regnum == I387_FOSEG_REGNUM (tdep))
2804         regcache_raw_collect (regcache, I387_FOSEG_REGNUM (tdep),
2805                               regs + 20);
2806     }
2807 }