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_update_frame_pc_hack (dummy
, pc
);
263 deprecated_update_frame_base_hack (dummy
, frame
);
264 get_frame_extra_info (dummy
)->status
= 0;
265 get_frame_extra_info (dummy
)->framesize
= 0;
266 memset (deprecated_get_frame_saved_regs (dummy
), '\000', SIZEOF_FRAME_SAVED_REGS
);
267 mcore_analyze_prologue (dummy
, 0, 0);
271 /* Function prologues on the Motorola MCore processors consist of:
273 - adjustments to the stack pointer (r1 used as scratch register)
274 - store word/multiples that use r0 as the base address
275 - making a copy of r0 into another register (a "frame" pointer)
277 Note that the MCore really doesn't have a real frame pointer.
278 Instead, the compiler may copy the SP into a register (usually
279 r8) to act as an arg pointer. For our target-dependent purposes,
280 the frame info's "frame" member will be the beginning of the
281 frame. The SP could, in fact, point below this.
283 The prologue ends when an instruction fails to meet either of
284 the first two criteria or when an FP is made. We make a special
285 exception for gcc. When compiling unoptimized code, gcc will
286 setup stack slots. We need to make sure that we skip the filling
287 of these stack slots as much as possible. This is only done
288 when SKIP_PROLOGUE is set, so that it does not mess up
291 /* Analyze the prologue of frame FI to determine where registers are saved,
292 the end of the prologue, etc. Return the address of the first line
293 of "real" code (i.e., the end of the prologue). */
296 mcore_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
, int skip_prologue
)
298 CORE_ADDR func_addr
, func_end
, addr
, stop
;
299 CORE_ADDR stack_size
;
302 int fp_regnum
= 0; /* dummy, valid when (flags & MY_FRAME_IN_FP) */
305 int register_offsets
[NUM_REGS
];
308 /* If provided, use the PC in the frame to look up the
309 start of this function. */
310 pc
= (fi
== NULL
? pc
: get_frame_pc (fi
));
312 /* Find the start of this function. */
313 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
315 /* If the start of this function could not be found or if the debbuger
316 is stopped at the first instruction of the prologue, do nothing. */
320 /* If the debugger is entry function, give up. */
321 if (func_addr
== entry_point_address ())
324 get_frame_extra_info (fi
)->status
|= NO_MORE_FRAMES
;
328 /* At the start of a function, our frame is in the stack pointer. */
329 flags
= MY_FRAME_IN_SP
;
331 /* Start decoding the prologue. We start by checking two special cases:
333 1. We're about to return
334 2. We're at the first insn of the prologue.
336 If we're about to return, our frame has already been deallocated.
337 If we are stopped at the first instruction of a prologue,
338 then our frame has not yet been set up. */
340 /* Get the first insn from memory (all MCore instructions are 16 bits) */
341 mcore_insn_debug (("MCORE: starting prologue decoding\n"));
342 insn
= get_insn (pc
);
343 mcore_dump_insn ("got 1: ", pc
, insn
);
345 /* Check for return. */
346 if (fi
!= NULL
&& IS_RTS (insn
))
348 mcore_insn_debug (("MCORE: got jmp r15"));
349 if (get_next_frame (fi
) == NULL
)
350 deprecated_update_frame_base_hack (fi
, read_sp ());
351 return get_frame_pc (fi
);
354 /* Check for first insn of prologue */
355 if (fi
!= NULL
&& get_frame_pc (fi
) == func_addr
)
357 if (get_next_frame (fi
) == NULL
)
358 deprecated_update_frame_base_hack (fi
, read_sp ());
359 return get_frame_pc (fi
);
362 /* Figure out where to stop scanning */
363 stop
= (fi
? get_frame_pc (fi
) : func_end
);
365 /* Don't walk off the end of the function */
366 stop
= (stop
> func_end
? func_end
: stop
);
368 /* REGISTER_OFFSETS will contain offsets, from the top of the frame
369 (NOT the frame pointer), for the various saved registers or -1
370 if the register is not saved. */
371 for (rn
= 0; rn
< NUM_REGS
; rn
++)
372 register_offsets
[rn
] = -1;
374 /* Analyze the prologue. Things we determine from analyzing the
376 * the size of the frame
377 * where saved registers are located (and which are saved)
379 mcore_insn_debug (("MCORE: Scanning prologue: func_addr=0x%x, stop=0x%x\n",
380 (unsigned int) func_addr
, (unsigned int) stop
));
383 for (addr
= func_addr
; addr
< stop
; addr
+= 2)
386 insn
= get_insn (addr
);
387 mcore_dump_insn ("got 2: ", addr
, insn
);
391 int offset
= 1 + ((insn
>> 4) & 0x1f);
392 mcore_insn_debug (("MCORE: got subi r0,%d; continuing\n", offset
));
396 else if (IS_STM (insn
))
398 /* Spill register(s) */
402 /* BIG WARNING! The MCore ABI does not restrict functions
403 to taking only one stack allocation. Therefore, when
404 we save a register, we record the offset of where it was
405 saved relative to the current framesize. This will
406 then give an offset from the SP upon entry to our
407 function. Remember, framesize is NOT constant until
408 we're done scanning the prologue. */
409 start_register
= (insn
& 0xf);
410 mcore_insn_debug (("MCORE: got stm r%d-r15,(r0)\n", start_register
));
412 for (rn
= start_register
, offset
= 0; rn
<= 15; rn
++, offset
+= 4)
414 register_offsets
[rn
] = framesize
- offset
;
415 mcore_insn_debug (("MCORE: r%d saved at 0x%x (offset %d)\n", rn
,
416 register_offsets
[rn
], offset
));
418 mcore_insn_debug (("MCORE: continuing\n"));
421 else if (IS_STWx0 (insn
))
423 /* Spill register: see note for IS_STM above. */
426 rn
= (insn
>> 8) & 0xf;
427 imm
= (insn
>> 4) & 0xf;
428 register_offsets
[rn
] = framesize
- (imm
<< 2);
429 mcore_insn_debug (("MCORE: r%d saved at offset 0x%x\n", rn
, register_offsets
[rn
]));
430 mcore_insn_debug (("MCORE: continuing\n"));
433 else if (IS_MOVx0 (insn
))
435 /* We have a frame pointer, so this prologue is over. Note
436 the register which is acting as the frame pointer. */
437 flags
|= MY_FRAME_IN_FP
;
438 flags
&= ~MY_FRAME_IN_SP
;
439 fp_regnum
= insn
& 0xf;
440 mcore_insn_debug (("MCORE: Found a frame pointer: r%d\n", fp_regnum
));
442 /* If we found an FP, we're at the end of the prologue. */
443 mcore_insn_debug (("MCORE: end of prologue\n"));
447 /* If we're decoding prologue, stop here. */
451 else if (IS_STWxy (insn
) && (flags
& MY_FRAME_IN_FP
) && ((insn
& 0xf) == fp_regnum
))
453 /* Special case. Skip over stack slot allocs, too. */
454 mcore_insn_debug (("MCORE: push arg onto stack.\n"));
457 else if (IS_LRW1 (insn
) || IS_MOVI1 (insn
)
458 || IS_BGENI1 (insn
) || IS_BMASKI1 (insn
))
464 mcore_insn_debug (("MCORE: looking at large frame\n"));
468 read_memory_integer ((addr
+ 2 + ((insn
& 0xff) << 2)) & 0xfffffffc, 4);
470 else if (IS_MOVI1 (insn
))
471 adjust
= (insn
>> 4) & 0x7f;
472 else if (IS_BGENI1 (insn
))
473 adjust
= 1 << ((insn
>> 4) & 0x1f);
474 else /* IS_BMASKI (insn) */
475 adjust
= (1 << (adjust
>> 4) & 0x1f) - 1;
477 mcore_insn_debug (("MCORE: base framesize=0x%x\n", adjust
));
479 /* May have zero or more insns which modify r1 */
480 mcore_insn_debug (("MCORE: looking for r1 adjusters...\n"));
482 insn2
= get_insn (addr
+ offset
);
483 while (IS_R1_ADJUSTER (insn2
))
487 imm
= (insn2
>> 4) & 0x1f;
488 mcore_dump_insn ("got 3: ", addr
+ offset
, insn
);
489 if (IS_ADDI1 (insn2
))
492 mcore_insn_debug (("MCORE: addi r1,%d\n", imm
+ 1));
494 else if (IS_SUBI1 (insn2
))
497 mcore_insn_debug (("MCORE: subi r1,%d\n", imm
+ 1));
499 else if (IS_RSUBI1 (insn2
))
501 adjust
= imm
- adjust
;
502 mcore_insn_debug (("MCORE: rsubi r1,%d\n", imm
+ 1));
504 else if (IS_NOT1 (insn2
))
507 mcore_insn_debug (("MCORE: not r1\n"));
509 else if (IS_ROTLI1 (insn2
))
512 mcore_insn_debug (("MCORE: rotli r1,%d\n", imm
+ 1));
514 else if (IS_BSETI1 (insn2
))
516 adjust
|= (1 << imm
);
517 mcore_insn_debug (("MCORE: bseti r1,%d\n", imm
));
519 else if (IS_BCLRI1 (insn2
))
521 adjust
&= ~(1 << imm
);
522 mcore_insn_debug (("MCORE: bclri r1,%d\n", imm
));
524 else if (IS_IXH1 (insn2
))
527 mcore_insn_debug (("MCORE: ix.h r1,r1\n"));
529 else if (IS_IXW1 (insn2
))
532 mcore_insn_debug (("MCORE: ix.w r1,r1\n"));
536 insn2
= get_insn (addr
+ offset
);
539 mcore_insn_debug (("MCORE: done looking for r1 adjusters\n"));
541 /* If the next insn adjusts the stack pointer, we keep everything;
542 if not, we scrap it and we've found the end of the prologue. */
543 if (IS_SUB01 (insn2
))
547 mcore_insn_debug (("MCORE: found stack adjustment of 0x%x bytes.\n", adjust
));
548 mcore_insn_debug (("MCORE: skipping to new address 0x%x\n", addr
));
549 mcore_insn_debug (("MCORE: continuing\n"));
553 /* None of these instructions are prologue, so don't touch
555 mcore_insn_debug (("MCORE: no subu r1,r0, NOT altering framesize.\n"));
559 /* This is not a prologue insn, so stop here. */
560 mcore_insn_debug (("MCORE: insn is not a prologue insn -- ending scan\n"));
564 mcore_insn_debug (("MCORE: done analyzing prologue\n"));
565 mcore_insn_debug (("MCORE: prologue end = 0x%x\n", addr
));
567 /* Save everything we have learned about this frame into FI. */
570 get_frame_extra_info (fi
)->framesize
= framesize
;
571 get_frame_extra_info (fi
)->fp_regnum
= fp_regnum
;
572 get_frame_extra_info (fi
)->status
= flags
;
574 /* Fix the frame pointer. When gcc uses r8 as a frame pointer,
575 it is really an arg ptr. We adjust fi->frame to be a "real"
577 if (get_next_frame (fi
) == NULL
)
579 if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_SP
)
580 deprecated_update_frame_base_hack (fi
, read_sp () + framesize
);
582 deprecated_update_frame_base_hack (fi
, read_register (fp_regnum
) + framesize
);
585 /* Note where saved registers are stored. The offsets in REGISTER_OFFSETS
586 are computed relative to the top of the frame. */
587 for (rn
= 0; rn
< NUM_REGS
; rn
++)
589 if (register_offsets
[rn
] >= 0)
591 deprecated_get_frame_saved_regs (fi
)[rn
] = get_frame_base (fi
) - register_offsets
[rn
];
592 mcore_insn_debug (("Saved register %s stored at 0x%08x, value=0x%08x\n",
593 mcore_register_names
[rn
], fi
->saved_regs
[rn
],
594 read_memory_integer (fi
->saved_regs
[rn
], 4)));
599 /* Return addr of first non-prologue insn. */
603 /* Given a GDB frame, determine the address of the calling function's
604 frame. This will be used to create a new GDB frame struct, and
605 then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
606 will be called for the new frame. */
609 mcore_frame_chain (struct frame_info
* fi
)
611 struct frame_info
*dummy
;
612 CORE_ADDR callers_addr
;
614 /* Analyze the prologue of this function. */
615 if (get_frame_extra_info (fi
)->status
== 0)
616 mcore_analyze_prologue (fi
, 0, 0);
618 /* If mcore_analyze_prologue set NO_MORE_FRAMES, quit now. */
619 if (get_frame_extra_info (fi
)->status
& NO_MORE_FRAMES
)
622 /* Now that we've analyzed our prologue, we can start to ask
623 for information about our caller. The easiest way to do
624 this is to analyze our caller's prologue.
626 If our caller has a frame pointer, then we need to find
627 the value of that register upon entry to our frame.
628 This value is either in fi->saved_regs[rn] if it's saved,
629 or it's still in a register.
631 If our caller does not have a frame pointer, then his frame base
632 is <our base> + -<caller's frame size>. */
633 dummy
= analyze_dummy_frame (DEPRECATED_FRAME_SAVED_PC (fi
), get_frame_base (fi
));
635 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_FP
)
637 int fp
= get_frame_extra_info (dummy
)->fp_regnum
;
639 /* Our caller has a frame pointer. */
640 if (deprecated_get_frame_saved_regs (fi
)[fp
] != 0)
642 /* The "FP" was saved on the stack. Don't forget to adjust
643 the "FP" with the framesize to get a real FP. */
644 callers_addr
= read_memory_integer (deprecated_get_frame_saved_regs (fi
)[fp
],
645 DEPRECATED_REGISTER_SIZE
)
646 + get_frame_extra_info (dummy
)->framesize
;
650 /* It's still in the register. Don't forget to adjust
651 the "FP" with the framesize to get a real FP. */
652 callers_addr
= read_register (fp
) + get_frame_extra_info (dummy
)->framesize
;
657 /* Our caller does not have a frame pointer. */
658 callers_addr
= get_frame_base (fi
) + get_frame_extra_info (dummy
)->framesize
;
664 /* Skip the prologue of the function at PC. */
667 mcore_skip_prologue (CORE_ADDR pc
)
669 CORE_ADDR func_addr
, func_end
;
670 struct symtab_and_line sal
;
672 /* If we have line debugging information, then the end of the
673 prologue should be the first assembly instruction of the first
675 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
677 sal
= find_pc_line (func_addr
, 0);
678 if (sal
.end
&& sal
.end
< func_end
)
682 return mcore_analyze_prologue (NULL
, pc
, 1);
685 /* Return the address at which function arguments are offset. */
687 mcore_frame_args_address (struct frame_info
* fi
)
689 return get_frame_base (fi
) - get_frame_extra_info (fi
)->framesize
;
693 mcore_frame_locals_address (struct frame_info
* fi
)
695 return get_frame_base (fi
) - get_frame_extra_info (fi
)->framesize
;
698 /* Return the frame pointer in use at address PC. */
701 mcore_virtual_frame_pointer (CORE_ADDR pc
, int *reg
, LONGEST
*offset
)
703 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
704 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_SP
)
711 *reg
= get_frame_extra_info (dummy
)->fp_regnum
;
716 /* Find the value of register REGNUM in frame FI. */
719 mcore_find_callers_reg (struct frame_info
*fi
, int regnum
)
721 for (; fi
!= NULL
; fi
= get_next_frame (fi
))
723 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
724 get_frame_base (fi
)))
725 return deprecated_read_register_dummy (get_frame_pc (fi
),
726 get_frame_base (fi
), regnum
);
727 else if (deprecated_get_frame_saved_regs (fi
)[regnum
] != 0)
728 return read_memory_integer (deprecated_get_frame_saved_regs (fi
)[regnum
],
729 DEPRECATED_REGISTER_SIZE
);
732 return read_register (regnum
);
735 /* Find the saved pc in frame FI. */
738 mcore_frame_saved_pc (struct frame_info
* fi
)
741 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
742 get_frame_base (fi
)))
743 return deprecated_read_register_dummy (get_frame_pc (fi
),
744 get_frame_base (fi
), PC_REGNUM
);
746 return mcore_find_callers_reg (fi
, PR_REGNUM
);
749 /* INFERIOR FUNCTION CALLS */
751 /* This routine gets called when either the user uses the "return"
752 command, or the call dummy breakpoint gets hit. */
755 mcore_pop_frame (void)
758 struct frame_info
*fi
= get_current_frame ();
760 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
761 get_frame_base (fi
)))
762 generic_pop_dummy_frame ();
765 /* Write out the PC we saved. */
766 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (fi
));
768 /* Restore any saved registers. */
769 for (rn
= 0; rn
< NUM_REGS
; rn
++)
771 if (deprecated_get_frame_saved_regs (fi
)[rn
] != 0)
775 value
= read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi
)[rn
],
776 DEPRECATED_REGISTER_SIZE
);
777 write_register (rn
, value
);
781 /* Actually cut back the stack. */
782 write_register (SP_REGNUM
, get_frame_base (fi
));
785 /* Finally, throw away any cached frame information. */
786 flush_cached_frames ();
789 /* Setup arguments and PR for a call to the target. First six arguments
790 go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on to the stack.
792 - Types with lengths greater than DEPRECATED_REGISTER_SIZE may not
793 be split between registers and the stack, and they must start in an
794 even-numbered register. Subsequent args will go onto the stack.
796 * Structs may be split between registers and stack, left-aligned.
798 * If the function returns a struct which will not fit into registers (it's
799 more than eight bytes), we must allocate for that, too. Gdb will tell
800 us where this buffer is (STRUCT_ADDR), and we simply place it into
801 FIRST_ARGREG, since the MCORE treats struct returns (of less than eight
802 bytes) as hidden first arguments. */
805 mcore_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
806 int struct_return
, CORE_ADDR struct_addr
)
818 stack_args
= (struct stack_arg
*) alloca (nargs
* sizeof (struct stack_arg
));
820 argreg
= FIRST_ARGREG
;
822 /* Align the stack. This is mostly a nop, but not always. It will be needed
823 if we call a function which has argument overflow. */
826 /* If this function returns a struct which does not fit in the
827 return registers, we must pass a buffer to the function
828 which it can use to save the return value. */
830 write_register (argreg
++, struct_addr
);
832 /* FIXME: what about unions? */
833 for (argnum
= 0; argnum
< nargs
; argnum
++)
835 char *val
= (char *) VALUE_CONTENTS (args
[argnum
]);
836 int len
= TYPE_LENGTH (VALUE_TYPE (args
[argnum
]));
837 struct type
*type
= VALUE_TYPE (args
[argnum
]);
840 mcore_insn_debug (("MCORE PUSH: argreg=%d; len=%d; %s\n",
841 argreg
, len
, TYPE_CODE (type
) == TYPE_CODE_STRUCT
? "struct" : "not struct"));
842 /* Arguments larger than a register must start in an even
843 numbered register. */
846 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
&& len
> DEPRECATED_REGISTER_SIZE
&& argreg
% 2)
848 mcore_insn_debug (("MCORE PUSH: %d > DEPRECATED_REGISTER_SIZE: and %s is not even\n",
849 len
, mcore_register_names
[argreg
]));
853 if ((argreg
<= LAST_ARGREG
&& len
<= (LAST_ARGREG
- argreg
+ 1) * DEPRECATED_REGISTER_SIZE
)
854 || (TYPE_CODE (type
) == TYPE_CODE_STRUCT
))
856 /* Something that will fit entirely into registers (or a struct
857 which may be split between registers and stack). */
858 mcore_insn_debug (("MCORE PUSH: arg %d going into regs\n", argnum
));
860 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& olen
< DEPRECATED_REGISTER_SIZE
)
862 /* Small structs must be right aligned within the register,
863 the most significant bits are undefined. */
864 write_register (argreg
, extract_unsigned_integer (val
, len
));
869 while (len
> 0 && argreg
<= LAST_ARGREG
)
871 write_register (argreg
, extract_unsigned_integer (val
, DEPRECATED_REGISTER_SIZE
));
873 val
+= DEPRECATED_REGISTER_SIZE
;
874 len
-= DEPRECATED_REGISTER_SIZE
;
877 /* Any remainder for the stack is noted below... */
879 else if (TYPE_CODE (VALUE_TYPE (args
[argnum
])) != TYPE_CODE_STRUCT
880 && len
> DEPRECATED_REGISTER_SIZE
)
882 /* All subsequent args go onto the stack. */
883 mcore_insn_debug (("MCORE PUSH: does not fit into regs, going onto stack\n"));
884 argnum
= LAST_ARGREG
+ 1;
889 /* Note that this must be saved onto the stack */
890 mcore_insn_debug (("MCORE PUSH: adding arg %d to stack\n", argnum
));
891 stack_args
[nstack_args
].val
= val
;
892 stack_args
[nstack_args
].len
= len
;
898 /* We're done with registers and stack allocation. Now do the actual
900 while (nstack_args
--)
902 sp
-= stack_args
[nstack_args
].len
;
903 write_memory (sp
, stack_args
[nstack_args
].val
, stack_args
[nstack_args
].len
);
906 /* Return adjusted stack pointer. */
910 /* Store the return address for the call dummy. For MCore, we've opted
911 to use generic call dummies, so we simply store the entry-point
912 address into the PR register (r15). */
915 mcore_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
917 write_register (PR_REGNUM
, entry_point_address ());
921 /* Setting/getting return values from functions.
923 The Motorola MCore processors use r2/r3 to return anything
924 not larger than 32 bits. Everything else goes into a caller-
925 supplied buffer, which is passed in via a hidden first
928 For gdb, this leaves us two routes, based on what
929 USE_STRUCT_CONVENTION (mcore_use_struct_convention) returns.
930 If this macro returns 1, gdb will call STORE_STRUCT_RETURN and
931 EXTRACT_STRUCT_VALUE_ADDRESS.
933 If USE_STRUCT_CONVENTION retruns 0, then gdb uses STORE_RETURN_VALUE
934 and EXTRACT_RETURN_VALUE to store/fetch the functions return value. */
936 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
937 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc
938 and TYPE is the type (which is known to be struct, union or array). */
941 mcore_use_struct_convention (int gcc_p
, struct type
*type
)
943 return (TYPE_LENGTH (type
) > 8);
946 /* Where is the return value saved? For MCore, a pointer to
947 this buffer was passed as a hidden first argument, so
948 just return that address. */
951 mcore_extract_struct_value_address (char *regbuf
)
953 return extract_unsigned_integer (regbuf
+ DEPRECATED_REGISTER_BYTE (FIRST_ARGREG
), DEPRECATED_REGISTER_SIZE
);
956 /* Given a function which returns a value of type TYPE, extract the
957 the function's return value and place the result into VALBUF.
958 REGBUF is the register contents of the target. */
961 mcore_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
963 /* Copy the return value (starting) in RETVAL_REGNUM to VALBUF. */
964 /* Only getting the first byte! if len = 1, we need the last byte of
965 the register, not the first. */
966 memcpy (valbuf
, regbuf
+ DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM
) +
967 (TYPE_LENGTH (type
) < 4 ? 4 - TYPE_LENGTH (type
) : 0), TYPE_LENGTH (type
));
970 /* Store the return value in VALBUF (of type TYPE) where the caller
973 Values less than 32 bits are stored in r2, right justified and
974 sign or zero extended.
976 Values between 32 and 64 bits are stored in r2 (most
977 significant word) and r3 (least significant word, left justified).
978 Note that this includes structures of less than eight bytes, too. */
981 mcore_store_return_value (struct type
*type
, char *valbuf
)
988 value_size
= TYPE_LENGTH (type
);
990 /* Return value fits into registers. */
991 return_size
= (value_size
+ DEPRECATED_REGISTER_SIZE
- 1) & ~(DEPRECATED_REGISTER_SIZE
- 1);
992 offset
= DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM
) + (return_size
- value_size
);
993 zeros
= alloca (return_size
);
994 memset (zeros
, 0, return_size
);
996 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RETVAL_REGNUM
), zeros
,
998 deprecated_write_register_bytes (offset
, valbuf
, value_size
);
1001 /* Initialize our target-dependent "stuff" for this newly created frame.
1003 This includes allocating space for saved registers and analyzing
1004 the prologue of this frame. */
1007 mcore_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1009 if (fi
&& get_next_frame (fi
))
1010 deprecated_update_frame_pc_hack (fi
, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi
)));
1012 frame_saved_regs_zalloc (fi
);
1014 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
1015 get_frame_extra_info (fi
)->status
= 0;
1016 get_frame_extra_info (fi
)->framesize
= 0;
1018 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
1019 get_frame_base (fi
)))
1021 /* We need to setup fi->frame here because call_function_by_hand
1022 gets it wrong by assuming it's always FP. */
1023 deprecated_update_frame_base_hack (fi
, deprecated_read_register_dummy (get_frame_pc (fi
), get_frame_base (fi
), SP_REGNUM
));
1026 mcore_analyze_prologue (fi
, 0, 0);
1029 /* Get an insturction from memory. */
1032 get_insn (CORE_ADDR pc
)
1035 int status
= read_memory_nobpt (pc
, buf
, 2);
1039 return extract_unsigned_integer (buf
, 2);
1042 static struct gdbarch
*
1043 mcore_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1045 static LONGEST call_dummy_words
[7] = { };
1046 struct gdbarch_tdep
*tdep
= NULL
;
1047 struct gdbarch
*gdbarch
;
1049 /* find a candidate among the list of pre-declared architectures. */
1050 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1052 return (arches
->gdbarch
);
1054 gdbarch
= gdbarch_alloc (&info
, 0);
1056 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1057 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1058 set_gdbarch_deprecated_init_frame_pc (gdbarch
, deprecated_init_frame_pc_default
);
1062 /* All registers are 32 bits */
1063 set_gdbarch_deprecated_register_size (gdbarch
, MCORE_REG_SIZE
);
1064 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, MCORE_REG_SIZE
);
1065 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, MCORE_REG_SIZE
);
1066 set_gdbarch_register_name (gdbarch
, mcore_register_name
);
1067 set_gdbarch_deprecated_register_virtual_type (gdbarch
, mcore_register_virtual_type
);
1068 set_gdbarch_deprecated_register_virtual_size (gdbarch
, mcore_register_size
);
1069 set_gdbarch_deprecated_register_raw_size (gdbarch
, mcore_register_size
);
1070 set_gdbarch_deprecated_register_byte (gdbarch
, mcore_register_byte
);
1071 set_gdbarch_deprecated_register_bytes (gdbarch
, MCORE_REG_SIZE
* MCORE_NUM_REGS
);
1072 set_gdbarch_num_regs (gdbarch
, MCORE_NUM_REGS
);
1073 set_gdbarch_pc_regnum (gdbarch
, 64);
1074 set_gdbarch_sp_regnum (gdbarch
, 0);
1075 set_gdbarch_deprecated_fp_regnum (gdbarch
, 0);
1079 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_words
);
1080 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
1081 set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1082 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, mcore_saved_pc_after_call
);
1083 set_gdbarch_function_start_offset (gdbarch
, 0);
1084 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1085 set_gdbarch_breakpoint_from_pc (gdbarch
, mcore_breakpoint_from_pc
);
1086 set_gdbarch_deprecated_push_return_address (gdbarch
, mcore_push_return_address
);
1087 set_gdbarch_deprecated_push_arguments (gdbarch
, mcore_push_arguments
);
1091 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, mcore_init_extra_frame_info
);
1092 set_gdbarch_deprecated_frame_chain (gdbarch
, mcore_frame_chain
);
1093 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, mcore_frame_init_saved_regs
);
1094 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, mcore_frame_saved_pc
);
1095 set_gdbarch_deprecated_store_return_value (gdbarch
, mcore_store_return_value
);
1096 set_gdbarch_deprecated_extract_return_value (gdbarch
,
1097 mcore_extract_return_value
);
1098 set_gdbarch_deprecated_store_struct_return (gdbarch
, mcore_store_struct_return
);
1099 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
,
1100 mcore_extract_struct_value_address
);
1101 set_gdbarch_skip_prologue (gdbarch
, mcore_skip_prologue
);
1102 set_gdbarch_frame_args_skip (gdbarch
, 0);
1103 set_gdbarch_deprecated_frame_args_address (gdbarch
, mcore_frame_args_address
);
1104 set_gdbarch_deprecated_frame_locals_address (gdbarch
, mcore_frame_locals_address
);
1105 set_gdbarch_deprecated_pop_frame (gdbarch
, mcore_pop_frame
);
1106 set_gdbarch_virtual_frame_pointer (gdbarch
, mcore_virtual_frame_pointer
);
1110 /* Stack grows down. */
1111 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1112 set_gdbarch_use_struct_convention (gdbarch
, mcore_use_struct_convention
);
1113 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1114 /* MCore will never pass a sturcture by reference. It will always be split
1115 between registers and stack. */
1116 set_gdbarch_deprecated_reg_struct_has_addr
1117 (gdbarch
, mcore_reg_struct_has_addr
);
1119 /* Should be using push_dummy_call. */
1120 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
1122 set_gdbarch_print_insn (gdbarch
, print_insn_mcore
);
1128 mcore_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1133 extern initialize_file_ftype _initialize_mcore_tdep
; /* -Wmissing-prototypes */
1136 _initialize_mcore_tdep (void)
1138 gdbarch_register (bfd_arch_mcore
, mcore_gdbarch_init
, mcore_dump_tdep
);
1141 add_show_from_set (add_set_cmd ("mcoredebug", no_class
,
1142 var_boolean
, (char *) &mcore_debug
,
1143 "Set mcore debugging.\n", &setlist
),