]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/sparc-nat.c
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / sparc-nat.c
1 /* Native-dependent code for SPARC.
2
3 Copyright (C) 2003, 2004, 2005, 2007 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 2 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, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include "defs.h"
23 #include "inferior.h"
24 #include "regcache.h"
25 #include "target.h"
26
27 #include "gdb_assert.h"
28 #include <signal.h>
29 #include "gdb_string.h"
30 #include <sys/ptrace.h>
31 #include "gdb_wait.h"
32 #ifdef HAVE_MACHINE_REG_H
33 #include <machine/reg.h>
34 #endif
35
36 #include "sparc-tdep.h"
37 #include "sparc-nat.h"
38 #include "inf-ptrace.h"
39
40 /* With some trickery we can use the code in this file for most (if
41 not all) ptrace(2) based SPARC systems, which includes SunOS 4,
42 GNU/Linux and the various SPARC BSD's.
43
44 First, we need a data structure for use with ptrace(2). SunOS has
45 `struct regs' and `struct fp_status' in <machine/reg.h>. BSD's
46 have `struct reg' and `struct fpreg' in <machine/reg.h>. GNU/Linux
47 has the same structures as SunOS 4, but they're in <asm/reg.h>,
48 which is a kernel header. As a general rule we avoid including
49 GNU/Linux kernel headers. Fortunately GNU/Linux has a `gregset_t'
50 and a `fpregset_t' that are equivalent to `struct regs' and `struct
51 fp_status' in <sys/ucontext.h>, which is automatically included by
52 <signal.h>. Settling on using the `gregset_t' and `fpregset_t'
53 typedefs, providing them for the other systems, therefore solves
54 the puzzle. */
55
56 #ifdef HAVE_MACHINE_REG_H
57 #ifdef HAVE_STRUCT_REG
58 typedef struct reg gregset_t;
59 typedef struct fpreg fpregset_t;
60 #else
61 typedef struct regs gregset_t;
62 typedef struct fp_status fpregset_t;
63 #endif
64 #endif
65
66 /* Second, we need to remap the BSD ptrace(2) requests to their SunOS
67 equivalents. GNU/Linux already follows SunOS here. */
68
69 #ifndef PTRACE_GETREGS
70 #define PTRACE_GETREGS PT_GETREGS
71 #endif
72
73 #ifndef PTRACE_SETREGS
74 #define PTRACE_SETREGS PT_SETREGS
75 #endif
76
77 #ifndef PTRACE_GETFPREGS
78 #define PTRACE_GETFPREGS PT_GETFPREGS
79 #endif
80
81 #ifndef PTRACE_SETFPREGS
82 #define PTRACE_SETFPREGS PT_SETFPREGS
83 #endif
84
85 /* Register set description. */
86 const struct sparc_gregset *sparc_gregset;
87 void (*sparc_supply_gregset) (const struct sparc_gregset *,
88 struct regcache *, int , const void *);
89 void (*sparc_collect_gregset) (const struct sparc_gregset *,
90 const struct regcache *, int, void *);
91 void (*sparc_supply_fpregset) (struct regcache *, int , const void *);
92 void (*sparc_collect_fpregset) (const struct regcache *, int , void *);
93 int (*sparc_gregset_supplies_p) (int);
94 int (*sparc_fpregset_supplies_p) (int);
95
96 /* Determine whether `gregset_t' contains register REGNUM. */
97
98 int
99 sparc32_gregset_supplies_p (int regnum)
100 {
101 /* Integer registers. */
102 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM)
103 || (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
104 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM)
105 || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM))
106 return 1;
107
108 /* Control registers. */
109 if (regnum == SPARC32_PC_REGNUM
110 || regnum == SPARC32_NPC_REGNUM
111 || regnum == SPARC32_PSR_REGNUM
112 || regnum == SPARC32_Y_REGNUM)
113 return 1;
114
115 return 0;
116 }
117
118 /* Determine whether `fpregset_t' contains register REGNUM. */
119
120 int
121 sparc32_fpregset_supplies_p (int regnum)
122 {
123 /* Floating-point registers. */
124 if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
125 return 1;
126
127 /* Control registers. */
128 if (regnum == SPARC32_FSR_REGNUM)
129 return 1;
130
131 return 0;
132 }
133
134 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
135 for all registers (including the floating-point registers). */
136
137 void
138 fetch_inferior_registers (int regnum)
139 {
140 struct regcache *regcache = current_regcache;
141 int pid;
142
143 /* NOTE: cagney/2002-12-03: This code assumes that the currently
144 selected light weight processes' registers can be written
145 directly into the selected thread's register cache. This works
146 fine when given an 1:1 LWP:thread model (such as found on
147 GNU/Linux) but will, likely, have problems when used on an N:1
148 (userland threads) or N:M (userland multiple LWP) model. In the
149 case of the latter two, the LWP's registers do not necessarily
150 belong to the selected thread (the LWP could be in the middle of
151 executing the thread switch code).
152
153 These functions should instead be paramaterized with an explicit
154 object (struct regcache, struct thread_info?) into which the LWPs
155 registers can be written. */
156 pid = TIDGET (inferior_ptid);
157 if (pid == 0)
158 pid = PIDGET (inferior_ptid);
159
160 if (regnum == SPARC_G0_REGNUM)
161 {
162 regcache_raw_supply (regcache, SPARC_G0_REGNUM, NULL);
163 return;
164 }
165
166 if (regnum == -1 || sparc_gregset_supplies_p (regnum))
167 {
168 gregset_t regs;
169
170 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
171 perror_with_name (_("Couldn't get registers"));
172
173 sparc_supply_gregset (sparc_gregset, regcache, -1, &regs);
174 if (regnum != -1)
175 return;
176 }
177
178 if (regnum == -1 || sparc_fpregset_supplies_p (regnum))
179 {
180 fpregset_t fpregs;
181
182 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
183 perror_with_name (_("Couldn't get floating point status"));
184
185 sparc_supply_fpregset (regcache, -1, &fpregs);
186 }
187 }
188
189 void
190 store_inferior_registers (int regnum)
191 {
192 struct regcache *regcache = current_regcache;
193 int pid;
194
195 /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers
196 about threaded assumptions. */
197 pid = TIDGET (inferior_ptid);
198 if (pid == 0)
199 pid = PIDGET (inferior_ptid);
200
201 if (regnum == -1 || sparc_gregset_supplies_p (regnum))
202 {
203 gregset_t regs;
204
205 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
206 perror_with_name (_("Couldn't get registers"));
207
208 sparc_collect_gregset (sparc_gregset, regcache, regnum, &regs);
209
210 if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
211 perror_with_name (_("Couldn't write registers"));
212
213 /* Deal with the stack regs. */
214 if (regnum == -1 || regnum == SPARC_SP_REGNUM
215 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM))
216 {
217 ULONGEST sp;
218
219 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
220 sparc_collect_rwindow (regcache, sp, regnum);
221 }
222
223 if (regnum != -1)
224 return;
225 }
226
227 if (regnum == -1 || sparc_fpregset_supplies_p (regnum))
228 {
229 fpregset_t fpregs, saved_fpregs;
230
231 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
232 perror_with_name (_("Couldn't get floating-point registers"));
233
234 memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
235 sparc_collect_fpregset (regcache, regnum, &fpregs);
236
237 /* Writing the floating-point registers will fail on NetBSD with
238 EINVAL if the inferior process doesn't have an FPU state
239 (i.e. if it didn't use the FPU yet). Therefore we don't try
240 to write the registers if nothing changed. */
241 if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0)
242 {
243 if (ptrace (PTRACE_SETFPREGS, pid,
244 (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
245 perror_with_name (_("Couldn't write floating-point registers"));
246 }
247
248 if (regnum != -1)
249 return;
250 }
251 }
252
253 \f
254 /* Fetch StackGhost Per-Process XOR cookie. */
255
256 LONGEST
257 sparc_xfer_wcookie (struct target_ops *ops, enum target_object object,
258 const char *annex, gdb_byte *readbuf,
259 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
260 {
261 unsigned long wcookie = 0;
262 char *buf = (char *)&wcookie;
263
264 gdb_assert (object == TARGET_OBJECT_WCOOKIE);
265 gdb_assert (readbuf && writebuf == NULL);
266
267 if (offset == sizeof (unsigned long))
268 return 0; /* Signal EOF. */
269 if (offset > sizeof (unsigned long))
270 return -1;
271
272 #ifdef PT_WCOOKIE
273 /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
274 running on an OpenBSD release that uses StackGhost (3.1 or
275 later). Since release 3.6, OpenBSD uses a fully randomized
276 cookie. */
277 {
278 int pid;
279
280 pid = TIDGET (inferior_ptid);
281 if (pid == 0)
282 pid = PIDGET (inferior_ptid);
283
284 /* Sanity check. The proper type for a cookie is register_t, but
285 we can't assume that this type exists on all systems supported
286 by the code in this file. */
287 gdb_assert (sizeof (wcookie) == sizeof (register_t));
288
289 /* Fetch the cookie. */
290 if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
291 {
292 if (errno != EINVAL)
293 perror_with_name (_("Couldn't get StackGhost cookie"));
294
295 /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
296 the request wasn't implemented until after OpenBSD 3.4. If
297 the kernel doesn't support the PT_WCOOKIE request, assume
298 we're running on a kernel that uses non-randomized cookies. */
299 wcookie = 0x3;
300 }
301 }
302 #endif /* PT_WCOOKIE */
303
304 if (len > sizeof (unsigned long) - offset)
305 len = sizeof (unsigned long) - offset;
306
307 memcpy (readbuf, buf + offset, len);
308 return len;
309 }
310
311 LONGEST (*inf_ptrace_xfer_partial) (struct target_ops *, enum target_object,
312 const char *, gdb_byte *, const gdb_byte *,
313 ULONGEST, LONGEST);
314
315 static LONGEST
316 sparc_xfer_partial (struct target_ops *ops, enum target_object object,
317 const char *annex, gdb_byte *readbuf,
318 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
319 {
320 if (object == TARGET_OBJECT_WCOOKIE)
321 return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf,
322 offset, len);
323
324 return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf,
325 offset, len);
326 }
327 \f
328 /* Create a prototype generic SPARC target. The client can override
329 it with local methods. */
330
331 struct target_ops *
332 sparc_target (void)
333 {
334 struct target_ops *t;
335
336 t = inf_ptrace_target ();
337 t->to_fetch_registers = fetch_inferior_registers;
338 t->to_store_registers = store_inferior_registers;
339 inf_ptrace_xfer_partial = t->to_xfer_partial;
340 t->to_xfer_partial = sparc_xfer_partial;
341 return t;
342 }
343
344 \f
345 /* Provide a prototype to silence -Wmissing-prototypes. */
346 void _initialize_sparc_nat (void);
347
348 void
349 _initialize_sparc_nat (void)
350 {
351 /* Deafult to using SunOS 4 register sets. */
352 if (sparc_gregset == NULL)
353 sparc_gregset = &sparc32_sunos4_gregset;
354 if (sparc_supply_gregset == NULL)
355 sparc_supply_gregset = sparc32_supply_gregset;
356 if (sparc_collect_gregset == NULL)
357 sparc_collect_gregset = sparc32_collect_gregset;
358 if (sparc_supply_fpregset == NULL)
359 sparc_supply_fpregset = sparc32_supply_fpregset;
360 if (sparc_collect_fpregset == NULL)
361 sparc_collect_fpregset = sparc32_collect_fpregset;
362 if (sparc_gregset_supplies_p == NULL)
363 sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
364 if (sparc_fpregset_supplies_p == NULL)
365 sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
366 }