1 /* Target-dependent code for the Matsushita MN10200 for GDB, the GNU debugger.
3 Copyright 1997, 1998, 1999, 2000, 2001, 2003 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,
21 Boston, MA 02111-1307, USA. */
29 #include "gdb_string.h"
35 /* Should call_function allocate stack space for a struct return? */
37 mn10200_use_struct_convention (int gcc_p
, struct type
*type
)
39 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
42 /* The main purpose of this file is dealing with prologues to extract
43 information about stack frames and saved registers.
45 For reference here's how prologues look on the mn10200:
51 Register saves for d2, d3, a1, a2 as needed. Saves start
52 at fp - <size> + <outgoing_args_size> and work towards higher
53 addresses. Note that the saves are actually done off the stack
54 pointer in the prologue! This makes for smaller code and easier
55 prologue scanning as the displacement fields will unlikely
58 Without frame pointer:
60 Register saves for d2, d3, a1, a2 as needed. Saves start
61 at sp + <outgoing_args_size> and work towards higher addresses.
64 add <local size>,sp -- optional
66 add <outgoing_size>,sp -- optional
68 The stack pointer remains constant throughout the life of most
69 functions. As a result the compiler will usually omit the
70 frame pointer, so we must handle frame pointerless functions. */
72 /* Analyze the prologue to determine where registers are saved,
73 the end of the prologue, etc etc. Return the end of the prologue
76 We store into FI (if non-null) several tidbits of information:
78 * stack_size -- size of this stack frame. Note that if we stop in
79 certain parts of the prologue/epilogue we may claim the size of the
80 current frame is zero. This happens when the current frame has
81 not been allocated yet or has already been deallocated.
83 * fsr -- Addresses of registers saved in the stack by this frame.
85 * status -- A (relatively) generic status indicator. It's a bitmask
86 with the following bits:
88 MY_FRAME_IN_SP: The base of the current frame is actually in
89 the stack pointer. This can happen for frame pointerless
90 functions, or cases where we're stopped in the prologue/epilogue
91 itself. For these cases mn10200_analyze_prologue will need up
92 update fi->frame before returning or analyzing the register
95 MY_FRAME_IN_FP: The base of the current frame is in the
96 frame pointer register ($a2).
98 CALLER_A2_IN_A0: $a2 from the caller's frame is temporarily
99 in $a0. This can happen if we're stopped in the prologue.
101 NO_MORE_FRAMES: Set this if the current frame is "start" or
102 if the first instruction looks like mov <imm>,sp. This tells
103 frame chain to not bother trying to unwind past this frame. */
109 #define MY_FRAME_IN_SP 0x1
110 #define MY_FRAME_IN_FP 0x2
111 #define CALLER_A2_IN_A0 0x4
112 #define NO_MORE_FRAMES 0x8
115 mn10200_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
)
117 CORE_ADDR func_addr
, func_end
, addr
, stop
;
118 CORE_ADDR stack_size
= 0;
119 unsigned char buf
[4];
122 int out_of_line_prologue
= 0;
124 /* Use the PC in the frame if it's provided to look up the
125 start of this function. */
126 pc
= (fi
? get_frame_pc (fi
) : pc
);
128 /* Find the start of this function. */
129 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
131 /* Do nothing if we couldn't find the start of this function or if we're
132 stopped at the first instruction in the prologue. */
136 /* If we're in start, then give up. */
137 if (strcmp (name
, "start") == 0)
140 fi
->status
= NO_MORE_FRAMES
;
144 /* At the start of a function our frame is in the stack pointer. */
146 fi
->status
= MY_FRAME_IN_SP
;
148 /* If we're physically on an RTS instruction, then our frame has already
151 fi->frame is bogus, we need to fix it. */
152 if (fi
&& get_frame_pc (fi
) + 1 == func_end
)
154 status
= target_read_memory (get_frame_pc (fi
), buf
, 1);
157 if (get_next_frame (fi
) == NULL
)
158 deprecated_update_frame_base_hack (fi
, read_sp ());
159 return get_frame_pc (fi
);
164 if (get_next_frame (fi
) == NULL
)
165 deprecated_update_frame_base_hack (fi
, read_sp ());
166 return get_frame_pc (fi
);
170 /* Similarly if we're stopped on the first insn of a prologue as our
171 frame hasn't been allocated yet. */
172 if (fi
&& get_frame_pc (fi
) == func_addr
)
174 if (get_next_frame (fi
) == NULL
)
175 deprecated_update_frame_base_hack (fi
, read_sp ());
176 return get_frame_pc (fi
);
179 /* Figure out where to stop scanning. */
180 stop
= fi
? get_frame_pc (fi
) : func_end
;
182 /* Don't walk off the end of the function. */
183 stop
= stop
> func_end
? func_end
: stop
;
185 /* Start scanning on the first instruction of this function. */
188 status
= target_read_memory (addr
, buf
, 2);
191 if (fi
&& get_next_frame (fi
) == NULL
&& fi
->status
& MY_FRAME_IN_SP
)
192 deprecated_update_frame_base_hack (fi
, read_sp ());
196 /* First see if this insn sets the stack pointer; if so, it's something
197 we won't understand, so quit now. */
199 || (buf
[0] == 0xf4 && buf
[1] == 0x77))
202 fi
->status
= NO_MORE_FRAMES
;
206 /* Now see if we have a frame pointer.
208 Search for mov a2,a0 (0xf278)
209 then mov a3,a2 (0xf27e). */
211 if (buf
[0] == 0xf2 && buf
[1] == 0x78)
213 /* Our caller's $a2 will be found in $a0 now. Note it for
216 fi
->status
|= CALLER_A2_IN_A0
;
220 /* We still haven't allocated our local stack. Handle this
221 as if we stopped on the first or last insn of a function. */
222 if (fi
&& get_next_frame (fi
) == NULL
)
223 deprecated_update_frame_base_hack (fi
, read_sp ());
227 status
= target_read_memory (addr
, buf
, 2);
230 if (fi
&& get_next_frame (fi
) == NULL
)
231 deprecated_update_frame_base_hack (fi
, read_sp ());
234 if (buf
[0] == 0xf2 && buf
[1] == 0x7e)
238 /* Our frame pointer is valid now. */
241 fi
->status
|= MY_FRAME_IN_FP
;
242 fi
->status
&= ~MY_FRAME_IN_SP
;
249 if (fi
&& get_next_frame (fi
) == NULL
)
250 deprecated_update_frame_base_hack (fi
, read_sp ());
255 /* Next we should allocate the local frame.
257 Search for add imm8,a3 (0xd3XX)
258 or add imm16,a3 (0xf70bXXXX)
259 or add imm24,a3 (0xf467XXXXXX).
261 If none of the above was found, then this prologue has
262 no stack, and therefore can't have any register saves,
264 status
= target_read_memory (addr
, buf
, 2);
267 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
268 deprecated_update_frame_base_hack (fi
, read_sp ());
273 stack_size
= extract_signed_integer (&buf
[1], 1);
275 fi
->stack_size
= stack_size
;
279 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
280 deprecated_update_frame_base_hack (fi
, read_sp () - stack_size
);
284 else if (buf
[0] == 0xf7 && buf
[1] == 0x0b)
286 status
= target_read_memory (addr
+ 2, buf
, 2);
289 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
290 deprecated_update_frame_base_hack (fi
, read_sp ());
293 stack_size
= extract_signed_integer (buf
, 2);
295 fi
->stack_size
= stack_size
;
299 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
300 deprecated_update_frame_base_hack (fi
, read_sp () - stack_size
);
304 else if (buf
[0] == 0xf4 && buf
[1] == 0x67)
306 status
= target_read_memory (addr
+ 2, buf
, 3);
309 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
310 deprecated_update_frame_base_hack (fi
, read_sp ());
313 stack_size
= extract_signed_integer (buf
, 3);
315 fi
->stack_size
= stack_size
;
319 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
320 deprecated_update_frame_base_hack (fi
, read_sp () - stack_size
);
325 /* Now see if we have a call to __prologue for an out of line
327 status
= target_read_memory (addr
, buf
, 2);
331 /* First check for 16bit pc-relative call to __prologue. */
335 status
= target_read_memory (addr
+ 1, buf
, 2);
338 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
339 deprecated_update_frame_base_hack (fi
, read_sp ());
343 /* Get the PC this instruction will branch to. */
344 temp
= (extract_signed_integer (buf
, 2) + addr
+ 3) & 0xffffff;
346 /* Get the name of the function at the target address. */
347 status
= find_pc_partial_function (temp
, &name
, NULL
, NULL
);
350 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
351 deprecated_update_frame_base_hack (fi
, read_sp ());
355 /* Note if it is an out of line prologue. */
356 out_of_line_prologue
= (strcmp (name
, "__prologue") == 0);
358 /* This sucks up 3 bytes of instruction space. */
359 if (out_of_line_prologue
)
364 if (fi
&& get_next_frame (fi
) == NULL
)
366 fi
->stack_size
-= 16;
367 deprecated_update_frame_base_hack (fi
, read_sp () - fi
->stack_size
);
372 /* Now check for the 24bit pc-relative call to __prologue. */
373 else if (buf
[0] == 0xf4 && buf
[1] == 0xe1)
376 status
= target_read_memory (addr
+ 2, buf
, 3);
379 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
380 deprecated_update_frame_base_hack (fi
, read_sp ());
384 /* Get the PC this instruction will branch to. */
385 temp
= (extract_signed_integer (buf
, 3) + addr
+ 5) & 0xffffff;
387 /* Get the name of the function at the target address. */
388 status
= find_pc_partial_function (temp
, &name
, NULL
, NULL
);
391 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
392 deprecated_update_frame_base_hack (fi
, read_sp ());
396 /* Note if it is an out of line prologue. */
397 out_of_line_prologue
= (strcmp (name
, "__prologue") == 0);
399 /* This sucks up 5 bytes of instruction space. */
400 if (out_of_line_prologue
)
405 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
407 fi
->stack_size
-= 16;
408 deprecated_update_frame_base_hack (fi
, read_sp () - fi
->stack_size
);
414 /* Now actually handle the out of line prologue. */
415 if (out_of_line_prologue
)
417 int outgoing_args_size
= 0;
419 /* First adjust the stack size for this function. The out of
420 line prologue saves 4 registers (16bytes of data). */
422 fi
->stack_size
-= 16;
424 /* Update fi->frame if necessary. */
425 if (fi
&& get_next_frame (fi
) == NULL
)
426 deprecated_update_frame_base_hack (fi
, read_sp () - fi
->stack_size
);
428 /* After the out of line prologue, there may be another
429 stack adjustment for the outgoing arguments.
431 Search for add imm8,a3 (0xd3XX)
432 or add imm16,a3 (0xf70bXXXX)
433 or add imm24,a3 (0xf467XXXXXX). */
435 status
= target_read_memory (addr
, buf
, 2);
440 fi
->fsr
.regs
[2] = get_frame_base (fi
) + fi
->stack_size
+ 4;
441 fi
->fsr
.regs
[3] = get_frame_base (fi
) + fi
->stack_size
+ 8;
442 fi
->fsr
.regs
[5] = get_frame_base (fi
) + fi
->stack_size
+ 12;
443 fi
->fsr
.regs
[6] = get_frame_base (fi
) + fi
->stack_size
+ 16;
450 outgoing_args_size
= extract_signed_integer (&buf
[1], 1);
453 else if (buf
[0] == 0xf7 && buf
[1] == 0x0b)
455 status
= target_read_memory (addr
+ 2, buf
, 2);
460 fi
->fsr
.regs
[2] = get_frame_base (fi
) + fi
->stack_size
+ 4;
461 fi
->fsr
.regs
[3] = get_frame_base (fi
) + fi
->stack_size
+ 8;
462 fi
->fsr
.regs
[5] = get_frame_base (fi
) + fi
->stack_size
+ 12;
463 fi
->fsr
.regs
[6] = get_frame_base (fi
) + fi
->stack_size
+ 16;
467 outgoing_args_size
= extract_signed_integer (buf
, 2);
470 else if (buf
[0] == 0xf4 && buf
[1] == 0x67)
472 status
= target_read_memory (addr
+ 2, buf
, 3);
475 if (fi
&& get_next_frame (fi
) == NULL
)
477 fi
->fsr
.regs
[2] = get_frame_base (fi
) + fi
->stack_size
+ 4;
478 fi
->fsr
.regs
[3] = get_frame_base (fi
) + fi
->stack_size
+ 8;
479 fi
->fsr
.regs
[5] = get_frame_base (fi
) + fi
->stack_size
+ 12;
480 fi
->fsr
.regs
[6] = get_frame_base (fi
) + fi
->stack_size
+ 16;
484 outgoing_args_size
= extract_signed_integer (buf
, 3);
488 outgoing_args_size
= 0;
490 /* Now that we know the size of the outgoing arguments, fix
491 fi->frame again if this is the innermost frame. */
492 if (fi
&& get_next_frame (fi
) == NULL
)
493 deprecated_update_frame_base_hack (fi
, get_frame_base (fi
) - outgoing_args_size
);
495 /* Note the register save information and update the stack
496 size for this frame too. */
499 fi
->fsr
.regs
[2] = get_frame_base (fi
) + fi
->stack_size
+ 4;
500 fi
->fsr
.regs
[3] = get_frame_base (fi
) + fi
->stack_size
+ 8;
501 fi
->fsr
.regs
[5] = get_frame_base (fi
) + fi
->stack_size
+ 12;
502 fi
->fsr
.regs
[6] = get_frame_base (fi
) + fi
->stack_size
+ 16;
503 fi
->stack_size
+= outgoing_args_size
;
505 /* There can be no more prologue insns, so return now. */
509 /* At this point fi->frame needs to be correct.
511 If MY_FRAME_IN_SP is set and we're the innermost frame, then we
512 need to fix fi->frame so that backtracing, find_frame_saved_regs,
513 etc work correctly. */
514 if (fi
&& get_next_frame (fi
) == NULL
&& (fi
->status
& MY_FRAME_IN_SP
) != 0)
515 deprecated_update_frame_base_hack (fi
, read_sp () - fi
->stack_size
);
517 /* And last we have the register saves. These are relatively
518 simple because they're physically done off the stack pointer,
519 and thus the number of different instructions we need to
520 check is greatly reduced because we know the displacements
523 Search for movx d2,(X,a3) (0xf55eXX)
524 then movx d3,(X,a3) (0xf55fXX)
525 then mov a1,(X,a3) (0x5dXX) No frame pointer case
526 then mov a2,(X,a3) (0x5eXX) No frame pointer case
527 or mov a0,(X,a3) (0x5cXX) Frame pointer case. */
529 status
= target_read_memory (addr
, buf
, 2);
532 if (buf
[0] == 0xf5 && buf
[1] == 0x5e)
536 status
= target_read_memory (addr
+ 2, buf
, 1);
539 fi
->fsr
.regs
[2] = (get_frame_base (fi
) + stack_size
540 + extract_signed_integer (buf
, 1));
545 status
= target_read_memory (addr
, buf
, 2);
549 if (buf
[0] == 0xf5 && buf
[1] == 0x5f)
553 status
= target_read_memory (addr
+ 2, buf
, 1);
556 fi
->fsr
.regs
[3] = (get_frame_base (fi
) + stack_size
557 + extract_signed_integer (buf
, 1));
562 status
= target_read_memory (addr
, buf
, 2);
570 status
= target_read_memory (addr
+ 1, buf
, 1);
573 fi
->fsr
.regs
[5] = (get_frame_base (fi
) + stack_size
574 + extract_signed_integer (buf
, 1));
579 status
= target_read_memory (addr
, buf
, 2);
583 if (buf
[0] == 0x5e || buf
[0] == 0x5c)
587 status
= target_read_memory (addr
+ 1, buf
, 1);
590 fi
->fsr
.regs
[6] = (get_frame_base (fi
) + stack_size
591 + extract_signed_integer (buf
, 1));
592 fi
->status
&= ~CALLER_A2_IN_A0
;
602 /* Function: frame_chain
603 Figure out and return the caller's frame pointer given current
606 We don't handle dummy frames yet but we would probably just return the
607 stack pointer that was in use at the time the function call was made? */
610 mn10200_frame_chain (struct frame_info
*fi
)
612 struct frame_info
*dummy_frame
= deprecated_frame_xmalloc ();
613 struct cleanup
*old_chain
= make_cleanup (xfree
, dummy_frame
);
616 /* Walk through the prologue to determine the stack size,
617 location of saved registers, end of the prologue, etc. */
619 mn10200_analyze_prologue (fi
, (CORE_ADDR
) 0);
621 /* Quit now if mn10200_analyze_prologue set NO_MORE_FRAMES. */
622 if (fi
->status
& NO_MORE_FRAMES
)
625 /* Now that we've analyzed our prologue, determine the frame
626 pointer for our caller.
628 If our caller has a frame pointer, then we need to
629 find the entry value of $a2 to our function.
631 If CALLER_A2_IN_A0, then the chain is in $a0.
633 If fsr.regs[6] is nonzero, then it's at the memory
634 location pointed to by fsr.regs[6].
636 Else it's still in $a2.
638 If our caller does not have a frame pointer, then his
639 frame base is fi->frame + -caller's stack size + 4. */
641 /* The easiest way to get that info is to analyze our caller's frame.
643 So we set up a dummy frame and call mn10200_analyze_prologue to
644 find stuff for us. */
645 deprecated_update_frame_pc_hack (dummy_frame
, FRAME_SAVED_PC (fi
));
646 deprecated_update_frame_base_hack (dummy_frame
, get_frame_base (fi
));
647 memset (dummy_frame
->fsr
.regs
, '\000', sizeof dummy_frame
->fsr
.regs
);
648 dummy_frame
->status
= 0;
649 dummy_frame
->stack_size
= 0;
650 mn10200_analyze_prologue (dummy_frame
, 0);
652 if (dummy_frame
->status
& MY_FRAME_IN_FP
)
654 /* Our caller has a frame pointer. So find the frame in $a2, $a0,
657 ret
= (read_memory_integer (fi
->fsr
.regs
[FP_REGNUM
], REGISTER_SIZE
)
659 else if (fi
->status
& CALLER_A2_IN_A0
)
660 ret
= read_register (4);
662 ret
= read_register (FP_REGNUM
);
666 /* Our caller does not have a frame pointer. So his frame starts
667 at the base of our frame (fi->frame) + <his size> + 4 (saved pc). */
668 ret
= get_frame_base (fi
) + -dummy_frame
->stack_size
+ 4;
670 do_cleanups (old_chain
);
674 /* Function: skip_prologue
675 Return the address of the first inst past the prologue of the function. */
678 mn10200_skip_prologue (CORE_ADDR pc
)
680 /* We used to check the debug symbols, but that can lose if
681 we have a null prologue. */
682 return mn10200_analyze_prologue (NULL
, pc
);
685 /* Function: pop_frame
686 This routine gets called when either the user uses the `return'
687 command, or the call dummy breakpoint gets hit. */
690 mn10200_pop_frame (struct frame_info
*frame
)
694 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
695 get_frame_base (frame
),
696 get_frame_base (frame
)))
697 generic_pop_dummy_frame ();
700 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
702 /* Restore any saved registers. */
703 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
704 if (frame
->fsr
.regs
[regnum
] != 0)
708 value
= read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
709 REGISTER_RAW_SIZE (regnum
));
710 write_register (regnum
, value
);
713 /* Actually cut back the stack. */
714 write_register (SP_REGNUM
, get_frame_base (frame
));
716 /* Don't we need to set the PC?!? XXX FIXME. */
719 /* Throw away any cached frame information. */
720 flush_cached_frames ();
723 /* Function: push_arguments
724 Setup arguments for a call to the target. Arguments go in
725 order on the stack. */
728 mn10200_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
729 unsigned char struct_return
, CORE_ADDR struct_addr
)
733 int stack_offset
= 0;
734 int regsused
= struct_return
? 1 : 0;
736 /* This should be a nop, but align the stack just in case something
737 went wrong. Stacks are two byte aligned on the mn10200. */
740 /* Now make space on the stack for the args.
742 XXX This doesn't appear to handle pass-by-invisible reference
744 for (argnum
= 0; argnum
< nargs
; argnum
++)
746 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 1) & ~1;
748 /* If we've used all argument registers, then this argument is
750 if (regsused
>= 2 || arg_length
> 4)
755 /* We know we've got some arg register space left. If this argument
756 will fit entirely in regs, then put it there. */
757 else if (arg_length
<= 2
758 || TYPE_CODE (VALUE_TYPE (args
[argnum
])) == TYPE_CODE_PTR
)
762 else if (regsused
== 0)
773 /* Allocate stack space. */
776 regsused
= struct_return
? 1 : 0;
777 /* Push all arguments onto the stack. */
778 for (argnum
= 0; argnum
< nargs
; argnum
++)
783 /* XXX Check this. What about UNIONS? */
784 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
785 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
787 /* XXX Wrong, we want a pointer to this argument. */
788 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
789 val
= (char *) VALUE_CONTENTS (*args
);
793 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
794 val
= (char *) VALUE_CONTENTS (*args
);
799 || TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_PTR
))
801 write_register (regsused
, extract_unsigned_integer (val
, 4));
804 else if (regsused
== 0 && len
== 4)
806 write_register (regsused
, extract_unsigned_integer (val
, 2));
807 write_register (regsused
+ 1, extract_unsigned_integer (val
+ 2, 2));
815 write_memory (sp
+ stack_offset
, val
, 2);
828 /* Function: push_return_address (pc)
829 Set up the return address for the inferior function call.
830 Needed for targets where we don't actually execute a JSR/BSR instruction */
833 mn10200_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
835 unsigned char buf
[4];
837 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
838 write_memory (sp
- 4, buf
, 4);
842 /* Function: store_struct_return (addr,sp)
843 Store the structure value return address for an inferior function
847 mn10200_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
849 /* The structure return address is passed as the first argument. */
850 write_register (0, addr
);
854 /* Function: frame_saved_pc
855 Find the caller of this frame. We do this by seeing if RP_REGNUM
856 is saved in the stack anywhere, otherwise we get it from the
857 registers. If the inner frame is a dummy frame, return its PC
858 instead of RP, because that's where "caller" of the dummy-frame
862 mn10200_frame_saved_pc (struct frame_info
*fi
)
864 /* The saved PC will always be at the base of the current frame. */
865 return (read_memory_integer (get_frame_base (fi
), REGISTER_SIZE
) & 0xffffff);
868 /* Function: init_extra_frame_info
869 Setup the frame's frame pointer, pc, and frame addresses for saved
870 registers. Most of the work is done in mn10200_analyze_prologue().
872 Note that when we are called for the last frame (currently active frame),
873 that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
874 be valid only if this routine uses FP. For previous frames, fi-frame will
875 always be correct. mn10200_analyze_prologue will fix fi->frame if
878 We can be called with the PC in the call dummy under two circumstances.
879 First, during normal backtracing, second, while figuring out the frame
880 pointer just prior to calling the target function (see run_stack_dummy). */
883 mn10200_init_extra_frame_info (struct frame_info
*fi
)
885 if (get_next_frame (fi
))
886 deprecated_update_frame_pc_hack (fi
, FRAME_SAVED_PC (get_next_frame (fi
)));
888 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
892 mn10200_analyze_prologue (fi
, 0);
896 _initialize_mn10200_tdep (void)
898 tm_print_insn
= print_insn_mn10200
;