1 /* Native-dependent code for SPARC. 2 3 Copyright (C) 2003-2023 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 (process_stratum_target *proc_target, 151 regcache *regcache, int regnum) 152 { 153 struct gdbarch *gdbarch = regcache->arch (); 154 ptid_t ptid = regcache->ptid (); 155 156 if (regnum == SPARC_G0_REGNUM) 157 { 158 gdb_byte zero[8] = { 0 }; 159 160 regcache->raw_supply (SPARC_G0_REGNUM, &zero); 161 return; 162 } 163 164 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum)) 165 { 166 gregset_t regs; 167 168 if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) ®s) == -1) 169 perror_with_name (_("Couldn't get registers")); 170 171 /* Deep down, sparc_supply_rwindow reads memory, so needs the global 172 thread context to be set. */ 173 scoped_restore restore_inferior_ptid 174 = make_scoped_restore (&inferior_ptid, ptid); 175 176 sparc_supply_gregset (sparc_gregmap, regcache, -1, ®s); 177 if (regnum != -1) 178 return; 179 } 180 181 if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum)) 182 { 183 fpregset_t fpregs; 184 185 if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1) 186 perror_with_name (_("Couldn't get floating point status")); 187 188 sparc_supply_fpregset (sparc_fpregmap, regcache, -1, &fpregs); 189 } 190 } 191 192 void 193 sparc_store_inferior_registers (process_stratum_target *proc_target, 194 regcache *regcache, int regnum) 195 { 196 struct gdbarch *gdbarch = regcache->arch (); 197 ptid_t ptid = regcache->ptid (); 198 199 if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum)) 200 { 201 gregset_t regs; 202 203 if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) ®s) == -1) 204 perror_with_name (_("Couldn't get registers")); 205 206 sparc_collect_gregset (sparc_gregmap, regcache, regnum, ®s); 207 208 if (gdb_ptrace (PTRACE_SETREGS, ptid, (PTRACE_TYPE_ARG3) ®s) == -1) 209 perror_with_name (_("Couldn't write registers")); 210 211 /* Deal with the stack regs. */ 212 if (regnum == -1 || regnum == SPARC_SP_REGNUM 213 || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM)) 214 { 215 ULONGEST sp; 216 217 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp); 218 219 /* Deep down, sparc_collect_rwindow writes memory, so needs the global 220 thread context to be set. */ 221 scoped_restore restore_inferior_ptid 222 = make_scoped_restore (&inferior_ptid, ptid); 223 224 sparc_collect_rwindow (regcache, sp, regnum); 225 } 226 227 if (regnum != -1) 228 return; 229 } 230 231 if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum)) 232 { 233 fpregset_t fpregs, saved_fpregs; 234 235 if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1) 236 perror_with_name (_("Couldn't get floating-point registers")); 237 238 memcpy (&saved_fpregs, &fpregs, sizeof (fpregs)); 239 sparc_collect_fpregset (sparc_fpregmap, regcache, regnum, &fpregs); 240 241 /* Writing the floating-point registers will fail on NetBSD with 242 EINVAL if the inferior process doesn't have an FPU state 243 (i.e. if it didn't use the FPU yet). Therefore we don't try 244 to write the registers if nothing changed. */ 245 if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0) 246 { 247 if (gdb_ptrace (PTRACE_SETFPREGS, ptid, 248 (PTRACE_TYPE_ARG3) &fpregs) == -1) 249 perror_with_name (_("Couldn't write floating-point registers")); 250 } 251 252 if (regnum != -1) 253 return; 254 } 255 } 256 257 258 /* Implement the to_xfer_partial target_ops method for 259 TARGET_OBJECT_WCOOKIE. Fetch StackGhost Per-Process XOR cookie. */ 260 261 enum target_xfer_status 262 sparc_xfer_wcookie (enum target_object object, 263 const char *annex, gdb_byte *readbuf, 264 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, 265 ULONGEST *xfered_len) 266 { 267 unsigned long wcookie = 0; 268 char *buf = (char *)&wcookie; 269 270 gdb_assert (object == TARGET_OBJECT_WCOOKIE); 271 gdb_assert (readbuf && writebuf == NULL); 272 273 if (offset == sizeof (unsigned long)) 274 return TARGET_XFER_EOF; /* Signal EOF. */ 275 if (offset > sizeof (unsigned long)) 276 return TARGET_XFER_E_IO; 277 278 #ifdef PT_WCOOKIE 279 /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're 280 running on an OpenBSD release that uses StackGhost (3.1 or 281 later). Since release 3.6, OpenBSD uses a fully randomized 282 cookie. */ 283 { 284 int pid = inferior_ptid.pid (); 285 286 /* Sanity check. The proper type for a cookie is register_t, but 287 we can't assume that this type exists on all systems supported 288 by the code in this file. */ 289 gdb_assert (sizeof (wcookie) == sizeof (register_t)); 290 291 /* Fetch the cookie. */ 292 if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1) 293 { 294 if (errno != EINVAL) 295 perror_with_name (_("Couldn't get StackGhost cookie")); 296 297 /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later, 298 the request wasn't implemented until after OpenBSD 3.4. If 299 the kernel doesn't support the PT_WCOOKIE request, assume 300 we're running on a kernel that uses non-randomized cookies. */ 301 wcookie = 0x3; 302 } 303 } 304 #endif /* PT_WCOOKIE */ 305 306 if (len > sizeof (unsigned long) - offset) 307 len = sizeof (unsigned long) - offset; 308 309 memcpy (readbuf, buf + offset, len); 310 *xfered_len = (ULONGEST) len; 311 return TARGET_XFER_OK; 312 } 313 314 315 void _initialize_sparc_nat (); 316 void 317 _initialize_sparc_nat () 318 { 319 /* Default to using SunOS 4 register sets. */ 320 if (sparc_gregmap == NULL) 321 sparc_gregmap = &sparc32_sunos4_gregmap; 322 if (sparc_fpregmap == NULL) 323 sparc_fpregmap = &sparc32_sunos4_fpregmap; 324 if (sparc_supply_gregset == NULL) 325 sparc_supply_gregset = sparc32_supply_gregset; 326 if (sparc_collect_gregset == NULL) 327 sparc_collect_gregset = sparc32_collect_gregset; 328 if (sparc_supply_fpregset == NULL) 329 sparc_supply_fpregset = sparc32_supply_fpregset; 330 if (sparc_collect_fpregset == NULL) 331 sparc_collect_fpregset = sparc32_collect_fpregset; 332 if (sparc_gregset_supplies_p == NULL) 333 sparc_gregset_supplies_p = sparc32_gregset_supplies_p; 334 if (sparc_fpregset_supplies_p == NULL) 335 sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p; 336 } 337