1 /* Native-dependent code for SPARC. 2 3 Copyright (C) 2003-2020 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 "gdbsupport/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 static PTRACE_TYPE_RET 82 gdb_ptrace (PTRACE_TYPE_ARG1 request, ptid_t ptid, PTRACE_TYPE_ARG3 addr) 83 { 84 #ifdef __NetBSD__ 85 /* Support for NetBSD threads: unlike other ptrace implementations in this 86 file, NetBSD requires that we pass both the pid and lwp. */ 87 return ptrace (request, ptid.pid (), addr, ptid.lwp ()); 88 #else 89 pid_t pid = get_ptrace_pid (ptid); 90 return ptrace (request, pid, addr, 0); 91 #endif 92 } 93 94 /* Register set description. */ 95 const struct sparc_gregmap *sparc_gregmap; 96 const struct sparc_fpregmap *sparc_fpregmap; 97 void (*sparc_supply_gregset) (const struct sparc_gregmap *, 98 struct regcache *, int , const void *); 99 void (*sparc_collect_gregset) (const struct sparc_gregmap *, 100 const struct regcache *, int, void *); 101 void (*sparc_supply_fpregset) (const struct sparc_fpregmap *, 102 struct regcache *, int , const void *); 103 void (*sparc_collect_fpregset) (const struct sparc_fpregmap *, 104 const struct regcache *, int , void *); 105 int (*sparc_gregset_supplies_p) (struct gdbarch *, int); 106 int (*sparc_fpregset_supplies_p) (struct gdbarch *, int); 107 108 /* Determine whether `gregset_t' contains register REGNUM. */ 109 110 int 111 sparc32_gregset_supplies_p (struct gdbarch *gdbarch, int regnum) 112 { 113 /* Integer registers. */ 114 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM) 115 || (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM) 116 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM) 117 || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM)) 118 return 1; 119 120 /* Control registers. */ 121 if (regnum == SPARC32_PC_REGNUM 122 || regnum == SPARC32_NPC_REGNUM 123 || regnum == SPARC32_PSR_REGNUM 124 || regnum == SPARC32_Y_REGNUM) 125 return 1; 126 127 return 0; 128 } 129 130 /* Determine whether `fpregset_t' contains register REGNUM. */ 131 132 int 133 sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, int regnum) 134 { 135 /* Floating-point registers. */ 136 if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM) 137 return 1; 138 139 /* Control registers. */ 140 if (regnum == SPARC32_FSR_REGNUM) 141 return 1; 142 143 return 0; 144 } 145 146 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this 147 for all registers (including the floating-point registers). */ 148 149 void 150 sparc_fetch_inferior_registers (struct regcache *regcache, int regnum) 151 { 152 struct gdbarch *gdbarch = regcache->arch (); 153 ptid_t ptid = regcache->ptid (); 154 155 if (regnum == SPARC_G0_REGNUM) 156 { 157 gdb_byte zero[8] = { 0 }; 158 159 regcache->raw_supply (SPARC_G0_REGNUM, &zero); 160 return; 161 } 162 163 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum)) 164 { 165 gregset_t regs; 166 167 if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) ®s) == -1) 168 perror_with_name (_("Couldn't get registers")); 169 170 sparc_supply_gregset (sparc_gregmap, regcache, -1, ®s); 171 if (regnum != -1) 172 return; 173 } 174 175 if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum)) 176 { 177 fpregset_t fpregs; 178 179 if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1) 180 perror_with_name (_("Couldn't get floating point status")); 181 182 sparc_supply_fpregset (sparc_fpregmap, regcache, -1, &fpregs); 183 } 184 } 185 186 void 187 sparc_store_inferior_registers (struct regcache *regcache, int regnum) 188 { 189 struct gdbarch *gdbarch = regcache->arch (); 190 ptid_t ptid = regcache->ptid (); 191 192 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum)) 193 { 194 gregset_t regs; 195 196 if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) ®s) == -1) 197 perror_with_name (_("Couldn't get registers")); 198 199 sparc_collect_gregset (sparc_gregmap, regcache, regnum, ®s); 200 201 if (gdb_ptrace (PTRACE_SETREGS, ptid, (PTRACE_TYPE_ARG3) ®s) == -1) 202 perror_with_name (_("Couldn't write registers")); 203 204 /* Deal with the stack regs. */ 205 if (regnum == -1 || regnum == SPARC_SP_REGNUM 206 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM)) 207 { 208 ULONGEST sp; 209 210 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp); 211 sparc_collect_rwindow (regcache, sp, regnum); 212 } 213 214 if (regnum != -1) 215 return; 216 } 217 218 if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum)) 219 { 220 fpregset_t fpregs, saved_fpregs; 221 222 if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1) 223 perror_with_name (_("Couldn't get floating-point registers")); 224 225 memcpy (&saved_fpregs, &fpregs, sizeof (fpregs)); 226 sparc_collect_fpregset (sparc_fpregmap, regcache, regnum, &fpregs); 227 228 /* Writing the floating-point registers will fail on NetBSD with 229 EINVAL if the inferior process doesn't have an FPU state 230 (i.e. if it didn't use the FPU yet). Therefore we don't try 231 to write the registers if nothing changed. */ 232 if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0) 233 { 234 if (gdb_ptrace (PTRACE_SETFPREGS, ptid, 235 (PTRACE_TYPE_ARG3) &fpregs) == -1) 236 perror_with_name (_("Couldn't write floating-point registers")); 237 } 238 239 if (regnum != -1) 240 return; 241 } 242 } 243 244 245 /* Implement the to_xfer_partial target_ops method for 246 TARGET_OBJECT_WCOOKIE. Fetch StackGhost Per-Process XOR cookie. */ 247 248 enum target_xfer_status 249 sparc_xfer_wcookie (enum target_object object, 250 const char *annex, gdb_byte *readbuf, 251 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, 252 ULONGEST *xfered_len) 253 { 254 unsigned long wcookie = 0; 255 char *buf = (char *)&wcookie; 256 257 gdb_assert (object == TARGET_OBJECT_WCOOKIE); 258 gdb_assert (readbuf && writebuf == NULL); 259 260 if (offset == sizeof (unsigned long)) 261 return TARGET_XFER_EOF; /* Signal EOF. */ 262 if (offset > sizeof (unsigned long)) 263 return TARGET_XFER_E_IO; 264 265 #ifdef PT_WCOOKIE 266 /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're 267 running on an OpenBSD release that uses StackGhost (3.1 or 268 later). Since release 3.6, OpenBSD uses a fully randomized 269 cookie. */ 270 { 271 int pid = inferior_ptid.pid (); 272 273 /* Sanity check. The proper type for a cookie is register_t, but 274 we can't assume that this type exists on all systems supported 275 by the code in this file. */ 276 gdb_assert (sizeof (wcookie) == sizeof (register_t)); 277 278 /* Fetch the cookie. */ 279 if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1) 280 { 281 if (errno != EINVAL) 282 perror_with_name (_("Couldn't get StackGhost cookie")); 283 284 /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later, 285 the request wasn't implemented until after OpenBSD 3.4. If 286 the kernel doesn't support the PT_WCOOKIE request, assume 287 we're running on a kernel that uses non-randomized cookies. */ 288 wcookie = 0x3; 289 } 290 } 291 #endif /* PT_WCOOKIE */ 292 293 if (len > sizeof (unsigned long) - offset) 294 len = sizeof (unsigned long) - offset; 295 296 memcpy (readbuf, buf + offset, len); 297 *xfered_len = (ULONGEST) len; 298 return TARGET_XFER_OK; 299 } 300 301 302 void _initialize_sparc_nat (); 303 void 304 _initialize_sparc_nat () 305 { 306 /* Default to using SunOS 4 register sets. */ 307 if (sparc_gregmap == NULL) 308 sparc_gregmap = &sparc32_sunos4_gregmap; 309 if (sparc_fpregmap == NULL) 310 sparc_fpregmap = &sparc32_sunos4_fpregmap; 311 if (sparc_supply_gregset == NULL) 312 sparc_supply_gregset = sparc32_supply_gregset; 313 if (sparc_collect_gregset == NULL) 314 sparc_collect_gregset = sparc32_collect_gregset; 315 if (sparc_supply_fpregset == NULL) 316 sparc_supply_fpregset = sparc32_supply_fpregset; 317 if (sparc_collect_fpregset == NULL) 318 sparc_collect_fpregset = sparc32_collect_fpregset; 319 if (sparc_gregset_supplies_p == NULL) 320 sparc_gregset_supplies_p = sparc32_gregset_supplies_p; 321 if (sparc_fpregset_supplies_p == NULL) 322 sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p; 323 } 324