GDB (xrefs)

/tmp/gdb-8.1/gdb/hppa-linux-nat.c
Go to the documentation of this file.
1 /* Functions specific to running GDB native on HPPA running GNU/Linux.
2
3 Copyright (C) 2004-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 "gdbcore.h"
22 #include "regcache.h"
23 #include "inferior.h"
24 #include "target.h"
25 #include "linux-nat.h"
26 #include "inf-ptrace.h"
27
28 #include <sys/procfs.h>
29 #include "nat/gdb_ptrace.h"
30 #include <linux/version.h>
31
32 #include <asm/ptrace.h>
33 #include "hppa-linux-offsets.h"
34
35 #include "hppa-tdep.h"
36
37 /* Prototypes for supply_gregset etc. */
38 #include "gregset.h"
39
40 /* These must match the order of the register names.
41
42 Some sort of lookup table is needed because the offsets associated
43 with the registers are all over the board. */
44
45 static const int u_offsets[] =
46 {
47 /* general registers */
48 -1,
49 PT_GR1,
50 PT_GR2,
51 PT_GR3,
52 PT_GR4,
53 PT_GR5,
54 PT_GR6,
55 PT_GR7,
56 PT_GR8,
57 PT_GR9,
58 PT_GR10,
59 PT_GR11,
60 PT_GR12,
61 PT_GR13,
62 PT_GR14,
63 PT_GR15,
64 PT_GR16,
65 PT_GR17,
66 PT_GR18,
67 PT_GR19,
68 PT_GR20,
69 PT_GR21,
70 PT_GR22,
71 PT_GR23,
72 PT_GR24,
73 PT_GR25,
74 PT_GR26,
75 PT_GR27,
76 PT_GR28,
77 PT_GR29,
78 PT_GR30,
79 PT_GR31,
80
81 PT_SAR,
82 PT_IAOQ0,
83 PT_IASQ0,
84 PT_IAOQ1,
85 PT_IASQ1,
86 -1, /* eiem */
87 PT_IIR,
88 PT_ISR,
89 PT_IOR,
90 PT_PSW,
91 -1, /* goto */
92
93 PT_SR4,
94 PT_SR0,
95 PT_SR1,
96 PT_SR2,
97 PT_SR3,
98 PT_SR5,
99 PT_SR6,
100 PT_SR7,
101
102 -1, /* cr0 */
103 -1, /* pid0 */
104 -1, /* pid1 */
105 -1, /* ccr */
106 -1, /* pid2 */
107 -1, /* pid3 */
108 -1, /* cr24 */
109 -1, /* cr25 */
110 -1, /* cr26 */
111 PT_CR27,
112 -1, /* cr28 */
113 -1, /* cr29 */
114 -1, /* cr30 */
115
116 /* Floating point regs. */
117 PT_FR0, PT_FR0 + 4,
118 PT_FR1, PT_FR1 + 4,
119 PT_FR2, PT_FR2 + 4,
120 PT_FR3, PT_FR3 + 4,
121 PT_FR4, PT_FR4 + 4,
122 PT_FR5, PT_FR5 + 4,
123 PT_FR6, PT_FR6 + 4,
124 PT_FR7, PT_FR7 + 4,
125 PT_FR8, PT_FR8 + 4,
126 PT_FR9, PT_FR9 + 4,
127 PT_FR10, PT_FR10 + 4,
128 PT_FR11, PT_FR11 + 4,
129 PT_FR12, PT_FR12 + 4,
130 PT_FR13, PT_FR13 + 4,
131 PT_FR14, PT_FR14 + 4,
132 PT_FR15, PT_FR15 + 4,
133 PT_FR16, PT_FR16 + 4,
134 PT_FR17, PT_FR17 + 4,
135 PT_FR18, PT_FR18 + 4,
136 PT_FR19, PT_FR19 + 4,
137 PT_FR20, PT_FR20 + 4,
138 PT_FR21, PT_FR21 + 4,
139 PT_FR22, PT_FR22 + 4,
140 PT_FR23, PT_FR23 + 4,
141 PT_FR24, PT_FR24 + 4,
142 PT_FR25, PT_FR25 + 4,
143 PT_FR26, PT_FR26 + 4,
144 PT_FR27, PT_FR27 + 4,
145 PT_FR28, PT_FR28 + 4,
146 PT_FR29, PT_FR29 + 4,
147 PT_FR30, PT_FR30 + 4,
148 PT_FR31, PT_FR31 + 4,
149 };
150
151 static CORE_ADDR
152 hppa_linux_register_addr (int regno, CORE_ADDR blockend)
153 {
154 CORE_ADDR addr;
155
156 if ((unsigned) regno >= ARRAY_SIZE (u_offsets))
157 error (_("Invalid register number %d."), regno);
158
159 if (u_offsets[regno] == -1)
160 addr = 0;
161 else
162 {
163 addr = (CORE_ADDR) u_offsets[regno];
164 }
165
166 return addr;
167 }
168
169 /*
170 * Registers saved in a coredump:
171 * gr0..gr31
172 * sr0..sr7
173 * iaoq0..iaoq1
174 * iasq0..iasq1
175 * sar, iir, isr, ior, ipsw
176 * cr0, cr24..cr31
177 * cr8,9,12,13
178 * cr10, cr15
179 */
180 #define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n)
181 #define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n)
182 static const int greg_map[] =
183 {
184 GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
185 GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
186 GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
187 GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
188 GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
189 GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
190 GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
191 GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
192
193 HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
194 HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
195
196 HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
197 HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
198
199 HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
200 HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
201
202 TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
203 TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
204
205 HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
206 HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
207 };
208
209
210
211 /* Fetch one register. */
212
213 static void
214 fetch_register (struct regcache *regcache, int regno)
215 {
216 struct gdbarch *gdbarch = regcache->arch ();
217 pid_t tid;
218 int val;
219
220 if (gdbarch_cannot_fetch_register (gdbarch, regno))
221 {
222 regcache_raw_supply (regcache, regno, NULL);
223 return;
224 }
225
226 tid = get_ptrace_pid (regcache_get_ptid (regcache));
227
228 errno = 0;
229 val = ptrace (PTRACE_PEEKUSER, tid, hppa_linux_register_addr (regno, 0), 0);
230 if (errno != 0)
231 error (_("Couldn't read register %s (#%d): %s."),
232 gdbarch_register_name (gdbarch, regno),
233 regno, safe_strerror (errno));
234
235 regcache_raw_supply (regcache, regno, &val);
236 }
237
238 /* Store one register. */
239
240 static void
241 store_register (const struct regcache *regcache, int regno)
242 {
243 struct gdbarch *gdbarch = regcache->arch ();
244 pid_t tid;
245 int val;
246
247 if (gdbarch_cannot_store_register (gdbarch, regno))
248 return;
249
250 tid = get_ptrace_pid (regcache_get_ptid (regcache));
251
252 errno = 0;
253 regcache_raw_collect (regcache, regno, &val);
254 ptrace (PTRACE_POKEUSER, tid, hppa_linux_register_addr (regno, 0), val);
255 if (errno != 0)
256 error (_("Couldn't write register %s (#%d): %s."),
257 gdbarch_register_name (gdbarch, regno),
258 regno, safe_strerror (errno));
259 }
260
261 /* Fetch registers from the child process. Fetch all registers if
262 regno == -1, otherwise fetch all general registers or all floating
263 point registers depending upon the value of regno. */
264
265 static void
266 hppa_linux_fetch_inferior_registers (struct target_ops *ops,
267 struct regcache *regcache, int regno)
268 {
269 if (-1 == regno)
270 {
271 for (regno = 0;
272 regno < gdbarch_num_regs (regcache->arch ());
273 regno++)
274 fetch_register (regcache, regno);
275 }
276 else
277 {
278 fetch_register (regcache, regno);
279 }
280 }
281
282 /* Store registers back into the inferior. Store all registers if
283 regno == -1, otherwise store all general registers or all floating
284 point registers depending upon the value of regno. */
285
286 static void
287 hppa_linux_store_inferior_registers (struct target_ops *ops,
288 struct regcache *regcache, int regno)
289 {
290 if (-1 == regno)
291 {
292 for (regno = 0;
293 regno < gdbarch_num_regs (regcache->arch ());
294 regno++)
295 store_register (regcache, regno);
296 }
297 else
298 {
299 store_register (regcache, regno);
300 }
301 }
302
303 /* Fill GDB's register array with the general-purpose register values
304 in *gregsetp. */
305
306 void
307 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
308 {
309 int i;
310 const greg_t *regp = (const elf_greg_t *) gregsetp;
311
312 for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++, regp++)
313 {
314 int regno = greg_map[i];
315 regcache_raw_supply (regcache, regno, regp);
316 }
317 }
318
319 /* Fill register regno (if it is a general-purpose register) in
320 *gregsetp with the appropriate value from GDB's register array.
321 If regno is -1, do this for all registers. */
322
323 void
324 fill_gregset (const struct regcache *regcache,
325 gdb_gregset_t *gregsetp, int regno)
326 {
327 int i;
328
329 for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++)
330 {
331 int mregno = greg_map[i];
332
333 if (regno == -1 || regno == mregno)
334 {
335 regcache_raw_collect(regcache, mregno, &(*gregsetp)[i]);
336 }
337 }
338 }
339
340 /* Given a pointer to a floating point register set in /proc format
341 (fpregset_t *), unpack the register contents and supply them as gdb's
342 idea of the current floating point register values. */
343
344 void
345 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
346 {
347 int regi;
348 const char *from;
349
350 for (regi = 0; regi <= 31; regi++)
351 {
352 from = (const char *) &((*fpregsetp)[regi]);
353 regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM, from);
354 regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM + 1, from + 4);
355 }
356 }
357
358 /* Given a pointer to a floating point register set in /proc format
359 (fpregset_t *), update the register specified by REGNO from gdb's idea
360 of the current floating point register set. If REGNO is -1, update
361 them all. */
362
363 void
364 fill_fpregset (const struct regcache *regcache,
365 gdb_fpregset_t *fpregsetp, int regno)
366 {
367 int i;
368
369 for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32 * 2; i++)
370 {
371 /* Gross. fpregset_t is double, registers[x] has single
372 precision reg. */
373 char *to = (char *) &((*fpregsetp)[(i - HPPA_FP0_REGNUM) / 2]);
374 if ((i - HPPA_FP0_REGNUM) & 1)
375 to += 4;
376 regcache_raw_collect (regcache, i, to);
377 }
378 }
379
380 void
381 _initialize_hppa_linux_nat (void)
382 {
383 struct target_ops *t;
384
385 /* Fill in the generic GNU/Linux methods. */
386 t = linux_target ();
387
388 /* Add our register access methods. */
389 t->to_fetch_registers = hppa_linux_fetch_inferior_registers;
390 t->to_store_registers = hppa_linux_store_inferior_registers;
391
392 /* Register the target. */
393 linux_nat_add_target (t);
394 }
gdbarch
Definition: gdbarch.c:127
_initialize_hppa_linux_nat
void _initialize_hppa_linux_nat(void)
Definition: hppa-linux-nat.c:381
selftests::ptid::tid
static constexpr ptid_t tid
Definition: ptid-selftests.c:43
HPPA_EIEM_REGNUM
Definition: hppa-tdep.h:48
PT_GR26
#define PT_GR26
Definition: hppa-linux-offsets.h:46
PT_FR26
#define PT_FR26
Definition: hppa-linux-offsets.h:78
PT_GR3
#define PT_GR3
Definition: hppa-linux-offsets.h:23
HPPA_CCR_REGNUM
Definition: hppa-tdep.h:65
PT_GR19
#define PT_GR19
Definition: hppa-linux-offsets.h:39
HPPA_PID2_REGNUM
Definition: hppa-tdep.h:63
supply_fpregset
void supply_fpregset(struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
Definition: hppa-linux-nat.c:345
PT_GR20
#define PT_GR20
Definition: hppa-linux-offsets.h:40
hppa-tdep.h
PT_GR16
#define PT_GR16
Definition: hppa-linux-offsets.h:36
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
PT_GR14
#define PT_GR14
Definition: hppa-linux-offsets.h:34
PT_FR6
#define PT_FR6
Definition: hppa-linux-offsets.h:58
HPPA_ISR_REGNUM
Definition: hppa-tdep.h:50
store_register
static void store_register(const struct regcache *regcache, int regno)
Definition: hppa-linux-nat.c:241
PT_SR2
#define PT_SR2
Definition: hppa-linux-offsets.h:86
regcache_get_ptid
ptid_t regcache_get_ptid(const struct regcache *regcache)
Definition: regcache.c:229
PT_FR23
#define PT_FR23
Definition: hppa-linux-offsets.h:75
PT_FR1
#define PT_FR1
Definition: hppa-linux-offsets.h:53
PT_PSW
#define PT_PSW
Definition: hppa-linux-offsets.h:20
HPPA_PCOQ_TAIL_REGNUM
Definition: hppa-tdep.h:46
HPPA_RCR_REGNUM
Definition: hppa-tdep.h:60
PT_FR19
#define PT_FR19
Definition: hppa-linux-offsets.h:71
PT_GR31
#define PT_GR31
Definition: hppa-linux-offsets.h:51
PT_FR28
#define PT_FR28
Definition: hppa-linux-offsets.h:80
PT_SR4
#define PT_SR4
Definition: hppa-linux-offsets.h:88
PT_FR20
#define PT_FR20
Definition: hppa-linux-offsets.h:72
HPPA_PCOQ_HEAD_REGNUM
Definition: hppa-tdep.h:44
PT_FR0
#define PT_FR0
Definition: hppa-linux-offsets.h:52
fill_gregset
void fill_gregset(const struct regcache *regcache, gdb_gregset_t *gregsetp, int regno)
Definition: hppa-linux-nat.c:324
u_offsets
static const int u_offsets[]
Definition: hppa-linux-nat.c:45
HPPA_IOR_REGNUM
Definition: hppa-tdep.h:51
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
PT_FR21
#define PT_FR21
Definition: hppa-linux-offsets.h:73
PT_GR9
#define PT_GR9
Definition: hppa-linux-offsets.h:29
PT_GR24
#define PT_GR24
Definition: hppa-linux-offsets.h:44
ptrace
PTRACE_TYPE_RET ptrace()
HPPA_SAR_REGNUM
Definition: hppa-tdep.h:42
PT_GR7
#define PT_GR7
Definition: hppa-linux-offsets.h:27
PT_GR8
#define PT_GR8
Definition: hppa-linux-offsets.h:28
PT_FR3
#define PT_FR3
Definition: hppa-linux-offsets.h:55
supply_gregset
void supply_gregset(struct regcache *regcache, const gdb_gregset_t *gregsetp)
Definition: hppa-linux-nat.c:307
PT_FR15
#define PT_FR15
Definition: hppa-linux-offsets.h:67
PT_GR21
#define PT_GR21
Definition: hppa-linux-offsets.h:41
PT_FR5
#define PT_FR5
Definition: hppa-linux-offsets.h:57
PT_FR31
#define PT_FR31
Definition: hppa-linux-offsets.h:83
GR_REGNUM
#define GR_REGNUM(_n)
Definition: hppa-linux-nat.c:180
PT_GR25
#define PT_GR25
Definition: hppa-linux-offsets.h:45
greg_map
static const int greg_map[]
Definition: hppa-linux-nat.c:182
PT_GR12
#define PT_GR12
Definition: hppa-linux-offsets.h:32
PT_GR15
#define PT_GR15
Definition: hppa-linux-offsets.h:35
PT_FR30
#define PT_FR30
Definition: hppa-linux-offsets.h:82
inf-ptrace.h
PT_GR18
#define PT_GR18
Definition: hppa-linux-offsets.h:38
PT_GR11
#define PT_GR11
Definition: hppa-linux-offsets.h:31
PT_FR29
#define PT_FR29
Definition: hppa-linux-offsets.h:81
target_ops
Definition: target.h:412
HPPA_PCSQ_HEAD_REGNUM
Definition: hppa-tdep.h:45
PT_SR1
#define PT_SR1
Definition: hppa-linux-offsets.h:85
gdb_gregset_t
GDB_GREGSET_T gdb_gregset_t
Definition: gregset.h:34
regcache.h
HPPA_IPSW_REGNUM
Definition: hppa-tdep.h:43
HPPA_PID3_REGNUM
Definition: hppa-tdep.h:64
gdbarch_cannot_store_register
int gdbarch_cannot_store_register(struct gdbarch *gdbarch, int regnum)
Definition: gdbarch.c:2538
HPPA_FP0_REGNUM
Definition: hppa-tdep.h:70
PT_IOR
#define PT_IOR
Definition: hppa-linux-offsets.h:103
gdbarch_cannot_fetch_register
int gdbarch_cannot_fetch_register(struct gdbarch *gdbarch, int regnum)
Definition: gdbarch.c:2521
gdb_fpregset_t
GDB_FPREGSET_T gdb_fpregset_t
Definition: gregset.h:35
PT_FR8
#define PT_FR8
Definition: hppa-linux-offsets.h:60
PT_GR22
#define PT_GR22
Definition: hppa-linux-offsets.h:42
PT_FR25
#define PT_FR25
Definition: hppa-linux-offsets.h:77
PT_SR0
#define PT_SR0
Definition: hppa-linux-offsets.h:84
inferior.h
PT_SR6
#define PT_SR6
Definition: hppa-linux-offsets.h:90
PT_FR12
#define PT_FR12
Definition: hppa-linux-offsets.h:64
HPPA_PID1_REGNUM
Definition: hppa-tdep.h:62
PT_GR6
#define PT_GR6
Definition: hppa-linux-offsets.h:26
PT_GR4
#define PT_GR4
Definition: hppa-linux-offsets.h:24
gdbarch_register_name
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2282
linux_nat_add_target
void linux_nat_add_target(struct target_ops *t)
Definition: linux-nat.c:4804
PT_GR29
#define PT_GR29
Definition: hppa-linux-offsets.h:49
PT_FR17
#define PT_FR17
Definition: hppa-linux-offsets.h:69
fill_fpregset
void fill_fpregset(const struct regcache *regcache, gdb_fpregset_t *fpregsetp, int regno)
Definition: hppa-linux-nat.c:364
PT_FR11
#define PT_FR11
Definition: hppa-linux-offsets.h:63
hppa-linux-offsets.h
fetch_register
static void fetch_register(struct regcache *regcache, int regno)
Definition: hppa-linux-nat.c:214
PT_FR24
#define PT_FR24
Definition: hppa-linux-offsets.h:76
PT_GR13
#define PT_GR13
Definition: hppa-linux-offsets.h:33
hppa_linux_register_addr
static CORE_ADDR hppa_linux_register_addr(int regno, CORE_ADDR blockend)
Definition: hppa-linux-nat.c:152
linux_target
struct target_ops * linux_target(void)
Definition: linux-nat.c:4377
HPPA_SR4_REGNUM
Definition: hppa-tdep.h:52
PT_GR10
#define PT_GR10
Definition: hppa-linux-offsets.h:30
gregset.h
PT_IIR
#define PT_IIR
Definition: hppa-linux-offsets.h:101
PT_GR30
#define PT_GR30
Definition: hppa-linux-offsets.h:50
hppa_linux_store_inferior_registers
static void hppa_linux_store_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: hppa-linux-nat.c:287
PT_FR14
#define PT_FR14
Definition: hppa-linux-offsets.h:66
PT_FR7
#define PT_FR7
Definition: hppa-linux-offsets.h:59
PT_FR10
#define PT_FR10
Definition: hppa-linux-offsets.h:62
PT_IASQ0
#define PT_IASQ0
Definition: hppa-linux-offsets.h:92
TR_REGNUM
#define TR_REGNUM(_n)
Definition: hppa-linux-nat.c:181
PT_IASQ1
#define PT_IASQ1
Definition: hppa-linux-offsets.h:93
target_ops::to_fetch_registers
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:457
PT_FR9
#define PT_FR9
Definition: hppa-linux-offsets.h:61
PT_SAR
#define PT_SAR
Definition: hppa-linux-offsets.h:100
PT_FR18
#define PT_FR18
Definition: hppa-linux-offsets.h:70
PT_FR2
#define PT_FR2
Definition: hppa-linux-offsets.h:54
gdbcore.h
HPPA_IIR_REGNUM
Definition: hppa-tdep.h:49
PT_SR7
#define PT_SR7
Definition: hppa-linux-offsets.h:91
PT_GR17
#define PT_GR17
Definition: hppa-linux-offsets.h:37
PT_GR5
#define PT_GR5
Definition: hppa-linux-offsets.h:25
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
hppa_linux_fetch_inferior_registers
static void hppa_linux_fetch_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: hppa-linux-nat.c:266
PT_IAOQ0
#define PT_IAOQ0
Definition: hppa-linux-offsets.h:94
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
PT_FR4
#define PT_FR4
Definition: hppa-linux-offsets.h:56
PT_FR13
#define PT_FR13
Definition: hppa-linux-offsets.h:65
PT_GR1
#define PT_GR1
Definition: hppa-linux-offsets.h:21
target.h
PT_GR28
#define PT_GR28
Definition: hppa-linux-offsets.h:48
PT_GR23
#define PT_GR23
Definition: hppa-linux-offsets.h:43
PT_SR5
#define PT_SR5
Definition: hppa-linux-offsets.h:89
regcache_raw_supply
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1004
PT_FR22
#define PT_FR22
Definition: hppa-linux-offsets.h:74
regcache
Definition: regcache.h:232
PT_FR27
#define PT_FR27
Definition: hppa-linux-offsets.h:79
gdb_ptrace.h
regcache_raw_collect
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1085
HPPA_PCSQ_TAIL_REGNUM
Definition: hppa-tdep.h:47
HPPA_PID0_REGNUM
Definition: hppa-tdep.h:61
PT_FR16
#define PT_FR16
Definition: hppa-linux-offsets.h:68
get_ptrace_pid
pid_t get_ptrace_pid(ptid_t ptid)
Definition: inf-ptrace.c:320
PT_IAOQ1
#define PT_IAOQ1
Definition: hppa-linux-offsets.h:95
target_ops::to_store_registers
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:459
PT_CR27
#define PT_CR27
Definition: hppa-linux-offsets.h:96
PT_GR27
#define PT_GR27
Definition: hppa-linux-offsets.h:47
error
void error(const char *fmt,...)
Definition: errors.c:38
PT_ISR
#define PT_ISR
Definition: hppa-linux-offsets.h:102
PT_SR3
#define PT_SR3
Definition: hppa-linux-offsets.h:87
PT_GR2
#define PT_GR2
Definition: hppa-linux-offsets.h:22
linux-nat.h