2011-11-23 Thomas Klein <th.r.klein@web.de>
[deliverable/binutils-gdb.git] / gdb / sparc-nat.c
CommitLineData
386c036b 1/* Native-dependent code for SPARC.
2555fe1a 2
7b6bb8da 3 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
0fb0cc75 4 Free Software Foundation, Inc.
c906108c 5
c5aa993b 6 This file is part of GDB.
c906108c 7
c5aa993b
JM
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
c5aa993b 11 (at your option) any later version.
c906108c 12
c5aa993b
JM
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
c906108c 17
c5aa993b 18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
20
21#include "defs.h"
22#include "inferior.h"
4e052eda 23#include "regcache.h"
baf92889 24#include "target.h"
c906108c 25
baf92889 26#include "gdb_assert.h"
c906108c 27#include <signal.h>
386c036b 28#include "gdb_string.h"
c906108c 29#include <sys/ptrace.h>
2555fe1a 30#include "gdb_wait.h"
386c036b 31#ifdef HAVE_MACHINE_REG_H
c906108c
SS
32#include <machine/reg.h>
33#endif
c906108c 34
386c036b
MK
35#include "sparc-tdep.h"
36#include "sparc-nat.h"
1b9445c2 37#include "inf-ptrace.h"
386c036b
MK
38
39/* With some trickery we can use the code in this file for most (if
40 not all) ptrace(2) based SPARC systems, which includes SunOS 4,
1a111ce3 41 GNU/Linux and the various SPARC BSD's.
386c036b
MK
42
43 First, we need a data structure for use with ptrace(2). SunOS has
44 `struct regs' and `struct fp_status' in <machine/reg.h>. BSD's
45 have `struct reg' and `struct fpreg' in <machine/reg.h>. GNU/Linux
46 has the same structures as SunOS 4, but they're in <asm/reg.h>,
47 which is a kernel header. As a general rule we avoid including
48 GNU/Linux kernel headers. Fortunately GNU/Linux has a `gregset_t'
49 and a `fpregset_t' that are equivalent to `struct regs' and `struct
50 fp_status' in <sys/ucontext.h>, which is automatically included by
51 <signal.h>. Settling on using the `gregset_t' and `fpregset_t'
52 typedefs, providing them for the other systems, therefore solves
53 the puzzle. */
54
55#ifdef HAVE_MACHINE_REG_H
56#ifdef HAVE_STRUCT_REG
57typedef struct reg gregset_t;
58typedef struct fpreg fpregset_t;
59#else
60typedef struct regs gregset_t;
61typedef struct fp_status fpregset_t;
62#endif
63#endif
64
65/* Second, we need to remap the BSD ptrace(2) requests to their SunOS
66 equivalents. GNU/Linux already follows SunOS here. */
c906108c 67
386c036b
MK
68#ifndef PTRACE_GETREGS
69#define PTRACE_GETREGS PT_GETREGS
70#endif
71
72#ifndef PTRACE_SETREGS
73#define PTRACE_SETREGS PT_SETREGS
74#endif
c906108c 75
386c036b
MK
76#ifndef PTRACE_GETFPREGS
77#define PTRACE_GETFPREGS PT_GETFPREGS
78#endif
79
80#ifndef PTRACE_SETFPREGS
81#define PTRACE_SETFPREGS PT_SETFPREGS
82#endif
83
84/* Register set description. */
85const struct sparc_gregset *sparc_gregset;
86void (*sparc_supply_gregset) (const struct sparc_gregset *,
87 struct regcache *, int , const void *);
88void (*sparc_collect_gregset) (const struct sparc_gregset *,
89 const struct regcache *, int, void *);
90void (*sparc_supply_fpregset) (struct regcache *, int , const void *);
91void (*sparc_collect_fpregset) (const struct regcache *, int , void *);
ec22ec34
UW
92int (*sparc_gregset_supplies_p) (struct gdbarch *, int);
93int (*sparc_fpregset_supplies_p) (struct gdbarch *, int);
386c036b
MK
94
95/* Determine whether `gregset_t' contains register REGNUM. */
96
97int
ec22ec34 98sparc32_gregset_supplies_p (struct gdbarch *gdbarch, int regnum)
386c036b
MK
99{
100 /* Integer registers. */
101 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM)
102 || (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
103 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM)
104 || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM))
105 return 1;
106
107 /* Control registers. */
108 if (regnum == SPARC32_PC_REGNUM
109 || regnum == SPARC32_NPC_REGNUM
110 || regnum == SPARC32_PSR_REGNUM
111 || regnum == SPARC32_Y_REGNUM)
112 return 1;
113
114 return 0;
115}
116
117/* Determine whether `fpregset_t' contains register REGNUM. */
118
119int
ec22ec34 120sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, int regnum)
386c036b
MK
121{
122 /* Floating-point registers. */
123 if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
124 return 1;
125
126 /* Control registers. */
127 if (regnum == SPARC32_FSR_REGNUM)
128 return 1;
129
130 return 0;
131}
132
133/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
134 for all registers (including the floating-point registers). */
c906108c
SS
135
136void
28439f5e
PA
137sparc_fetch_inferior_registers (struct target_ops *ops,
138 struct regcache *regcache, int regnum)
c906108c 139{
ec22ec34 140 struct gdbarch *gdbarch = get_regcache_arch (regcache);
386c036b 141 int pid;
02ae7771
AC
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. */
386c036b
MK
156 pid = TIDGET (inferior_ptid);
157 if (pid == 0)
158 pid = PIDGET (inferior_ptid);
02ae7771 159
386c036b 160 if (regnum == SPARC_G0_REGNUM)
c906108c 161 {
22e74ef9
MK
162 gdb_byte zero[8] = { 0 };
163
164 regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
386c036b 165 return;
c906108c
SS
166 }
167
ec22ec34 168 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
c906108c 169 {
386c036b 170 gregset_t regs;
c906108c 171
49ec097f 172 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
e2e0b3e5 173 perror_with_name (_("Couldn't get registers"));
386c036b
MK
174
175 sparc_supply_gregset (sparc_gregset, regcache, -1, &regs);
176 if (regnum != -1)
177 return;
c906108c 178 }
386c036b 179
ec22ec34 180 if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
c906108c 181 {
386c036b
MK
182 fpregset_t fpregs;
183
49ec097f 184 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
e2e0b3e5 185 perror_with_name (_("Couldn't get floating point status"));
386c036b
MK
186
187 sparc_supply_fpregset (regcache, -1, &fpregs);
c906108c
SS
188 }
189}
190
c906108c 191void
28439f5e
PA
192sparc_store_inferior_registers (struct target_ops *ops,
193 struct regcache *regcache, int regnum)
c906108c 194{
ec22ec34 195 struct gdbarch *gdbarch = get_regcache_arch (regcache);
386c036b 196 int pid;
02ae7771
AC
197
198 /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers
199 about threaded assumptions. */
386c036b
MK
200 pid = TIDGET (inferior_ptid);
201 if (pid == 0)
202 pid = PIDGET (inferior_ptid);
c906108c 203
ec22ec34 204 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
e1925118 205 {
386c036b 206 gregset_t regs;
c906108c 207
49ec097f 208 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
e2e0b3e5 209 perror_with_name (_("Couldn't get registers"));
c906108c 210
386c036b 211 sparc_collect_gregset (sparc_gregset, regcache, regnum, &regs);
c906108c 212
49ec097f 213 if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
e2e0b3e5 214 perror_with_name (_("Couldn't write registers"));
c5aa993b 215
386c036b
MK
216 /* Deal with the stack regs. */
217 if (regnum == -1 || regnum == SPARC_SP_REGNUM
218 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM))
219 {
220 ULONGEST sp;
c906108c 221
386c036b
MK
222 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
223 sparc_collect_rwindow (regcache, sp, regnum);
224 }
c906108c 225
386c036b
MK
226 if (regnum != -1)
227 return;
c906108c 228 }
c906108c 229
ec22ec34 230 if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
c5aa993b 231 {
386c036b 232 fpregset_t fpregs, saved_fpregs;
c906108c 233
49ec097f 234 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
e2e0b3e5 235 perror_with_name (_("Couldn't get floating-point registers"));
c906108c 236
386c036b
MK
237 memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
238 sparc_collect_fpregset (regcache, regnum, &fpregs);
c906108c 239
386c036b
MK
240 /* Writing the floating-point registers will fail on NetBSD with
241 EINVAL if the inferior process doesn't have an FPU state
242 (i.e. if it didn't use the FPU yet). Therefore we don't try
243 to write the registers if nothing changed. */
244 if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0)
c5aa993b 245 {
386c036b 246 if (ptrace (PTRACE_SETFPREGS, pid,
49ec097f 247 (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
e2e0b3e5 248 perror_with_name (_("Couldn't write floating-point registers"));
c5aa993b 249 }
c906108c 250
386c036b
MK
251 if (regnum != -1)
252 return;
253 }
c906108c 254}
baf92889 255
c906108c 256\f
baf92889
MK
257/* Fetch StackGhost Per-Process XOR cookie. */
258
259LONGEST
260sparc_xfer_wcookie (struct target_ops *ops, enum target_object object,
961cb7b5
MK
261 const char *annex, gdb_byte *readbuf,
262 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
baf92889
MK
263{
264 unsigned long wcookie = 0;
265 char *buf = (char *)&wcookie;
266
267 gdb_assert (object == TARGET_OBJECT_WCOOKIE);
268 gdb_assert (readbuf && writebuf == NULL);
269
2c9771d3
MK
270 if (offset == sizeof (unsigned long))
271 return 0; /* Signal EOF. */
272 if (offset > sizeof (unsigned long))
baf92889 273 return -1;
c5aa993b 274
baf92889
MK
275#ifdef PT_WCOOKIE
276 /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
277 running on an OpenBSD release that uses StackGhost (3.1 or
2c9771d3
MK
278 later). Since release 3.6, OpenBSD uses a fully randomized
279 cookie. */
645d6d10
MK
280 {
281 int pid;
282
283 pid = TIDGET (inferior_ptid);
284 if (pid == 0)
285 pid = PIDGET (inferior_ptid);
286
287 /* Sanity check. The proper type for a cookie is register_t, but
288 we can't assume that this type exists on all systems supported
289 by the code in this file. */
290 gdb_assert (sizeof (wcookie) == sizeof (register_t));
291
292 /* Fetch the cookie. */
49ec097f 293 if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
645d6d10
MK
294 {
295 if (errno != EINVAL)
e2e0b3e5 296 perror_with_name (_("Couldn't get StackGhost cookie"));
645d6d10
MK
297
298 /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
299 the request wasn't implemented until after OpenBSD 3.4. If
300 the kernel doesn't support the PT_WCOOKIE request, assume
301 we're running on a kernel that uses non-randomized cookies. */
302 wcookie = 0x3;
303 }
304 }
baf92889
MK
305#endif /* PT_WCOOKIE */
306
307 if (len > sizeof (unsigned long) - offset)
308 len = sizeof (unsigned long) - offset;
309
310 memcpy (readbuf, buf + offset, len);
311 return len;
312}
cbfc58d1
MK
313
314LONGEST (*inf_ptrace_xfer_partial) (struct target_ops *, enum target_object,
961cb7b5 315 const char *, gdb_byte *, const gdb_byte *,
cbfc58d1
MK
316 ULONGEST, LONGEST);
317
318static LONGEST
319sparc_xfer_partial (struct target_ops *ops, enum target_object object,
961cb7b5
MK
320 const char *annex, gdb_byte *readbuf,
321 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
cbfc58d1
MK
322{
323 if (object == TARGET_OBJECT_WCOOKIE)
324 return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf,
325 offset, len);
326
327 return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf,
328 offset, len);
329}
1b9445c2
MK
330\f
331/* Create a prototype generic SPARC target. The client can override
332 it with local methods. */
333
334struct target_ops *
335sparc_target (void)
336{
337 struct target_ops *t;
338
339 t = inf_ptrace_target ();
6f7a27d5
UW
340 t->to_fetch_registers = sparc_fetch_inferior_registers;
341 t->to_store_registers = sparc_store_inferior_registers;
cbfc58d1
MK
342 inf_ptrace_xfer_partial = t->to_xfer_partial;
343 t->to_xfer_partial = sparc_xfer_partial;
1b9445c2
MK
344 return t;
345}
baf92889
MK
346
347\f
386c036b
MK
348/* Provide a prototype to silence -Wmissing-prototypes. */
349void _initialize_sparc_nat (void);
c906108c
SS
350
351void
386c036b 352_initialize_sparc_nat (void)
c906108c 353{
386c036b
MK
354 /* Deafult to using SunOS 4 register sets. */
355 if (sparc_gregset == NULL)
356 sparc_gregset = &sparc32_sunos4_gregset;
357 if (sparc_supply_gregset == NULL)
358 sparc_supply_gregset = sparc32_supply_gregset;
359 if (sparc_collect_gregset == NULL)
360 sparc_collect_gregset = sparc32_collect_gregset;
361 if (sparc_supply_fpregset == NULL)
362 sparc_supply_fpregset = sparc32_supply_fpregset;
363 if (sparc_collect_fpregset == NULL)
364 sparc_collect_fpregset = sparc32_collect_fpregset;
365 if (sparc_gregset_supplies_p == NULL)
366 sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
367 if (sparc_fpregset_supplies_p == NULL)
368 sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
c906108c 369}
This page took 1.109773 seconds and 4 git commands to generate.