Commit | Line | Data |
---|---|---|
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 | |
57 | typedef struct reg gregset_t; | |
58 | typedef struct fpreg fpregset_t; | |
59 | #else | |
60 | typedef struct regs gregset_t; | |
61 | typedef 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. */ | |
85 | const struct sparc_gregset *sparc_gregset; | |
86 | void (*sparc_supply_gregset) (const struct sparc_gregset *, | |
87 | struct regcache *, int , const void *); | |
88 | void (*sparc_collect_gregset) (const struct sparc_gregset *, | |
89 | const struct regcache *, int, void *); | |
90 | void (*sparc_supply_fpregset) (struct regcache *, int , const void *); | |
91 | void (*sparc_collect_fpregset) (const struct regcache *, int , void *); | |
ec22ec34 UW |
92 | int (*sparc_gregset_supplies_p) (struct gdbarch *, int); |
93 | int (*sparc_fpregset_supplies_p) (struct gdbarch *, int); | |
386c036b MK |
94 | |
95 | /* Determine whether `gregset_t' contains register REGNUM. */ | |
96 | ||
97 | int | |
ec22ec34 | 98 | sparc32_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 | ||
119 | int | |
ec22ec34 | 120 | sparc32_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 | |
136 | void | |
28439f5e PA |
137 | sparc_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) ®s, 0) == -1) |
e2e0b3e5 | 173 | perror_with_name (_("Couldn't get registers")); |
386c036b MK |
174 | |
175 | sparc_supply_gregset (sparc_gregset, regcache, -1, ®s); | |
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 | 191 | void |
28439f5e PA |
192 | sparc_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) ®s, 0) == -1) |
e2e0b3e5 | 209 | perror_with_name (_("Couldn't get registers")); |
c906108c | 210 | |
386c036b | 211 | sparc_collect_gregset (sparc_gregset, regcache, regnum, ®s); |
c906108c | 212 | |
49ec097f | 213 | if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 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 | ||
259 | LONGEST | |
260 | sparc_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 | |
314 | LONGEST (*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 | ||
318 | static LONGEST | |
319 | sparc_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 | ||
334 | struct target_ops * | |
335 | sparc_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. */ |
349 | void _initialize_sparc_nat (void); | |
c906108c SS |
350 | |
351 | void | |
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 | } |