1 /* Target-machine dependent code for Motorola MCore for GDB, the GNU debugger
2 Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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. */
29 #include "arch-utils.h"
30 #include "gdb_string.h"
34 static CORE_ADDR
mcore_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
,
36 static int get_insn (CORE_ADDR pc
);
43 /* All registers are 4 bytes long. */
44 #define MCORE_REG_SIZE 4
45 #define MCORE_NUM_REGS 65
47 /* Some useful register numbers. */
49 #define FIRST_ARGREG 2
51 #define RETVAL_REGNUM 2
54 /* Additional info that we use for managing frames */
55 struct frame_extra_info
57 /* A generic status word */
60 /* Size of this frame */
63 /* The register that is acting as a frame pointer, if
64 it is being used. This is undefined if status
65 does not contain the flag MY_FRAME_IN_FP. */
69 /* frame_extra_info status flags */
71 /* The base of the current frame is actually in the stack pointer.
72 This happens when there is no frame pointer (MCore ABI does not
73 require a frame pointer) or when we're stopped in the prologue or
74 epilogue itself. In these cases, mcore_analyze_prologue will need
75 to update fi->frame before returning or analyzing the register
77 #define MY_FRAME_IN_SP 0x1
79 /* The base of the current frame is in a frame pointer register.
80 This register is noted in frame_extra_info->fp_regnum.
82 Note that the existence of an FP might also indicate that the
83 function has called alloca. */
84 #define MY_FRAME_IN_FP 0x2
86 /* This flag is set to indicate that this frame is the top-most
87 frame. This tells frame chain not to bother trying to unwind
89 #define NO_MORE_FRAMES 0x4
91 /* Instruction macros used for analyzing the prologue */
92 #define IS_SUBI0(x) (((x) & 0xfe0f) == 0x2400) /* subi r0,oimm5 */
93 #define IS_STM(x) (((x) & 0xfff0) == 0x0070) /* stm rf-r15,r0 */
94 #define IS_STWx0(x) (((x) & 0xf00f) == 0x9000) /* stw rz,(r0,disp) */
95 #define IS_STWxy(x) (((x) & 0xf000) == 0x9000) /* stw rx,(ry,disp) */
96 #define IS_MOVx0(x) (((x) & 0xfff0) == 0x1200) /* mov rn,r0 */
97 #define IS_LRW1(x) (((x) & 0xff00) == 0x7100) /* lrw r1,literal */
98 #define IS_MOVI1(x) (((x) & 0xf80f) == 0x6001) /* movi r1,imm7 */
99 #define IS_BGENI1(x) (((x) & 0xfe0f) == 0x3201) /* bgeni r1,imm5 */
100 #define IS_BMASKI1(x) (((x) & 0xfe0f) == 0x2C01) /* bmaski r1,imm5 */
101 #define IS_ADDI1(x) (((x) & 0xfe0f) == 0x2001) /* addi r1,oimm5 */
102 #define IS_SUBI1(x) (((x) & 0xfe0f) == 0x2401) /* subi r1,oimm5 */
103 #define IS_RSUBI1(x) (((x) & 0xfe0f) == 0x2801) /* rsubi r1,imm5 */
104 #define IS_NOT1(x) (((x) & 0xffff) == 0x01f1) /* not r1 */
105 #define IS_ROTLI1(x) (((x) & 0xfe0f) == 0x3801) /* rotli r1,imm5 */
106 #define IS_BSETI1(x) (((x) & 0xfe0f) == 0x3401) /* bseti r1,imm5 */
107 #define IS_BCLRI1(x) (((x) & 0xfe0f) == 0x3001) /* bclri r1,imm5 */
108 #define IS_IXH1(x) (((x) & 0xffff) == 0x1d11) /* ixh r1,r1 */
109 #define IS_IXW1(x) (((x) & 0xffff) == 0x1511) /* ixw r1,r1 */
110 #define IS_SUB01(x) (((x) & 0xffff) == 0x0510) /* subu r0,r1 */
111 #define IS_RTS(x) (((x) & 0xffff) == 0x00cf) /* jmp r15 */
113 #define IS_R1_ADJUSTER(x) \
114 (IS_ADDI1(x) || IS_SUBI1(x) || IS_ROTLI1(x) || IS_BSETI1(x) \
115 || IS_BCLRI1(x) || IS_RSUBI1(x) || IS_NOT1(x) \
116 || IS_IXH1(x) || IS_IXW1(x))
121 mcore_dump_insn (char *commnt
, CORE_ADDR pc
, int insn
)
125 printf_filtered ("MCORE: %s %08x %08x ",
126 commnt
, (unsigned int) pc
, (unsigned int) insn
);
127 gdb_print_insn (pc
, gdb_stdout
);
128 printf_filtered ("\n");
131 #define mcore_insn_debug(args) { if (mcore_debug) printf_filtered args; }
132 #else /* !MCORE_DEBUG */
133 #define mcore_dump_insn(a,b,c) {}
134 #define mcore_insn_debug(args) {}
139 mcore_register_virtual_type (int regnum
)
141 if (regnum
< 0 || regnum
>= MCORE_NUM_REGS
)
142 internal_error (__FILE__
, __LINE__
,
143 "mcore_register_virtual_type: illegal register number %d",
146 return builtin_type_int
;
150 mcore_register_byte (int regnum
)
152 if (regnum
< 0 || regnum
>= MCORE_NUM_REGS
)
153 internal_error (__FILE__
, __LINE__
,
154 "mcore_register_byte: illegal register number %d",
157 return (regnum
* MCORE_REG_SIZE
);
161 mcore_register_size (int regnum
)
164 if (regnum
< 0 || regnum
>= MCORE_NUM_REGS
)
165 internal_error (__FILE__
, __LINE__
,
166 "mcore_register_size: illegal register number %d",
169 return MCORE_REG_SIZE
;
172 /* The registers of the Motorola MCore processors */
175 mcore_register_name (int regnum
)
178 static char *register_names
[] = {
179 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
180 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
181 "ar0", "ar1", "ar2", "ar3", "ar4", "ar5", "ar6", "ar7",
182 "ar8", "ar9", "ar10", "ar11", "ar12", "ar13", "ar14", "ar15",
183 "psr", "vbr", "epsr", "fpsr", "epc", "fpc", "ss0", "ss1",
184 "ss2", "ss3", "ss4", "gcr", "gsr", "cr13", "cr14", "cr15",
185 "cr16", "cr17", "cr18", "cr19", "cr20", "cr21", "cr22", "cr23",
186 "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31",
191 regnum
>= sizeof (register_names
) / sizeof (register_names
[0]))
192 internal_error (__FILE__
, __LINE__
,
193 "mcore_register_name: illegal register number %d",
196 return register_names
[regnum
];
199 /* Given the address at which to insert a breakpoint (BP_ADDR),
200 what will that breakpoint be?
202 For MCore, we have a breakpoint instruction. Since all MCore
203 instructions are 16 bits, this is all we need, regardless of
204 address. bpkt = 0x0000 */
206 static const unsigned char *
207 mcore_breakpoint_from_pc (CORE_ADDR
* bp_addr
, int *bp_size
)
209 static char breakpoint
[] =
216 mcore_saved_pc_after_call (struct frame_info
*frame
)
218 return read_register (PR_REGNUM
);
221 /* This is currently handled by init_extra_frame_info. */
223 mcore_frame_init_saved_regs (struct frame_info
*frame
)
228 /* This is currently handled by mcore_push_arguments */
230 mcore_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
236 mcore_reg_struct_has_addr (int gcc_p
, struct type
*type
)
242 /* Helper function for several routines below. This funtion simply
243 sets up a fake, aka dummy, frame (not a _call_ dummy frame) that
244 we can analyze with mcore_analyze_prologue. */
246 static struct frame_info
*
247 analyze_dummy_frame (CORE_ADDR pc
, CORE_ADDR frame
)
249 static struct frame_info
*dummy
= NULL
;
253 struct frame_extra_info
*extra_info
;
254 CORE_ADDR
*saved_regs
;
255 dummy
= deprecated_frame_xmalloc ();
256 saved_regs
= (CORE_ADDR
*) xmalloc (SIZEOF_FRAME_SAVED_REGS
);
257 deprecated_set_frame_saved_regs_hack (dummy
, saved_regs
);
258 extra_info
= XMALLOC (struct frame_extra_info
);
259 deprecated_set_frame_extra_info_hack (dummy
, extra_info
);
262 deprecated_set_frame_next_hack (dummy
, NULL
);
263 deprecated_set_frame_prev_hack (dummy
, NULL
);
264 deprecated_update_frame_pc_hack (dummy
, pc
);
265 deprecated_update_frame_base_hack (dummy
, frame
);
266 get_frame_extra_info (dummy
)->status
= 0;
267 get_frame_extra_info (dummy
)->framesize
= 0;
268 memset (get_frame_saved_regs (dummy
), '\000', SIZEOF_FRAME_SAVED_REGS
);
269 mcore_analyze_prologue (dummy
, 0, 0);
273 /* Function prologues on the Motorola MCore processors consist of:
275 - adjustments to the stack pointer (r1 used as scratch register)
276 - store word/multiples that use r0 as the base address
277 - making a copy of r0 into another register (a "frame" pointer)
279 Note that the MCore really doesn't have a real frame pointer.
280 Instead, the compiler may copy the SP into a register (usually
281 r8) to act as an arg pointer. For our target-dependent purposes,
282 the frame info's "frame" member will be the beginning of the
283 frame. The SP could, in fact, point below this.
285 The prologue ends when an instruction fails to meet either of
286 the first two criteria or when an FP is made. We make a special
287 exception for gcc. When compiling unoptimized code, gcc will
288 setup stack slots. We need to make sure that we skip the filling
289 of these stack slots as much as possible. This is only done
290 when SKIP_PROLOGUE is set, so that it does not mess up
293 /* Analyze the prologue of frame FI to determine where registers are saved,
294 the end of the prologue, etc. Return the address of the first line
295 of "real" code (i.e., the end of the prologue). */
298 mcore_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
, int skip_prologue
)
300 CORE_ADDR func_addr
, func_end
, addr
, stop
;
301 CORE_ADDR stack_size
;
304 int fp_regnum
= 0; /* dummy, valid when (flags & MY_FRAME_IN_FP) */
307 int register_offsets
[NUM_REGS
];
310 /* If provided, use the PC in the frame to look up the
311 start of this function. */
312 pc
= (fi
== NULL
? pc
: get_frame_pc (fi
));
314 /* Find the start of this function. */
315 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
317 /* If the start of this function could not be found or if the debbuger
318 is stopped at the first instruction of the prologue, do nothing. */
322 /* If the debugger is entry function, give up. */
323 if (func_addr
== entry_point_address ())
326 get_frame_extra_info (fi
)->status
|= NO_MORE_FRAMES
;
330 /* At the start of a function, our frame is in the stack pointer. */
331 flags
= MY_FRAME_IN_SP
;
333 /* Start decoding the prologue. We start by checking two special cases:
335 1. We're about to return
336 2. We're at the first insn of the prologue.
338 If we're about to return, our frame has already been deallocated.
339 If we are stopped at the first instruction of a prologue,
340 then our frame has not yet been set up. */
342 /* Get the first insn from memory (all MCore instructions are 16 bits) */
343 mcore_insn_debug (("MCORE: starting prologue decoding\n"));
344 insn
= get_insn (pc
);
345 mcore_dump_insn ("got 1: ", pc
, insn
);
347 /* Check for return. */
348 if (fi
!= NULL
&& IS_RTS (insn
))
350 mcore_insn_debug (("MCORE: got jmp r15"));
351 if (get_next_frame (fi
) == NULL
)
352 deprecated_update_frame_base_hack (fi
, read_sp ());
353 return get_frame_pc (fi
);
356 /* Check for first insn of prologue */
357 if (fi
!= NULL
&& get_frame_pc (fi
) == func_addr
)
359 if (get_next_frame (fi
) == NULL
)
360 deprecated_update_frame_base_hack (fi
, read_sp ());
361 return get_frame_pc (fi
);
364 /* Figure out where to stop scanning */
365 stop
= (fi
? get_frame_pc (fi
) : func_end
);
367 /* Don't walk off the end of the function */
368 stop
= (stop
> func_end
? func_end
: stop
);
370 /* REGISTER_OFFSETS will contain offsets, from the top of the frame
371 (NOT the frame pointer), for the various saved registers or -1
372 if the register is not saved. */
373 for (rn
= 0; rn
< NUM_REGS
; rn
++)
374 register_offsets
[rn
] = -1;
376 /* Analyze the prologue. Things we determine from analyzing the
378 * the size of the frame
379 * where saved registers are located (and which are saved)
381 mcore_insn_debug (("MCORE: Scanning prologue: func_addr=0x%x, stop=0x%x\n",
382 (unsigned int) func_addr
, (unsigned int) stop
));
385 for (addr
= func_addr
; addr
< stop
; addr
+= 2)
388 insn
= get_insn (addr
);
389 mcore_dump_insn ("got 2: ", addr
, insn
);
393 int offset
= 1 + ((insn
>> 4) & 0x1f);
394 mcore_insn_debug (("MCORE: got subi r0,%d; continuing\n", offset
));
398 else if (IS_STM (insn
))
400 /* Spill register(s) */
404 /* BIG WARNING! The MCore ABI does not restrict functions
405 to taking only one stack allocation. Therefore, when
406 we save a register, we record the offset of where it was
407 saved relative to the current framesize. This will
408 then give an offset from the SP upon entry to our
409 function. Remember, framesize is NOT constant until
410 we're done scanning the prologue. */
411 start_register
= (insn
& 0xf);
412 mcore_insn_debug (("MCORE: got stm r%d-r15,(r0)\n", start_register
));
414 for (rn
= start_register
, offset
= 0; rn
<= 15; rn
++, offset
+= 4)
416 register_offsets
[rn
] = framesize
- offset
;
417 mcore_insn_debug (("MCORE: r%d saved at 0x%x (offset %d)\n", rn
,
418 register_offsets
[rn
], offset
));
420 mcore_insn_debug (("MCORE: continuing\n"));
423 else if (IS_STWx0 (insn
))
425 /* Spill register: see note for IS_STM above. */
428 rn
= (insn
>> 8) & 0xf;
429 imm
= (insn
>> 4) & 0xf;
430 register_offsets
[rn
] = framesize
- (imm
<< 2);
431 mcore_insn_debug (("MCORE: r%d saved at offset 0x%x\n", rn
, register_offsets
[rn
]));
432 mcore_insn_debug (("MCORE: continuing\n"));
435 else if (IS_MOVx0 (insn
))
437 /* We have a frame pointer, so this prologue is over. Note
438 the register which is acting as the frame pointer. */
439 flags
|= MY_FRAME_IN_FP
;
440 flags
&= ~MY_FRAME_IN_SP
;
441 fp_regnum
= insn
& 0xf;
442 mcore_insn_debug (("MCORE: Found a frame pointer: r%d\n", fp_regnum
));
444 /* If we found an FP, we're at the end of the prologue. */
445 mcore_insn_debug (("MCORE: end of prologue\n"));
449 /* If we're decoding prologue, stop here. */
453 else if (IS_STWxy (insn
) && (flags
& MY_FRAME_IN_FP
) && ((insn
& 0xf) == fp_regnum
))
455 /* Special case. Skip over stack slot allocs, too. */
456 mcore_insn_debug (("MCORE: push arg onto stack.\n"));
459 else if (IS_LRW1 (insn
) || IS_MOVI1 (insn
)
460 || IS_BGENI1 (insn
) || IS_BMASKI1 (insn
))
466 mcore_insn_debug (("MCORE: looking at large frame\n"));
470 read_memory_integer ((addr
+ 2 + ((insn
& 0xff) << 2)) & 0xfffffffc, 4);
472 else if (IS_MOVI1 (insn
))
473 adjust
= (insn
>> 4) & 0x7f;
474 else if (IS_BGENI1 (insn
))
475 adjust
= 1 << ((insn
>> 4) & 0x1f);
476 else /* IS_BMASKI (insn) */
477 adjust
= (1 << (adjust
>> 4) & 0x1f) - 1;
479 mcore_insn_debug (("MCORE: base framesize=0x%x\n", adjust
));
481 /* May have zero or more insns which modify r1 */
482 mcore_insn_debug (("MCORE: looking for r1 adjusters...\n"));
484 insn2
= get_insn (addr
+ offset
);
485 while (IS_R1_ADJUSTER (insn2
))
489 imm
= (insn2
>> 4) & 0x1f;
490 mcore_dump_insn ("got 3: ", addr
+ offset
, insn
);
491 if (IS_ADDI1 (insn2
))
494 mcore_insn_debug (("MCORE: addi r1,%d\n", imm
+ 1));
496 else if (IS_SUBI1 (insn2
))
499 mcore_insn_debug (("MCORE: subi r1,%d\n", imm
+ 1));
501 else if (IS_RSUBI1 (insn2
))
503 adjust
= imm
- adjust
;
504 mcore_insn_debug (("MCORE: rsubi r1,%d\n", imm
+ 1));
506 else if (IS_NOT1 (insn2
))
509 mcore_insn_debug (("MCORE: not r1\n"));
511 else if (IS_ROTLI1 (insn2
))
514 mcore_insn_debug (("MCORE: rotli r1,%d\n", imm
+ 1));
516 else if (IS_BSETI1 (insn2
))
518 adjust
|= (1 << imm
);
519 mcore_insn_debug (("MCORE: bseti r1,%d\n", imm
));
521 else if (IS_BCLRI1 (insn2
))
523 adjust
&= ~(1 << imm
);
524 mcore_insn_debug (("MCORE: bclri r1,%d\n", imm
));
526 else if (IS_IXH1 (insn2
))
529 mcore_insn_debug (("MCORE: ix.h r1,r1\n"));
531 else if (IS_IXW1 (insn2
))
534 mcore_insn_debug (("MCORE: ix.w r1,r1\n"));
538 insn2
= get_insn (addr
+ offset
);
541 mcore_insn_debug (("MCORE: done looking for r1 adjusters\n"));
543 /* If the next insn adjusts the stack pointer, we keep everything;
544 if not, we scrap it and we've found the end of the prologue. */
545 if (IS_SUB01 (insn2
))
549 mcore_insn_debug (("MCORE: found stack adjustment of 0x%x bytes.\n", adjust
));
550 mcore_insn_debug (("MCORE: skipping to new address 0x%x\n", addr
));
551 mcore_insn_debug (("MCORE: continuing\n"));
555 /* None of these instructions are prologue, so don't touch
557 mcore_insn_debug (("MCORE: no subu r1,r0, NOT altering framesize.\n"));
561 /* This is not a prologue insn, so stop here. */
562 mcore_insn_debug (("MCORE: insn is not a prologue insn -- ending scan\n"));
566 mcore_insn_debug (("MCORE: done analyzing prologue\n"));
567 mcore_insn_debug (("MCORE: prologue end = 0x%x\n", addr
));
569 /* Save everything we have learned about this frame into FI. */
572 get_frame_extra_info (fi
)->framesize
= framesize
;
573 get_frame_extra_info (fi
)->fp_regnum
= fp_regnum
;
574 get_frame_extra_info (fi
)->status
= flags
;
576 /* Fix the frame pointer. When gcc uses r8 as a frame pointer,
577 it is really an arg ptr. We adjust fi->frame to be a "real"
579 if (get_next_frame (fi
) == NULL
)
581 if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_SP
)
582 deprecated_update_frame_base_hack (fi
, read_sp () + framesize
);
584 deprecated_update_frame_base_hack (fi
, read_register (fp_regnum
) + framesize
);
587 /* Note where saved registers are stored. The offsets in REGISTER_OFFSETS
588 are computed relative to the top of the frame. */
589 for (rn
= 0; rn
< NUM_REGS
; rn
++)
591 if (register_offsets
[rn
] >= 0)
593 get_frame_saved_regs (fi
)[rn
] = get_frame_base (fi
) - register_offsets
[rn
];
594 mcore_insn_debug (("Saved register %s stored at 0x%08x, value=0x%08x\n",
595 mcore_register_names
[rn
], fi
->saved_regs
[rn
],
596 read_memory_integer (fi
->saved_regs
[rn
], 4)));
601 /* Return addr of first non-prologue insn. */
605 /* Given a GDB frame, determine the address of the calling function's
606 frame. This will be used to create a new GDB frame struct, and
607 then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
608 will be called for the new frame. */
611 mcore_frame_chain (struct frame_info
* fi
)
613 struct frame_info
*dummy
;
614 CORE_ADDR callers_addr
;
616 /* Analyze the prologue of this function. */
617 if (get_frame_extra_info (fi
)->status
== 0)
618 mcore_analyze_prologue (fi
, 0, 0);
620 /* If mcore_analyze_prologue set NO_MORE_FRAMES, quit now. */
621 if (get_frame_extra_info (fi
)->status
& NO_MORE_FRAMES
)
624 /* Now that we've analyzed our prologue, we can start to ask
625 for information about our caller. The easiest way to do
626 this is to analyze our caller's prologue.
628 If our caller has a frame pointer, then we need to find
629 the value of that register upon entry to our frame.
630 This value is either in fi->saved_regs[rn] if it's saved,
631 or it's still in a register.
633 If our caller does not have a frame pointer, then his frame base
634 is <our base> + -<caller's frame size>. */
635 dummy
= analyze_dummy_frame (DEPRECATED_FRAME_SAVED_PC (fi
), get_frame_base (fi
));
637 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_FP
)
639 int fp
= get_frame_extra_info (dummy
)->fp_regnum
;
641 /* Our caller has a frame pointer. */
642 if (get_frame_saved_regs (fi
)[fp
] != 0)
644 /* The "FP" was saved on the stack. Don't forget to adjust
645 the "FP" with the framesize to get a real FP. */
646 callers_addr
= read_memory_integer (get_frame_saved_regs (fi
)[fp
],
647 DEPRECATED_REGISTER_SIZE
)
648 + get_frame_extra_info (dummy
)->framesize
;
652 /* It's still in the register. Don't forget to adjust
653 the "FP" with the framesize to get a real FP. */
654 callers_addr
= read_register (fp
) + get_frame_extra_info (dummy
)->framesize
;
659 /* Our caller does not have a frame pointer. */
660 callers_addr
= get_frame_base (fi
) + get_frame_extra_info (dummy
)->framesize
;
666 /* Skip the prologue of the function at PC. */
669 mcore_skip_prologue (CORE_ADDR pc
)
671 CORE_ADDR func_addr
, func_end
;
672 struct symtab_and_line sal
;
674 /* If we have line debugging information, then the end of the
675 prologue should be the first assembly instruction of the first
677 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
679 sal
= find_pc_line (func_addr
, 0);
680 if (sal
.end
&& sal
.end
< func_end
)
684 return mcore_analyze_prologue (NULL
, pc
, 1);
687 /* Return the address at which function arguments are offset. */
689 mcore_frame_args_address (struct frame_info
* fi
)
691 return get_frame_base (fi
) - get_frame_extra_info (fi
)->framesize
;
695 mcore_frame_locals_address (struct frame_info
* fi
)
697 return get_frame_base (fi
) - get_frame_extra_info (fi
)->framesize
;
700 /* Return the frame pointer in use at address PC. */
703 mcore_virtual_frame_pointer (CORE_ADDR pc
, int *reg
, LONGEST
*offset
)
705 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
706 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_SP
)
713 *reg
= get_frame_extra_info (dummy
)->fp_regnum
;
718 /* Find the value of register REGNUM in frame FI. */
721 mcore_find_callers_reg (struct frame_info
*fi
, int regnum
)
723 for (; fi
!= NULL
; fi
= get_next_frame (fi
))
725 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
726 get_frame_base (fi
)))
727 return deprecated_read_register_dummy (get_frame_pc (fi
),
728 get_frame_base (fi
), regnum
);
729 else if (get_frame_saved_regs (fi
)[regnum
] != 0)
730 return read_memory_integer (get_frame_saved_regs (fi
)[regnum
],
731 DEPRECATED_REGISTER_SIZE
);
734 return read_register (regnum
);
737 /* Find the saved pc in frame FI. */
740 mcore_frame_saved_pc (struct frame_info
* fi
)
743 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
744 get_frame_base (fi
)))
745 return deprecated_read_register_dummy (get_frame_pc (fi
),
746 get_frame_base (fi
), PC_REGNUM
);
748 return mcore_find_callers_reg (fi
, PR_REGNUM
);
751 /* INFERIOR FUNCTION CALLS */
753 /* This routine gets called when either the user uses the "return"
754 command, or the call dummy breakpoint gets hit. */
757 mcore_pop_frame (void)
760 struct frame_info
*fi
= get_current_frame ();
762 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
763 get_frame_base (fi
)))
764 generic_pop_dummy_frame ();
767 /* Write out the PC we saved. */
768 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (fi
));
770 /* Restore any saved registers. */
771 for (rn
= 0; rn
< NUM_REGS
; rn
++)
773 if (get_frame_saved_regs (fi
)[rn
] != 0)
777 value
= read_memory_unsigned_integer (get_frame_saved_regs (fi
)[rn
],
778 DEPRECATED_REGISTER_SIZE
);
779 write_register (rn
, value
);
783 /* Actually cut back the stack. */
784 write_register (SP_REGNUM
, get_frame_base (fi
));
787 /* Finally, throw away any cached frame information. */
788 flush_cached_frames ();
791 /* Setup arguments and PR for a call to the target. First six arguments
792 go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on to the stack.
794 - Types with lengths greater than DEPRECATED_REGISTER_SIZE may not
795 be split between registers and the stack, and they must start in an
796 even-numbered register. Subsequent args will go onto the stack.
798 * Structs may be split between registers and stack, left-aligned.
800 * If the function returns a struct which will not fit into registers (it's
801 more than eight bytes), we must allocate for that, too. Gdb will tell
802 us where this buffer is (STRUCT_ADDR), and we simply place it into
803 FIRST_ARGREG, since the MCORE treats struct returns (of less than eight
804 bytes) as hidden first arguments. */
807 mcore_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
808 int struct_return
, CORE_ADDR struct_addr
)
820 stack_args
= (struct stack_arg
*) alloca (nargs
* sizeof (struct stack_arg
));
822 argreg
= FIRST_ARGREG
;
824 /* Align the stack. This is mostly a nop, but not always. It will be needed
825 if we call a function which has argument overflow. */
828 /* If this function returns a struct which does not fit in the
829 return registers, we must pass a buffer to the function
830 which it can use to save the return value. */
832 write_register (argreg
++, struct_addr
);
834 /* FIXME: what about unions? */
835 for (argnum
= 0; argnum
< nargs
; argnum
++)
837 char *val
= (char *) VALUE_CONTENTS (args
[argnum
]);
838 int len
= TYPE_LENGTH (VALUE_TYPE (args
[argnum
]));
839 struct type
*type
= VALUE_TYPE (args
[argnum
]);
842 mcore_insn_debug (("MCORE PUSH: argreg=%d; len=%d; %s\n",
843 argreg
, len
, TYPE_CODE (type
) == TYPE_CODE_STRUCT
? "struct" : "not struct"));
844 /* Arguments larger than a register must start in an even
845 numbered register. */
848 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&& len
> DEPRECATED_REGISTER_SIZE
&& argreg
% 2)
850 mcore_insn_debug (("MCORE PUSH: %d > DEPRECATED_REGISTER_SIZE: and %s is not even\n",
851 len
, mcore_register_names
[argreg
]));
855 if ((argreg
<= LAST_ARGREG
&& len
<= (LAST_ARGREG
- argreg
+ 1) * DEPRECATED_REGISTER_SIZE
)
856 || (TYPE_CODE (type
) == TYPE_CODE_STRUCT
))
858 /* Something that will fit entirely into registers (or a struct
859 which may be split between registers and stack). */
860 mcore_insn_debug (("MCORE PUSH: arg %d going into regs\n", argnum
));
862 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& olen
< DEPRECATED_REGISTER_SIZE
)
864 /* Small structs must be right aligned within the register,
865 the most significant bits are undefined. */
866 write_register (argreg
, extract_unsigned_integer (val
, len
));
871 while (len
> 0 && argreg
<= LAST_ARGREG
)
873 write_register (argreg
, extract_unsigned_integer (val
, DEPRECATED_REGISTER_SIZE
));
875 val
+= DEPRECATED_REGISTER_SIZE
;
876 len
-= DEPRECATED_REGISTER_SIZE
;
879 /* Any remainder for the stack is noted below... */
881 else if (TYPE_CODE (VALUE_TYPE (args
[argnum
])) != TYPE_CODE_STRUCT
882 && len
> DEPRECATED_REGISTER_SIZE
)
884 /* All subsequent args go onto the stack. */
885 mcore_insn_debug (("MCORE PUSH: does not fit into regs, going onto stack\n"));
886 argnum
= LAST_ARGREG
+ 1;
891 /* Note that this must be saved onto the stack */
892 mcore_insn_debug (("MCORE PUSH: adding arg %d to stack\n", argnum
));
893 stack_args
[nstack_args
].val
= val
;
894 stack_args
[nstack_args
].len
= len
;
900 /* We're done with registers and stack allocation. Now do the actual
902 while (nstack_args
--)
904 sp
-= stack_args
[nstack_args
].len
;
905 write_memory (sp
, stack_args
[nstack_args
].val
, stack_args
[nstack_args
].len
);
908 /* Return adjusted stack pointer. */
912 /* Store the return address for the call dummy. For MCore, we've opted
913 to use generic call dummies, so we simply store the entry-point
914 address into the PR register (r15). */
917 mcore_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
919 write_register (PR_REGNUM
, entry_point_address ());
923 /* Setting/getting return values from functions.
925 The Motorola MCore processors use r2/r3 to return anything
926 not larger than 32 bits. Everything else goes into a caller-
927 supplied buffer, which is passed in via a hidden first
930 For gdb, this leaves us two routes, based on what
931 USE_STRUCT_CONVENTION (mcore_use_struct_convention) returns.
932 If this macro returns 1, gdb will call STORE_STRUCT_RETURN and
933 EXTRACT_STRUCT_VALUE_ADDRESS.
935 If USE_STRUCT_CONVENTION retruns 0, then gdb uses STORE_RETURN_VALUE
936 and EXTRACT_RETURN_VALUE to store/fetch the functions return value. */
938 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
939 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
940 and TYPE is the type (which is known to be struct, union or array). */
943 mcore_use_struct_convention (int gcc_p
, struct type
*type
)
945 return (TYPE_LENGTH (type
) > 8);
948 /* Where is the return value saved? For MCore, a pointer to
949 this buffer was passed as a hidden first argument, so
950 just return that address. */
953 mcore_extract_struct_value_address (char *regbuf
)
955 return extract_unsigned_integer (regbuf
+ REGISTER_BYTE (FIRST_ARGREG
), DEPRECATED_REGISTER_SIZE
);
958 /* Given a function which returns a value of type TYPE, extract the
959 the function's return value and place the result into VALBUF.
960 REGBUF is the register contents of the target. */
963 mcore_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
965 /* Copy the return value (starting) in RETVAL_REGNUM to VALBUF. */
966 /* Only getting the first byte! if len = 1, we need the last byte of
967 the register, not the first. */
968 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (RETVAL_REGNUM
) +
969 (TYPE_LENGTH (type
) < 4 ? 4 - TYPE_LENGTH (type
) : 0), TYPE_LENGTH (type
));
972 /* Store the return value in VALBUF (of type TYPE) where the caller
975 Values less than 32 bits are stored in r2, right justified and
976 sign or zero extended.
978 Values between 32 and 64 bits are stored in r2 (most
979 significant word) and r3 (least significant word, left justified).
980 Note that this includes structures of less than eight bytes, too. */
983 mcore_store_return_value (struct type
*type
, char *valbuf
)
990 value_size
= TYPE_LENGTH (type
);
992 /* Return value fits into registers. */
993 return_size
= (value_size
+ DEPRECATED_REGISTER_SIZE
- 1) & ~(DEPRECATED_REGISTER_SIZE
- 1);
994 offset
= REGISTER_BYTE (RETVAL_REGNUM
) + (return_size
- value_size
);
995 zeros
= alloca (return_size
);
996 memset (zeros
, 0, return_size
);
998 deprecated_write_register_bytes (REGISTER_BYTE (RETVAL_REGNUM
), zeros
,
1000 deprecated_write_register_bytes (offset
, valbuf
, value_size
);
1003 /* Initialize our target-dependent "stuff" for this newly created frame.
1005 This includes allocating space for saved registers and analyzing
1006 the prologue of this frame. */
1009 mcore_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1011 if (fi
&& get_next_frame (fi
))
1012 deprecated_update_frame_pc_hack (fi
, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi
)));
1014 frame_saved_regs_zalloc (fi
);
1016 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
1017 get_frame_extra_info (fi
)->status
= 0;
1018 get_frame_extra_info (fi
)->framesize
= 0;
1020 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
1021 get_frame_base (fi
)))
1023 /* We need to setup fi->frame here because call_function_by_hand
1024 gets it wrong by assuming it's always FP. */
1025 deprecated_update_frame_base_hack (fi
, deprecated_read_register_dummy (get_frame_pc (fi
), get_frame_base (fi
), SP_REGNUM
));
1028 mcore_analyze_prologue (fi
, 0, 0);
1031 /* Get an insturction from memory. */
1034 get_insn (CORE_ADDR pc
)
1037 int status
= read_memory_nobpt (pc
, buf
, 2);
1041 return extract_unsigned_integer (buf
, 2);
1044 static struct gdbarch
*
1045 mcore_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1047 static LONGEST call_dummy_words
[7] = { };
1048 struct gdbarch_tdep
*tdep
= NULL
;
1049 struct gdbarch
*gdbarch
;
1051 /* find a candidate among the list of pre-declared architectures. */
1052 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1054 return (arches
->gdbarch
);
1056 gdbarch
= gdbarch_alloc (&info
, 0);
1058 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1059 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1060 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
1064 /* All registers are 32 bits */
1065 set_gdbarch_deprecated_register_size (gdbarch
, MCORE_REG_SIZE
);
1066 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, MCORE_REG_SIZE
);
1067 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, MCORE_REG_SIZE
);
1068 set_gdbarch_register_name (gdbarch
, mcore_register_name
);
1069 set_gdbarch_deprecated_register_virtual_type (gdbarch
, mcore_register_virtual_type
);
1070 set_gdbarch_deprecated_register_virtual_size (gdbarch
, mcore_register_size
);
1071 set_gdbarch_deprecated_register_raw_size (gdbarch
, mcore_register_size
);
1072 set_gdbarch_deprecated_register_byte (gdbarch
, mcore_register_byte
);
1073 set_gdbarch_deprecated_register_bytes (gdbarch
, MCORE_REG_SIZE
* MCORE_NUM_REGS
);
1074 set_gdbarch_num_regs (gdbarch
, MCORE_NUM_REGS
);
1075 set_gdbarch_pc_regnum (gdbarch
, 64);
1076 set_gdbarch_sp_regnum (gdbarch
, 0);
1077 set_gdbarch_deprecated_fp_regnum (gdbarch
, 0);
1081 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_words
);
1082 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
1083 set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1084 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, mcore_saved_pc_after_call
);
1085 set_gdbarch_function_start_offset (gdbarch
, 0);
1086 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1087 set_gdbarch_breakpoint_from_pc (gdbarch
, mcore_breakpoint_from_pc
);
1088 set_gdbarch_deprecated_push_return_address (gdbarch
, mcore_push_return_address
);
1089 set_gdbarch_deprecated_push_arguments (gdbarch
, mcore_push_arguments
);
1093 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, mcore_init_extra_frame_info
);
1094 set_gdbarch_deprecated_frame_chain (gdbarch
, mcore_frame_chain
);
1095 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, mcore_frame_init_saved_regs
);
1096 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, mcore_frame_saved_pc
);
1097 set_gdbarch_deprecated_store_return_value (gdbarch
, mcore_store_return_value
);
1098 set_gdbarch_deprecated_extract_return_value (gdbarch
,
1099 mcore_extract_return_value
);
1100 set_gdbarch_deprecated_store_struct_return (gdbarch
, mcore_store_struct_return
);
1101 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1102 mcore_extract_struct_value_address
);
1103 set_gdbarch_skip_prologue (gdbarch
, mcore_skip_prologue
);
1104 set_gdbarch_frame_args_skip (gdbarch
, 0);
1105 set_gdbarch_deprecated_frame_args_address (gdbarch
, mcore_frame_args_address
);
1106 set_gdbarch_deprecated_frame_locals_address (gdbarch
, mcore_frame_locals_address
);
1107 set_gdbarch_deprecated_pop_frame (gdbarch
, mcore_pop_frame
);
1108 set_gdbarch_virtual_frame_pointer (gdbarch
, mcore_virtual_frame_pointer
);
1112 /* Stack grows down. */
1113 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1114 set_gdbarch_use_struct_convention (gdbarch
, mcore_use_struct_convention
);
1115 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1116 /* MCore will never pass a sturcture by reference. It will always be split
1117 between registers and stack. */
1118 set_gdbarch_deprecated_reg_struct_has_addr
1119 (gdbarch
, mcore_reg_struct_has_addr
);
1121 /* Should be using push_dummy_call. */
1122 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
1124 set_gdbarch_print_insn (gdbarch
, print_insn_mcore
);
1130 mcore_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1135 extern initialize_file_ftype _initialize_mcore_tdep
; /* -Wmissing-prototypes */
1138 _initialize_mcore_tdep (void)
1140 gdbarch_register (bfd_arch_mcore
, mcore_gdbarch_init
, mcore_dump_tdep
);
1143 add_show_from_set (add_set_cmd ("mcoredebug", no_class
,
1144 var_boolean
, (char *) &mcore_debug
,
1145 "Set mcore debugging.\n", &setlist
),