1/* Native-dependent code for SPARC. 2 3 Copyright 2003, 2004 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., 59 Temple Place - Suite 330, 20 Boston, MA 02111-1307, 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 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, 41 GNU/Linux and the various SPARC BSD's. 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. */ 67 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 75 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 *); 92int (*sparc_gregset_supplies_p) (int); 93int (*sparc_fpregset_supplies_p) (int); 94 95/* Determine whether `gregset_t' contains register REGNUM. */ 96 97int 98sparc32_gregset_supplies_p (int regnum) 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 120sparc32_fpregset_supplies_p (int regnum) 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). */ 135 136void 137fetch_inferior_registers (int regnum) 138{ 139 struct regcache *regcache = current_regcache; 140 int pid; 141 142 /* NOTE: cagney/2002-12-03: This code assumes that the currently 143 selected light weight processes' registers can be written 144 directly into the selected thread's register cache. This works 145 fine when given an 1:1 LWP:thread model (such as found on 146 GNU/Linux) but will, likely, have problems when used on an N:1 147 (userland threads) or N:M (userland multiple LWP) model. In the 148 case of the latter two, the LWP's registers do not necessarily 149 belong to the selected thread (the LWP could be in the middle of 150 executing the thread switch code). 151 152 These functions should instead be paramaterized with an explicit 153 object (struct regcache, struct thread_info?) into which the LWPs 154 registers can be written. */ 155 pid = TIDGET (inferior_ptid); 156 if (pid == 0) 157 pid = PIDGET (inferior_ptid); 158 159 if (regnum == SPARC_G0_REGNUM) 160 { 161 regcache_raw_supply (regcache, SPARC_G0_REGNUM, NULL); 162 return; 163 } 164 165 if (regnum == -1 || sparc_gregset_supplies_p (regnum)) 166 { 167 gregset_t regs; 168 169 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_ARG3_TYPE) ®s, 0) == -1) 170 perror_with_name ("Couldn't get registers"); 171 172 sparc_supply_gregset (sparc_gregset, regcache, -1, ®s); 173 if (regnum != -1) 174 return; 175 } 176 177 if (regnum == -1 || sparc_fpregset_supplies_p (regnum)) 178 { 179 fpregset_t fpregs; 180 181 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_ARG3_TYPE) &fpregs, 0) == -1) 182 perror_with_name ("Couldn't get floating point status"); 183 184 sparc_supply_fpregset (regcache, -1, &fpregs); 185 } 186} 187 188void 189store_inferior_registers (int regnum) 190{ 191 struct regcache *regcache = current_regcache; 192 int pid; 193 194 /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers 195 about threaded assumptions. */ 196 pid = TIDGET (inferior_ptid); 197 if (pid == 0) 198 pid = PIDGET (inferior_ptid); 199 200 if (regnum == -1 || sparc_gregset_supplies_p (regnum)) 201 { 202 gregset_t regs; 203 204 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_ARG3_TYPE) ®s, 0) == -1) 205 perror_with_name ("Couldn't get registers"); 206 207 sparc_collect_gregset (sparc_gregset, regcache, regnum, ®s); 208 209 if (ptrace (PTRACE_SETREGS, pid, (PTRACE_ARG3_TYPE) ®s, 0) == -1) 210 perror_with_name ("Couldn't write registers"); 211 212 /* Deal with the stack regs. */ 213 if (regnum == -1 || regnum == SPARC_SP_REGNUM 214 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM)) 215 { 216 ULONGEST sp; 217 218 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp); 219 sparc_collect_rwindow (regcache, sp, regnum); 220 } 221 222 if (regnum != -1) 223 return; 224 } 225 226 if (regnum == -1 || sparc_fpregset_supplies_p (regnum)) 227 { 228 fpregset_t fpregs, saved_fpregs; 229 230 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_ARG3_TYPE) &fpregs, 0) == -1) 231 perror_with_name ("Couldn't get floating-point registers"); 232 233 memcpy (&saved_fpregs, &fpregs, sizeof (fpregs)); 234 sparc_collect_fpregset (regcache, regnum, &fpregs); 235 236 /* Writing the floating-point registers will fail on NetBSD with 237 EINVAL if the inferior process doesn't have an FPU state 238 (i.e. if it didn't use the FPU yet). Therefore we don't try 239 to write the registers if nothing changed. */ 240 if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0) 241 { 242 if (ptrace (PTRACE_SETFPREGS, pid, 243 (PTRACE_ARG3_TYPE) &fpregs, 0) == -1) 244 perror_with_name ("Couldn't write floating-point registers"); 245 } 246 247 if (regnum != -1) 248 return; 249 } 250} 251 252 253/* Fetch StackGhost Per-Process XOR cookie. */ 254 255LONGEST 256sparc_xfer_wcookie (struct target_ops *ops, enum target_object object, 257 const char *annex, void *readbuf, const void *writebuf, 258 ULONGEST offset, LONGEST len) 259{ 260 unsigned long wcookie = 0; 261 char *buf = (char *)&wcookie; 262 263 gdb_assert (object == TARGET_OBJECT_WCOOKIE); 264 gdb_assert (readbuf && writebuf == NULL); 265 266 if (offset >= sizeof (unsigned long)) 267 return -1; 268 269#ifdef PT_WCOOKIE 270 /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're 271 running on an OpenBSD release that uses StackGhost (3.1 or 272 later). As of release 3.4, OpenBSD doesn't use a randomized 273 cookie yet, but a future release probably will. */ 274 { 275 int pid; 276 277 pid = TIDGET (inferior_ptid); 278 if (pid == 0) 279 pid = PIDGET (inferior_ptid); 280 281 /* Sanity check. The proper type for a cookie is register_t, but 282 we can't assume that this type exists on all systems supported 283 by the code in this file. */ 284 gdb_assert (sizeof (wcookie) == sizeof (register_t)); 285 286 /* Fetch the cookie. */ 287 if (ptrace (PT_WCOOKIE, pid, (PTRACE_ARG3_TYPE) &wcookie, 0) == -1) 288 { 289 if (errno != EINVAL) 290 perror_with_name ("Couldn't get StackGhost cookie"); 291 292 /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later, 293 the request wasn't implemented until after OpenBSD 3.4. If 294 the kernel doesn't support the PT_WCOOKIE request, assume 295 we're running on a kernel that uses non-randomized cookies. */ 296 wcookie = 0x3; 297 } 298 } 299#endif /* PT_WCOOKIE */ 300 301 if (len > sizeof (unsigned long) - offset) 302 len = sizeof (unsigned long) - offset; 303 304 memcpy (readbuf, buf + offset, len); 305 return len; 306} 307 308 309/* Provide a prototype to silence -Wmissing-prototypes. */ 310void _initialize_sparc_nat (void); 311 312void 313_initialize_sparc_nat (void) 314{ 315 /* Deafult to using SunOS 4 register sets. */ 316 if (sparc_gregset == NULL) 317 sparc_gregset = &sparc32_sunos4_gregset; 318 if (sparc_supply_gregset == NULL) 319 sparc_supply_gregset = sparc32_supply_gregset; 320 if (sparc_collect_gregset == NULL) 321 sparc_collect_gregset = sparc32_collect_gregset; 322 if (sparc_supply_fpregset == NULL) 323 sparc_supply_fpregset = sparc32_supply_fpregset; 324 if (sparc_collect_fpregset == NULL) 325 sparc_collect_fpregset = sparc32_collect_fpregset; 326 if (sparc_gregset_supplies_p == NULL) 327 sparc_gregset_supplies_p = sparc32_gregset_supplies_p; 328 if (sparc_fpregset_supplies_p == NULL) 329 sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p; 330} 331