1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2 Prologue analysis module, extracted from mn10300-tdep.c, Oct. 1, 2004.
4 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
5 Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
28 #include "gdb_string.h"
29 #include "trad-frame.h"
30 #include "mn10300-tdep.h"
32 enum movm_register_bits
{
33 movm_exother_bit
= 0x01,
34 movm_exreg1_bit
= 0x02,
35 movm_exreg0_bit
= 0x04,
36 movm_other_bit
= 0x08,
43 /* Values for frame_info.status */
54 * status -- actually frame type (SP, FP, or last frame)
55 * stack size -- offset to the next frame
57 * The former might ultimately be stored in the frame_base.
58 * Seems like there'd be a way to store the later too.
60 * Temporarily supply empty stub functions as place holders.
64 my_frame_is_in_sp (struct frame_info
*fi
, void **this_cache
)
66 struct trad_frame_cache
*cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
67 trad_frame_set_this_base (cache
,
68 frame_unwind_register_unsigned (fi
,
73 my_frame_is_in_fp (struct frame_info
*fi
, void **this_cache
)
75 struct trad_frame_cache
*cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
76 trad_frame_set_this_base (cache
,
77 frame_unwind_register_unsigned (fi
,
82 my_frame_is_last (struct frame_info
*fi
)
87 is_my_frame_in_sp (struct frame_info
*fi
)
93 is_my_frame_in_fp (struct frame_info
*fi
)
99 is_my_frame_last (struct frame_info
*fi
)
105 set_my_stack_size (struct frame_info
*fi
, CORE_ADDR size
)
110 /* Set offsets of registers saved by movm instruction.
111 This is a helper function for mn10300_analyze_prologue. */
114 set_movm_offsets (struct frame_info
*fi
,
118 struct trad_frame_cache
*cache
;
122 if (fi
== NULL
|| this_cache
== NULL
)
125 cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
129 base
= trad_frame_get_this_base (cache
);
130 if (movm_args
& movm_other_bit
)
132 /* The `other' bit leaves a blank area of four bytes at the
133 beginning of its block of saved registers, making it 32 bytes
135 trad_frame_set_reg_addr (cache
, E_LAR_REGNUM
, base
+ offset
+ 4);
136 trad_frame_set_reg_addr (cache
, E_LIR_REGNUM
, base
+ offset
+ 8);
137 trad_frame_set_reg_addr (cache
, E_MDR_REGNUM
, base
+ offset
+ 12);
138 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
+ 1, base
+ offset
+ 16);
139 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
, base
+ offset
+ 20);
140 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
+ 1, base
+ offset
+ 24);
141 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
, base
+ offset
+ 28);
145 if (movm_args
& movm_a3_bit
)
147 trad_frame_set_reg_addr (cache
, E_A3_REGNUM
, base
+ offset
);
150 if (movm_args
& movm_a2_bit
)
152 trad_frame_set_reg_addr (cache
, E_A2_REGNUM
, base
+ offset
);
155 if (movm_args
& movm_d3_bit
)
157 trad_frame_set_reg_addr (cache
, E_D3_REGNUM
, base
+ offset
);
160 if (movm_args
& movm_d2_bit
)
162 trad_frame_set_reg_addr (cache
, E_D2_REGNUM
, base
+ offset
);
167 if (movm_args
& movm_exother_bit
)
169 trad_frame_set_reg_addr (cache
, E_MCVF_REGNUM
, base
+ offset
);
170 trad_frame_set_reg_addr (cache
, E_MCRL_REGNUM
, base
+ offset
+ 4);
171 trad_frame_set_reg_addr (cache
, E_MCRH_REGNUM
, base
+ offset
+ 8);
172 trad_frame_set_reg_addr (cache
, E_MDRQ_REGNUM
, base
+ offset
+ 12);
173 trad_frame_set_reg_addr (cache
, E_E1_REGNUM
, base
+ offset
+ 16);
174 trad_frame_set_reg_addr (cache
, E_E0_REGNUM
, base
+ offset
+ 20);
177 if (movm_args
& movm_exreg1_bit
)
179 trad_frame_set_reg_addr (cache
, E_E7_REGNUM
, base
+ offset
);
180 trad_frame_set_reg_addr (cache
, E_E6_REGNUM
, base
+ offset
+ 4);
181 trad_frame_set_reg_addr (cache
, E_E5_REGNUM
, base
+ offset
+ 8);
182 trad_frame_set_reg_addr (cache
, E_E4_REGNUM
, base
+ offset
+ 12);
185 if (movm_args
& movm_exreg0_bit
)
187 trad_frame_set_reg_addr (cache
, E_E3_REGNUM
, base
+ offset
);
188 trad_frame_set_reg_addr (cache
, E_E2_REGNUM
, base
+ offset
+ 4);
192 /* The last (or first) thing on the stack will be the PC. */
193 trad_frame_set_reg_addr (cache
, E_PC_REGNUM
, base
+ offset
);
194 /* Save the SP in the 'traditional' way.
195 This will be the same location where the PC is saved. */
196 trad_frame_set_reg_value (cache
, E_SP_REGNUM
, base
+ offset
);
199 /* The main purpose of this file is dealing with prologues to extract
200 information about stack frames and saved registers.
202 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
203 function is pretty readable, and has a nice explanation of how the
204 prologue is generated. The prologues generated by that code will
205 have the following form (NOTE: the current code doesn't handle all
208 + If this is an old-style varargs function, then its arguments
209 need to be flushed back to the stack:
214 + If we use any of the callee-saved registers, save them now.
216 movm [some callee-saved registers],(sp)
218 + If we have any floating-point registers to save:
220 - Decrement the stack pointer to reserve space for the registers.
221 If the function doesn't need a frame pointer, we may combine
222 this with the adjustment that reserves space for the frame.
226 - Save the floating-point registers. We have two possible
229 . Save them at fixed offset from the SP:
231 fmov fsN,(OFFSETN,sp)
232 fmov fsM,(OFFSETM,sp)
235 Note that, if OFFSETN happens to be zero, you'll get the
236 different opcode: fmov fsN,(sp)
238 . Or, set a0 to the start of the save area, and then use
239 post-increment addressing to save the FP registers.
247 + If the function needs a frame pointer, we set it here.
251 + Now we reserve space for the stack frame proper. This could be
252 merged into the `add -SIZE, sp' instruction for FP saves up
253 above, unless we needed to set the frame pointer in the previous
254 step, or the frame is so large that allocating the whole thing at
255 once would put the FP register save slots out of reach of the
256 addressing mode (128 bytes).
260 One day we might keep the stack pointer constant, that won't
261 change the code for prologues, but it will make the frame
262 pointerless case much more common. */
264 /* Analyze the prologue to determine where registers are saved,
265 the end of the prologue, etc etc. Return the end of the prologue
268 We store into FI (if non-null) several tidbits of information:
270 * stack_size -- size of this stack frame. Note that if we stop in
271 certain parts of the prologue/epilogue we may claim the size of the
272 current frame is zero. This happens when the current frame has
273 not been allocated yet or has already been deallocated.
275 * fsr -- Addresses of registers saved in the stack by this frame.
277 * status -- A (relatively) generic status indicator. It's a bitmask
278 with the following bits:
280 MY_FRAME_IN_SP: The base of the current frame is actually in
281 the stack pointer. This can happen for frame pointerless
282 functions, or cases where we're stopped in the prologue/epilogue
283 itself. For these cases mn10300_analyze_prologue will need up
284 update fi->frame before returning or analyzing the register
287 MY_FRAME_IN_FP: The base of the current frame is in the
288 frame pointer register ($a3).
290 NO_MORE_FRAMES: Set this if the current frame is "start" or
291 if the first instruction looks like mov <imm>,sp. This tells
292 frame chain to not bother trying to unwind past this frame. */
295 mn10300_analyze_prologue (struct frame_info
*fi
,
299 CORE_ADDR func_addr
, func_end
, addr
, stop
;
302 unsigned char buf
[4];
303 int status
, movm_args
= 0;
306 /* Use the PC in the frame if it's provided to look up the
307 start of this function.
309 Note: kevinb/2003-07-16: We used to do the following here:
310 pc = (fi ? get_frame_pc (fi) : pc);
311 But this is (now) badly broken when called from analyze_dummy_frame().
315 pc
= (pc
? pc
: get_frame_pc (fi
));
316 /* At the start of a function our frame is in the stack pointer. */
317 my_frame_is_in_sp (fi
, this_cache
);
320 /* Find the start of this function. */
321 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
323 /* Do nothing if we couldn't find the start of this function
325 MVS: comment went on to say "or if we're stopped at the first
326 instruction in the prologue" -- but code doesn't reflect that,
327 and I don't want to do that anyway. */
333 /* If we're in start, then give up. */
334 if (strcmp (name
, "start") == 0)
337 my_frame_is_last (fi
);
342 /* Get the next two bytes into buf, we need two because rets is a two
343 byte insn and the first isn't enough to uniquely identify it. */
344 status
= deprecated_read_memory_nobpt (pc
, buf
, 2);
348 /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
349 changes to the frame in prologue examination code. */
350 /* If we're physically on an "rets" instruction, then our frame has
351 already been deallocated. Note this can also be true for retf
352 and ret if they specify a size of zero.
354 In this case fi->frame is bogus, we need to fix it. */
355 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
357 if (get_next_frame (fi
) == NULL
)
358 deprecated_update_frame_base_hack (fi
, read_sp ());
359 return get_frame_pc (fi
);
362 /* Similarly if we're stopped on the first insn of a prologue as our
363 frame hasn't been allocated yet. */
364 if (fi
&& get_frame_pc (fi
) == func_addr
)
366 if (get_next_frame (fi
) == NULL
)
367 deprecated_update_frame_base_hack (fi
, read_sp ());
368 return get_frame_pc (fi
);
372 /* NOTE: from here on, we don't want to return without jumping to
376 /* Figure out where to stop scanning. */
377 stop
= fi
? pc
: func_end
;
379 /* Don't walk off the end of the function. */
380 stop
= stop
> func_end
? func_end
: stop
;
382 /* Start scanning on the first instruction of this function. */
385 /* Suck in two bytes. */
387 || (status
= deprecated_read_memory_nobpt (addr
, buf
, 2)) != 0)
388 goto finish_prologue
;
390 /* First see if this insn sets the stack pointer from a register; if
391 so, it's probably the initialization of the stack pointer in _start,
392 so mark this as the bottom-most frame. */
393 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
396 my_frame_is_last (fi
);
397 goto finish_prologue
;
400 /* Now look for movm [regs],sp, which saves the callee saved registers.
402 At this time we don't know if fi->frame is valid, so we only note
403 that we encountered a movm instruction. Later, we'll set the entries
404 in fsr.regs as needed. */
407 /* Extract the register list for the movm instruction. */
412 /* Quit now if we're beyond the stop point. */
414 goto finish_prologue
;
416 /* Get the next two bytes so the prologue scan can continue. */
417 status
= deprecated_read_memory_nobpt (addr
, buf
, 2);
419 goto finish_prologue
;
422 /* Now see if we set up a frame pointer via "mov sp,a3" */
427 /* The frame pointer is now valid. */
430 my_frame_is_in_fp (fi
, this_cache
);
433 /* Quit now if we're beyond the stop point. */
435 goto finish_prologue
;
437 /* Get two more bytes so scanning can continue. */
438 status
= deprecated_read_memory_nobpt (addr
, buf
, 2);
440 goto finish_prologue
;
443 /* Next we should allocate the local frame. No more prologue insns
444 are found after allocating the local frame.
446 Search for add imm8,sp (0xf8feXX)
447 or add imm16,sp (0xfafeXXXX)
448 or add imm32,sp (0xfcfeXXXXXXXX).
450 If none of the above was found, then this prologue has no
454 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
456 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
458 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
463 /* Suck in imm_size more bytes, they'll hold the size of the
465 status
= deprecated_read_memory_nobpt (addr
+ 2, buf
, imm_size
);
467 goto finish_prologue
;
469 /* Note the size of the stack in the frame info structure. */
470 stack_size
= extract_signed_integer (buf
, imm_size
);
472 set_my_stack_size (fi
, stack_size
);
474 /* We just consumed 2 + imm_size bytes. */
475 addr
+= 2 + imm_size
;
477 /* No more prologue insns follow, so begin preparation to return. */
478 goto finish_prologue
;
480 /* Do the essentials and get out of here. */
482 /* Note if/where callee saved registers were saved. */
484 set_movm_offsets (fi
, this_cache
, movm_args
);
This page took 0.039746 seconds and 4 git commands to generate.