1 /* Low level interface to ptrace, for the remote server for GDB. 2 Copyright (C) 1995-2024 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #include "linux-low.h" 20 21 #include "nat/gdb_ptrace.h" 22 23 #include "gdb_proc_service.h" 24 25 /* The stack pointer is offset from the stack frame by a BIAS of 2047 26 (0x7ff) for 64-bit code. BIAS is likely to be defined on SPARC 27 hosts, so undefine it first. */ 28 #undef BIAS 29 #define BIAS 2047 30 31 #ifdef HAVE_SYS_REG_H 32 #include <sys/reg.h> 33 #endif 34 35 #define INSN_SIZE 4 36 37 #define SPARC_R_REGS_NUM 32 38 #define SPARC_F_REGS_NUM 48 39 #define SPARC_CONTROL_REGS_NUM 6 40 41 #define sparc_num_regs \ 42 (SPARC_R_REGS_NUM + SPARC_F_REGS_NUM + SPARC_CONTROL_REGS_NUM) 43 44 /* Linux target op definitions for the SPARC architecture. */ 45 46 class sparc_target : public linux_process_target 47 { 48 public: 49 50 const regs_info *get_regs_info () override; 51 52 const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) override; 53 54 protected: 55 56 void low_arch_setup () override; 57 58 bool low_cannot_fetch_register (int regno) override; 59 60 bool low_cannot_store_register (int regno) override; 61 62 bool low_supports_breakpoints () override; 63 64 CORE_ADDR low_get_pc (regcache *regcache) override; 65 66 /* No low_set_pc is needed. */ 67 68 bool low_breakpoint_at (CORE_ADDR pc) override; 69 }; 70 71 /* The singleton target ops object. */ 72 73 static sparc_target the_sparc_target; 74 75 bool 76 sparc_target::low_supports_breakpoints () 77 { 78 return true; 79 } 80 81 CORE_ADDR 82 sparc_target::low_get_pc (regcache *regcache) 83 { 84 return linux_get_pc_64bit (regcache); 85 } 86 87 /* Each offset is multiplied by 8, because of the register size. 88 These offsets apply to the buffer sent/filled by ptrace. 89 Additionally, the array elements order corresponds to the .dat file, and the 90 gdb's registers enumeration order. */ 91 92 static int sparc_regmap[] = { 93 /* These offsets correspond to GET/SETREGSET. */ 94 -1, 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, /* g0 .. g7 */ 95 7*8, 8*8, 9*8, 10*8, 11*8, 12*8, 13*8, 14*8, /* o0 .. o5, sp, o7 */ 96 -1, -1, -1, -1, -1, -1, -1, -1, /* l0 .. l7 */ 97 -1, -1, -1, -1, -1, -1, -1, -1, /* i0 .. i5, fp, i7 */ 98 99 /* Floating point registers offsets correspond to GET/SETFPREGSET. */ 100 0*4, 1*4, 2*4, 3*4, 4*4, 5*4, 6*4, 7*4, /* f0 .. f7 */ 101 8*4, 9*4, 10*4, 11*4, 12*4, 13*4, 14*4, 15*4, /* f8 .. f15 */ 102 16*4, 17*4, 18*4, 19*4, 20*4, 21*4, 22*4, 23*4, /* f16 .. f23 */ 103 24*4, 25*4, 26*4, 27*4, 28*4, 29*4, 30*4, 31*4, /* f24 .. f31 */ 104 105 /* F32 offset starts next to f31: 31*4+4 = 16 * 8. */ 106 16*8, 17*8, 18*8, 19*8, 20*8, 21*8, 22*8, 23*8, /* f32 .. f46 */ 107 24*8, 25*8, 26*8, 27*8, 28*8, 29*8, 30*8, 31*8, /* f48 .. f62 */ 108 109 17 *8, /* pc */ 110 18 *8, /* npc */ 111 16 *8, /* state */ 112 /* FSR offset also corresponds to GET/SETFPREGSET, ans is placed 113 next to f62. */ 114 32 *8, /* fsr */ 115 -1, /* fprs */ 116 /* Y register is 32-bits length, but gdb takes care of that. */ 117 19 *8, /* y */ 118 119 }; 120 121 122 struct regs_range_t 123 { 124 int regno_start; 125 int regno_end; 126 }; 127 128 static const struct regs_range_t gregs_ranges[] = { 129 { 0, 31 }, /* g0 .. i7 */ 130 { 80, 82 }, /* pc .. state */ 131 { 84, 85 } /* fprs .. y */ 132 }; 133 134 #define N_GREGS_RANGES (sizeof (gregs_ranges) / sizeof (struct regs_range_t)) 135 136 static const struct regs_range_t fpregs_ranges[] = { 137 { 32, 79 }, /* f0 .. f62 */ 138 { 83, 83 } /* fsr */ 139 }; 140 141 #define N_FPREGS_RANGES (sizeof (fpregs_ranges) / sizeof (struct regs_range_t)) 142 143 /* Defined in auto-generated file reg-sparc64.c. */ 144 void init_registers_sparc64 (void); 145 extern const struct target_desc *tdesc_sparc64; 146 147 bool 148 sparc_target::low_cannot_store_register (int regno) 149 { 150 return (regno >= sparc_num_regs || sparc_regmap[regno] == -1); 151 } 152 153 bool 154 sparc_target::low_cannot_fetch_register (int regno) 155 { 156 return (regno >= sparc_num_regs || sparc_regmap[regno] == -1); 157 } 158 159 static void 160 sparc_fill_gregset_to_stack (struct regcache *regcache, const void *buf) 161 { 162 int i; 163 CORE_ADDR addr = 0; 164 unsigned char tmp_reg_buf[8]; 165 const int l0_regno = find_regno (regcache->tdesc, "l0"); 166 const int i7_regno = l0_regno + 15; 167 168 /* These registers have to be stored in the stack. */ 169 memcpy (&addr, 170 ((char *) buf) + sparc_regmap[find_regno (regcache->tdesc, "sp")], 171 sizeof (addr)); 172 173 addr += BIAS; 174 175 for (i = l0_regno; i <= i7_regno; i++) 176 { 177 collect_register (regcache, i, tmp_reg_buf); 178 the_target->write_memory (addr, tmp_reg_buf, sizeof (tmp_reg_buf)); 179 addr += sizeof (tmp_reg_buf); 180 } 181 } 182 183 static void 184 sparc_fill_gregset (struct regcache *regcache, void *buf) 185 { 186 int i; 187 int range; 188 189 for (range = 0; range < N_GREGS_RANGES; range++) 190 for (i = gregs_ranges[range].regno_start; 191 i <= gregs_ranges[range].regno_end; i++) 192 if (sparc_regmap[i] != -1) 193 collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]); 194 195 sparc_fill_gregset_to_stack (regcache, buf); 196 } 197 198 static void 199 sparc_fill_fpregset (struct regcache *regcache, void *buf) 200 { 201 int i; 202 int range; 203 204 for (range = 0; range < N_FPREGS_RANGES; range++) 205 for (i = fpregs_ranges[range].regno_start; 206 i <= fpregs_ranges[range].regno_end; i++) 207 collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]); 208 209 } 210 211 static void 212 sparc_store_gregset_from_stack (struct regcache *regcache, const void *buf) 213 { 214 int i; 215 CORE_ADDR addr = 0; 216 unsigned char tmp_reg_buf[8]; 217 const int l0_regno = find_regno (regcache->tdesc, "l0"); 218 const int i7_regno = l0_regno + 15; 219 220 /* These registers have to be obtained from the stack. */ 221 memcpy (&addr, 222 ((char *) buf) + sparc_regmap[find_regno (regcache->tdesc, "sp")], 223 sizeof (addr)); 224 225 addr += BIAS; 226 227 for (i = l0_regno; i <= i7_regno; i++) 228 { 229 the_target->read_memory (addr, tmp_reg_buf, sizeof (tmp_reg_buf)); 230 supply_register (regcache, i, tmp_reg_buf); 231 addr += sizeof (tmp_reg_buf); 232 } 233 } 234 235 static void 236 sparc_store_gregset (struct regcache *regcache, const void *buf) 237 { 238 int i; 239 char zerobuf[8]; 240 int range; 241 242 memset (zerobuf, 0, sizeof (zerobuf)); 243 244 for (range = 0; range < N_GREGS_RANGES; range++) 245 for (i = gregs_ranges[range].regno_start; 246 i <= gregs_ranges[range].regno_end; i++) 247 if (sparc_regmap[i] != -1) 248 supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]); 249 else 250 supply_register (regcache, i, zerobuf); 251 252 sparc_store_gregset_from_stack (regcache, buf); 253 } 254 255 static void 256 sparc_store_fpregset (struct regcache *regcache, const void *buf) 257 { 258 int i; 259 int range; 260 261 for (range = 0; range < N_FPREGS_RANGES; range++) 262 for (i = fpregs_ranges[range].regno_start; 263 i <= fpregs_ranges[range].regno_end; 264 i++) 265 supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]); 266 } 267 268 static const gdb_byte sparc_breakpoint[INSN_SIZE] = { 269 0x91, 0xd0, 0x20, 0x01 270 }; 271 #define sparc_breakpoint_len INSN_SIZE 272 273 /* Implementation of target ops method "sw_breakpoint_from_kind". */ 274 275 const gdb_byte * 276 sparc_target::sw_breakpoint_from_kind (int kind, int *size) 277 { 278 *size = sparc_breakpoint_len; 279 return sparc_breakpoint; 280 } 281 282 bool 283 sparc_target::low_breakpoint_at (CORE_ADDR where) 284 { 285 unsigned char insn[INSN_SIZE]; 286 287 read_memory (where, (unsigned char *) insn, sizeof (insn)); 288 289 if (memcmp (sparc_breakpoint, insn, sizeof (insn)) == 0) 290 return true; 291 292 /* If necessary, recognize more trap instructions here. GDB only 293 uses TRAP Always. */ 294 295 return false; 296 } 297 298 void 299 sparc_target::low_arch_setup () 300 { 301 current_process ()->tdesc = tdesc_sparc64; 302 } 303 304 static struct regset_info sparc_regsets[] = { 305 { PTRACE_GETREGS, PTRACE_SETREGS, 0, sizeof (elf_gregset_t), 306 GENERAL_REGS, 307 sparc_fill_gregset, sparc_store_gregset }, 308 { PTRACE_GETFPREGS, PTRACE_SETFPREGS, 0, sizeof (fpregset_t), 309 FP_REGS, 310 sparc_fill_fpregset, sparc_store_fpregset }, 311 NULL_REGSET 312 }; 313 314 static struct regsets_info sparc_regsets_info = 315 { 316 sparc_regsets, /* regsets */ 317 0, /* num_regsets */ 318 NULL, /* disabled_regsets */ 319 }; 320 321 static struct usrregs_info sparc_usrregs_info = 322 { 323 sparc_num_regs, 324 /* No regmap needs to be provided since this impl. doesn't use 325 USRREGS. */ 326 NULL 327 }; 328 329 static struct regs_info myregs_info = 330 { 331 NULL, /* regset_bitmap */ 332 &sparc_usrregs_info, 333 &sparc_regsets_info 334 }; 335 336 const regs_info * 337 sparc_target::get_regs_info () 338 { 339 return &myregs_info; 340 } 341 342 /* The linux target ops object. */ 343 344 linux_process_target *the_linux_target = &the_sparc_target; 345 346 void 347 initialize_low_arch (void) 348 { 349 /* Initialize the Linux target descriptions. */ 350 init_registers_sparc64 (); 351 352 initialize_regsets_info (&sparc_regsets_info); 353 } 354