1 /* Target-machine dependent code for Motorola MCore for GDB, the GNU debugger
3 Copyright 1999, 2000, 2001, 2002, 2003, 2004 Free Software
6 This file is part of GDB.
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.
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.
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. */
31 #include "arch-utils.h"
32 #include "gdb_string.h"
36 static CORE_ADDR mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc,
38 static int get_insn (CORE_ADDR pc);
45 /* All registers are 4 bytes long. */
46 #define MCORE_REG_SIZE 4
47 #define MCORE_NUM_REGS 65
49 /* Some useful register numbers. */
51 #define FIRST_ARGREG 2
53 #define RETVAL_REGNUM 2
56 /* Additional info that we use for managing frames */
57 struct frame_extra_info
59 /* A generic status word */
62 /* Size of this frame */
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. */
71 /* frame_extra_info status flags */
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
79 #define MY_FRAME_IN_SP 0x1
81 /* The base of the current frame is in a frame pointer register.
82 This register is noted in frame_extra_info->fp_regnum.
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
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
91 #define NO_MORE_FRAMES 0x4
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 */
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))
123 mcore_dump_insn (char *commnt, CORE_ADDR pc, int insn)
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");
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) {}
141 mcore_register_virtual_type (int regnum)
143 if (regnum < 0 || regnum >= MCORE_NUM_REGS)
144 internal_error (__FILE__, __LINE__,
145 "mcore_register_virtual_type: illegal register number %d",
148 return builtin_type_int;
152 mcore_register_byte (int regnum)
154 if (regnum < 0 || regnum >= MCORE_NUM_REGS)
155 internal_error (__FILE__, __LINE__,
156 "mcore_register_byte: illegal register number %d",
159 return (regnum * MCORE_REG_SIZE);
163 mcore_register_size (int regnum)
166 if (regnum < 0 || regnum >= MCORE_NUM_REGS)
167 internal_error (__FILE__, __LINE__,
168 "mcore_register_size: illegal register number %d",
171 return MCORE_REG_SIZE;
174 /* The registers of the Motorola MCore processors */
177 mcore_register_name (int regnum)
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",
193 regnum >= sizeof (register_names) / sizeof (register_names[0]))
194 internal_error (__FILE__, __LINE__,
195 "mcore_register_name: illegal register number %d",
198 return register_names[regnum];
201 /* Given the address at which to insert a breakpoint (BP_ADDR),
202 what will that breakpoint be?
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 */
208 static const unsigned char *
209 mcore_breakpoint_from_pc (CORE_ADDR * bp_addr, int *bp_size)
211 static char breakpoint[] =
218 mcore_saved_pc_after_call (struct frame_info *frame)
220 return read_register (PR_REGNUM);
223 /* This is currently handled by init_extra_frame_info. */
225 mcore_frame_init_saved_regs (struct frame_info *frame)
230 /* This is currently handled by mcore_push_arguments */
232 mcore_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
238 mcore_reg_struct_has_addr (int gcc_p, struct type *type)
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. */
248 static struct frame_info *
249 analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
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);
264 /* Function prologues on the Motorola MCore processors consist of:
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)
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.
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
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). */
289 mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue)
291 CORE_ADDR func_addr, func_end, addr, stop;
292 CORE_ADDR stack_size;
295 int fp_regnum = 0; /* dummy, valid when (flags & MY_FRAME_IN_FP) */
298 int register_offsets[NUM_REGS];
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));
305 /* Find the start of this function. */
306 status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
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. */
313 /* If the debugger is entry function, give up. */
314 if (func_addr == entry_point_address ())
317 get_frame_extra_info (fi)->status |= NO_MORE_FRAMES;
321 /* At the start of a function, our frame is in the stack pointer. */
322 flags = MY_FRAME_IN_SP;
324 /* Start decoding the prologue. We start by checking two special cases:
326 1. We're about to return
327 2. We're at the first insn of the prologue.
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. */
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);
338 /* Check for return. */
339 if (fi != NULL && IS_RTS (insn))
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);
347 /* Check for first insn of prologue */
348 if (fi != NULL && get_frame_pc (fi) == func_addr)
350 if (get_next_frame (fi) == NULL)
351 deprecated_update_frame_base_hack (fi, read_sp ());
352 return get_frame_pc (fi);
355 /* Figure out where to stop scanning */
356 stop = (fi ? get_frame_pc (fi) : func_end);
358 /* Don't walk off the end of the function */
359 stop = (stop > func_end ? func_end : stop);
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;
367 /* Analyze the prologue. Things we determine from analyzing the
369 * the size of the frame
370 * where saved registers are located (and which are saved)
372 mcore_insn_debug (("MCORE: Scanning prologue: func_addr=0x%x, stop=0x%x\n",
373 (unsigned int) func_addr, (unsigned int) stop));
376 for (addr = func_addr; addr < stop; addr += 2)
379 insn = get_insn (addr);
380 mcore_dump_insn ("got 2: ", addr, insn);
384 int offset = 1 + ((insn >> 4) & 0x1f);
385 mcore_insn_debug (("MCORE: got subi r0,%d; continuing\n", offset));
389 else if (IS_STM (insn))
391 /* Spill register(s) */
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));
405 for (rn = start_register, offset = 0; rn <= 15; rn++, offset += 4)
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));
411 mcore_insn_debug (("MCORE: continuing\n"));
414 else if (IS_STWx0 (insn))
416 /* Spill register: see note for IS_STM above. */
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"));
426 else if (IS_MOVx0 (insn))
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));
435 /* If we found an FP, we're at the end of the prologue. */
436 mcore_insn_debug (("MCORE: end of prologue\n"));
440 /* If we're decoding prologue, stop here. */
444 else if (IS_STWxy (insn) && (flags & MY_FRAME_IN_FP) && ((insn & 0xf) == fp_regnum))
446 /* Special case. Skip over stack slot allocs, too. */
447 mcore_insn_debug (("MCORE: push arg onto stack.\n"));
450 else if (IS_LRW1 (insn) || IS_MOVI1 (insn)
451 || IS_BGENI1 (insn) || IS_BMASKI1 (insn))
457 mcore_insn_debug (("MCORE: looking at large frame\n"));
461 read_memory_integer ((addr + 2 + ((insn & 0xff) << 2)) & 0xfffffffc, 4);
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;
470 mcore_insn_debug (("MCORE: base framesize=0x%x\n", adjust));
472 /* May have zero or more insns which modify r1 */
473 mcore_insn_debug (("MCORE: looking for r1 adjusters...\n"));
475 insn2 = get_insn (addr + offset);
476 while (IS_R1_ADJUSTER (insn2))
480 imm = (insn2 >> 4) & 0x1f;
481 mcore_dump_insn ("got 3: ", addr + offset, insn);
482 if (IS_ADDI1 (insn2))
485 mcore_insn_debug (("MCORE: addi r1,%d\n", imm + 1));
487 else if (IS_SUBI1 (insn2))
490 mcore_insn_debug (("MCORE: subi r1,%d\n", imm + 1));
492 else if (IS_RSUBI1 (insn2))
494 adjust = imm - adjust;
495 mcore_insn_debug (("MCORE: rsubi r1,%d\n", imm + 1));
497 else if (IS_NOT1 (insn2))
500 mcore_insn_debug (("MCORE: not r1\n"));
502 else if (IS_ROTLI1 (insn2))
505 mcore_insn_debug (("MCORE: rotli r1,%d\n", imm + 1));
507 else if (IS_BSETI1 (insn2))
509 adjust |= (1 << imm);
510 mcore_insn_debug (("MCORE: bseti r1,%d\n", imm));
512 else if (IS_BCLRI1 (insn2))
514 adjust &= ~(1 << imm);
515 mcore_insn_debug (("MCORE: bclri r1,%d\n", imm));
517 else if (IS_IXH1 (insn2))
520 mcore_insn_debug (("MCORE: ix.h r1,r1\n"));
522 else if (IS_IXW1 (insn2))
525 mcore_insn_debug (("MCORE: ix.w r1,r1\n"));
529 insn2 = get_insn (addr + offset);
532 mcore_insn_debug (("MCORE: done looking for r1 adjusters\n"));
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))
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"));
546 /* None of these instructions are prologue, so don't touch
548 mcore_insn_debug (("MCORE: no subu r1,r0, NOT altering framesize.\n"));
552 /* This is not a prologue insn, so stop here. */
553 mcore_insn_debug (("MCORE: insn is not a prologue insn -- ending scan\n"));
557 mcore_insn_debug (("MCORE: done analyzing prologue\n"));
558 mcore_insn_debug (("MCORE: prologue end = 0x%x\n", addr));
560 /* Save everything we have learned about this frame into FI. */
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;
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"
570 if (get_next_frame (fi) == NULL)
572 if (get_frame_extra_info (fi)->status & MY_FRAME_IN_SP)
573 deprecated_update_frame_base_hack (fi, read_sp () + framesize);
575 deprecated_update_frame_base_hack (fi, read_register (fp_regnum) + framesize);
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++)
582 if (register_offsets[rn] >= 0)
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)));
592 /* Return addr of first non-prologue insn. */
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. */
602 mcore_frame_chain (struct frame_info * fi)
604 struct frame_info *dummy;
605 CORE_ADDR callers_addr;
607 /* Analyze the prologue of this function. */
608 if (get_frame_extra_info (fi)->status == 0)
609 mcore_analyze_prologue (fi, 0, 0);
611 /* If mcore_analyze_prologue set NO_MORE_FRAMES, quit now. */
612 if (get_frame_extra_info (fi)->status & NO_MORE_FRAMES)
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.
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.
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));
628 if (get_frame_extra_info (dummy)->status & MY_FRAME_IN_FP)
630 int fp = get_frame_extra_info (dummy)->fp_regnum;
632 /* Our caller has a frame pointer. */
633 if (deprecated_get_frame_saved_regs (fi)[fp] != 0)
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;
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;
650 /* Our caller does not have a frame pointer. */
651 callers_addr = get_frame_base (fi) + get_frame_extra_info (dummy)->framesize;
657 /* Skip the prologue of the function at PC. */
660 mcore_skip_prologue (CORE_ADDR pc)
662 CORE_ADDR func_addr, func_end;
663 struct symtab_and_line sal;
665 /* If we have line debugging information, then the end of the
666 prologue should be the first assembly instruction of the first
668 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
670 sal = find_pc_line (func_addr, 0);
671 if (sal.end && sal.end < func_end)
675 return mcore_analyze_prologue (NULL, pc, 1);
678 /* Return the address at which function arguments are offset. */
680 mcore_frame_args_address (struct frame_info * fi)
682 return get_frame_base (fi) - get_frame_extra_info (fi)->framesize;
686 mcore_frame_locals_address (struct frame_info * fi)
688 return get_frame_base (fi) - get_frame_extra_info (fi)->framesize;
691 /* Return the frame pointer in use at address PC. */
694 mcore_virtual_frame_pointer (CORE_ADDR pc, int *reg, LONGEST *offset)
696 struct frame_info *dummy = analyze_dummy_frame (pc, 0);
697 if (get_frame_extra_info (dummy)->status & MY_FRAME_IN_SP)
704 *reg = get_frame_extra_info (dummy)->fp_regnum;
709 /* Find the value of register REGNUM in frame FI. */
712 mcore_find_callers_reg (struct frame_info *fi, int regnum)
714 for (; fi != NULL; fi = get_next_frame (fi))
716 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
717 get_frame_base (fi)))
718 return deprecated_read_register_dummy (get_frame_pc (fi),
719 get_frame_base (fi), regnum);
720 else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0)
721 return read_memory_integer (deprecated_get_frame_saved_regs (fi)[regnum],
722 DEPRECATED_REGISTER_SIZE);
725 return read_register (regnum);
728 /* Find the saved pc in frame FI. */
731 mcore_frame_saved_pc (struct frame_info * fi)
734 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
735 get_frame_base (fi)))
736 return deprecated_read_register_dummy (get_frame_pc (fi),
737 get_frame_base (fi), PC_REGNUM);
739 return mcore_find_callers_reg (fi, PR_REGNUM);
742 /* INFERIOR FUNCTION CALLS */
744 /* This routine gets called when either the user uses the "return"
745 command, or the call dummy breakpoint gets hit. */
748 mcore_pop_frame (void)
751 struct frame_info *fi = get_current_frame ();
753 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
754 get_frame_base (fi)))
755 generic_pop_dummy_frame ();
758 /* Write out the PC we saved. */
759 write_register (PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (fi));
761 /* Restore any saved registers. */
762 for (rn = 0; rn < NUM_REGS; rn++)
764 if (deprecated_get_frame_saved_regs (fi)[rn] != 0)
768 value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[rn],
769 DEPRECATED_REGISTER_SIZE);
770 write_register (rn, value);
774 /* Actually cut back the stack. */
775 write_register (SP_REGNUM, get_frame_base (fi));
778 /* Finally, throw away any cached frame information. */
779 flush_cached_frames ();
782 /* Setup arguments and PR for a call to the target. First six arguments
783 go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on to the stack.
785 - Types with lengths greater than DEPRECATED_REGISTER_SIZE may not
786 be split between registers and the stack, and they must start in an
787 even-numbered register. Subsequent args will go onto the stack.
789 * Structs may be split between registers and stack, left-aligned.
791 * If the function returns a struct which will not fit into registers (it's
792 more than eight bytes), we must allocate for that, too. Gdb will tell
793 us where this buffer is (STRUCT_ADDR), and we simply place it into
794 FIRST_ARGREG, since the MCORE treats struct returns (of less than eight
795 bytes) as hidden first arguments. */
798 mcore_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
799 int struct_return, CORE_ADDR struct_addr)
811 stack_args = (struct stack_arg *) alloca (nargs * sizeof (struct stack_arg));
813 argreg = FIRST_ARGREG;
815 /* Align the stack. This is mostly a nop, but not always. It will be needed
816 if we call a function which has argument overflow. */
819 /* If this function returns a struct which does not fit in the
820 return registers, we must pass a buffer to the function
821 which it can use to save the return value. */
823 write_register (argreg++, struct_addr);
825 /* FIXME: what about unions? */
826 for (argnum = 0; argnum < nargs; argnum++)
828 char *val = (char *) VALUE_CONTENTS (args[argnum]);
829 int len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
830 struct type *type = VALUE_TYPE (args[argnum]);
833 mcore_insn_debug (("MCORE PUSH: argreg=%d; len=%d; %s\n",
834 argreg, len, TYPE_CODE (type) == TYPE_CODE_STRUCT ? "struct" : "not struct"));
835 /* Arguments larger than a register must start in an even
836 numbered register. */
839 if (TYPE_CODE (type) != TYPE_CODE_STRUCT && len > DEPRECATED_REGISTER_SIZE && argreg % 2)
841 mcore_insn_debug (("MCORE PUSH: %d > DEPRECATED_REGISTER_SIZE: and %s is not even\n",
842 len, mcore_register_names[argreg]));
846 if ((argreg <= LAST_ARGREG && len <= (LAST_ARGREG - argreg + 1) * DEPRECATED_REGISTER_SIZE)
847 || (TYPE_CODE (type) == TYPE_CODE_STRUCT))
849 /* Something that will fit entirely into registers (or a struct
850 which may be split between registers and stack). */
851 mcore_insn_debug (("MCORE PUSH: arg %d going into regs\n", argnum));
853 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && olen < DEPRECATED_REGISTER_SIZE)
855 /* Small structs must be right aligned within the register,
856 the most significant bits are undefined. */
857 write_register (argreg, extract_unsigned_integer (val, len));
862 while (len > 0 && argreg <= LAST_ARGREG)
864 write_register (argreg, extract_unsigned_integer (val, DEPRECATED_REGISTER_SIZE));
866 val += DEPRECATED_REGISTER_SIZE;
867 len -= DEPRECATED_REGISTER_SIZE;
870 /* Any remainder for the stack is noted below... */
872 else if (TYPE_CODE (VALUE_TYPE (args[argnum])) != TYPE_CODE_STRUCT
873 && len > DEPRECATED_REGISTER_SIZE)
875 /* All subsequent args go onto the stack. */
876 mcore_insn_debug (("MCORE PUSH: does not fit into regs, going onto stack\n"));
877 argnum = LAST_ARGREG + 1;
882 /* Note that this must be saved onto the stack */
883 mcore_insn_debug (("MCORE PUSH: adding arg %d to stack\n", argnum));
884 stack_args[nstack_args].val = val;
885 stack_args[nstack_args].len = len;
891 /* We're done with registers and stack allocation. Now do the actual
893 while (nstack_args--)
895 sp -= stack_args[nstack_args].len;
896 write_memory (sp, stack_args[nstack_args].val, stack_args[nstack_args].len);
899 /* Return adjusted stack pointer. */
903 /* Store the return address for the call dummy. For MCore, we've opted
904 to use generic call dummies, so we simply store the entry-point
905 address into the PR register (r15). */
908 mcore_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
910 write_register (PR_REGNUM, entry_point_address ());
914 /* Setting/getting return values from functions.
916 The Motorola MCore processors use r2/r3 to return anything
917 not larger than 32 bits. Everything else goes into a caller-
918 supplied buffer, which is passed in via a hidden first
921 For gdb, this leaves us two routes, based on what
922 USE_STRUCT_CONVENTION (mcore_use_struct_convention) returns. If
923 this macro returns 1, gdb will call STORE_STRUCT_RETURN to store
926 If USE_STRUCT_CONVENTION returns 0, then gdb uses
927 STORE_RETURN_VALUE and EXTRACT_RETURN_VALUE to store/fetch the
928 functions return value. */
931 mcore_use_struct_convention (int gcc_p, struct type *type)
933 return (TYPE_LENGTH (type) > 8);
936 /* Given a function which returns a value of type TYPE, extract the
937 the function's return value and place the result into VALBUF.
938 REGBUF is the register contents of the target. */
941 mcore_extract_return_value (struct type *type, char *regbuf, char *valbuf)
943 /* Copy the return value (starting) in RETVAL_REGNUM to VALBUF. */
944 /* Only getting the first byte! if len = 1, we need the last byte of
945 the register, not the first. */
946 memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM) +
947 (TYPE_LENGTH (type) < 4 ? 4 - TYPE_LENGTH (type) : 0), TYPE_LENGTH (type));
950 /* Store the return value in VALBUF (of type TYPE) where the caller
953 Values less than 32 bits are stored in r2, right justified and
954 sign or zero extended.
956 Values between 32 and 64 bits are stored in r2 (most
957 significant word) and r3 (least significant word, left justified).
958 Note that this includes structures of less than eight bytes, too. */
961 mcore_store_return_value (struct type *type, char *valbuf)
968 value_size = TYPE_LENGTH (type);
970 /* Return value fits into registers. */
971 return_size = (value_size + DEPRECATED_REGISTER_SIZE - 1) & ~(DEPRECATED_REGISTER_SIZE - 1);
972 offset = DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM) + (return_size - value_size);
973 zeros = alloca (return_size);
974 memset (zeros, 0, return_size);
976 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM), zeros,
978 deprecated_write_register_bytes (offset, valbuf, value_size);
981 /* Initialize our target-dependent "stuff" for this newly created frame.
983 This includes allocating space for saved registers and analyzing
984 the prologue of this frame. */
987 mcore_init_extra_frame_info (int fromleaf, struct frame_info *fi)
989 if (fi && get_next_frame (fi))
990 deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
992 frame_saved_regs_zalloc (fi);
994 frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
995 get_frame_extra_info (fi)->status = 0;
996 get_frame_extra_info (fi)->framesize = 0;
998 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
999 get_frame_base (fi)))
1001 /* We need to setup fi->frame here because call_function_by_hand
1002 gets it wrong by assuming it's always FP. */
1003 deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
1006 mcore_analyze_prologue (fi, 0, 0);
1009 /* Get an insturction from memory. */
1012 get_insn (CORE_ADDR pc)
1015 int status = read_memory_nobpt (pc, buf, 2);
1019 return extract_unsigned_integer (buf, 2);
1022 static struct gdbarch *
1023 mcore_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1025 static LONGEST call_dummy_words[7] = { };
1026 struct gdbarch_tdep *tdep = NULL;
1027 struct gdbarch *gdbarch;
1029 /* find a candidate among the list of pre-declared architectures. */
1030 arches = gdbarch_list_lookup_by_info (arches, &info);
1032 return (arches->gdbarch);
1034 gdbarch = gdbarch_alloc (&info, 0);
1036 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1037 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1038 set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
1042 /* All registers are 32 bits */
1043 set_gdbarch_deprecated_register_size (gdbarch, MCORE_REG_SIZE);
1044 set_gdbarch_deprecated_max_register_raw_size (gdbarch, MCORE_REG_SIZE);
1045 set_gdbarch_deprecated_max_register_virtual_size (gdbarch, MCORE_REG_SIZE);
1046 set_gdbarch_register_name (gdbarch, mcore_register_name);
1047 set_gdbarch_deprecated_register_virtual_type (gdbarch, mcore_register_virtual_type);
1048 set_gdbarch_deprecated_register_virtual_size (gdbarch, mcore_register_size);
1049 set_gdbarch_deprecated_register_raw_size (gdbarch, mcore_register_size);
1050 set_gdbarch_deprecated_register_byte (gdbarch, mcore_register_byte);
1051 set_gdbarch_deprecated_register_bytes (gdbarch, MCORE_REG_SIZE * MCORE_NUM_REGS);
1052 set_gdbarch_num_regs (gdbarch, MCORE_NUM_REGS);
1053 set_gdbarch_pc_regnum (gdbarch, 64);
1054 set_gdbarch_sp_regnum (gdbarch, 0);
1055 set_gdbarch_deprecated_fp_regnum (gdbarch, 0);
1059 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
1060 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
1061 set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1062 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, mcore_saved_pc_after_call);
1063 set_gdbarch_breakpoint_from_pc (gdbarch, mcore_breakpoint_from_pc);
1064 set_gdbarch_deprecated_push_return_address (gdbarch, mcore_push_return_address);
1065 set_gdbarch_deprecated_push_arguments (gdbarch, mcore_push_arguments);
1069 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, mcore_init_extra_frame_info);
1070 set_gdbarch_deprecated_frame_chain (gdbarch, mcore_frame_chain);
1071 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, mcore_frame_init_saved_regs);
1072 set_gdbarch_deprecated_frame_saved_pc (gdbarch, mcore_frame_saved_pc);
1073 set_gdbarch_deprecated_store_return_value (gdbarch, mcore_store_return_value);
1074 set_gdbarch_deprecated_extract_return_value (gdbarch,
1075 mcore_extract_return_value);
1076 set_gdbarch_deprecated_store_struct_return (gdbarch, mcore_store_struct_return);
1077 set_gdbarch_skip_prologue (gdbarch, mcore_skip_prologue);
1078 set_gdbarch_deprecated_frame_args_address (gdbarch, mcore_frame_args_address);
1079 set_gdbarch_deprecated_frame_locals_address (gdbarch, mcore_frame_locals_address);
1080 set_gdbarch_deprecated_pop_frame (gdbarch, mcore_pop_frame);
1081 set_gdbarch_virtual_frame_pointer (gdbarch, mcore_virtual_frame_pointer);
1085 /* Stack grows down. */
1086 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1087 set_gdbarch_use_struct_convention (gdbarch, mcore_use_struct_convention);
1088 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1089 /* MCore will never pass a sturcture by reference. It will always be split
1090 between registers and stack. */
1091 set_gdbarch_deprecated_reg_struct_has_addr
1092 (gdbarch, mcore_reg_struct_has_addr);
1094 /* Should be using push_dummy_call. */
1095 set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1097 set_gdbarch_print_insn (gdbarch, print_insn_mcore);
1103 mcore_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1108 extern initialize_file_ftype _initialize_mcore_tdep; /* -Wmissing-prototypes */
1111 _initialize_mcore_tdep (void)
1113 gdbarch_register (bfd_arch_mcore, mcore_gdbarch_init, mcore_dump_tdep);
1116 add_show_from_set (add_set_cmd ("mcoredebug", no_class,
1117 var_boolean, (char *) &mcore_debug,
1118 "Set mcore debugging.\n", &setlist),