1/* Target-dependent code for NetBSD/mips. 2 3 Copyright (C) 2002, 2003, 2004, 2006, 2007 Free Software Foundation, Inc. 4 5 Contributed by Wasabi Systems, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22#include "defs.h" 23#include "gdbcore.h" 24#include "regcache.h" 25#include "regset.h" 26#include "target.h" 27#include "value.h" 28#include "osabi.h" 29 30#include "gdb_assert.h" 31#include "gdb_string.h" 32 33#include "nbsd-tdep.h" 34#include "mipsnbsd-tdep.h" 35#include "mips-tdep.h" 36 37#include "solib-svr4.h" 38 39/* Shorthand for some register numbers used below. */ 40#define MIPS_PC_REGNUM MIPS_EMBED_PC_REGNUM 41#define MIPS_FP0_REGNUM MIPS_EMBED_FP0_REGNUM 42#define MIPS_FSR_REGNUM MIPS_EMBED_FP0_REGNUM + 32 43 44/* Core file support. */ 45 46/* Number of registers in `struct reg' from <machine/reg.h>. */ 47#define MIPSNBSD_NUM_GREGS 38 48 49/* Number of registers in `struct fpreg' from <machine/reg.h>. */ 50#define MIPSNBSD_NUM_FPREGS 33 51 52/* Supply register REGNUM from the buffer specified by FPREGS and LEN 53 in the floating-point register set REGSET to register cache 54 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ 55 56static void 57mipsnbsd_supply_fpregset (const struct regset *regset, 58 struct regcache *regcache, 59 int regnum, const void *fpregs, size_t len) 60{ 61 size_t regsize = mips_isa_regsize (get_regcache_arch (regcache)); 62 const char *regs = fpregs; 63 int i; 64 65 gdb_assert (len >= MIPSNBSD_NUM_FPREGS * regsize); 66 67 for (i = MIPS_FP0_REGNUM; i <= MIPS_FSR_REGNUM; i++) 68 { 69 if (regnum == i || regnum == -1) 70 regcache_raw_supply (regcache, i, 71 regs + (i - MIPS_FP0_REGNUM) * regsize); 72 } 73} 74 75/* Supply register REGNUM from the buffer specified by GREGS and LEN 76 in the general-purpose register set REGSET to register cache 77 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ 78 79static void 80mipsnbsd_supply_gregset (const struct regset *regset, 81 struct regcache *regcache, int regnum, 82 const void *gregs, size_t len) 83{ 84 size_t regsize = mips_isa_regsize (get_regcache_arch (regcache)); 85 const char *regs = gregs; 86 int i; 87 88 gdb_assert (len >= MIPSNBSD_NUM_GREGS * regsize); 89 90 for (i = 0; i <= MIPS_PC_REGNUM; i++) 91 { 92 if (regnum == i || regnum == -1) 93 regcache_raw_supply (regcache, i, regs + i * regsize); 94 } 95 96 if (len >= (MIPSNBSD_NUM_GREGS + MIPSNBSD_NUM_FPREGS) * regsize) 97 { 98 regs += MIPSNBSD_NUM_GREGS * regsize; 99 len -= MIPSNBSD_NUM_GREGS * regsize; 100 mipsnbsd_supply_fpregset (regset, regcache, regnum, regs, len); 101 } 102} 103 104/* NetBSD/mips register sets. */ 105 106static struct regset mipsnbsd_gregset = 107{ 108 NULL, 109 mipsnbsd_supply_gregset 110}; 111 112static struct regset mipsnbsd_fpregset = 113{ 114 NULL, 115 mipsnbsd_supply_fpregset 116}; 117 118/* Return the appropriate register set for the core section identified 119 by SECT_NAME and SECT_SIZE. */ 120 121static const struct regset * 122mipsnbsd_regset_from_core_section (struct gdbarch *gdbarch, 123 const char *sect_name, size_t sect_size) 124{ 125 size_t regsize = mips_isa_regsize (gdbarch); 126 127 if (strcmp (sect_name, ".reg") == 0 128 && sect_size >= MIPSNBSD_NUM_GREGS * regsize) 129 return &mipsnbsd_gregset; 130 131 if (strcmp (sect_name, ".reg2") == 0 132 && sect_size >= MIPSNBSD_NUM_FPREGS * regsize) 133 return &mipsnbsd_fpregset; 134 135 return NULL; 136} 137 138 139/* Conveniently, GDB uses the same register numbering as the 140 ptrace register structure used by NetBSD/mips. */ 141 142void 143mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno) 144{ 145 int i; 146 147 for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++) 148 { 149 if (regno == i || regno == -1) 150 { 151 if (gdbarch_cannot_fetch_register (current_gdbarch, i)) 152 regcache_raw_supply (regcache, i, NULL); 153 else 154 regcache_raw_supply (regcache, i, 155 regs + (i * mips_isa_regsize (current_gdbarch))); 156 } 157 } 158} 159 160void 161mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno) 162{ 163 int i; 164 165 for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++) 166 if ((regno == i || regno == -1) 167 && ! gdbarch_cannot_store_register (current_gdbarch, i)) 168 regcache_raw_collect (regcache, i, 169 regs + (i * mips_isa_regsize (current_gdbarch))); 170} 171 172void 173mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno) 174{ 175 int i; 176 177 for (i = gdbarch_fp0_regnum (current_gdbarch); 178 i <= mips_regnum (current_gdbarch)->fp_implementation_revision; 179 i++) 180 { 181 if (regno == i || regno == -1) 182 { 183 if (gdbarch_cannot_fetch_register (current_gdbarch, i)) 184 regcache_raw_supply (regcache, i, NULL); 185 else 186 regcache_raw_supply (regcache, i, 187 fpregs 188 + ((i - gdbarch_fp0_regnum (current_gdbarch)) 189 * mips_isa_regsize (current_gdbarch))); 190 } 191 } 192} 193 194void 195mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno) 196{ 197 int i; 198 199 for (i = gdbarch_fp0_regnum (current_gdbarch); 200 i <= mips_regnum (current_gdbarch)->fp_control_status; 201 i++) 202 if ((regno == i || regno == -1) 203 && ! gdbarch_cannot_store_register (current_gdbarch, i)) 204 regcache_raw_collect (regcache, i, 205 fpregs + ((i - gdbarch_fp0_regnum 206 (current_gdbarch)) 207 * mips_isa_regsize (current_gdbarch))); 208} 209 210/* Under NetBSD/mips, signal handler invocations can be identified by the 211 designated code sequence that is used to return from a signal handler. 212 In particular, the return address of a signal handler points to the 213 following code sequence: 214 215 addu a0, sp, 16 216 li v0, 295 # __sigreturn14 217 syscall 218 219 Each instruction has a unique encoding, so we simply attempt to match 220 the instruction the PC is pointing to with any of the above instructions. 221 If there is a hit, we know the offset to the start of the designated 222 sequence and can then check whether we really are executing in the 223 signal trampoline. If not, -1 is returned, otherwise the offset from the 224 start of the return sequence is returned. */ 225 226#define RETCODE_NWORDS 3 227#define RETCODE_SIZE (RETCODE_NWORDS * 4) 228 229static const unsigned char sigtramp_retcode_mipsel[RETCODE_SIZE] = 230{ 231 0x10, 0x00, 0xa4, 0x27, /* addu a0, sp, 16 */ 232 0x27, 0x01, 0x02, 0x24, /* li v0, 295 */ 233 0x0c, 0x00, 0x00, 0x00, /* syscall */ 234}; 235 236static const unsigned char sigtramp_retcode_mipseb[RETCODE_SIZE] = 237{ 238 0x27, 0xa4, 0x00, 0x10, /* addu a0, sp, 16 */ 239 0x24, 0x02, 0x01, 0x27, /* li v0, 295 */ 240 0x00, 0x00, 0x00, 0x0c, /* syscall */ 241}; 242 243static LONGEST 244mipsnbsd_sigtramp_offset (struct frame_info *next_frame) 245{ 246 CORE_ADDR pc = frame_pc_unwind (next_frame); 247 const char *retcode = gdbarch_byte_order (current_gdbarch) 248 == BFD_ENDIAN_BIG ? sigtramp_retcode_mipseb : 249 sigtramp_retcode_mipsel; 250 unsigned char ret[RETCODE_SIZE], w[4]; 251 LONGEST off; 252 int i; 253 254 if (!safe_frame_unwind_memory (next_frame, pc, w, sizeof (w))) 255 return -1; 256 257 for (i = 0; i < RETCODE_NWORDS; i++) 258 { 259 if (memcmp (w, retcode + (i * 4), 4) == 0) 260 break; 261 } 262 if (i == RETCODE_NWORDS) 263 return -1; 264 265 off = i * 4; 266 pc -= off; 267 268 if (!safe_frame_unwind_memory (next_frame, pc, ret, sizeof (ret))) 269 return -1; 270 271 if (memcmp (ret, retcode, RETCODE_SIZE) == 0) 272 return off; 273 274 return -1; 275} 276 277/* Figure out where the longjmp will land. We expect that we have 278 just entered longjmp and haven't yet setup the stack frame, so the 279 args are still in the argument regs. MIPS_A0_REGNUM points at the 280 jmp_buf structure from which we extract the PC that we will land 281 at. The PC is copied into *pc. This routine returns true on 282 success. */ 283 284#define NBSD_MIPS_JB_PC (2 * 4) 285#define NBSD_MIPS_JB_ELEMENT_SIZE mips_isa_regsize (current_gdbarch) 286#define NBSD_MIPS_JB_OFFSET (NBSD_MIPS_JB_PC * \ 287 NBSD_MIPS_JB_ELEMENT_SIZE) 288 289static int 290mipsnbsd_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) 291{ 292 CORE_ADDR jb_addr; 293 char *buf; 294 295 buf = alloca (NBSD_MIPS_JB_ELEMENT_SIZE); 296 297 jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM); 298 299 if (target_read_memory (jb_addr + NBSD_MIPS_JB_OFFSET, buf, 300 NBSD_MIPS_JB_ELEMENT_SIZE)) 301 return 0; 302 303 *pc = extract_unsigned_integer (buf, NBSD_MIPS_JB_ELEMENT_SIZE); 304 305 return 1; 306} 307 308static int 309mipsnbsd_cannot_fetch_register (int regno) 310{ 311 return (regno == MIPS_ZERO_REGNUM 312 || regno == mips_regnum (current_gdbarch)->fp_implementation_revision); 313} 314 315static int 316mipsnbsd_cannot_store_register (int regno) 317{ 318 return (regno == MIPS_ZERO_REGNUM 319 || regno == mips_regnum (current_gdbarch)->fp_implementation_revision); 320} 321 322/* Shared library support. */ 323 324/* NetBSD/mips uses a slightly different `struct link_map' than the 325 other NetBSD platforms. */ 326 327static struct link_map_offsets * 328mipsnbsd_ilp32_fetch_link_map_offsets (void) 329{ 330 static struct link_map_offsets lmo; 331 static struct link_map_offsets *lmp = NULL; 332 333 if (lmp == NULL) 334 { 335 lmp = &lmo; 336 337 lmo.r_version_offset = 0; 338 lmo.r_version_size = 4; 339 lmo.r_map_offset = 4; 340 lmo.r_ldsomap_offset = -1; 341 342 /* Everything we need is in the first 24 bytes. */ 343 lmo.link_map_size = 24; 344 lmo.l_addr_offset = 4; 345 lmo.l_name_offset = 8; 346 lmo.l_ld_offset = 12; 347 lmo.l_next_offset = 16; 348 lmo.l_prev_offset = 20; 349 } 350 351 return lmp; 352} 353 354static struct link_map_offsets * 355mipsnbsd_lp64_fetch_link_map_offsets (void) 356{ 357 static struct link_map_offsets lmo; 358 static struct link_map_offsets *lmp = NULL; 359 360 if (lmp == NULL) 361 { 362 lmp = &lmo; 363 364 lmo.r_version_offset = 0; 365 lmo.r_version_size = 4; 366 lmo.r_map_offset = 8; 367 lmo.r_ldsomap_offset = -1; 368 369 /* Everything we need is in the first 40 bytes. */ 370 lmo.link_map_size = 48; 371 lmo.l_addr_offset = 0; 372 lmo.l_name_offset = 16; 373 lmo.l_ld_offset = 24; 374 lmo.l_next_offset = 32; 375 lmo.l_prev_offset = 40; 376 } 377 378 return lmp; 379} 380 381 382static void 383mipsnbsd_init_abi (struct gdbarch_info info, 384 struct gdbarch *gdbarch) 385{ 386 set_gdbarch_regset_from_core_section 387 (gdbarch, mipsnbsd_regset_from_core_section); 388 389 set_gdbarch_get_longjmp_target (gdbarch, mipsnbsd_get_longjmp_target); 390 391 set_gdbarch_cannot_fetch_register (gdbarch, mipsnbsd_cannot_fetch_register); 392 set_gdbarch_cannot_store_register (gdbarch, mipsnbsd_cannot_store_register); 393 394 set_gdbarch_software_single_step (gdbarch, mips_software_single_step); 395 396 /* NetBSD/mips has SVR4-style shared libraries. */ 397 set_solib_svr4_fetch_link_map_offsets 398 (gdbarch, (gdbarch_ptr_bit (gdbarch) == 32 ? 399 mipsnbsd_ilp32_fetch_link_map_offsets : 400 mipsnbsd_lp64_fetch_link_map_offsets)); 401} 402 403 404static enum gdb_osabi 405mipsnbsd_core_osabi_sniffer (bfd *abfd) 406{ 407 if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0) 408 return GDB_OSABI_NETBSD_ELF; 409 410 return GDB_OSABI_UNKNOWN; 411} 412 413void 414_initialize_mipsnbsd_tdep (void) 415{ 416 gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_NETBSD_ELF, 417 mipsnbsd_init_abi); 418} 419