1 /* Target dependent code for the Motorola 68000 series. 2 Copyright (C) 1990, 1992 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 2 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, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 19 20 #include "defs.h" 21 #include "frame.h" 22 #include "symtab.h" 23 #include "gdbcore.h" 24 #include "value.h" 25 #include "gdb_string.h" 26 27 28 /* Push an empty stack frame, to record the current PC, etc. */ 29 30 void 31 m68k_push_dummy_frame () 32 { 33 register CORE_ADDR sp = read_register (SP_REGNUM); 34 register int regnum; 35 char raw_buffer[12]; 36 37 sp = push_word (sp, read_register (PC_REGNUM)); 38 sp = push_word (sp, read_register (FP_REGNUM)); 39 write_register (FP_REGNUM, sp); 40 41 /* Always save the floating-point registers, whether they exist on 42 this target or not. */ 43 for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) 44 { 45 read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); 46 sp = push_bytes (sp, raw_buffer, 12); 47 } 48 49 for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) 50 { 51 sp = push_word (sp, read_register (regnum)); 52 } 53 sp = push_word (sp, read_register (PS_REGNUM)); 54 write_register (SP_REGNUM, sp); 55 } 56 57 /* Discard from the stack the innermost frame, 58 restoring all saved registers. */ 59 60 void 61 m68k_pop_frame () 62 { 63 register struct frame_info *frame = get_current_frame (); 64 register CORE_ADDR fp; 65 register int regnum; 66 struct frame_saved_regs fsr; 67 char raw_buffer[12]; 68 69 fp = FRAME_FP (frame); 70 get_frame_saved_regs (frame, &fsr); 71 for (regnum = FP0_REGNUM + 7 ; regnum >= FP0_REGNUM ; regnum--) 72 { 73 if (fsr.regs[regnum]) 74 { 75 read_memory (fsr.regs[regnum], raw_buffer, 12); 76 write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); 77 } 78 } 79 for (regnum = FP_REGNUM - 1 ; regnum >= 0 ; regnum--) 80 { 81 if (fsr.regs[regnum]) 82 { 83 write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); 84 } 85 } 86 if (fsr.regs[PS_REGNUM]) 87 { 88 write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); 89 } 90 write_register (FP_REGNUM, read_memory_integer (fp, 4)); 91 write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); 92 write_register (SP_REGNUM, fp + 8); 93 flush_cached_frames (); 94 } 95 96 97 /* Given an ip value corresponding to the start of a function, 98 return the ip of the first instruction after the function 99 prologue. This is the generic m68k support. Machines which 100 require something different can override the SKIP_PROLOGUE 101 macro to point elsewhere. 102 103 Some instructions which typically may appear in a function 104 prologue include: 105 106 A link instruction, word form: 107 108 link.w %a6,&0 4e56 XXXX 109 110 A link instruction, long form: 111 112 link.l %fp,&F%1 480e XXXX XXXX 113 114 A movm instruction to preserve integer regs: 115 116 movm.l &M%1,(4,%sp) 48ef XXXX XXXX 117 118 A fmovm instruction to preserve float regs: 119 120 fmovm &FPM%1,(FPO%1,%sp) f237 XXXX XXXX XXXX XXXX 121 122 Some profiling setup code (FIXME, not recognized yet): 123 124 lea.l (.L3,%pc),%a1 43fb XXXX XXXX XXXX 125 bsr _mcount 61ff XXXX XXXX 126 127 */ 128 129 #define P_LINK_L 0x480e 130 #define P_LINK_W 0x4e56 131 #define P_MOV_L 0x207c 132 #define P_JSR 0x4eb9 133 #define P_BSR 0x61ff 134 #define P_LEA_L 0x43fb 135 #define P_MOVM_L 0x48ef 136 #define P_FMOVM 0xf237 137 #define P_TRAP 0x4e40 138 139 CORE_ADDR 140 m68k_skip_prologue (ip) 141 CORE_ADDR ip; 142 { 143 register CORE_ADDR limit; 144 struct symtab_and_line sal; 145 register int op; 146 147 /* Find out if there is a known limit for the extent of the prologue. 148 If so, ensure we don't go past it. If not, assume "infinity". */ 149 150 sal = find_pc_line (ip, 0); 151 limit = (sal.end) ? sal.end : (CORE_ADDR) ~0; 152 153 while (ip < limit) 154 { 155 op = read_memory_integer (ip, 2); 156 op &= 0xFFFF; 157 158 if (op == P_LINK_W) 159 { 160 ip += 4; /* Skip link.w */ 161 } 162 else if (op == 0x4856) 163 ip += 2; /* Skip pea %fp */ 164 else if (op == 0x2c4f) 165 ip += 2; /* Skip move.l %sp, %fp */ 166 else if (op == P_LINK_L) 167 { 168 ip += 6; /* Skip link.l */ 169 } 170 else if (op == P_MOVM_L) 171 { 172 ip += 6; /* Skip movm.l */ 173 } 174 else if (op == P_FMOVM) 175 { 176 ip += 10; /* Skip fmovm */ 177 } 178 else 179 { 180 break; /* Found unknown code, bail out. */ 181 } 182 } 183 return (ip); 184 } 185 186 void 187 m68k_find_saved_regs (frame_info, saved_regs) 188 struct frame_info *frame_info; 189 struct frame_saved_regs *saved_regs; 190 { 191 register int regnum; 192 register int regmask; 193 register CORE_ADDR next_addr; 194 register CORE_ADDR pc; 195 196 /* First possible address for a pc in a call dummy for this frame. */ 197 CORE_ADDR possible_call_dummy_start = 198 (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 4 - 8*12; 199 200 int nextinsn; 201 memset (saved_regs, 0, sizeof (*saved_regs)); 202 if ((frame_info)->pc >= possible_call_dummy_start 203 && (frame_info)->pc <= (frame_info)->frame) 204 { 205 206 /* It is a call dummy. We could just stop now, since we know 207 what the call dummy saves and where. But this code proceeds 208 to parse the "prologue" which is part of the call dummy. 209 This is needlessly complex and confusing. FIXME. */ 210 211 next_addr = (frame_info)->frame; 212 pc = possible_call_dummy_start; 213 } 214 else 215 { 216 pc = get_pc_function_start ((frame_info)->pc); 217 218 if (0x4856 == read_memory_integer (pc, 2) 219 && 0x2c4f == read_memory_integer (pc + 2, 2)) 220 { 221 /* 222 pea %fp 223 move.l %sp, %fp */ 224 225 pc += 4; 226 next_addr = frame_info->frame; 227 } 228 else if (044016 == read_memory_integer (pc, 2)) 229 /* link.l %fp */ 230 /* Find the address above the saved 231 regs using the amount of storage from the link instruction. */ 232 next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 4), pc+=4; 233 else if (047126 == read_memory_integer (pc, 2)) 234 /* link.w %fp */ 235 /* Find the address above the saved 236 regs using the amount of storage from the link instruction. */ 237 next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 2), pc+=2; 238 else goto lose; 239 240 /* If have an addal #-n, sp next, adjust next_addr. */ 241 if ((0177777 & read_memory_integer (pc, 2)) == 0157774) 242 next_addr += read_memory_integer (pc += 2, 4), pc += 4; 243 } 244 regmask = read_memory_integer (pc + 2, 2); 245 246 /* Here can come an fmovem. Check for it. */ 247 nextinsn = 0xffff & read_memory_integer (pc, 2); 248 if (0xf227 == nextinsn 249 && (regmask & 0xff00) == 0xe000) 250 { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */ 251 for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) 252 if (regmask & 1) 253 saved_regs->regs[regnum] = (next_addr -= 12); 254 regmask = read_memory_integer (pc + 2, 2); } 255 256 /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */ 257 if (0044327 == read_memory_integer (pc, 2)) 258 { pc += 4; /* Regmask's low bit is for register 0, the first written */ 259 for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) 260 if (regmask & 1) 261 saved_regs->regs[regnum] = (next_addr += 4) - 4; } 262 else if (0044347 == read_memory_integer (pc, 2)) 263 { 264 pc += 4; /* Regmask's low bit is for register 15, the first pushed */ 265 for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) 266 if (regmask & 1) 267 saved_regs->regs[regnum] = (next_addr -= 4); 268 } 269 else if (0x2f00 == (0xfff0 & read_memory_integer (pc, 2))) 270 { 271 regnum = 0xf & read_memory_integer (pc, 2); pc += 2; 272 saved_regs->regs[regnum] = (next_addr -= 4); 273 /* gcc, at least, may use a pair of movel instructions when saving 274 exactly 2 registers. */ 275 if (0x2f00 == (0xfff0 & read_memory_integer (pc, 2))) 276 { 277 regnum = 0xf & read_memory_integer (pc, 2); 278 pc += 2; 279 saved_regs->regs[regnum] = (next_addr -= 4); 280 } 281 } 282 283 /* fmovemx to index of sp may follow. */ 284 regmask = read_memory_integer (pc + 2, 2); 285 nextinsn = 0xffff & read_memory_integer (pc, 2); 286 if (0xf236 == nextinsn 287 && (regmask & 0xff00) == 0xf000) 288 { pc += 10; /* Regmask's low bit is for register fp0, the first written */ 289 for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) 290 if (regmask & 1) 291 saved_regs->regs[regnum] = (next_addr += 12) - 12; 292 regmask = read_memory_integer (pc + 2, 2); } 293 294 /* clrw -(sp); movw ccr,-(sp) may follow. */ 295 if (0x426742e7 == read_memory_integer (pc, 4)) 296 saved_regs->regs[PS_REGNUM] = (next_addr -= 4); 297 lose: ; 298 saved_regs->regs[SP_REGNUM] = (frame_info)->frame + 8; 299 saved_regs->regs[FP_REGNUM] = (frame_info)->frame; 300 saved_regs->regs[PC_REGNUM] = (frame_info)->frame + 4; 301 #ifdef SIG_SP_FP_OFFSET 302 /* Adjust saved SP_REGNUM for fake _sigtramp frames. */ 303 if (frame_info->signal_handler_caller && frame_info->next) 304 saved_regs->regs[SP_REGNUM] = frame_info->next->frame + SIG_SP_FP_OFFSET; 305 #endif 306 } 307 308 309 #ifdef USE_PROC_FS /* Target dependent support for /proc */ 310 311 #include <sys/procfs.h> 312 313 /* The /proc interface divides the target machine's register set up into 314 two different sets, the general register set (gregset) and the floating 315 point register set (fpregset). For each set, there is an ioctl to get 316 the current register set and another ioctl to set the current values. 317 318 The actual structure passed through the ioctl interface is, of course, 319 naturally machine dependent, and is different for each set of registers. 320 For the m68k for example, the general register set is typically defined 321 by: 322 323 typedef int gregset_t[18]; 324 325 #define R_D0 0 326 ... 327 #define R_PS 17 328 329 and the floating point set by: 330 331 typedef struct fpregset { 332 int f_pcr; 333 int f_psr; 334 int f_fpiaddr; 335 int f_fpregs[8][3]; (8 regs, 96 bits each) 336 } fpregset_t; 337 338 These routines provide the packing and unpacking of gregset_t and 339 fpregset_t formatted data. 340 341 */ 342 343 /* Atari SVR4 has R_SR but not R_PS */ 344 345 #if !defined (R_PS) && defined (R_SR) 346 #define R_PS R_SR 347 #endif 348 349 /* Given a pointer to a general register set in /proc format (gregset_t *), 350 unpack the register contents and supply them as gdb's idea of the current 351 register values. */ 352 353 void 354 supply_gregset (gregsetp) 355 gregset_t *gregsetp; 356 { 357 register int regi; 358 register greg_t *regp = (greg_t *) gregsetp; 359 360 for (regi = 0 ; regi < R_PC ; regi++) 361 { 362 supply_register (regi, (char *) (regp + regi)); 363 } 364 supply_register (PS_REGNUM, (char *) (regp + R_PS)); 365 supply_register (PC_REGNUM, (char *) (regp + R_PC)); 366 } 367 368 void 369 fill_gregset (gregsetp, regno) 370 gregset_t *gregsetp; 371 int regno; 372 { 373 register int regi; 374 register greg_t *regp = (greg_t *) gregsetp; 375 extern char registers[]; 376 377 for (regi = 0 ; regi < R_PC ; regi++) 378 { 379 if ((regno == -1) || (regno == regi)) 380 { 381 *(regp + regi) = *(int *) ®isters[REGISTER_BYTE (regi)]; 382 } 383 } 384 if ((regno == -1) || (regno == PS_REGNUM)) 385 { 386 *(regp + R_PS) = *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)]; 387 } 388 if ((regno == -1) || (regno == PC_REGNUM)) 389 { 390 *(regp + R_PC) = *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)]; 391 } 392 } 393 394 #if defined (FP0_REGNUM) 395 396 /* Given a pointer to a floating point register set in /proc format 397 (fpregset_t *), unpack the register contents and supply them as gdb's 398 idea of the current floating point register values. */ 399 400 void 401 supply_fpregset (fpregsetp) 402 fpregset_t *fpregsetp; 403 { 404 register int regi; 405 char *from; 406 407 for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++) 408 { 409 from = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]); 410 supply_register (regi, from); 411 } 412 supply_register (FPC_REGNUM, (char *) &(fpregsetp -> f_pcr)); 413 supply_register (FPS_REGNUM, (char *) &(fpregsetp -> f_psr)); 414 supply_register (FPI_REGNUM, (char *) &(fpregsetp -> f_fpiaddr)); 415 } 416 417 /* Given a pointer to a floating point register set in /proc format 418 (fpregset_t *), update the register specified by REGNO from gdb's idea 419 of the current floating point register set. If REGNO is -1, update 420 them all. */ 421 422 void 423 fill_fpregset (fpregsetp, regno) 424 fpregset_t *fpregsetp; 425 int regno; 426 { 427 int regi; 428 char *to; 429 char *from; 430 extern char registers[]; 431 432 for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++) 433 { 434 if ((regno == -1) || (regno == regi)) 435 { 436 from = (char *) ®isters[REGISTER_BYTE (regi)]; 437 to = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]); 438 memcpy (to, from, REGISTER_RAW_SIZE (regi)); 439 } 440 } 441 if ((regno == -1) || (regno == FPC_REGNUM)) 442 { 443 fpregsetp -> f_pcr = *(int *) ®isters[REGISTER_BYTE (FPC_REGNUM)]; 444 } 445 if ((regno == -1) || (regno == FPS_REGNUM)) 446 { 447 fpregsetp -> f_psr = *(int *) ®isters[REGISTER_BYTE (FPS_REGNUM)]; 448 } 449 if ((regno == -1) || (regno == FPI_REGNUM)) 450 { 451 fpregsetp -> f_fpiaddr = *(int *) ®isters[REGISTER_BYTE (FPI_REGNUM)]; 452 } 453 } 454 455 #endif /* defined (FP0_REGNUM) */ 456 457 #endif /* USE_PROC_FS */ 458 459 #ifdef GET_LONGJMP_TARGET 460 /* Figure out where the longjmp will land. Slurp the args out of the stack. 461 We expect the first arg to be a pointer to the jmp_buf structure from which 462 we extract the pc (JB_PC) that we will land at. The pc is copied into PC. 463 This routine returns true on success. */ 464 465 int 466 get_longjmp_target(pc) 467 CORE_ADDR *pc; 468 { 469 char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT]; 470 CORE_ADDR sp, jb_addr; 471 472 sp = read_register(SP_REGNUM); 473 474 if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */ 475 buf, 476 TARGET_PTR_BIT / TARGET_CHAR_BIT)) 477 return 0; 478 479 jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT); 480 481 if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf, 482 TARGET_PTR_BIT / TARGET_CHAR_BIT)) 483 return 0; 484 485 *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT); 486 487 return 1; 488 } 489 #endif /* GET_LONGJMP_TARGET */ 490 491 /* Immediately after a function call, return the saved pc before the frame 492 is setup. For sun3's, we check for the common case of being inside of a 493 system call, and if so, we know that Sun pushes the call # on the stack 494 prior to doing the trap. */ 495 496 CORE_ADDR 497 m68k_saved_pc_after_call(frame) 498 struct frame_info *frame; 499 { 500 #ifdef SYSCALL_TRAP 501 int op; 502 503 op = read_memory_integer (frame->pc - SYSCALL_TRAP_OFFSET, 2); 504 505 if (op == SYSCALL_TRAP) 506 return read_memory_integer (read_register (SP_REGNUM) + 4, 4); 507 else 508 #endif /* SYSCALL_TRAP */ 509 return read_memory_integer (read_register (SP_REGNUM), 4); 510 } 511 512 void 513 _initialize_m68k_tdep () 514 { 515 tm_print_insn = print_insn_m68k; 516 } 517