1 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
3 Copyright (C) 2000-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "ia64-tdep.h"
22 #include "arch-utils.h"
26 #include "solib-svr4.h"
28 #include "linux-tdep.h"
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. */
38 #define GATE_AREA_START 0xa000000000000100LL
39 #define GATE_AREA_END 0xa000000000020000LL
41 /* Offset to sigcontext structure from frame of handler. */
42 #define IA64_LINUX_SIGCONTEXT_OFFSET 192
45 ia64_linux_pc_in_sigtramp (CORE_ADDR pc
)
47 return (pc
>= (CORE_ADDR
) GATE_AREA_START
&& pc
< (CORE_ADDR
) GATE_AREA_END
);
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. */
56 ia64_linux_sigcontext_register_address (struct gdbarch
*gdbarch
,
57 CORE_ADDR sp
, int regno
)
59 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
61 CORE_ADDR sigcontext_addr
= 0;
63 /* The address of the sigcontext area is found at offset 16 in the
65 read_memory (sp
+ 16, buf
, 8);
66 sigcontext_addr
= extract_unsigned_integer (buf
, 8, byte_order
);
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
);
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
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;
99 return sigcontext_addr
+ 120;
100 case IA64_PR_REGNUM
:
101 return sigcontext_addr
+ 128;
108 ia64_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
110 ia64_write_pc (regcache
, pc
);
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.
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);
124 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
128 ia64_linux_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
130 return ((isdigit (*s
) && s
[1] == '[' && s
[2] == 'r') /* Displacement. */
131 || *s
== 'r' /* Register value. */
132 || isdigit (*s
)); /* Literal number. */
135 /* Core file support. */
137 static const struct regcache_map_entry ia64_linux_gregmap
[] =
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 },
159 /* Size of 'gregset_t', as defined by the Linux kernel. Note that
160 this is more than actually mapped in the regmap above. */
162 #define IA64_LINUX_GREGS_SIZE (128 * 8)
164 static const struct regcache_map_entry ia64_linux_fpregmap
[] =
166 { 128, IA64_FR0_REGNUM
, 16 }, /* f0 ... f127 */
170 #define IA64_LINUX_FPREGS_SIZE (128 * 16)
173 ia64_linux_supply_fpregset (const struct regset
*regset
,
174 struct regcache
*regcache
,
175 int regnum
, const void *regs
, size_t len
)
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 };
181 regcache_supply_regset (regset
, regcache
, regnum
, regs
, len
);
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 (regcache
, IA64_FR0_REGNUM
, f_zero
);
188 if (regnum
== -1 || regnum
== IA64_FR1_REGNUM
)
189 regcache_raw_supply (regcache
, IA64_FR1_REGNUM
, f_one
);
192 static const struct regset ia64_linux_gregset
=
195 regcache_supply_regset
, regcache_collect_regset
198 static const struct regset ia64_linux_fpregset
=
201 ia64_linux_supply_fpregset
, regcache_collect_regset
204 static const struct regset
*
205 ia64_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
206 const char *sect_name
,
209 if (strcmp (sect_name
, ".reg") == 0
210 && sect_size
>= IA64_LINUX_GREGS_SIZE
)
211 return &ia64_linux_gregset
;
213 if (strcmp (sect_name
, ".reg2") == 0
214 && sect_size
>= IA64_LINUX_FPREGS_SIZE
)
215 return &ia64_linux_fpregset
;
221 ia64_linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
223 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
224 static const char *const stap_register_prefixes
[] = { "r", NULL
};
225 static const char *const stap_register_indirection_prefixes
[] = { "[",
227 static const char *const stap_register_indirection_suffixes
[] = { "]",
230 linux_init_abi (info
, gdbarch
);
232 /* Set the method of obtaining the sigcontext addresses at which
233 registers are saved. */
234 tdep
->sigcontext_register_address
= ia64_linux_sigcontext_register_address
;
236 /* Set the pc_in_sigtramp method. */
237 tdep
->pc_in_sigtramp
= ia64_linux_pc_in_sigtramp
;
239 set_gdbarch_write_pc (gdbarch
, ia64_linux_write_pc
);
241 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
243 set_solib_svr4_fetch_link_map_offsets
244 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
246 /* Enable TLS support. */
247 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
248 svr4_fetch_objfile_link_map
);
250 /* Core file support. */
251 set_gdbarch_regset_from_core_section (gdbarch
,
252 ia64_linux_regset_from_core_section
);
254 /* SystemTap related. */
255 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
256 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
257 stap_register_indirection_prefixes
);
258 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
259 stap_register_indirection_suffixes
);
260 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
261 set_gdbarch_stap_is_single_operand (gdbarch
,
262 ia64_linux_stap_is_single_operand
);
265 /* Provide a prototype to silence -Wmissing-prototypes. */
266 extern initialize_file_ftype _initialize_ia64_linux_tdep
;
269 _initialize_ia64_linux_tdep (void)
271 gdbarch_register_osabi (bfd_arch_ia64
, 0, GDB_OSABI_LINUX
,
272 ia64_linux_init_abi
);