1 /* Functions specific to running GDB native on HPPA running GNU/Linux. 2 3 Copyright (C) 2004-2024 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 "gdbcore.h" 21 #include "regcache.h" 22 #include "inferior.h" 23 #include "target.h" 24 #include "linux-nat.h" 25 #include "inf-ptrace.h" 26 #include "gdbarch.h" 27 28 #include <sys/procfs.h> 29 #include "nat/gdb_ptrace.h" 30 #include <linux/version.h> 31 32 #include <asm/ptrace.h> 33 #include "hppa-linux-offsets.h" 34 35 #include "hppa-tdep.h" 36 37 class hppa_linux_nat_target final : public linux_nat_target 38 { 39 public: 40 /* Add our register access methods. */ 41 void fetch_registers (struct regcache *, int) override; 42 void store_registers (struct regcache *, int) override; 43 }; 44 45 static hppa_linux_nat_target the_hppa_linux_nat_target; 46 47 /* Prototypes for supply_gregset etc. */ 48 #include "gregset.h" 49 50 /* These must match the order of the register names. 51 52 Some sort of lookup table is needed because the offsets associated 53 with the registers are all over the board. */ 54 55 static const int u_offsets[] = 56 { 57 /* general registers */ 58 -1, 59 PT_GR1, 60 PT_GR2, 61 PT_GR3, 62 PT_GR4, 63 PT_GR5, 64 PT_GR6, 65 PT_GR7, 66 PT_GR8, 67 PT_GR9, 68 PT_GR10, 69 PT_GR11, 70 PT_GR12, 71 PT_GR13, 72 PT_GR14, 73 PT_GR15, 74 PT_GR16, 75 PT_GR17, 76 PT_GR18, 77 PT_GR19, 78 PT_GR20, 79 PT_GR21, 80 PT_GR22, 81 PT_GR23, 82 PT_GR24, 83 PT_GR25, 84 PT_GR26, 85 PT_GR27, 86 PT_GR28, 87 PT_GR29, 88 PT_GR30, 89 PT_GR31, 90 91 PT_SAR, 92 PT_IAOQ0, 93 PT_IASQ0, 94 PT_IAOQ1, 95 PT_IASQ1, 96 -1, /* eiem */ 97 PT_IIR, 98 PT_ISR, 99 PT_IOR, 100 PT_PSW, 101 -1, /* goto */ 102 103 PT_SR4, 104 PT_SR0, 105 PT_SR1, 106 PT_SR2, 107 PT_SR3, 108 PT_SR5, 109 PT_SR6, 110 PT_SR7, 111 112 -1, /* cr0 */ 113 -1, /* pid0 */ 114 -1, /* pid1 */ 115 -1, /* ccr */ 116 -1, /* pid2 */ 117 -1, /* pid3 */ 118 -1, /* cr24 */ 119 -1, /* cr25 */ 120 -1, /* cr26 */ 121 PT_CR27, 122 -1, /* cr28 */ 123 -1, /* cr29 */ 124 -1, /* cr30 */ 125 126 /* Floating point regs. */ 127 PT_FR0, PT_FR0 + 4, 128 PT_FR1, PT_FR1 + 4, 129 PT_FR2, PT_FR2 + 4, 130 PT_FR3, PT_FR3 + 4, 131 PT_FR4, PT_FR4 + 4, 132 PT_FR5, PT_FR5 + 4, 133 PT_FR6, PT_FR6 + 4, 134 PT_FR7, PT_FR7 + 4, 135 PT_FR8, PT_FR8 + 4, 136 PT_FR9, PT_FR9 + 4, 137 PT_FR10, PT_FR10 + 4, 138 PT_FR11, PT_FR11 + 4, 139 PT_FR12, PT_FR12 + 4, 140 PT_FR13, PT_FR13 + 4, 141 PT_FR14, PT_FR14 + 4, 142 PT_FR15, PT_FR15 + 4, 143 PT_FR16, PT_FR16 + 4, 144 PT_FR17, PT_FR17 + 4, 145 PT_FR18, PT_FR18 + 4, 146 PT_FR19, PT_FR19 + 4, 147 PT_FR20, PT_FR20 + 4, 148 PT_FR21, PT_FR21 + 4, 149 PT_FR22, PT_FR22 + 4, 150 PT_FR23, PT_FR23 + 4, 151 PT_FR24, PT_FR24 + 4, 152 PT_FR25, PT_FR25 + 4, 153 PT_FR26, PT_FR26 + 4, 154 PT_FR27, PT_FR27 + 4, 155 PT_FR28, PT_FR28 + 4, 156 PT_FR29, PT_FR29 + 4, 157 PT_FR30, PT_FR30 + 4, 158 PT_FR31, PT_FR31 + 4, 159 }; 160 161 static CORE_ADDR 162 hppa_linux_register_addr (int regno, CORE_ADDR blockend) 163 { 164 CORE_ADDR addr; 165 166 if ((unsigned) regno >= ARRAY_SIZE (u_offsets)) 167 error (_("Invalid register number %d."), regno); 168 169 if (u_offsets[regno] == -1) 170 addr = 0; 171 else 172 { 173 addr = (CORE_ADDR) u_offsets[regno]; 174 } 175 176 return addr; 177 } 178 179 /* 180 * Registers saved in a coredump: 181 * gr0..gr31 182 * sr0..sr7 183 * iaoq0..iaoq1 184 * iasq0..iasq1 185 * sar, iir, isr, ior, ipsw 186 * cr0, cr24..cr31 187 * cr8,9,12,13 188 * cr10, cr15 189 */ 190 #define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n) 191 #define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n) 192 static const int greg_map[] = 193 { 194 GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3), 195 GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7), 196 GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11), 197 GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15), 198 GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19), 199 GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23), 200 GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27), 201 GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31), 202 203 HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4, 204 HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7, 205 206 HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM, 207 HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM, 208 209 HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM, 210 HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM, 211 212 TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3), 213 TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7), 214 215 HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM, 216 HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM, 217 }; 218 219 220 221 /* Fetch one register. */ 222 223 static void 224 fetch_register (struct regcache *regcache, int regno) 225 { 226 struct gdbarch *gdbarch = regcache->arch (); 227 pid_t tid; 228 int val; 229 230 if (gdbarch_cannot_fetch_register (gdbarch, regno)) 231 { 232 regcache->raw_supply (regno, NULL); 233 return; 234 } 235 236 tid = get_ptrace_pid (regcache->ptid ()); 237 238 errno = 0; 239 val = ptrace (PTRACE_PEEKUSER, tid, hppa_linux_register_addr (regno, 0), 0); 240 if (errno != 0) 241 error (_("Couldn't read register %s (#%d): %s."), 242 gdbarch_register_name (gdbarch, regno), 243 regno, safe_strerror (errno)); 244 245 regcache->raw_supply (regno, &val); 246 } 247 248 /* Store one register. */ 249 250 static void 251 store_register (const struct regcache *regcache, int regno) 252 { 253 struct gdbarch *gdbarch = regcache->arch (); 254 pid_t tid; 255 int val; 256 257 if (gdbarch_cannot_store_register (gdbarch, regno)) 258 return; 259 260 tid = get_ptrace_pid (regcache->ptid ()); 261 262 errno = 0; 263 regcache->raw_collect (regno, &val); 264 ptrace (PTRACE_POKEUSER, tid, hppa_linux_register_addr (regno, 0), val); 265 if (errno != 0) 266 error (_("Couldn't write register %s (#%d): %s."), 267 gdbarch_register_name (gdbarch, regno), 268 regno, safe_strerror (errno)); 269 } 270 271 /* Fetch registers from the child process. Fetch all registers if 272 regno == -1, otherwise fetch all general registers or all floating 273 point registers depending upon the value of regno. */ 274 275 void 276 hppa_linux_nat_target::fetch_registers (struct regcache *regcache, int regno) 277 { 278 if (-1 == regno) 279 { 280 for (regno = 0; 281 regno < gdbarch_num_regs (regcache->arch ()); 282 regno++) 283 fetch_register (regcache, regno); 284 } 285 else 286 { 287 fetch_register (regcache, regno); 288 } 289 } 290 291 /* Store registers back into the inferior. Store all registers if 292 regno == -1, otherwise store all general registers or all floating 293 point registers depending upon the value of regno. */ 294 295 void 296 hppa_linux_nat_target::store_registers (struct regcache *regcache, int regno) 297 { 298 if (-1 == regno) 299 { 300 for (regno = 0; 301 regno < gdbarch_num_regs (regcache->arch ()); 302 regno++) 303 store_register (regcache, regno); 304 } 305 else 306 { 307 store_register (regcache, regno); 308 } 309 } 310 311 /* Fill GDB's register array with the general-purpose register values 312 in *gregsetp. */ 313 314 void 315 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp) 316 { 317 int i; 318 const greg_t *regp = (const elf_greg_t *) gregsetp; 319 320 for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++, regp++) 321 { 322 int regno = greg_map[i]; 323 regcache->raw_supply (regno, regp); 324 } 325 } 326 327 /* Fill register regno (if it is a general-purpose register) in 328 *gregsetp with the appropriate value from GDB's register array. 329 If regno is -1, do this for all registers. */ 330 331 void 332 fill_gregset (const struct regcache *regcache, 333 gdb_gregset_t *gregsetp, int regno) 334 { 335 int i; 336 337 for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++) 338 { 339 int mregno = greg_map[i]; 340 341 if (regno == -1 || regno == mregno) 342 regcache->raw_collect (mregno, &(*gregsetp)[i]); 343 } 344 } 345 346 /* Given a pointer to a floating point register set in /proc format 347 (fpregset_t *), unpack the register contents and supply them as gdb's 348 idea of the current floating point register values. */ 349 350 void 351 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp) 352 { 353 int regi; 354 const char *from; 355 356 for (regi = 0; regi <= 31; regi++) 357 { 358 from = (const char *) &((*fpregsetp)[regi]); 359 regcache->raw_supply (2*regi + HPPA_FP0_REGNUM, from); 360 regcache->raw_supply (2*regi + HPPA_FP0_REGNUM + 1, from + 4); 361 } 362 } 363 364 /* Given a pointer to a floating point register set in /proc format 365 (fpregset_t *), update the register specified by REGNO from gdb's idea 366 of the current floating point register set. If REGNO is -1, update 367 them all. */ 368 369 void 370 fill_fpregset (const struct regcache *regcache, 371 gdb_fpregset_t *fpregsetp, int regno) 372 { 373 int i; 374 375 for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32 * 2; i++) 376 { 377 /* Gross. fpregset_t is double, registers[x] has single 378 precision reg. */ 379 char *to = (char *) &((*fpregsetp)[(i - HPPA_FP0_REGNUM) / 2]); 380 if ((i - HPPA_FP0_REGNUM) & 1) 381 to += 4; 382 regcache->raw_collect (i, to); 383 } 384 } 385 386 void _initialize_hppa_linux_nat (); 387 void 388 _initialize_hppa_linux_nat () 389 { 390 /* Register the target. */ 391 linux_target = &the_hppa_linux_nat_target; 392 add_inf_child_target (&the_hppa_linux_nat_target); 393 } 394