1 /* Native-dependent code for SPARC. 2 3 Copyright (C) 2003-2017 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 "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 target_ops *ops, 138 struct regcache *regcache, int regnum) 139 { 140 struct gdbarch *gdbarch = get_regcache_arch (regcache); 141 pid_t 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 = get_ptrace_pid (regcache_get_ptid (regcache)); 157 158 if (regnum == SPARC_G0_REGNUM) 159 { 160 gdb_byte zero[8] = { 0 }; 161 162 regcache_raw_supply (regcache, 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, ptid_get_lwp (inferior_ptid)) == -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, ptid_get_lwp (inferior_ptid)) == -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 target_ops *ops, 191 struct regcache *regcache, int regnum) 192 { 193 struct gdbarch *gdbarch = get_regcache_arch (regcache); 194 pid_t pid; 195 196 /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers 197 about threaded assumptions. */ 198 pid = get_ptrace_pid (regcache_get_ptid (regcache)); 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, ptid_get_lwp (inferior_ptid)) == -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, ptid_get_lwp (inferior_ptid)) == -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, ptid_get_lwp (inferior_ptid)) == -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, ptid_get_lwp (inferior_ptid)) == -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 static enum target_xfer_status 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, 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 = ptid_get_pid (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_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 target_xfer_partial_ftype *inf_ptrace_xfer_partial; 310 311 static enum target_xfer_status 312 sparc_xfer_partial (struct target_ops *ops, enum target_object object, 313 const char *annex, gdb_byte *readbuf, 314 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, 315 ULONGEST *xfered_len) 316 { 317 if (object == TARGET_OBJECT_WCOOKIE) 318 return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf, 319 offset, len, xfered_len); 320 321 return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf, 322 offset, len, xfered_len); 323 } 324 325 /* Create a prototype generic SPARC target. The client can override 326 it with local methods. */ 327 328 struct target_ops * 329 sparc_target (void) 330 { 331 struct target_ops *t; 332 333 t = inf_ptrace_target (); 334 t->to_fetch_registers = sparc_fetch_inferior_registers; 335 t->to_store_registers = sparc_store_inferior_registers; 336 inf_ptrace_xfer_partial = t->to_xfer_partial; 337 t->to_xfer_partial = sparc_xfer_partial; 338 return t; 339 } 340 341 342 /* Provide a prototype to silence -Wmissing-prototypes. */ 343 void _initialize_sparc_nat (void); 344 345 void 346 _initialize_sparc_nat (void) 347 { 348 /* Deafult to using SunOS 4 register sets. */ 349 if (sparc_gregmap == NULL) 350 sparc_gregmap = &sparc32_sunos4_gregmap; 351 if (sparc_fpregmap == NULL) 352 sparc_fpregmap = &sparc32_sunos4_fpregmap; 353 if (sparc_supply_gregset == NULL) 354 sparc_supply_gregset = sparc32_supply_gregset; 355 if (sparc_collect_gregset == NULL) 356 sparc_collect_gregset = sparc32_collect_gregset; 357 if (sparc_supply_fpregset == NULL) 358 sparc_supply_fpregset = sparc32_supply_fpregset; 359 if (sparc_collect_fpregset == NULL) 360 sparc_collect_fpregset = sparc32_collect_fpregset; 361 if (sparc_gregset_supplies_p == NULL) 362 sparc_gregset_supplies_p = sparc32_gregset_supplies_p; 363 if (sparc_fpregset_supplies_p == NULL) 364 sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p; 365 } 366