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