1 /* Target-dependent code for the Fujitsu FR30.
2 Copyright 1999, 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. */
27 #include "gdb_string.h"
31 /* An expression that tells us whether the function invocation represented
32 by FI does not have a frame on the stack associated with it. */
34 fr30_frameless_function_invocation (fi
)
35 struct frame_info
*fi
;
38 CORE_ADDR func_start
, after_prologue
;
39 func_start
= (get_pc_function_start ((fi
)->pc
) +
40 FUNCTION_START_OFFSET
);
41 after_prologue
= func_start
;
42 after_prologue
= SKIP_PROLOGUE (after_prologue
);
43 frameless
= (after_prologue
== func_start
);
47 /* Function: pop_frame
48 This routine gets called when either the user uses the `return'
49 command, or the call dummy breakpoint gets hit. */
54 struct frame_info
*frame
= get_current_frame();
56 CORE_ADDR sp
= read_register(SP_REGNUM
);
58 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
59 generic_pop_dummy_frame ();
62 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
64 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
65 if (frame
->fsr
.regs
[regnum
] != 0) {
66 write_register (regnum
,
67 read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
68 REGISTER_RAW_SIZE(regnum
)));
70 write_register (SP_REGNUM
, sp
+ frame
->framesize
);
72 flush_cached_frames ();
76 /* Function: fr30_store_return_value
77 Put a value where a caller expects to see it. Used by the 'return'
80 fr30_store_return_value (struct type
*type
,
83 /* Here's how the FR30 returns values (gleaned from gcc/config/
86 If the return value is 32 bits long or less, it goes in r4.
88 If the return value is 64 bits long or less, it goes in r4 (most
89 significant word) and r5 (least significant word.
91 If the function returns a structure, of any size, the caller
92 passes the function an invisible first argument where the callee
93 should store the value. But GDB doesn't let you do that anyway.
95 If you're returning a value smaller than a word, it's not really
96 necessary to zero the upper bytes of the register; the caller is
97 supposed to ignore them. However, the FR30 typically keeps its
98 values extended to the full register width, so we should emulate
101 /* The FR30 is big-endian, so if we return a small value (like a
102 short or a char), we need to position it correctly within the
103 register. We round the size up to a register boundary, and then
104 adjust the offset so as to place the value at the right end. */
105 int value_size
= TYPE_LENGTH (type
);
106 int returned_size
= (value_size
+ FR30_REGSIZE
- 1) & ~(FR30_REGSIZE
- 1);
107 int offset
= (REGISTER_BYTE (RETVAL_REG
)
108 + (returned_size
- value_size
));
109 char *zeros
= alloca (returned_size
);
110 memset (zeros
, 0, returned_size
);
112 write_register_bytes (REGISTER_BYTE (RETVAL_REG
), zeros
, returned_size
);
113 write_register_bytes (offset
, valbuf
, value_size
);
117 /* Function: skip_prologue
118 Return the address of the first code past the prologue of the function. */
121 fr30_skip_prologue(CORE_ADDR pc
)
123 CORE_ADDR func_addr
, func_end
;
125 /* See what the symbol table says */
127 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
129 struct symtab_and_line sal
;
131 sal
= find_pc_line (func_addr
, 0);
133 if (sal
.line
!= 0 && sal
.end
< func_end
) {
138 /* Either we didn't find the start of this function (nothing we can do),
139 or there's no line info, or the line after the prologue is after
140 the end of the function (there probably isn't a prologue). */
146 /* Function: push_arguments
147 Setup arguments and RP for a call to the target. First four args
148 go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on stack...
149 Structs are passed by reference. XXX not right now Z.R.
150 64 bit quantities (doubles and long longs) may be split between
151 the regs and the stack.
152 When calling a function that returns a struct, a pointer to the struct
153 is passed in as a secret first argument (always in FIRST_ARGREG).
155 Stack space for the args has NOT been allocated: that job is up to us.
159 fr30_push_arguments(nargs
, args
, sp
, struct_return
, struct_addr
)
164 CORE_ADDR struct_addr
;
174 struct stack_arg
*stack_args
=
175 (struct stack_arg
*)alloca (nargs
* sizeof (struct stack_arg
));
178 argreg
= FIRST_ARGREG
;
180 /* the struct_return pointer occupies the first parameter-passing reg */
182 write_register (argreg
++, struct_addr
);
186 /* Process args from left to right. Store as many as allowed in
187 registers, save the rest to be pushed on the stack */
188 for(argnum
= 0; argnum
< nargs
; argnum
++)
191 value_ptr arg
= args
[argnum
];
192 struct type
* arg_type
= check_typedef (VALUE_TYPE (arg
));
193 struct type
* target_type
= TYPE_TARGET_TYPE (arg_type
);
194 int len
= TYPE_LENGTH (arg_type
);
195 enum type_code typecode
= TYPE_CODE (arg_type
);
199 val
= (char *) VALUE_CONTENTS (arg
);
202 /* Copy the argument to general registers or the stack in
203 register-sized pieces. Large arguments are split between
204 registers and stack. */
207 if (argreg
<= LAST_ARGREG
)
209 int partial_len
= len
< REGISTER_SIZE
? len
: REGISTER_SIZE
;
210 regval
= extract_address (val
, partial_len
);
212 /* It's a simple argument being passed in a general
214 write_register (argreg
, regval
);
221 /* keep for later pushing */
222 stack_args
[nstack_args
].val
= val
;
223 stack_args
[nstack_args
++].len
= len
;
229 /* now do the real stack pushing, process args right to left */
232 sp
-= stack_args
[nstack_args
].len
;
233 write_memory(sp
, stack_args
[nstack_args
].val
,
234 stack_args
[nstack_args
].len
);
237 /* Return adjusted stack pointer. */
241 void _initialize_fr30_tdep
PARAMS ((void));
244 _initialize_fr30_tdep ()
246 extern int print_insn_fr30(bfd_vma
, disassemble_info
*);
247 tm_print_insn
= print_insn_fr30
;
250 /* Function: check_prologue_cache
251 Check if prologue for this frame's PC has already been scanned.
252 If it has, copy the relevant information about that prologue and
253 return non-zero. Otherwise do not copy anything and return zero.
255 The information saved in the cache includes:
256 * the frame register number;
257 * the size of the stack frame;
258 * the offsets of saved regs (relative to the old SP); and
259 * the offset from the stack pointer to the frame pointer
261 The cache contains only one entry, since this is adequate
262 for the typical sequence of prologue scan requests we get.
263 When performing a backtrace, GDB will usually ask to scan
264 the same function twice in a row (once to get the frame chain,
265 and once to fill in the extra frame information).
268 static struct frame_info prologue_cache
;
271 check_prologue_cache (fi
)
272 struct frame_info
* fi
;
276 if (fi
->pc
== prologue_cache
.pc
)
278 fi
->framereg
= prologue_cache
.framereg
;
279 fi
->framesize
= prologue_cache
.framesize
;
280 fi
->frameoffset
= prologue_cache
.frameoffset
;
281 for (i
= 0; i
<= NUM_REGS
; i
++)
282 fi
->fsr
.regs
[i
] = prologue_cache
.fsr
.regs
[i
];
290 /* Function: save_prologue_cache
291 Copy the prologue information from fi to the prologue cache.
295 save_prologue_cache (fi
)
296 struct frame_info
* fi
;
300 prologue_cache
.pc
= fi
->pc
;
301 prologue_cache
.framereg
= fi
->framereg
;
302 prologue_cache
.framesize
= fi
->framesize
;
303 prologue_cache
.frameoffset
= fi
->frameoffset
;
305 for (i
= 0; i
<= NUM_REGS
; i
++) {
306 prologue_cache
.fsr
.regs
[i
] = fi
->fsr
.regs
[i
];
311 /* Function: scan_prologue
312 Scan the prologue of the function that contains PC, and record what
313 we find in PI. PI->fsr must be zeroed by the called. Returns the
314 pc after the prologue. Note that the addresses saved in pi->fsr
315 are actually just frame relative (negative offsets from the frame
316 pointer). This is because we don't know the actual value of the
317 frame pointer yet. In some circumstances, the frame pointer can't
318 be determined till after we have scanned the prologue. */
321 fr30_scan_prologue (fi
)
322 struct frame_info
* fi
;
324 int sp_offset
, fp_offset
;
325 CORE_ADDR prologue_start
, prologue_end
, current_pc
;
327 /* Check if this function is already in the cache of frame information. */
328 if (check_prologue_cache (fi
))
331 /* Assume there is no frame until proven otherwise. */
332 fi
->framereg
= SP_REGNUM
;
336 /* Find the function prologue. If we can't find the function in
337 the symbol table, peek in the stack frame to find the PC. */
338 if (find_pc_partial_function (fi
->pc
, NULL
, &prologue_start
, &prologue_end
))
340 /* Assume the prologue is everything between the first instruction
341 in the function and the first source line. */
342 struct symtab_and_line sal
= find_pc_line (prologue_start
, 0);
344 if (sal
.line
== 0) /* no line info, use current PC */
345 prologue_end
= fi
->pc
;
346 else if (sal
.end
< prologue_end
) /* next line begins after fn end */
347 prologue_end
= sal
.end
; /* (probably means no prologue) */
351 /* XXX Z.R. What now??? The following is entirely bogus */
352 prologue_start
= (read_memory_integer (fi
->frame
, 4) & 0x03fffffc) - 12;
353 prologue_end
= prologue_start
+ 40;
356 /* Now search the prologue looking for instructions that set up the
357 frame pointer, adjust the stack pointer, and save registers. */
359 sp_offset
= fp_offset
= 0;
360 for (current_pc
= prologue_start
; current_pc
< prologue_end
; current_pc
+= 2)
364 insn
= read_memory_unsigned_integer (current_pc
, 2);
366 if ((insn
& 0xfe00) == 0x8e00) /* stm0 or stm1 */
368 int reg
, mask
= insn
& 0xff;
370 /* scan in one sweep - create virtual 16-bit mask from either insn's mask */
371 if((insn
& 0x0100) == 0)
373 mask
<<= 8; /* stm0 - move to upper byte in virtual mask */
376 /* Calculate offsets of saved registers (to be turned later into addresses). */
377 for (reg
= R4_REGNUM
; reg
<= R11_REGNUM
; reg
++)
378 if (mask
& (1 << (15 - reg
)))
381 fi
->fsr
.regs
[reg
] = sp_offset
;
384 else if((insn
& 0xfff0) == 0x1700) /* st rx,@-r15 */
386 int reg
= insn
& 0xf;
389 fi
->fsr
.regs
[reg
] = sp_offset
;
391 else if((insn
& 0xff00) == 0x0f00) /* enter */
393 fp_offset
= fi
->fsr
.regs
[FP_REGNUM
] = sp_offset
- 4;
394 sp_offset
-= 4 * (insn
& 0xff);
395 fi
->framereg
= FP_REGNUM
;
397 else if(insn
== 0x1781) /* st rp,@-sp */
400 fi
->fsr
.regs
[RP_REGNUM
] = sp_offset
;
402 else if(insn
== 0x170e) /* st fp,@-sp */
405 fi
->fsr
.regs
[FP_REGNUM
] = sp_offset
;
407 else if(insn
== 0x8bfe) /* mov sp,fp */
409 fi
->framereg
= FP_REGNUM
;
411 else if((insn
& 0xff00) == 0xa300) /* addsp xx */
413 sp_offset
+= 4 * (signed char)(insn
& 0xff);
415 else if((insn
& 0xff0f) == 0x9b00 && /* ldi:20 xx,r0 */
416 read_memory_unsigned_integer(current_pc
+4, 2)
417 == 0xac0f) /* sub r0,sp */
419 /* large stack adjustment */
420 sp_offset
-= (((insn
& 0xf0) << 12) | read_memory_unsigned_integer(current_pc
+2, 2));
423 else if(insn
== 0x9f80 && /* ldi:32 xx,r0 */
424 read_memory_unsigned_integer(current_pc
+6, 2)
425 == 0xac0f) /* sub r0,sp */
427 /* large stack adjustment */
429 (read_memory_unsigned_integer(current_pc
+2, 2) << 16 |
430 read_memory_unsigned_integer(current_pc
+4, 2));
435 /* The frame size is just the negative of the offset (from the original SP)
436 of the last thing thing we pushed on the stack. The frame offset is
437 [new FP] - [new SP]. */
438 fi
->framesize
= -sp_offset
;
439 fi
->frameoffset
= fp_offset
- sp_offset
;
441 save_prologue_cache (fi
);
444 /* Function: init_extra_frame_info
445 Setup the frame's frame pointer, pc, and frame addresses for saved
446 registers. Most of the work is done in scan_prologue().
448 Note that when we are called for the last frame (currently active frame),
449 that fi->pc and fi->frame will already be setup. However, fi->frame will
450 be valid only if this routine uses FP. For previous frames, fi-frame will
451 always be correct (since that is derived from fr30_frame_chain ()).
453 We can be called with the PC in the call dummy under two circumstances.
454 First, during normal backtracing, second, while figuring out the frame
455 pointer just prior to calling the target function (see run_stack_dummy). */
458 fr30_init_extra_frame_info (fi
)
459 struct frame_info
* fi
;
464 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
466 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
468 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
470 /* We need to setup fi->frame here because run_stack_dummy gets it wrong
471 by assuming it's always FP. */
472 fi
->frame
= generic_read_register_dummy (fi
->pc
, fi
->frame
, SP_REGNUM
);
477 fr30_scan_prologue (fi
);
479 if (!fi
->next
) /* this is the innermost frame? */
480 fi
->frame
= read_register (fi
->framereg
);
481 else /* not the innermost frame */
482 /* If we have an FP, the callee saved it. */
483 if (fi
->framereg
== FP_REGNUM
)
484 if (fi
->next
->fsr
.regs
[fi
->framereg
] != 0)
485 fi
->frame
= read_memory_integer (fi
->next
->fsr
.regs
[fi
->framereg
],
487 /* Calculate actual addresses of saved registers using offsets determined
488 by fr30_scan_prologue. */
489 for (reg
= 0; reg
< NUM_REGS
; reg
++)
490 if (fi
->fsr
.regs
[reg
] != 0) {
491 fi
->fsr
.regs
[reg
] += fi
->frame
+ fi
->framesize
- fi
->frameoffset
;
495 /* Function: find_callers_reg
496 Find REGNUM on the stack. Otherwise, it's in an active register.
497 One thing we might want to do here is to check REGNUM against the
498 clobber mask, and somehow flag it as invalid if it isn't saved on
499 the stack somewhere. This would provide a graceful failure mode
500 when trying to get the value of caller-saves registers for an inner
504 fr30_find_callers_reg (fi
, regnum
)
505 struct frame_info
*fi
;
508 for (; fi
; fi
= fi
->next
)
509 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
510 return generic_read_register_dummy (fi
->pc
, fi
->frame
, regnum
);
511 else if (fi
->fsr
.regs
[regnum
] != 0)
512 return read_memory_unsigned_integer (fi
->fsr
.regs
[regnum
],
513 REGISTER_RAW_SIZE(regnum
));
515 return read_register (regnum
);
519 /* Function: frame_chain
520 Figure out the frame prior to FI. Unfortunately, this involves
521 scanning the prologue of the caller, which will also be done
522 shortly by fr30_init_extra_frame_info. For the dummy frame, we
523 just return the stack pointer that was in use at the time the
524 function call was made. */
528 fr30_frame_chain (fi
)
529 struct frame_info
* fi
;
531 CORE_ADDR fn_start
, callers_pc
, fp
;
532 struct frame_info caller_fi
;
535 /* is this a dummy frame? */
536 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
537 return fi
->frame
; /* dummy frame same as caller's frame */
539 /* is caller-of-this a dummy frame? */
540 callers_pc
= FRAME_SAVED_PC(fi
); /* find out who called us: */
541 fp
= fr30_find_callers_reg (fi
, FP_REGNUM
);
542 if (PC_IN_CALL_DUMMY (callers_pc
, fp
, fp
))
543 return fp
; /* dummy frame's frame may bear no relation to ours */
545 if (find_pc_partial_function (fi
->pc
, 0, &fn_start
, 0))
546 if (fn_start
== entry_point_address ())
547 return 0; /* in _start fn, don't chain further */
549 framereg
= fi
->framereg
;
551 /* If the caller is the startup code, we're at the end of the chain. */
552 if (find_pc_partial_function (callers_pc
, 0, &fn_start
, 0))
553 if (fn_start
== entry_point_address ())
556 memset (& caller_fi
, 0, sizeof (caller_fi
));
557 caller_fi
.pc
= callers_pc
;
558 fr30_scan_prologue (& caller_fi
);
559 framereg
= caller_fi
.framereg
;
561 /* If the caller used a frame register, return its value.
562 Otherwise, return the caller's stack pointer. */
563 if (framereg
== FP_REGNUM
)
564 return fr30_find_callers_reg (fi
, framereg
);
566 return fi
->frame
+ fi
->framesize
;
569 /* Function: frame_saved_pc
570 Find the caller of this frame. We do this by seeing if RP_REGNUM
571 is saved in the stack anywhere, otherwise we get it from the
572 registers. If the inner frame is a dummy frame, return its PC
573 instead of RP, because that's where "caller" of the dummy-frame
577 fr30_frame_saved_pc (fi
)
578 struct frame_info
*fi
;
580 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
581 return generic_read_register_dummy(fi
->pc
, fi
->frame
, PC_REGNUM
);
583 return fr30_find_callers_reg (fi
, RP_REGNUM
);
586 /* Function: fix_call_dummy
587 Pokes the callee function's address into the CALL_DUMMY assembly stub.
588 Assumes that the CALL_DUMMY looks like this:
594 fr30_fix_call_dummy (dummy
, sp
, fun
, nargs
, args
, type
, gcc_p
)
605 offset24
= (long) fun
- (long) entry_point_address ();
606 offset24
&= 0x3fffff;
607 offset24
|= 0xff800000; /* jarl <offset24>, r31 */
609 store_unsigned_integer ((unsigned int *)&dummy
[2], 2, offset24
& 0xffff);
610 store_unsigned_integer ((unsigned int *)&dummy
[0], 2, offset24
>> 16);