]>
Commit | Line | Data |
---|---|---|
1 | /* Native-dependent code for SPARC. | |
2 | ||
3 | Copyright (C) 2003, 2004, 2005 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) ®s, 0) == -1) | |
171 | perror_with_name (_("Couldn't get registers")); | |
172 | ||
173 | sparc_supply_gregset (sparc_gregset, regcache, -1, ®s); | |
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) ®s, 0) == -1) | |
206 | perror_with_name (_("Couldn't get registers")); | |
207 | ||
208 | sparc_collect_gregset (sparc_gregset, regcache, regnum, ®s); | |
209 | ||
210 | if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 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 -1; | |
269 | ||
270 | #ifdef PT_WCOOKIE | |
271 | /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're | |
272 | running on an OpenBSD release that uses StackGhost (3.1 or | |
273 | later). As of release 3.4, OpenBSD doesn't use a randomized | |
274 | cookie yet, but a future release probably will. */ | |
275 | { | |
276 | int pid; | |
277 | ||
278 | pid = TIDGET (inferior_ptid); | |
279 | if (pid == 0) | |
280 | pid = PIDGET (inferior_ptid); | |
281 | ||
282 | /* Sanity check. The proper type for a cookie is register_t, but | |
283 | we can't assume that this type exists on all systems supported | |
284 | by the code in this file. */ | |
285 | gdb_assert (sizeof (wcookie) == sizeof (register_t)); | |
286 | ||
287 | /* Fetch the cookie. */ | |
288 | if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1) | |
289 | { | |
290 | if (errno != EINVAL) | |
291 | perror_with_name (_("Couldn't get StackGhost cookie")); | |
292 | ||
293 | /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later, | |
294 | the request wasn't implemented until after OpenBSD 3.4. If | |
295 | the kernel doesn't support the PT_WCOOKIE request, assume | |
296 | we're running on a kernel that uses non-randomized cookies. */ | |
297 | wcookie = 0x3; | |
298 | } | |
299 | } | |
300 | #endif /* PT_WCOOKIE */ | |
301 | ||
302 | if (len > sizeof (unsigned long) - offset) | |
303 | len = sizeof (unsigned long) - offset; | |
304 | ||
305 | memcpy (readbuf, buf + offset, len); | |
306 | return len; | |
307 | } | |
308 | ||
309 | LONGEST (*inf_ptrace_xfer_partial) (struct target_ops *, enum target_object, | |
310 | const char *, gdb_byte *, const gdb_byte *, | |
311 | ULONGEST, LONGEST); | |
312 | ||
313 | static LONGEST | |
314 | sparc_xfer_partial (struct target_ops *ops, enum target_object object, | |
315 | const char *annex, gdb_byte *readbuf, | |
316 | const gdb_byte *writebuf, ULONGEST offset, LONGEST len) | |
317 | { | |
318 | if (object == TARGET_OBJECT_WCOOKIE) | |
319 | return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf, | |
320 | offset, len); | |
321 | ||
322 | return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf, | |
323 | offset, len); | |
324 | } | |
325 | \f | |
326 | /* Create a prototype generic SPARC target. The client can override | |
327 | it with local methods. */ | |
328 | ||
329 | struct target_ops * | |
330 | sparc_target (void) | |
331 | { | |
332 | struct target_ops *t; | |
333 | ||
334 | t = inf_ptrace_target (); | |
335 | t->to_fetch_registers = fetch_inferior_registers; | |
336 | t->to_store_registers = store_inferior_registers; | |
337 | inf_ptrace_xfer_partial = t->to_xfer_partial; | |
338 | t->to_xfer_partial = sparc_xfer_partial; | |
339 | return t; | |
340 | } | |
341 | ||
342 | \f | |
343 | /* Provide a prototype to silence -Wmissing-prototypes. */ | |
344 | void _initialize_sparc_nat (void); | |
345 | ||
346 | void | |
347 | _initialize_sparc_nat (void) | |
348 | { | |
349 | /* Deafult to using SunOS 4 register sets. */ | |
350 | if (sparc_gregset == NULL) | |
351 | sparc_gregset = &sparc32_sunos4_gregset; | |
352 | if (sparc_supply_gregset == NULL) | |
353 | sparc_supply_gregset = sparc32_supply_gregset; | |
354 | if (sparc_collect_gregset == NULL) | |
355 | sparc_collect_gregset = sparc32_collect_gregset; | |
356 | if (sparc_supply_fpregset == NULL) | |
357 | sparc_supply_fpregset = sparc32_supply_fpregset; | |
358 | if (sparc_collect_fpregset == NULL) | |
359 | sparc_collect_fpregset = sparc32_collect_fpregset; | |
360 | if (sparc_gregset_supplies_p == NULL) | |
361 | sparc_gregset_supplies_p = sparc32_gregset_supplies_p; | |
362 | if (sparc_fpregset_supplies_p == NULL) | |
363 | sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p; | |
364 | } |