1/* Target-machine dependent code for Motorola MCore for GDB, the GNU debugger 2 3 Copyright 1999, 2000, 2001, 2002, 2003, 2004 Free Software 4 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, Boston, MA 02111-1307, USA. */ 21 22#include "defs.h" 23#include "frame.h" 24#include "symtab.h" 25#include "value.h" 26#include "gdbcmd.h" 27#include "regcache.h" 28#include "objfiles.h" 29#include "gdbcore.h" 30#include "inferior.h" 31#include "arch-utils.h" 32#include "gdb_string.h" 33#include "disasm.h" 34#include "dis-asm.h" 35 36static CORE_ADDR mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, 37 int skip_prologue); 38static int get_insn (CORE_ADDR pc); 39 40#ifdef MCORE_DEBUG 41int mcore_debug = 0; 42#endif 43 44 45/* All registers are 4 bytes long. */ 46#define MCORE_REG_SIZE 4 47#define MCORE_NUM_REGS 65 48 49/* Some useful register numbers. */ 50#define PR_REGNUM 15 51#define FIRST_ARGREG 2 52#define LAST_ARGREG 7 53#define RETVAL_REGNUM 2 54 55 56/* Additional info that we use for managing frames */ 57struct frame_extra_info 58 { 59 /* A generic status word */ 60 int status; 61 62 /* Size of this frame */ 63 int framesize; 64 65 /* The register that is acting as a frame pointer, if 66 it is being used. This is undefined if status 67 does not contain the flag MY_FRAME_IN_FP. */ 68 int fp_regnum; 69 }; 70 71/* frame_extra_info status flags */ 72 73/* The base of the current frame is actually in the stack pointer. 74 This happens when there is no frame pointer (MCore ABI does not 75 require a frame pointer) or when we're stopped in the prologue or 76 epilogue itself. In these cases, mcore_analyze_prologue will need 77 to update fi->frame before returning or analyzing the register 78 save instructions. */ 79#define MY_FRAME_IN_SP 0x1 80 81/* The base of the current frame is in a frame pointer register. 82 This register is noted in frame_extra_info->fp_regnum. 83 84 Note that the existence of an FP might also indicate that the 85 function has called alloca. */ 86#define MY_FRAME_IN_FP 0x2 87 88/* This flag is set to indicate that this frame is the top-most 89 frame. This tells frame chain not to bother trying to unwind 90 beyond this frame. */ 91#define NO_MORE_FRAMES 0x4 92 93/* Instruction macros used for analyzing the prologue */ 94#define IS_SUBI0(x) (((x) & 0xfe0f) == 0x2400) /* subi r0,oimm5 */ 95#define IS_STM(x) (((x) & 0xfff0) == 0x0070) /* stm rf-r15,r0 */ 96#define IS_STWx0(x) (((x) & 0xf00f) == 0x9000) /* stw rz,(r0,disp) */ 97#define IS_STWxy(x) (((x) & 0xf000) == 0x9000) /* stw rx,(ry,disp) */ 98#define IS_MOVx0(x) (((x) & 0xfff0) == 0x1200) /* mov rn,r0 */ 99#define IS_LRW1(x) (((x) & 0xff00) == 0x7100) /* lrw r1,literal */ 100#define IS_MOVI1(x) (((x) & 0xf80f) == 0x6001) /* movi r1,imm7 */ 101#define IS_BGENI1(x) (((x) & 0xfe0f) == 0x3201) /* bgeni r1,imm5 */ 102#define IS_BMASKI1(x) (((x) & 0xfe0f) == 0x2C01) /* bmaski r1,imm5 */ 103#define IS_ADDI1(x) (((x) & 0xfe0f) == 0x2001) /* addi r1,oimm5 */ 104#define IS_SUBI1(x) (((x) & 0xfe0f) == 0x2401) /* subi r1,oimm5 */ 105#define IS_RSUBI1(x) (((x) & 0xfe0f) == 0x2801) /* rsubi r1,imm5 */ 106#define IS_NOT1(x) (((x) & 0xffff) == 0x01f1) /* not r1 */ 107#define IS_ROTLI1(x) (((x) & 0xfe0f) == 0x3801) /* rotli r1,imm5 */ 108#define IS_BSETI1(x) (((x) & 0xfe0f) == 0x3401) /* bseti r1,imm5 */ 109#define IS_BCLRI1(x) (((x) & 0xfe0f) == 0x3001) /* bclri r1,imm5 */ 110#define IS_IXH1(x) (((x) & 0xffff) == 0x1d11) /* ixh r1,r1 */ 111#define IS_IXW1(x) (((x) & 0xffff) == 0x1511) /* ixw r1,r1 */ 112#define IS_SUB01(x) (((x) & 0xffff) == 0x0510) /* subu r0,r1 */ 113#define IS_RTS(x) (((x) & 0xffff) == 0x00cf) /* jmp r15 */ 114 115#define IS_R1_ADJUSTER(x) \ 116 (IS_ADDI1(x) || IS_SUBI1(x) || IS_ROTLI1(x) || IS_BSETI1(x) \ 117 || IS_BCLRI1(x) || IS_RSUBI1(x) || IS_NOT1(x) \ 118 || IS_IXH1(x) || IS_IXW1(x)) 119 120 121#ifdef MCORE_DEBUG 122static void 123mcore_dump_insn (char *commnt, CORE_ADDR pc, int insn) 124{ 125 if (mcore_debug) 126 { 127 printf_filtered ("MCORE: %s %08x %08x ", 128 commnt, (unsigned int) pc, (unsigned int) insn); 129 gdb_print_insn (pc, gdb_stdout); 130 printf_filtered ("\n"); 131 } 132} 133#define mcore_insn_debug(args) { if (mcore_debug) printf_filtered args; } 134#else /* !MCORE_DEBUG */ 135#define mcore_dump_insn(a,b,c) {} 136#define mcore_insn_debug(args) {} 137#endif 138 139 140static struct type * 141mcore_register_virtual_type (int regnum) 142{ 143 if (regnum < 0 || regnum >= MCORE_NUM_REGS) 144 internal_error (__FILE__, __LINE__, 145 "mcore_register_virtual_type: illegal register number %d", 146 regnum); 147 else 148 return builtin_type_int; 149} 150 151static int 152mcore_register_byte (int regnum) 153{ 154 if (regnum < 0 || regnum >= MCORE_NUM_REGS) 155 internal_error (__FILE__, __LINE__, 156 "mcore_register_byte: illegal register number %d", 157 regnum); 158 else 159 return (regnum * MCORE_REG_SIZE); 160} 161 162static int 163mcore_register_size (int regnum) 164{ 165 166 if (regnum < 0 || regnum >= MCORE_NUM_REGS) 167 internal_error (__FILE__, __LINE__, 168 "mcore_register_size: illegal register number %d", 169 regnum); 170 else 171 return MCORE_REG_SIZE; 172} 173 174/* The registers of the Motorola MCore processors */ 175 176static const char * 177mcore_register_name (int regnum) 178{ 179 180 static char *register_names[] = { 181 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 182 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 183 "ar0", "ar1", "ar2", "ar3", "ar4", "ar5", "ar6", "ar7", 184 "ar8", "ar9", "ar10", "ar11", "ar12", "ar13", "ar14", "ar15", 185 "psr", "vbr", "epsr", "fpsr", "epc", "fpc", "ss0", "ss1", 186 "ss2", "ss3", "ss4", "gcr", "gsr", "cr13", "cr14", "cr15", 187 "cr16", "cr17", "cr18", "cr19", "cr20", "cr21", "cr22", "cr23", 188 "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31", 189 "pc" 190 }; 191 192 if (regnum < 0 || 193 regnum >= sizeof (register_names) / sizeof (register_names[0])) 194 internal_error (__FILE__, __LINE__, 195 "mcore_register_name: illegal register number %d", 196 regnum); 197 else 198 return register_names[regnum]; 199} 200 201/* Given the address at which to insert a breakpoint (BP_ADDR), 202 what will that breakpoint be? 203 204 For MCore, we have a breakpoint instruction. Since all MCore 205 instructions are 16 bits, this is all we need, regardless of 206 address. bpkt = 0x0000 */ 207 208static const unsigned char * 209mcore_breakpoint_from_pc (CORE_ADDR * bp_addr, int *bp_size) 210{ 211 static char breakpoint[] = 212 {0x00, 0x00}; 213 *bp_size = 2; 214 return breakpoint; 215} 216 217static CORE_ADDR 218mcore_saved_pc_after_call (struct frame_info *frame) 219{ 220 return read_register (PR_REGNUM); 221} 222 223/* This is currently handled by init_extra_frame_info. */ 224static void 225mcore_frame_init_saved_regs (struct frame_info *frame) 226{ 227 228} 229 230/* This is currently handled by mcore_push_arguments */ 231static void 232mcore_store_struct_return (CORE_ADDR addr, CORE_ADDR sp) 233{ 234 235} 236 237static int 238mcore_reg_struct_has_addr (int gcc_p, struct type *type) 239{ 240 return 0; 241} 242 243 244/* Helper function for several routines below. This funtion simply 245 sets up a fake, aka dummy, frame (not a _call_ dummy frame) that 246 we can analyze with mcore_analyze_prologue. */ 247 248static struct frame_info * 249analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame) 250{ 251 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); 252 struct frame_info *dummy 253 = deprecated_frame_xmalloc_with_cleanup (SIZEOF_FRAME_SAVED_REGS, 254 sizeof (struct frame_extra_info)); 255 deprecated_update_frame_pc_hack (dummy, pc); 256 deprecated_update_frame_base_hack (dummy, frame); 257 get_frame_extra_info (dummy)->status = 0; 258 get_frame_extra_info (dummy)->framesize = 0; 259 mcore_analyze_prologue (dummy, 0, 0); 260 do_cleanups (old_chain); 261 return dummy; 262} 263 264/* Function prologues on the Motorola MCore processors consist of: 265 266 - adjustments to the stack pointer (r1 used as scratch register) 267 - store word/multiples that use r0 as the base address 268 - making a copy of r0 into another register (a "frame" pointer) 269 270 Note that the MCore really doesn't have a real frame pointer. 271 Instead, the compiler may copy the SP into a register (usually 272 r8) to act as an arg pointer. For our target-dependent purposes, 273 the frame info's "frame" member will be the beginning of the 274 frame. The SP could, in fact, point below this. 275 276 The prologue ends when an instruction fails to meet either of 277 the first two criteria or when an FP is made. We make a special 278 exception for gcc. When compiling unoptimized code, gcc will 279 setup stack slots. We need to make sure that we skip the filling 280 of these stack slots as much as possible. This is only done 281 when SKIP_PROLOGUE is set, so that it does not mess up 282 backtraces. */ 283 284/* Analyze the prologue of frame FI to determine where registers are saved, 285 the end of the prologue, etc. Return the address of the first line 286 of "real" code (i.e., the end of the prologue). */ 287 288static CORE_ADDR 289mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue) 290{ 291 CORE_ADDR func_addr, func_end, addr, stop; 292 CORE_ADDR stack_size; 293 int insn, rn; 294 int status; 295 int fp_regnum = 0; /* dummy, valid when (flags & MY_FRAME_IN_FP) */ 296 int flags; 297 int framesize; 298 int register_offsets[NUM_REGS]; 299 char *name; 300 301 /* If provided, use the PC in the frame to look up the 302 start of this function. */ 303 pc = (fi == NULL ? pc : get_frame_pc (fi)); 304 305 /* Find the start of this function. */ 306 status = find_pc_partial_function (pc, &name, &func_addr, &func_end); 307 308 /* If the start of this function could not be found or if the debbuger 309 is stopped at the first instruction of the prologue, do nothing. */ 310 if (status == 0) 311 return pc; 312 313 /* If the debugger is entry function, give up. */ 314 if (func_addr == entry_point_address ()) 315 { 316 if (fi != NULL) 317 get_frame_extra_info (fi)->status |= NO_MORE_FRAMES; 318 return pc; 319 } 320 321 /* At the start of a function, our frame is in the stack pointer. */ 322 flags = MY_FRAME_IN_SP; 323 324 /* Start decoding the prologue. We start by checking two special cases: 325 326 1. We're about to return 327 2. We're at the first insn of the prologue. 328 329 If we're about to return, our frame has already been deallocated. 330 If we are stopped at the first instruction of a prologue, 331 then our frame has not yet been set up. */ 332 333 /* Get the first insn from memory (all MCore instructions are 16 bits) */ 334 mcore_insn_debug (("MCORE: starting prologue decoding\n")); 335 insn = get_insn (pc); 336 mcore_dump_insn ("got 1: ", pc, insn); 337 338 /* Check for return. */ 339 if (fi != NULL && IS_RTS (insn)) 340 { 341 mcore_insn_debug (("MCORE: got jmp r15")); 342 if (get_next_frame (fi) == NULL) 343 deprecated_update_frame_base_hack (fi, read_sp ()); 344 return get_frame_pc (fi); 345 } 346 347 /* Check for first insn of prologue */ 348 if (fi != NULL && get_frame_pc (fi) == func_addr) 349 { 350 if (get_next_frame (fi) == NULL) 351 deprecated_update_frame_base_hack (fi, read_sp ()); 352 return get_frame_pc (fi); 353 } 354 355 /* Figure out where to stop scanning */ 356 stop = (fi ? get_frame_pc (fi) : func_end); 357 358 /* Don't walk off the end of the function */ 359 stop = (stop > func_end ? func_end : stop); 360 361 /* REGISTER_OFFSETS will contain offsets, from the top of the frame 362 (NOT the frame pointer), for the various saved registers or -1 363 if the register is not saved. */ 364 for (rn = 0; rn < NUM_REGS; rn++) 365 register_offsets[rn] = -1; 366 367 /* Analyze the prologue. Things we determine from analyzing the 368 prologue include: 369 * the size of the frame 370 * where saved registers are located (and which are saved) 371 * FP used? */ 372 mcore_insn_debug (("MCORE: Scanning prologue: func_addr=0x%x, stop=0x%x\n", 373 (unsigned int) func_addr, (unsigned int) stop)); 374 375 framesize = 0; 376 for (addr = func_addr; addr < stop; addr += 2) 377 { 378 /* Get next insn */ 379 insn = get_insn (addr); 380 mcore_dump_insn ("got 2: ", addr, insn); 381 382 if (IS_SUBI0 (insn)) 383 { 384 int offset = 1 + ((insn >> 4) & 0x1f); 385 mcore_insn_debug (("MCORE: got subi r0,%d; continuing\n", offset)); 386 framesize += offset; 387 continue; 388 } 389 else if (IS_STM (insn)) 390 { 391 /* Spill register(s) */ 392 int offset; 393 int start_register; 394 395 /* BIG WARNING! The MCore ABI does not restrict functions 396 to taking only one stack allocation. Therefore, when 397 we save a register, we record the offset of where it was 398 saved relative to the current framesize. This will 399 then give an offset from the SP upon entry to our 400 function. Remember, framesize is NOT constant until 401 we're done scanning the prologue. */ 402 start_register = (insn & 0xf); 403 mcore_insn_debug (("MCORE: got stm r%d-r15,(r0)\n", start_register)); 404 405 for (rn = start_register, offset = 0; rn <= 15; rn++, offset += 4) 406 { 407 register_offsets[rn] = framesize - offset; 408 mcore_insn_debug (("MCORE: r%d saved at 0x%x (offset %d)\n", rn, 409 register_offsets[rn], offset)); 410 } 411 mcore_insn_debug (("MCORE: continuing\n")); 412 continue; 413 } 414 else if (IS_STWx0 (insn)) 415 { 416 /* Spill register: see note for IS_STM above. */ 417 int imm; 418 419 rn = (insn >> 8) & 0xf; 420 imm = (insn >> 4) & 0xf; 421 register_offsets[rn] = framesize - (imm << 2); 422 mcore_insn_debug (("MCORE: r%d saved at offset 0x%x\n", rn, register_offsets[rn])); 423 mcore_insn_debug (("MCORE: continuing\n")); 424 continue; 425 } 426 else if (IS_MOVx0 (insn)) 427 { 428 /* We have a frame pointer, so this prologue is over. Note 429 the register which is acting as the frame pointer. */ 430 flags |= MY_FRAME_IN_FP; 431 flags &= ~MY_FRAME_IN_SP; 432 fp_regnum = insn & 0xf; 433 mcore_insn_debug (("MCORE: Found a frame pointer: r%d\n", fp_regnum)); 434 435 /* If we found an FP, we're at the end of the prologue. */ 436 mcore_insn_debug (("MCORE: end of prologue\n")); 437 if (skip_prologue) 438 continue; 439 440 /* If we're decoding prologue, stop here. */ 441 addr += 2; 442 break; 443 } 444 else if (IS_STWxy (insn) && (flags & MY_FRAME_IN_FP) && ((insn & 0xf) == fp_regnum)) 445 { 446 /* Special case. Skip over stack slot allocs, too. */ 447 mcore_insn_debug (("MCORE: push arg onto stack.\n")); 448 continue; 449 } 450 else if (IS_LRW1 (insn) || IS_MOVI1 (insn) 451 || IS_BGENI1 (insn) || IS_BMASKI1 (insn)) 452 { 453 int adjust = 0; 454 int offset = 0; 455 int insn2; 456 457 mcore_insn_debug (("MCORE: looking at large frame\n")); 458 if (IS_LRW1 (insn)) 459 { 460 adjust = 461 read_memory_integer ((addr + 2 + ((insn & 0xff) << 2)) & 0xfffffffc, 4); 462 } 463 else if (IS_MOVI1 (insn)) 464 adjust = (insn >> 4) & 0x7f; 465 else if (IS_BGENI1 (insn)) 466 adjust = 1 << ((insn >> 4) & 0x1f); 467 else /* IS_BMASKI (insn) */ 468 adjust = (1 << (adjust >> 4) & 0x1f) - 1; 469 470 mcore_insn_debug (("MCORE: base framesize=0x%x\n", adjust)); 471 472 /* May have zero or more insns which modify r1 */ 473 mcore_insn_debug (("MCORE: looking for r1 adjusters...\n")); 474 offset = 2; 475 insn2 = get_insn (addr + offset); 476 while (IS_R1_ADJUSTER (insn2)) 477 { 478 int imm; 479 480 imm = (insn2 >> 4) & 0x1f; 481 mcore_dump_insn ("got 3: ", addr + offset, insn); 482 if (IS_ADDI1 (insn2)) 483 { 484 adjust += (imm + 1); 485 mcore_insn_debug (("MCORE: addi r1,%d\n", imm + 1)); 486 } 487 else if (IS_SUBI1 (insn2)) 488 { 489 adjust -= (imm + 1); 490 mcore_insn_debug (("MCORE: subi r1,%d\n", imm + 1)); 491 } 492 else if (IS_RSUBI1 (insn2)) 493 { 494 adjust = imm - adjust; 495 mcore_insn_debug (("MCORE: rsubi r1,%d\n", imm + 1)); 496 } 497 else if (IS_NOT1 (insn2)) 498 { 499 adjust = ~adjust; 500 mcore_insn_debug (("MCORE: not r1\n")); 501 } 502 else if (IS_ROTLI1 (insn2)) 503 { 504 adjust <<= imm; 505 mcore_insn_debug (("MCORE: rotli r1,%d\n", imm + 1)); 506 } 507 else if (IS_BSETI1 (insn2)) 508 { 509 adjust |= (1 << imm); 510 mcore_insn_debug (("MCORE: bseti r1,%d\n", imm)); 511 } 512 else if (IS_BCLRI1 (insn2)) 513 { 514 adjust &= ~(1 << imm); 515 mcore_insn_debug (("MCORE: bclri r1,%d\n", imm)); 516 } 517 else if (IS_IXH1 (insn2)) 518 { 519 adjust *= 3; 520 mcore_insn_debug (("MCORE: ix.h r1,r1\n")); 521 } 522 else if (IS_IXW1 (insn2)) 523 { 524 adjust *= 5; 525 mcore_insn_debug (("MCORE: ix.w r1,r1\n")); 526 } 527 528 offset += 2; 529 insn2 = get_insn (addr + offset); 530 }; 531 532 mcore_insn_debug (("MCORE: done looking for r1 adjusters\n")); 533 534 /* If the next insn adjusts the stack pointer, we keep everything; 535 if not, we scrap it and we've found the end of the prologue. */ 536 if (IS_SUB01 (insn2)) 537 { 538 addr += offset; 539 framesize += adjust; 540 mcore_insn_debug (("MCORE: found stack adjustment of 0x%x bytes.\n", adjust)); 541 mcore_insn_debug (("MCORE: skipping to new address 0x%x\n", addr)); 542 mcore_insn_debug (("MCORE: continuing\n")); 543 continue; 544 } 545 546 /* None of these instructions are prologue, so don't touch 547 anything. */ 548 mcore_insn_debug (("MCORE: no subu r1,r0, NOT altering framesize.\n")); 549 break; 550 } 551 552 /* This is not a prologue insn, so stop here. */ 553 mcore_insn_debug (("MCORE: insn is not a prologue insn -- ending scan\n")); 554 break; 555 } 556 557 mcore_insn_debug (("MCORE: done analyzing prologue\n")); 558 mcore_insn_debug (("MCORE: prologue end = 0x%x\n", addr)); 559 560 /* Save everything we have learned about this frame into FI. */ 561 if (fi != NULL) 562 { 563 get_frame_extra_info (fi)->framesize = framesize; 564 get_frame_extra_info (fi)->fp_regnum = fp_regnum; 565 get_frame_extra_info (fi)->status = flags; 566 567 /* Fix the frame pointer. When gcc uses r8 as a frame pointer, 568 it is really an arg ptr. We adjust fi->frame to be a "real" 569 frame pointer. */ 570 if (get_next_frame (fi) == NULL) 571 { 572 if (get_frame_extra_info (fi)->status & MY_FRAME_IN_SP) 573 deprecated_update_frame_base_hack (fi, read_sp () + framesize); 574 else 575 deprecated_update_frame_base_hack (fi, read_register (fp_regnum) + framesize); 576 } 577 578 /* Note where saved registers are stored. The offsets in REGISTER_OFFSETS 579 are computed relative to the top of the frame. */ 580 for (rn = 0; rn < NUM_REGS; rn++) 581 { 582 if (register_offsets[rn] >= 0) 583 { 584 deprecated_get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - register_offsets[rn]; 585 mcore_insn_debug (("Saved register %s stored at 0x%08x, value=0x%08x\n", 586 mcore_register_names[rn], fi->saved_regs[rn], 587 read_memory_integer (fi->saved_regs[rn], 4))); 588 } 589 } 590 } 591 592 /* Return addr of first non-prologue insn. */ 593 return addr; 594} 595 596/* Given a GDB frame, determine the address of the calling function's 597 frame. This will be used to create a new GDB frame struct, and 598 then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC 599 will be called for the new frame. */ 600 601static CORE_ADDR 602mcore_frame_chain (struct frame_info * fi) 603{ 604 struct frame_info *dummy; 605 CORE_ADDR callers_addr; 606 607 /* Analyze the prologue of this function. */ 608 if (get_frame_extra_info (fi)->status == 0) 609 mcore_analyze_prologue (fi, 0, 0); 610 611 /* If mcore_analyze_prologue set NO_MORE_FRAMES, quit now. */ 612 if (get_frame_extra_info (fi)->status & NO_MORE_FRAMES) 613 return 0; 614 615 /* Now that we've analyzed our prologue, we can start to ask 616 for information about our caller. The easiest way to do 617 this is to analyze our caller's prologue. 618 619 If our caller has a frame pointer, then we need to find 620 the value of that register upon entry to our frame. 621 This value is either in fi->saved_regs[rn] if it's saved, 622 or it's still in a register. 623 624 If our caller does not have a frame pointer, then his frame base 625 is <our base> + -<caller's frame size>. */ 626 dummy = analyze_dummy_frame (DEPRECATED_FRAME_SAVED_PC (fi), get_frame_base (fi)); 627 628 if (get_frame_extra_info (dummy)->status & MY_FRAME_IN_FP) 629 { 630 int fp = get_frame_extra_info (dummy)->fp_regnum; 631 632 /* Our caller has a frame pointer. */ 633 if (deprecated_get_frame_saved_regs (fi)[fp] != 0) 634 { 635 /* The "FP" was saved on the stack. Don't forget to adjust 636 the "FP" with the framesize to get a real FP. */ 637 callers_addr = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp], 638 DEPRECATED_REGISTER_SIZE) 639 + get_frame_extra_info (dummy)->framesize; 640 } 641 else 642 { 643 /* It's still in the register. Don't forget to adjust 644 the "FP" with the framesize to get a real FP. */ 645 callers_addr = read_register (fp) + get_frame_extra_info (dummy)->framesize; 646 } 647 } 648 else 649 { 650 /* Our caller does not have a frame pointer. */ 651 callers_addr = get_frame_base (fi) + get_frame_extra_info (dummy)->framesize; 652 } 653 654 return callers_addr; 655} 656 657/* Skip the prologue of the function at PC. */ 658 659static CORE_ADDR 660mcore_skip_prologue (CORE_ADDR pc) 661{ 662 CORE_ADDR func_addr, func_end; 663 struct symtab_and_line sal; 664 665 /* If we have line debugging information, then the end of the 666 prologue should be the first assembly instruction of the first 667 source line */ 668 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) 669 { 670 sal = find_pc_line (func_addr, 0); 671 if (sal.end && sal.end < func_end) 672 return sal.end; 673 } 674 675 return mcore_analyze_prologue (NULL, pc, 1); 676} 677 678/* Return the address at which function arguments are offset. */ 679static CORE_ADDR 680mcore_frame_args_address (struct frame_info * fi) 681{ 682 return get_frame_base (fi) - get_frame_extra_info (fi)->framesize; 683} 684 685static CORE_ADDR 686mcore_frame_locals_address (struct frame_info * fi) 687{ 688 return get_frame_base (fi) - get_frame_extra_info (fi)->framesize; 689} 690 691/* Return the frame pointer in use at address PC. */ 692 693static void 694mcore_virtual_frame_pointer (CORE_ADDR pc, int *reg, LONGEST *offset) 695{ 696 struct frame_info *dummy = analyze_dummy_frame (pc, 0); 697 if (get_frame_extra_info (dummy)->status & MY_FRAME_IN_SP) 698 { 699 *reg = SP_REGNUM; 700 *offset = 0; 701 } 702 else 703 { 704 *reg = get_frame_extra_info (dummy)->fp_regnum; 705 *offset = 0; 706 } 707} 708 709/* Find the value of register REGNUM in frame FI. */ 710 711static CORE_ADDR 712mcore_find_callers_reg (struct frame_info *fi, int regnum) 713{ 714 for (; fi != NULL; fi = get_next_frame (fi)) 715 { 716 if (deprecated_pc_in_call_dummy (get_frame_pc (fi))) 717 return deprecated_read_register_dummy (get_frame_pc (fi), 718 get_frame_base (fi), regnum); 719 else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0) 720 return read_memory_integer (deprecated_get_frame_saved_regs (fi)[regnum], 721 DEPRECATED_REGISTER_SIZE); 722 } 723 724 return read_register (regnum); 725} 726 727/* Find the saved pc in frame FI. */ 728 729static CORE_ADDR 730mcore_frame_saved_pc (struct frame_info * fi) 731{ 732 733 if (deprecated_pc_in_call_dummy (get_frame_pc (fi))) 734 return deprecated_read_register_dummy (get_frame_pc (fi), 735 get_frame_base (fi), PC_REGNUM); 736 else 737 return mcore_find_callers_reg (fi, PR_REGNUM); 738} 739 740/* INFERIOR FUNCTION CALLS */ 741 742/* This routine gets called when either the user uses the "return" 743 command, or the call dummy breakpoint gets hit. */ 744 745static void 746mcore_pop_frame (void) 747{ 748 int rn; 749 struct frame_info *fi = get_current_frame (); 750 751 if (deprecated_pc_in_call_dummy (get_frame_pc (fi))) 752 deprecated_pop_dummy_frame (); 753 else 754 { 755 /* Write out the PC we saved. */ 756 write_register (PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (fi)); 757 758 /* Restore any saved registers. */ 759 for (rn = 0; rn < NUM_REGS; rn++) 760 { 761 if (deprecated_get_frame_saved_regs (fi)[rn] != 0) 762 { 763 ULONGEST value; 764 765 value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[rn], 766 DEPRECATED_REGISTER_SIZE); 767 write_register (rn, value); 768 } 769 } 770 771 /* Actually cut back the stack. */ 772 write_register (SP_REGNUM, get_frame_base (fi)); 773 } 774 775 /* Finally, throw away any cached frame information. */ 776 flush_cached_frames (); 777} 778 779/* Setup arguments and PR for a call to the target. First six arguments 780 go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on to the stack. 781 782 - Types with lengths greater than DEPRECATED_REGISTER_SIZE may not 783 be split between registers and the stack, and they must start in an 784 even-numbered register. Subsequent args will go onto the stack. 785 786 * Structs may be split between registers and stack, left-aligned. 787 788 * If the function returns a struct which will not fit into registers (it's 789 more than eight bytes), we must allocate for that, too. Gdb will tell 790 us where this buffer is (STRUCT_ADDR), and we simply place it into 791 FIRST_ARGREG, since the MCORE treats struct returns (of less than eight 792 bytes) as hidden first arguments. */ 793 794static CORE_ADDR 795mcore_push_arguments (int nargs, struct value **args, CORE_ADDR sp, 796 int struct_return, CORE_ADDR struct_addr) 797{ 798 int argreg; 799 int argnum; 800 struct stack_arg 801 { 802 int len; 803 char *val; 804 } 805 *stack_args; 806 int nstack_args = 0; 807 808 stack_args = (struct stack_arg *) alloca (nargs * sizeof (struct stack_arg)); 809 810 argreg = FIRST_ARGREG; 811 812 /* Align the stack. This is mostly a nop, but not always. It will be needed 813 if we call a function which has argument overflow. */ 814 sp &= ~3; 815 816 /* If this function returns a struct which does not fit in the 817 return registers, we must pass a buffer to the function 818 which it can use to save the return value. */ 819 if (struct_return) 820 write_register (argreg++, struct_addr); 821 822 /* FIXME: what about unions? */ 823 for (argnum = 0; argnum < nargs; argnum++) 824 { 825 char *val = (char *) VALUE_CONTENTS (args[argnum]); 826 int len = TYPE_LENGTH (VALUE_TYPE (args[argnum])); 827 struct type *type = VALUE_TYPE (args[argnum]); 828 int olen; 829 830 mcore_insn_debug (("MCORE PUSH: argreg=%d; len=%d; %s\n", 831 argreg, len, TYPE_CODE (type) == TYPE_CODE_STRUCT ? "struct" : "not struct")); 832 /* Arguments larger than a register must start in an even 833 numbered register. */ 834 olen = len; 835 836 if (TYPE_CODE (type) != TYPE_CODE_STRUCT && len > DEPRECATED_REGISTER_SIZE && argreg % 2) 837 { 838 mcore_insn_debug (("MCORE PUSH: %d > DEPRECATED_REGISTER_SIZE: and %s is not even\n", 839 len, mcore_register_names[argreg])); 840 argreg++; 841 } 842 843 if ((argreg <= LAST_ARGREG && len <= (LAST_ARGREG - argreg + 1) * DEPRECATED_REGISTER_SIZE) 844 || (TYPE_CODE (type) == TYPE_CODE_STRUCT)) 845 { 846 /* Something that will fit entirely into registers (or a struct 847 which may be split between registers and stack). */ 848 mcore_insn_debug (("MCORE PUSH: arg %d going into regs\n", argnum)); 849 850 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && olen < DEPRECATED_REGISTER_SIZE) 851 { 852 /* Small structs must be right aligned within the register, 853 the most significant bits are undefined. */ 854 write_register (argreg, extract_unsigned_integer (val, len)); 855 argreg++; 856 len = 0; 857 } 858 859 while (len > 0 && argreg <= LAST_ARGREG) 860 { 861 write_register (argreg, extract_unsigned_integer (val, DEPRECATED_REGISTER_SIZE)); 862 argreg++; 863 val += DEPRECATED_REGISTER_SIZE; 864 len -= DEPRECATED_REGISTER_SIZE; 865 } 866 867 /* Any remainder for the stack is noted below... */ 868 } 869 else if (TYPE_CODE (VALUE_TYPE (args[argnum])) != TYPE_CODE_STRUCT 870 && len > DEPRECATED_REGISTER_SIZE) 871 { 872 /* All subsequent args go onto the stack. */ 873 mcore_insn_debug (("MCORE PUSH: does not fit into regs, going onto stack\n")); 874 argnum = LAST_ARGREG + 1; 875 } 876 877 if (len > 0) 878 { 879 /* Note that this must be saved onto the stack */ 880 mcore_insn_debug (("MCORE PUSH: adding arg %d to stack\n", argnum)); 881 stack_args[nstack_args].val = val; 882 stack_args[nstack_args].len = len; 883 nstack_args++; 884 } 885 886 } 887 888 /* We're done with registers and stack allocation. Now do the actual 889 stack pushes. */ 890 while (nstack_args--) 891 { 892 sp -= stack_args[nstack_args].len; 893 write_memory (sp, stack_args[nstack_args].val, stack_args[nstack_args].len); 894 } 895 896 /* Return adjusted stack pointer. */ 897 return sp; 898} 899 900/* Store the return address for the call dummy. For MCore, we've opted 901 to use generic call dummies, so we simply store the entry-point 902 address into the PR register (r15). */ 903 904static CORE_ADDR 905mcore_push_return_address (CORE_ADDR pc, CORE_ADDR sp) 906{ 907 write_register (PR_REGNUM, entry_point_address ()); 908 return sp; 909} 910 911/* Setting/getting return values from functions. 912 913 The Motorola MCore processors use r2/r3 to return anything 914 not larger than 32 bits. Everything else goes into a caller- 915 supplied buffer, which is passed in via a hidden first 916 argument. 917 918 For gdb, this leaves us two routes, based on what 919 DEPRECATED_USE_STRUCT_CONVENTION (mcore_use_struct_convention) 920 returns. If this macro returns 1, gdb will call 921 STORE_STRUCT_RETURN to store the return value. 922 923 If DEPRECATED_USE_STRUCT_CONVENTION returns 0, then gdb uses 924 STORE_RETURN_VALUE and EXTRACT_RETURN_VALUE to store/fetch the 925 functions return value. */ 926 927static int 928mcore_use_struct_convention (int gcc_p, struct type *type) 929{ 930 return (TYPE_LENGTH (type) > 8); 931} 932 933/* Given a function which returns a value of type TYPE, extract the 934 the function's return value and place the result into VALBUF. 935 REGBUF is the register contents of the target. */ 936 937static void 938mcore_extract_return_value (struct type *type, char *regbuf, char *valbuf) 939{ 940 /* Copy the return value (starting) in RETVAL_REGNUM to VALBUF. */ 941 /* Only getting the first byte! if len = 1, we need the last byte of 942 the register, not the first. */ 943 memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM) + 944 (TYPE_LENGTH (type) < 4 ? 4 - TYPE_LENGTH (type) : 0), TYPE_LENGTH (type)); 945} 946 947/* Store the return value in VALBUF (of type TYPE) where the caller 948 expects to see it. 949 950 Values less than 32 bits are stored in r2, right justified and 951 sign or zero extended. 952 953 Values between 32 and 64 bits are stored in r2 (most 954 significant word) and r3 (least significant word, left justified). 955 Note that this includes structures of less than eight bytes, too. */ 956 957static void 958mcore_store_return_value (struct type *type, char *valbuf) 959{ 960 int value_size; 961 int return_size; 962 int offset; 963 char *zeros; 964 965 value_size = TYPE_LENGTH (type); 966 967 /* Return value fits into registers. */ 968 return_size = (value_size + DEPRECATED_REGISTER_SIZE - 1) & ~(DEPRECATED_REGISTER_SIZE - 1); 969 offset = DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM) + (return_size - value_size); 970 zeros = alloca (return_size); 971 memset (zeros, 0, return_size); 972 973 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM), zeros, 974 return_size); 975 deprecated_write_register_bytes (offset, valbuf, value_size); 976} 977 978/* Initialize our target-dependent "stuff" for this newly created frame. 979 980 This includes allocating space for saved registers and analyzing 981 the prologue of this frame. */ 982 983static void 984mcore_init_extra_frame_info (int fromleaf, struct frame_info *fi) 985{ 986 if (fi && get_next_frame (fi)) 987 deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi))); 988 989 frame_saved_regs_zalloc (fi); 990 991 frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info)); 992 get_frame_extra_info (fi)->status = 0; 993 get_frame_extra_info (fi)->framesize = 0; 994 995 if (deprecated_pc_in_call_dummy (get_frame_pc (fi))) 996 { 997 /* We need to setup fi->frame here because call_function_by_hand 998 gets it wrong by assuming it's always FP. */ 999 deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM)); 1000 } 1001 else 1002 mcore_analyze_prologue (fi, 0, 0); 1003} 1004 1005/* Get an insturction from memory. */ 1006 1007static int 1008get_insn (CORE_ADDR pc) 1009{ 1010 char buf[4]; 1011 int status = deprecated_read_memory_nobpt (pc, buf, 2); 1012 if (status != 0) 1013 return 0; 1014 1015 return extract_unsigned_integer (buf, 2); 1016} 1017 1018static struct gdbarch * 1019mcore_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 1020{ 1021 struct gdbarch_tdep *tdep = NULL; 1022 struct gdbarch *gdbarch; 1023 1024 /* find a candidate among the list of pre-declared architectures. */ 1025 arches = gdbarch_list_lookup_by_info (arches, &info); 1026 if (arches != NULL) 1027 return (arches->gdbarch); 1028 1029 gdbarch = gdbarch_alloc (&info, 0); 1030 1031 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is 1032 ready to unwind the PC first (see frame.c:get_prev_frame()). */ 1033 set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default); 1034 1035 /* Registers: */ 1036 1037 /* All registers are 32 bits */ 1038 set_gdbarch_deprecated_register_size (gdbarch, MCORE_REG_SIZE); 1039 set_gdbarch_register_name (gdbarch, mcore_register_name); 1040 set_gdbarch_deprecated_register_virtual_type (gdbarch, mcore_register_virtual_type); 1041 set_gdbarch_deprecated_register_virtual_size (gdbarch, mcore_register_size); 1042 set_gdbarch_deprecated_register_raw_size (gdbarch, mcore_register_size); 1043 set_gdbarch_deprecated_register_byte (gdbarch, mcore_register_byte); 1044 set_gdbarch_num_regs (gdbarch, MCORE_NUM_REGS); 1045 set_gdbarch_pc_regnum (gdbarch, 64); 1046 set_gdbarch_sp_regnum (gdbarch, 0); 1047 set_gdbarch_deprecated_fp_regnum (gdbarch, 0); 1048 1049 /* Call Dummies: */ 1050 1051 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, mcore_saved_pc_after_call); 1052 set_gdbarch_breakpoint_from_pc (gdbarch, mcore_breakpoint_from_pc); 1053 set_gdbarch_deprecated_push_return_address (gdbarch, mcore_push_return_address); 1054 set_gdbarch_deprecated_push_arguments (gdbarch, mcore_push_arguments); 1055 1056 /* Frames: */ 1057 1058 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, mcore_init_extra_frame_info); 1059 set_gdbarch_deprecated_frame_chain (gdbarch, mcore_frame_chain); 1060 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, mcore_frame_init_saved_regs); 1061 set_gdbarch_deprecated_frame_saved_pc (gdbarch, mcore_frame_saved_pc); 1062 set_gdbarch_deprecated_store_return_value (gdbarch, mcore_store_return_value); 1063 set_gdbarch_deprecated_extract_return_value (gdbarch, 1064 mcore_extract_return_value); 1065 set_gdbarch_deprecated_store_struct_return (gdbarch, mcore_store_struct_return); 1066 set_gdbarch_skip_prologue (gdbarch, mcore_skip_prologue); 1067 set_gdbarch_deprecated_frame_args_address (gdbarch, mcore_frame_args_address); 1068 set_gdbarch_deprecated_frame_locals_address (gdbarch, mcore_frame_locals_address); 1069 set_gdbarch_deprecated_pop_frame (gdbarch, mcore_pop_frame); 1070 set_gdbarch_virtual_frame_pointer (gdbarch, mcore_virtual_frame_pointer); 1071 1072 /* Misc.: */ 1073 1074 /* Stack grows down. */ 1075 set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 1076 set_gdbarch_deprecated_use_struct_convention (gdbarch, mcore_use_struct_convention); 1077 set_gdbarch_believe_pcc_promotion (gdbarch, 1); 1078 /* MCore will never pass a sturcture by reference. It will always be split 1079 between registers and stack. */ 1080 set_gdbarch_deprecated_reg_struct_has_addr 1081 (gdbarch, mcore_reg_struct_has_addr); 1082 1083 /* Should be using push_dummy_call. */ 1084 set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp); 1085 1086 set_gdbarch_print_insn (gdbarch, print_insn_mcore); 1087 1088 return gdbarch; 1089} 1090 1091static void 1092mcore_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file) 1093{ 1094 1095} 1096 1097extern initialize_file_ftype _initialize_mcore_tdep; /* -Wmissing-prototypes */ 1098 1099void 1100_initialize_mcore_tdep (void) 1101{ 1102 gdbarch_register (bfd_arch_mcore, mcore_gdbarch_init, mcore_dump_tdep); 1103 1104#ifdef MCORE_DEBUG 1105 deprecated_add_show_from_set 1106 (add_set_cmd ("mcoredebug", no_class, 1107 var_boolean, (char *) &mcore_debug, 1108 "Set mcore debugging.\n", &setlist), 1109 &showlist); 1110#endif 1111} 1112