1 /* Native-dependent code for SPARC. 2 3 Copyright (C) 2003-2019 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 3 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, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "inferior.h" 22 #include "regcache.h" 23 #include "target.h" 24 25 #include <signal.h> 26 #include <sys/ptrace.h> 27 #include "common/gdb_wait.h" 28 #ifdef HAVE_MACHINE_REG_H 29 #include <machine/reg.h> 30 #endif 31 32 #include "sparc-tdep.h" 33 #include "sparc-nat.h" 34 #include "inf-ptrace.h" 35 36 /* With some trickery we can use the code in this file for most (if 37 not all) ptrace(2) based SPARC systems, which includes SunOS 4, 38 GNU/Linux and the various SPARC BSD's. 39 40 First, we need a data structure for use with ptrace(2). SunOS has 41 `struct regs' and `struct fp_status' in <machine/reg.h>. BSD's 42 have `struct reg' and `struct fpreg' in <machine/reg.h>. GNU/Linux 43 has the same structures as SunOS 4, but they're in <asm/reg.h>, 44 which is a kernel header. As a general rule we avoid including 45 GNU/Linux kernel headers. Fortunately GNU/Linux has a `gregset_t' 46 and a `fpregset_t' that are equivalent to `struct regs' and `struct 47 fp_status' in <sys/ucontext.h>, which is automatically included by 48 <signal.h>. Settling on using the `gregset_t' and `fpregset_t' 49 typedefs, providing them for the other systems, therefore solves 50 the puzzle. */ 51 52 #ifdef HAVE_MACHINE_REG_H 53 #ifdef HAVE_STRUCT_REG 54 typedef struct reg gregset_t; 55 typedef struct fpreg fpregset_t; 56 #else 57 typedef struct regs gregset_t; 58 typedef struct fp_status fpregset_t; 59 #endif 60 #endif 61 62 /* Second, we need to remap the BSD ptrace(2) requests to their SunOS 63 equivalents. GNU/Linux already follows SunOS here. */ 64 65 #ifndef PTRACE_GETREGS 66 #define PTRACE_GETREGS PT_GETREGS 67 #endif 68 69 #ifndef PTRACE_SETREGS 70 #define PTRACE_SETREGS PT_SETREGS 71 #endif 72 73 #ifndef PTRACE_GETFPREGS 74 #define PTRACE_GETFPREGS PT_GETFPREGS 75 #endif 76 77 #ifndef PTRACE_SETFPREGS 78 #define PTRACE_SETFPREGS PT_SETFPREGS 79 #endif 80 81 /* Register set description. */ 82 const struct sparc_gregmap *sparc_gregmap; 83 const struct sparc_fpregmap *sparc_fpregmap; 84 void (*sparc_supply_gregset) (const struct sparc_gregmap *, 85 struct regcache *, int , const void *); 86 void (*sparc_collect_gregset) (const struct sparc_gregmap *, 87 const struct regcache *, int, void *); 88 void (*sparc_supply_fpregset) (const struct sparc_fpregmap *, 89 struct regcache *, int , const void *); 90 void (*sparc_collect_fpregset) (const struct sparc_fpregmap *, 91 const struct regcache *, int , void *); 92 int (*sparc_gregset_supplies_p) (struct gdbarch *, int); 93 int (*sparc_fpregset_supplies_p) (struct gdbarch *, int); 94 95 /* Determine whether `gregset_t' contains register REGNUM. */ 96 97 int 98 sparc32_gregset_supplies_p (struct gdbarch *gdbarch, 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 119 int 120 sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, 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 136 void 137 sparc_fetch_inferior_registers (struct regcache *regcache, int regnum) 138 { 139 struct gdbarch *gdbarch = regcache->arch (); 140 pid_t pid; 141 int lwp = regcache->ptid ().lwp (); 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 = get_ptrace_pid (regcache->ptid ()); 157 158 if (regnum == SPARC_G0_REGNUM) 159 { 160 gdb_byte zero[8] = { 0 }; 161 162 regcache->raw_supply (SPARC_G0_REGNUM, &zero); 163 return; 164 } 165 166 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum)) 167 { 168 gregset_t regs; 169 170 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) ®s, lwp) == -1) 171 perror_with_name (_("Couldn't get registers")); 172 173 sparc_supply_gregset (sparc_gregmap, regcache, -1, ®s); 174 if (regnum != -1) 175 return; 176 } 177 178 if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum)) 179 { 180 fpregset_t fpregs; 181 182 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, lwp) == -1) 183 perror_with_name (_("Couldn't get floating point status")); 184 185 sparc_supply_fpregset (sparc_fpregmap, regcache, -1, &fpregs); 186 } 187 } 188 189 void 190 sparc_store_inferior_registers (struct regcache *regcache, int regnum) 191 { 192 struct gdbarch *gdbarch = regcache->arch (); 193 pid_t pid; 194 int lwp = regcache->ptid ().lwp (); 195 196 /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers 197 about threaded assumptions. */ 198 pid = get_ptrace_pid (regcache->ptid ()); 199 200 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum)) 201 { 202 gregset_t regs; 203 204 if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) ®s, lwp) == -1) 205 perror_with_name (_("Couldn't get registers")); 206 207 sparc_collect_gregset (sparc_gregmap, regcache, regnum, ®s); 208 209 if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) ®s, inferior_ptid.lwp ()) == -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 (gdbarch, regnum)) 227 { 228 fpregset_t fpregs, saved_fpregs; 229 230 if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, lwp) == -1) 231 perror_with_name (_("Couldn't get floating-point registers")); 232 233 memcpy (&saved_fpregs, &fpregs, sizeof (fpregs)); 234 sparc_collect_fpregset (sparc_fpregmap, 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_TYPE_ARG3) &fpregs, lwp) == -1) 244 perror_with_name (_("Couldn't write floating-point registers")); 245 } 246 247 if (regnum != -1) 248 return; 249 } 250 } 251 252 253 /* Implement the to_xfer_partial target_ops method for 254 TARGET_OBJECT_WCOOKIE. Fetch StackGhost Per-Process XOR cookie. */ 255 256 enum target_xfer_status 257 sparc_xfer_wcookie (enum target_object object, 258 const char *annex, gdb_byte *readbuf, 259 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, 260 ULONGEST *xfered_len) 261 { 262 unsigned long wcookie = 0; 263 char *buf = (char *)&wcookie; 264 265 gdb_assert (object == TARGET_OBJECT_WCOOKIE); 266 gdb_assert (readbuf && writebuf == NULL); 267 268 if (offset == sizeof (unsigned long)) 269 return TARGET_XFER_EOF; /* Signal EOF. */ 270 if (offset > sizeof (unsigned long)) 271 return TARGET_XFER_E_IO; 272 273 #ifdef PT_WCOOKIE 274 /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're 275 running on an OpenBSD release that uses StackGhost (3.1 or 276 later). Since release 3.6, OpenBSD uses a fully randomized 277 cookie. */ 278 { 279 int pid = inferior_ptid.pid (); 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_TYPE_ARG3) &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 *xfered_len = (ULONGEST) len; 306 return TARGET_XFER_OK; 307 } 308 309 310 void 311 _initialize_sparc_nat (void) 312 { 313 /* Deafult to using SunOS 4 register sets. */ 314 if (sparc_gregmap == NULL) 315 sparc_gregmap = &sparc32_sunos4_gregmap; 316 if (sparc_fpregmap == NULL) 317 sparc_fpregmap = &sparc32_sunos4_fpregmap; 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