1 /* Functions specific to running gdb native on an ns32k running NetBSD 2 3 Copyright 1989, 1992, 1993, 1994, 1996, 1998, 1999, 2000, 2001, 4 2004 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23 #include <sys/types.h> 24 #include <sys/ptrace.h> 25 #include <machine/reg.h> 26 #include <machine/frame.h> 27 #include <machine/pcb.h> 28 29 #include "defs.h" 30 #include "inferior.h" 31 #include "target.h" 32 #include "gdbcore.h" 33 #include "regcache.h" 34 35 #define RF(dst, src) \ 36 memcpy(&deprecated_registers[DEPRECATED_REGISTER_BYTE(dst)], &src, sizeof(src)) 37 38 #define RS(src, dst) \ 39 memcpy(&dst, &deprecated_registers[DEPRECATED_REGISTER_BYTE(src)], sizeof(dst)) 40 41 void 42 fetch_inferior_registers (int regno) 43 { 44 struct reg inferior_registers; 45 struct fpreg inferior_fpregisters; 46 47 ptrace (PT_GETREGS, PIDGET (inferior_ptid), 48 (PTRACE_TYPE_ARG3) & inferior_registers, 0); 49 ptrace (PT_GETFPREGS, PIDGET (inferior_ptid), 50 (PTRACE_TYPE_ARG3) & inferior_fpregisters, 0); 51 52 RF (R0_REGNUM + 0, inferior_registers.r_r0); 53 RF (R0_REGNUM + 1, inferior_registers.r_r1); 54 RF (R0_REGNUM + 2, inferior_registers.r_r2); 55 RF (R0_REGNUM + 3, inferior_registers.r_r3); 56 RF (R0_REGNUM + 4, inferior_registers.r_r4); 57 RF (R0_REGNUM + 5, inferior_registers.r_r5); 58 RF (R0_REGNUM + 6, inferior_registers.r_r6); 59 RF (R0_REGNUM + 7, inferior_registers.r_r7); 60 61 RF (SP_REGNUM, inferior_registers.r_sp); 62 RF (DEPRECATED_FP_REGNUM, inferior_registers.r_fp); 63 RF (PC_REGNUM, inferior_registers.r_pc); 64 RF (PS_REGNUM, inferior_registers.r_psr); 65 66 RF (FPS_REGNUM, inferior_fpregisters.r_fsr); 67 RF (FP0_REGNUM + 0, inferior_fpregisters.r_freg[0]); 68 RF (FP0_REGNUM + 2, inferior_fpregisters.r_freg[2]); 69 RF (FP0_REGNUM + 4, inferior_fpregisters.r_freg[4]); 70 RF (FP0_REGNUM + 6, inferior_fpregisters.r_freg[6]); 71 RF (LP0_REGNUM + 1, inferior_fpregisters.r_freg[1]); 72 RF (LP0_REGNUM + 3, inferior_fpregisters.r_freg[3]); 73 RF (LP0_REGNUM + 5, inferior_fpregisters.r_freg[5]); 74 RF (LP0_REGNUM + 7, inferior_fpregisters.r_freg[7]); 75 deprecated_registers_fetched (); 76 } 77 78 void 79 store_inferior_registers (int regno) 80 { 81 struct reg inferior_registers; 82 struct fpreg inferior_fpregisters; 83 84 RS (R0_REGNUM + 0, inferior_registers.r_r0); 85 RS (R0_REGNUM + 1, inferior_registers.r_r1); 86 RS (R0_REGNUM + 2, inferior_registers.r_r2); 87 RS (R0_REGNUM + 3, inferior_registers.r_r3); 88 RS (R0_REGNUM + 4, inferior_registers.r_r4); 89 RS (R0_REGNUM + 5, inferior_registers.r_r5); 90 RS (R0_REGNUM + 6, inferior_registers.r_r6); 91 RS (R0_REGNUM + 7, inferior_registers.r_r7); 92 93 RS (SP_REGNUM, inferior_registers.r_sp); 94 RS (DEPRECATED_FP_REGNUM, inferior_registers.r_fp); 95 RS (PC_REGNUM, inferior_registers.r_pc); 96 RS (PS_REGNUM, inferior_registers.r_psr); 97 98 RS (FPS_REGNUM, inferior_fpregisters.r_fsr); 99 RS (FP0_REGNUM + 0, inferior_fpregisters.r_freg[0]); 100 RS (FP0_REGNUM + 2, inferior_fpregisters.r_freg[2]); 101 RS (FP0_REGNUM + 4, inferior_fpregisters.r_freg[4]); 102 RS (FP0_REGNUM + 6, inferior_fpregisters.r_freg[6]); 103 RS (LP0_REGNUM + 1, inferior_fpregisters.r_freg[1]); 104 RS (LP0_REGNUM + 3, inferior_fpregisters.r_freg[3]); 105 RS (LP0_REGNUM + 5, inferior_fpregisters.r_freg[5]); 106 RS (LP0_REGNUM + 7, inferior_fpregisters.r_freg[7]); 107 108 ptrace (PT_SETREGS, PIDGET (inferior_ptid), 109 (PTRACE_TYPE_ARG3) & inferior_registers, 0); 110 ptrace (PT_SETFPREGS, PIDGET (inferior_ptid), 111 (PTRACE_TYPE_ARG3) & inferior_fpregisters, 0); 112 } 113 114 115 /* XXX - Add this to machine/regs.h instead? */ 116 struct coreregs 117 { 118 struct reg intreg; 119 struct fpreg freg; 120 }; 121 122 /* Get registers from a core file. REG_ADDR is unused. */ 123 static void 124 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which, 125 unsigned int reg_addr) 126 { 127 struct coreregs *core_reg; 128 129 core_reg = (struct coreregs *) core_reg_sect; 130 131 /* 132 * We have *all* registers 133 * in the first core section. 134 * Ignore which. 135 */ 136 137 if (core_reg_size < sizeof (*core_reg)) 138 { 139 fprintf_unfiltered (gdb_stderr, "Couldn't read regs from core file\n"); 140 return; 141 } 142 143 /* Integer registers */ 144 RF (R0_REGNUM + 0, core_reg->intreg.r_r0); 145 RF (R0_REGNUM + 1, core_reg->intreg.r_r1); 146 RF (R0_REGNUM + 2, core_reg->intreg.r_r2); 147 RF (R0_REGNUM + 3, core_reg->intreg.r_r3); 148 RF (R0_REGNUM + 4, core_reg->intreg.r_r4); 149 RF (R0_REGNUM + 5, core_reg->intreg.r_r5); 150 RF (R0_REGNUM + 6, core_reg->intreg.r_r6); 151 RF (R0_REGNUM + 7, core_reg->intreg.r_r7); 152 153 RF (SP_REGNUM, core_reg->intreg.r_sp); 154 RF (DEPRECATED_FP_REGNUM, core_reg->intreg.r_fp); 155 RF (PC_REGNUM, core_reg->intreg.r_pc); 156 RF (PS_REGNUM, core_reg->intreg.r_psr); 157 158 /* Floating point registers */ 159 RF (FPS_REGNUM, core_reg->freg.r_fsr); 160 RF (FP0_REGNUM + 0, core_reg->freg.r_freg[0]); 161 RF (FP0_REGNUM + 2, core_reg->freg.r_freg[2]); 162 RF (FP0_REGNUM + 4, core_reg->freg.r_freg[4]); 163 RF (FP0_REGNUM + 6, core_reg->freg.r_freg[6]); 164 RF (LP0_REGNUM + 1, core_reg->freg.r_freg[1]); 165 RF (LP0_REGNUM + 3, core_reg->freg.r_freg[3]); 166 RF (LP0_REGNUM + 5, core_reg->freg.r_freg[5]); 167 RF (LP0_REGNUM + 7, core_reg->freg.r_freg[7]); 168 deprecated_registers_fetched (); 169 } 170 171 /* Register that we are able to handle ns32knbsd core file formats. 172 FIXME: is this really bfd_target_unknown_flavour? */ 173 174 static struct core_fns nat_core_fns = 175 { 176 bfd_target_unknown_flavour, /* core_flavour */ 177 default_check_format, /* check_format */ 178 default_core_sniffer, /* core_sniffer */ 179 fetch_core_registers, /* core_read_registers */ 180 NULL /* next */ 181 }; 182 183 void 184 _initialize_ns32knbsd_nat (void) 185 { 186 deprecated_add_core_fns (&nat_core_fns); 187 } 188 189 190 /* 191 * kernel_u_size() is not helpful on NetBSD because 192 * the "u" struct is NOT in the core dump file. 193 */ 194 195 #ifdef FETCH_KCORE_REGISTERS 196 /* 197 * Get registers from a kernel crash dump or live kernel. 198 * Called by kcore-nbsd.c:get_kcore_registers(). 199 */ 200 void 201 fetch_kcore_registers (struct pcb *pcb) 202 { 203 struct switchframe sf; 204 struct reg intreg; 205 int dummy; 206 207 /* Integer registers */ 208 if (target_read_memory ((CORE_ADDR) pcb->pcb_ksp, (char *) &sf, sizeof sf)) 209 error ("Cannot read integer registers."); 210 211 /* We use the psr at kernel entry */ 212 if (target_read_memory ((CORE_ADDR) pcb->pcb_onstack, (char *) &intreg, sizeof intreg)) 213 error ("Cannot read processor status register."); 214 215 dummy = 0; 216 RF (R0_REGNUM + 0, dummy); 217 RF (R0_REGNUM + 1, dummy); 218 RF (R0_REGNUM + 2, dummy); 219 RF (R0_REGNUM + 3, sf.sf_r3); 220 RF (R0_REGNUM + 4, sf.sf_r4); 221 RF (R0_REGNUM + 5, sf.sf_r5); 222 RF (R0_REGNUM + 6, sf.sf_r6); 223 RF (R0_REGNUM + 7, sf.sf_r7); 224 225 dummy = pcb->pcb_kfp + 8; 226 RF (SP_REGNUM, dummy); 227 RF (DEPRECATED_FP_REGNUM, sf.sf_fp); 228 RF (PC_REGNUM, sf.sf_pc); 229 RF (PS_REGNUM, intreg.r_psr); 230 231 /* Floating point registers */ 232 RF (FPS_REGNUM, pcb->pcb_fsr); 233 RF (FP0_REGNUM + 0, pcb->pcb_freg[0]); 234 RF (FP0_REGNUM + 2, pcb->pcb_freg[2]); 235 RF (FP0_REGNUM + 4, pcb->pcb_freg[4]); 236 RF (FP0_REGNUM + 6, pcb->pcb_freg[6]); 237 RF (LP0_REGNUM + 1, pcb->pcb_freg[1]); 238 RF (LP0_REGNUM + 3, pcb->pcb_freg[3]); 239 RF (LP0_REGNUM + 5, pcb->pcb_freg[5]); 240 RF (LP0_REGNUM + 7, pcb->pcb_freg[7]); 241 deprecated_registers_fetched (); 242 } 243 #endif /* FETCH_KCORE_REGISTERS */ 244 245 void 246 clear_regs (void) 247 { 248 double zero = 0.0; 249 int null = 0; 250 251 /* Integer registers */ 252 RF (R0_REGNUM + 0, null); 253 RF (R0_REGNUM + 1, null); 254 RF (R0_REGNUM + 2, null); 255 RF (R0_REGNUM + 3, null); 256 RF (R0_REGNUM + 4, null); 257 RF (R0_REGNUM + 5, null); 258 RF (R0_REGNUM + 6, null); 259 RF (R0_REGNUM + 7, null); 260 261 RF (SP_REGNUM, null); 262 RF (DEPRECATED_FP_REGNUM, null); 263 RF (PC_REGNUM, null); 264 RF (PS_REGNUM, null); 265 266 /* Floating point registers */ 267 RF (FPS_REGNUM, zero); 268 RF (FP0_REGNUM + 0, zero); 269 RF (FP0_REGNUM + 2, zero); 270 RF (FP0_REGNUM + 4, zero); 271 RF (FP0_REGNUM + 6, zero); 272 RF (LP0_REGNUM + 0, zero); 273 RF (LP0_REGNUM + 1, zero); 274 RF (LP0_REGNUM + 2, zero); 275 RF (LP0_REGNUM + 3, zero); 276 return; 277 } 278 279 /* Return number of args passed to a frame. 280 Can return -1, meaning no way to tell. */ 281 282 int 283 frame_num_args (struct frame_info *fi) 284 { 285 CORE_ADDR enter_addr; 286 CORE_ADDR argp; 287 int inst; 288 int args; 289 int i; 290 291 if (read_memory_integer (fi->frame, 4) == 0 && fi->pc < 0x10000) 292 { 293 /* main is always called with three args */ 294 return (3); 295 } 296 enter_addr = ns32k_get_enter_addr (fi->pc); 297 if (enter_addr = 0) 298 return (-1); 299 argp = (enter_addr == 1 300 ? DEPRECATED_SAVED_PC_AFTER_CALL (fi) 301 : DEPRECATED_FRAME_SAVED_PC (fi)); 302 for (i = 0; i < 16; i++) 303 { 304 /* 305 * After a bsr gcc may emit the following instructions 306 * to remove the arguments from the stack: 307 * cmpqd 0,tos - to remove 4 bytes from the stack 308 * cmpd tos,tos - to remove 8 bytes from the stack 309 * adjsp[bwd] -n - to remove n bytes from the stack 310 * Gcc sometimes delays emitting these instructions and 311 * may even throw a branch between our feet. 312 */ 313 inst = read_memory_integer (argp, 4); 314 args = read_memory_integer (argp + 2, 4); 315 if ((inst & 0xff) == 0xea) 316 { /* br */ 317 args = ((inst >> 8) & 0xffffff) | (args << 24); 318 if (args & 0x80) 319 { 320 if (args & 0x40) 321 { 322 args = ntohl (args); 323 } 324 else 325 { 326 args = ntohs (args & 0xffff); 327 if (args & 0x2000) 328 args |= 0xc000; 329 } 330 } 331 else 332 { 333 args = args & 0xff; 334 if (args & 0x40) 335 args |= 0x80; 336 } 337 argp += args; 338 continue; 339 } 340 if ((inst & 0xffff) == 0xb81f) /* cmpqd 0,tos */ 341 return (1); 342 else if ((inst & 0xffff) == 0xbdc7) /* cmpd tos,tos */ 343 return (2); 344 else if ((inst & 0xfffc) == 0xa57c) 345 { /* adjsp[bwd] */ 346 switch (inst & 3) 347 { 348 case 0: 349 args = ((args & 0xff) + 0x80); 350 break; 351 case 1: 352 args = ((ntohs (args) & 0xffff) + 0x8000); 353 break; 354 case 3: 355 args = -ntohl (args); 356 break; 357 default: 358 return (-1); 359 } 360 if (args / 4 > 10 || (args & 3) != 0) 361 continue; 362 return (args / 4); 363 } 364 argp += 1; 365 } 366 return (-1); 367 } 368