GDB (xrefs)
Loading...
Searching...
No Matches
ia64-linux-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for the IA-64 for GDB, the GNU debugger.
2
3 Copyright (C) 2000-2023 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
44static int
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
55static CORE_ADDR
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
107static void
108ia64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
109{
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. */
122}
123
124/* Implementation of `gdbarch_stap_is_single_operand', as defined in
125 gdbarch.h. */
126
127static int
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
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
165 {
166 { 128, IA64_FR0_REGNUM, 16 }, /* f0 ... f127 */
167 { 0 }
168 };
169
170#define IA64_LINUX_FPREGS_SIZE (128 * 16)
171
172static void
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
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)
188 if (regnum == -1 || regnum == IA64_FR1_REGNUM)
190}
191
197
203
204static void
207 void *cb_data,
208 const struct regcache *regcache)
209{
211 NULL, cb_data);
213 &ia64_linux_fpregset, NULL, cb_data);
214}
215
216static void
218{
219 ia64_gdbarch_tdep *tdep = gdbarch_tdep<ia64_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, 0);
227
228 /* Set the method of obtaining the sigcontext addresses at which
229 registers are saved. */
231
232 /* Set the pc_in_sigtramp method. */
234
236
238
241
242 /* Enable TLS support. */
245
246 /* Core file support. */
249
250 /* SystemTap related. */
251 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
259}
260
262void
int regnum
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1062
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition corefile.c:238
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_stap_gdb_register_prefix(struct gdbarch *gdbarch, const char *stap_gdb_register_prefix)
Definition gdbarch.c:4662
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand)
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
Definition gdbarch.c:4628
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address)
void set_gdbarch_stap_register_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_prefixes)
Definition gdbarch.c:4594
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
Definition gdbarch.c:4645
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
void iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
Definition gdbarch.h:104
static int ia64_linux_pc_in_sigtramp(CORE_ADDR pc)
static CORE_ADDR ia64_linux_sigcontext_register_address(struct gdbarch *gdbarch, CORE_ADDR sp, int regno)
static void ia64_linux_write_pc(struct regcache *regcache, CORE_ADDR pc)
#define GATE_AREA_END
static int ia64_linux_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
static const struct regcache_map_entry ia64_linux_gregmap[]
#define GATE_AREA_START
#define IA64_LINUX_FPREGS_SIZE
static void ia64_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static const struct regset ia64_linux_gregset
static void ia64_linux_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs, size_t len)
#define IA64_LINUX_GREGS_SIZE
static const struct regcache_map_entry ia64_linux_fpregmap[]
static const struct regset ia64_linux_fpregset
void _initialize_ia64_linux_tdep()
static void ia64_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
void ia64_write_pc(struct regcache *regcache, CORE_ADDR new_pc)
Definition ia64-tdep.c:895
#define IA64_GR31_REGNUM
Definition ia64-tdep.h:47
#define IA64_RNAT_REGNUM
Definition ia64-tdep.h:180
#define IA64_BSPSTORE_REGNUM
Definition ia64-tdep.h:179
#define IA64_CCV_REGNUM
Definition ia64-tdep.h:189
#define IA64_BR7_REGNUM
Definition ia64-tdep.h:146
#define IA64_PR_REGNUM
Definition ia64-tdep.h:160
#define IA64_GR10_REGNUM
Definition ia64-tdep.h:44
#define IA64_FPSR_REGNUM
Definition ia64-tdep.h:191
#define IA64_PSR_REGNUM
Definition ia64-tdep.h:166
#define IA64_RSC_REGNUM
Definition ia64-tdep.h:177
#define IA64_CFM_REGNUM
Definition ia64-tdep.h:169
#define IA64_FR1_REGNUM
Definition ia64-tdep.h:53
#define IA64_PFS_REGNUM
Definition ia64-tdep.h:193
#define IA64_BR0_REGNUM
Definition ia64-tdep.h:139
#define IA64_BSP_REGNUM
Definition ia64-tdep.h:178
#define IA64_IP_REGNUM
Definition ia64-tdep.h:163
#define IA64_GR0_REGNUM
Definition ia64-tdep.h:34
#define IA64_EC_REGNUM
Definition ia64-tdep.h:195
#define IA64_FR127_REGNUM
Definition ia64-tdep.h:66
#define IA64_LC_REGNUM
Definition ia64-tdep.h:194
#define IA64_UNAT_REGNUM
Definition ia64-tdep.h:190
#define IA64_FR0_REGNUM
Definition ia64-tdep.h:52
link_map_offsets * linux_lp64_fetch_link_map_offsets()
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, int num_disp_step_buffers)
CORE_ADDR find_solib_trampoline_target(frame_info_ptr frame, CORE_ADDR pc)
Definition minsyms.c:1554
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition osabi.c:146
@ GDB_OSABI_LINUX
Definition osabi.h:32
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition regcache.c:1273
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition regcache.c:1251
@ REGCACHE_MAP_SKIP
Definition regcache.h:121
static const char *const stap_register_indirection_prefixes[]
static const char *const stap_register_indirection_suffixes[]
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
int(* pc_in_sigtramp)(CORE_ADDR)
Definition ia64-tdep.h:236
CORE_ADDR(* sigcontext_register_address)(struct gdbarch *, CORE_ADDR, int)
Definition ia64-tdep.h:234
Definition regcache.h:111