Automatic date update in version.in
[external/binutils.git] / gdb / ia64-linux-tdep.c
1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
2
3    Copyright (C) 2000-2018 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "ia64-tdep.h"
22 #include "arch-utils.h"
23 #include "gdbcore.h"
24 #include "regcache.h"
25 #include "osabi.h"
26 #include "solib-svr4.h"
27 #include "symtab.h"
28 #include "linux-tdep.h"
29 #include "regset.h"
30
31 #include <ctype.h>
32
33 /* The sigtramp code is in a non-readable (executable-only) region
34    of memory called the ``gate page''.  The addresses in question
35    were determined by examining the system headers.  They are
36    overly generous to allow for different pages sizes.  */
37
38 #define GATE_AREA_START 0xa000000000000100LL
39 #define GATE_AREA_END   0xa000000000020000LL
40
41 /* Offset to sigcontext structure from frame of handler.  */
42 #define IA64_LINUX_SIGCONTEXT_OFFSET 192
43
44 static int
45 ia64_linux_pc_in_sigtramp (CORE_ADDR pc)
46 {
47   return (pc >= (CORE_ADDR) GATE_AREA_START && pc < (CORE_ADDR) GATE_AREA_END);
48 }
49
50 /* IA-64 GNU/Linux specific function which, given a frame address and
51    a register number, returns the address at which that register may be
52    found.  0 is returned for registers which aren't stored in the
53    sigcontext structure.  */
54
55 static CORE_ADDR
56 ia64_linux_sigcontext_register_address (struct gdbarch *gdbarch,
57                                         CORE_ADDR sp, int regno)
58 {
59   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
60   gdb_byte buf[8];
61   CORE_ADDR sigcontext_addr = 0;
62
63   /* The address of the sigcontext area is found at offset 16 in the
64      sigframe.  */
65   read_memory (sp + 16, buf, 8);
66   sigcontext_addr = extract_unsigned_integer (buf, 8, byte_order);
67
68   if (IA64_GR0_REGNUM <= regno && regno <= IA64_GR31_REGNUM)
69     return sigcontext_addr + 200 + 8 * (regno - IA64_GR0_REGNUM);
70   else if (IA64_BR0_REGNUM <= regno && regno <= IA64_BR7_REGNUM)
71     return sigcontext_addr + 136 + 8 * (regno - IA64_BR0_REGNUM);
72   else if (IA64_FR0_REGNUM <= regno && regno <= IA64_FR127_REGNUM)
73     return sigcontext_addr + 464 + 16 * (regno - IA64_FR0_REGNUM);
74   else
75     switch (regno)
76       {
77       case IA64_IP_REGNUM :
78         return sigcontext_addr + 40;
79       case IA64_CFM_REGNUM :
80         return sigcontext_addr + 48;
81       case IA64_PSR_REGNUM :
82         return sigcontext_addr + 56;            /* user mask only */
83       /* sc_ar_rsc is provided, from which we could compute bspstore, but
84          I don't think it's worth it.  Anyway, if we want it, it's at offset
85          64.  */
86       case IA64_BSP_REGNUM :
87         return sigcontext_addr + 72;
88       case IA64_RNAT_REGNUM :
89         return sigcontext_addr + 80;
90       case IA64_CCV_REGNUM :
91         return sigcontext_addr + 88;
92       case IA64_UNAT_REGNUM :
93         return sigcontext_addr + 96;
94       case IA64_FPSR_REGNUM :
95         return sigcontext_addr + 104;
96       case IA64_PFS_REGNUM :
97         return sigcontext_addr + 112;
98       case IA64_LC_REGNUM :
99         return sigcontext_addr + 120;
100       case IA64_PR_REGNUM :
101         return sigcontext_addr + 128;
102       default :
103         return 0;
104       }
105 }
106
107 static void
108 ia64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
109 {
110   ia64_write_pc (regcache, pc);
111
112   /* We must be careful with modifying the instruction-pointer: if we
113      just interrupt a system call, the kernel would ordinarily try to
114      restart it when we resume the inferior, which typically results
115      in SIGSEGV or SIGILL.  We prevent this by clearing r10, which
116      will tell the kernel that r8 does NOT contain a valid error code
117      and hence it will skip system-call restart.
118
119      The clearing of r10 is safe as long as ia64_write_pc() is only
120      called as part of setting up an inferior call.  */
121   regcache_cooked_write_unsigned (regcache, IA64_GR10_REGNUM, 0);
122 }
123
124 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
125    gdbarch.h.  */
126
127 static int
128 ia64_linux_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
129 {
130   return ((isdigit (*s) && s[1] == '[' && s[2] == 'r') /* Displacement.  */
131           || *s == 'r' /* Register value.  */
132           || isdigit (*s));  /* Literal number.  */
133 }
134
135 /* Core file support. */
136
137 static const struct regcache_map_entry ia64_linux_gregmap[] =
138   {
139     { 32, IA64_GR0_REGNUM, 8 }, /* r0 ... r31 */
140     { 1, REGCACHE_MAP_SKIP, 8 }, /* FIXME: NAT collection bits? */
141     { 1, IA64_PR_REGNUM, 8 },
142     { 8, IA64_BR0_REGNUM, 8 },  /* b0 ... b7 */
143     { 1, IA64_IP_REGNUM, 8 },
144     { 1, IA64_CFM_REGNUM, 8 },
145     { 1, IA64_PSR_REGNUM, 8 },
146     { 1, IA64_RSC_REGNUM, 8 },
147     { 1, IA64_BSP_REGNUM, 8 },
148     { 1, IA64_BSPSTORE_REGNUM, 8 },
149     { 1, IA64_RNAT_REGNUM, 8 },
150     { 1, IA64_CCV_REGNUM, 8 },
151     { 1, IA64_UNAT_REGNUM, 8 },
152     { 1, IA64_FPSR_REGNUM, 8 },
153     { 1, IA64_PFS_REGNUM, 8 },
154     { 1, IA64_LC_REGNUM, 8 },
155     { 1, IA64_EC_REGNUM, 8 },
156     { 0 }
157   };
158
159 /* Size of 'gregset_t', as defined by the Linux kernel.  Note that
160    this is more than actually mapped in the regmap above.  */
161
162 #define IA64_LINUX_GREGS_SIZE (128 * 8)
163
164 static const struct regcache_map_entry ia64_linux_fpregmap[] =
165   {
166     { 128, IA64_FR0_REGNUM, 16 }, /* f0 ... f127 */
167     { 0 }
168   };
169
170 #define IA64_LINUX_FPREGS_SIZE (128 * 16)
171
172 static void
173 ia64_linux_supply_fpregset (const struct regset *regset,
174                             struct regcache *regcache,
175                             int regnum, const void *regs, size_t len)
176 {
177   const gdb_byte f_zero[16] = { 0 };
178   const gdb_byte f_one[16] =
179     { 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0 };
180
181   regcache_supply_regset (regset, regcache, regnum, regs, len);
182
183   /* Kernel generated cores have fr1==0 instead of 1.0.  Older GDBs
184      did the same.  So ignore whatever might be recorded in fpregset_t
185      for fr0/fr1 and always supply their expected values.  */
186   if (regnum == -1 || regnum == IA64_FR0_REGNUM)
187     regcache->raw_supply (IA64_FR0_REGNUM, f_zero);
188   if (regnum == -1 || regnum == IA64_FR1_REGNUM)
189     regcache->raw_supply (IA64_FR1_REGNUM, f_one);
190 }
191
192 static const struct regset ia64_linux_gregset =
193   {
194     ia64_linux_gregmap,
195     regcache_supply_regset, regcache_collect_regset
196   };
197
198 static const struct regset ia64_linux_fpregset =
199   {
200     ia64_linux_fpregmap,
201     ia64_linux_supply_fpregset, regcache_collect_regset
202   };
203
204 static void
205 ia64_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
206                                          iterate_over_regset_sections_cb *cb,
207                                          void *cb_data,
208                                          const struct regcache *regcache)
209 {
210   cb (".reg", IA64_LINUX_GREGS_SIZE, IA64_LINUX_GREGS_SIZE, &ia64_linux_gregset,
211       NULL, cb_data);
212   cb (".reg2", IA64_LINUX_FPREGS_SIZE, IA64_LINUX_FPREGS_SIZE,
213       &ia64_linux_fpregset, NULL, cb_data);
214 }
215
216 static void
217 ia64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
218 {
219   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
220   static const char *const stap_register_prefixes[] = { "r", NULL };
221   static const char *const stap_register_indirection_prefixes[] = { "[",
222                                                                     NULL };
223   static const char *const stap_register_indirection_suffixes[] = { "]",
224                                                                     NULL };
225
226   linux_init_abi (info, gdbarch);
227
228   /* Set the method of obtaining the sigcontext addresses at which
229      registers are saved.  */
230   tdep->sigcontext_register_address = ia64_linux_sigcontext_register_address;
231
232   /* Set the pc_in_sigtramp method.  */
233   tdep->pc_in_sigtramp = ia64_linux_pc_in_sigtramp;
234
235   set_gdbarch_write_pc (gdbarch, ia64_linux_write_pc);
236
237   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
238
239   set_solib_svr4_fetch_link_map_offsets
240     (gdbarch, svr4_lp64_fetch_link_map_offsets);
241
242   /* Enable TLS support.  */
243   set_gdbarch_fetch_tls_load_module_address (gdbarch,
244                                              svr4_fetch_objfile_link_map);
245
246   /* Core file support. */
247   set_gdbarch_iterate_over_regset_sections
248     (gdbarch, ia64_linux_iterate_over_regset_sections);
249
250   /* SystemTap related.  */
251   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
252   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
253                                           stap_register_indirection_prefixes);
254   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
255                                             stap_register_indirection_suffixes);
256   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
257   set_gdbarch_stap_is_single_operand (gdbarch,
258                                       ia64_linux_stap_is_single_operand);
259 }
260
261 void
262 _initialize_ia64_linux_tdep (void)
263 {
264   gdbarch_register_osabi (bfd_arch_ia64, 0, GDB_OSABI_LINUX,
265                           ia64_linux_init_abi);
266 }