1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
2 Copyright 1996, 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"
33 fprintf(stderr
, "%s(%d): Not implemented yet\n", f
, l
);
35 #define NIY() niy(__FILE__, __LINE__)
44 fr30_frame_chain(struct frame_info
*fi
)
50 fr30_frame_saved_pc(struct frame_info
*fi
)
56 fr30_skip_prologue(CORE_ADDR pc
)
63 fr30_push_arguments(nargs
, args
, sp
, struct_return
, struct_addr
)
68 CORE_ADDR struct_addr
;
78 struct stack_arg
*stack_args
=
79 (struct stack_arg
*)alloca (nargs
* sizeof (struct stack_arg
));
83 /* Initialize the integer and float register pointers. */
84 argreg
= FIRST_ARGREG
;
86 /* the struct_return pointer occupies the first parameter-passing reg */
88 write_register (argreg
++, struct_addr
);
91 /* The offset onto the stack at which we will start copying parameters
92 (after the registers are used up) begins at 16 in the old ABI.
93 This leaves room for the "home" area for register parameters. */
94 stack_offset
= REGISTER_SIZE
* 4;
96 /* XXX which ABI are we using ? Z.R. */
100 /* Process args from left to right. Store as many as allowed in
101 registers, save the rest to be pushed on the stack */
102 for(argnum
= 0; argnum
< nargs
; argnum
++)
105 value_ptr arg
= args
[argnum
];
106 struct type
* arg_type
= check_typedef (VALUE_TYPE (arg
));
107 struct type
* target_type
= TYPE_TARGET_TYPE (arg_type
);
108 int len
= TYPE_LENGTH (arg_type
);
109 enum type_code typecode
= TYPE_CODE (arg_type
);
113 val
= (char *) VALUE_CONTENTS (arg
);
116 /* Copy the argument to general registers or the stack in
117 register-sized pieces. Large arguments are split between
118 registers and stack. */
121 if (argreg
<= LAST_ARGREG
)
123 int partial_len
= len
< REGISTER_SIZE
? len
: REGISTER_SIZE
;
124 regval
= extract_address (val
, partial_len
);
126 /* It's a simple argument being passed in a general
128 write_register (argreg
, regval
);
135 /* keep for later pushing */
136 stack_args
[nstack_args
].val
= val
;
137 stack_args
[nstack_args
++].len
= len
;
143 /* now do the real stack pushing, process args right to left */
146 sp
-= stack_args
[nstack_args
].len
;
147 write_memory(sp
, stack_args
[nstack_args
].val
,
148 stack_args
[nstack_args
].len
);
151 /* Return adjusted stack pointer. */
155 _initialize_fr30_tdep()
157 extern int print_insn_fr30(bfd_vma
, disassemble_info
*);
159 tm_print_insn
= print_insn_fr30
;
163 #if(0) /* Z.R. for now */
164 /* Info gleaned from scanning a function's prologue. */
166 struct pifsr
/* Info about one saved reg */
168 int framereg
; /* Frame reg (SP or FP) */
169 int offset
; /* Offset from framereg */
170 int cur_frameoffset
; /* Current frameoffset */
171 int reg
; /* Saved register number */
179 struct pifsr
*pifsrs
;
182 static CORE_ADDR xfr30_scan_prologue
PARAMS ((CORE_ADDR pc
,
183 struct prologue_info
*fs
));
185 /* Function: scan_prologue
186 Scan the prologue of the function that contains PC, and record what
187 we find in PI. PI->fsr must be zeroed by the called. Returns the
188 pc after the prologue. Note that the addresses saved in pi->fsr
189 are actually just frame relative (negative offsets from the frame
190 pointer). This is because we don't know the actual value of the
191 frame pointer yet. In some circumstances, the frame pointer can't
192 be determined till after we have scanned the prologue. */
195 xfr30_scan_prologue (pc
, pi
)
197 struct prologue_info
*pi
;
199 CORE_ADDR func_addr
, prologue_end
, current_pc
;
200 struct pifsr
*pifsr
, *pifsr_tmp
;
204 CORE_ADDR save_pc
, save_end
;
209 /* First, figure out the bounds of the prologue so that we can limit the
210 search to something reasonable. */
212 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
214 struct symtab_and_line sal
;
216 sal
= find_pc_line (func_addr
, 0);
218 if (func_addr
== entry_point_address ())
219 pi
->start_function
= 1;
221 pi
->start_function
= 0;
227 prologue_end
= sal
.end
;
233 { /* We're in the boondocks */
234 func_addr
= pc
- 100;
238 prologue_end
= min (prologue_end
, pc
);
240 /* Now, search the prologue looking for instructions that setup fp, save
241 rp, adjust sp and such. We also record the frame offset of any saved
245 pi
->framereg
= SP_REGNUM
;
255 printf_filtered ("Current_pc = 0x%.8lx, prologue_end = 0x%.8lx\n",
256 (long)func_addr
, (long)prologue_end
);
259 for (current_pc
= func_addr
; current_pc
< prologue_end
; current_pc
+= 2)
264 printf_filtered ("0x%.8lx ", (long)current_pc
);
265 (*tm_print_insn
) (current_pc
, &tm_print_insn_info
);
268 insn
= read_memory_unsigned_integer (current_pc
, 2);
270 if ((insn
& 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p
)
271 { /* jarl <func>,10 */
272 long low_disp
= read_memory_unsigned_integer (current_pc
+ 2, 2) & ~ (long) 1;
273 long disp
= (((((insn
& 0x3f) << 16) + low_disp
)
274 & ~ (long) 1) ^ 0x00200000) - 0x00200000;
276 save_pc
= current_pc
;
277 save_end
= prologue_end
;
279 current_pc
+= disp
- 2;
280 prologue_end
= (current_pc
281 + (2 * 3) /* moves to/from ep */
282 + 4 /* addi <const>,sp,sp */
284 + (2 * 12) /* sst.w to save r2, r20-r29, r31 */
285 + 20); /* slop area */
288 printf_filtered ("\tfound jarl <func>,r10, disp = %ld, low_disp = %ld, new pc = 0x%.8lx\n",
289 disp
, low_disp
, (long)current_pc
+ 2);
293 else if ((insn
& 0xffe0) == 0x0060 && regsave_func_p
)
294 { /* jmp after processing register save function */
295 current_pc
= save_pc
+ 2;
296 prologue_end
= save_end
;
299 printf_filtered ("\tfound jmp after regsave func");
302 else if ((insn
& 0x07c0) == 0x0780 /* jarl or jr */
303 || (insn
& 0xffe0) == 0x0060 /* jmp */
304 || (insn
& 0x0780) == 0x0580) /* branch */
307 printf_filtered ("\n");
309 break; /* Ran into end of prologue */
312 else if ((insn
& 0xffe0) == ((SP_REGNUM
<< 11) | 0x0240)) /* add <imm>,sp */
313 pi
->frameoffset
+= ((insn
& 0x1f) ^ 0x10) - 0x10;
314 else if (insn
== ((SP_REGNUM
<< 11) | 0x0600 | SP_REGNUM
)) /* addi <imm>,sp,sp */
315 pi
->frameoffset
+= read_memory_integer (current_pc
+ 2, 2);
316 else if (insn
== ((FP_RAW_REGNUM
<< 11) | 0x0000 | SP_REGNUM
)) /* mov sp,fp */
319 pi
->framereg
= FP_RAW_REGNUM
;
322 else if (insn
== ((R12_REGNUM
<< 11) | 0x0640 | R0_REGNUM
)) /* movhi hi(const),r0,r12 */
323 r12_tmp
= read_memory_integer (current_pc
+ 2, 2) << 16;
324 else if (insn
== ((R12_REGNUM
<< 11) | 0x0620 | R12_REGNUM
)) /* movea lo(const),r12,r12 */
325 r12_tmp
+= read_memory_integer (current_pc
+ 2, 2);
326 else if (insn
== ((SP_REGNUM
<< 11) | 0x01c0 | R12_REGNUM
) && r12_tmp
) /* add r12,sp */
327 pi
->frameoffset
= r12_tmp
;
328 else if (insn
== ((EP_REGNUM
<< 11) | 0x0000 | SP_REGNUM
)) /* mov sp,ep */
330 else if (insn
== ((EP_REGNUM
<< 11) | 0x0000 | R1_REGNUM
)) /* mov r1,ep */
332 else if (((insn
& 0x07ff) == (0x0760 | SP_REGNUM
) /* st.w <reg>,<offset>[sp] */
334 && (insn
& 0x07ff) == (0x0760 | FP_RAW_REGNUM
))) /* st.w <reg>,<offset>[fp] */
336 && (((reg
= (insn
>> 11) & 0x1f) >= SAVE1_START_REGNUM
&& reg
<= SAVE1_END_REGNUM
)
337 || (reg
>= SAVE2_START_REGNUM
&& reg
<= SAVE2_END_REGNUM
)
338 || (reg
>= SAVE3_START_REGNUM
&& reg
<= SAVE3_END_REGNUM
)))
341 pifsr
->offset
= read_memory_integer (current_pc
+ 2, 2) & ~1;
342 pifsr
->cur_frameoffset
= pi
->frameoffset
;
344 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
349 else if (ep_used
/* sst.w <reg>,<offset>[ep] */
350 && ((insn
& 0x0781) == 0x0501)
352 && (((reg
= (insn
>> 11) & 0x1f) >= SAVE1_START_REGNUM
&& reg
<= SAVE1_END_REGNUM
)
353 || (reg
>= SAVE2_START_REGNUM
&& reg
<= SAVE2_END_REGNUM
)
354 || (reg
>= SAVE3_START_REGNUM
&& reg
<= SAVE3_END_REGNUM
)))
357 pifsr
->offset
= (insn
& 0x007e) << 1;
358 pifsr
->cur_frameoffset
= pi
->frameoffset
;
360 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
365 if ((insn
& 0x0780) >= 0x0600) /* Four byte instruction? */
369 printf_filtered ("\n");
374 pifsr
->framereg
= 0; /* Tie off last entry */
376 /* Fix up any offsets to the final offset. If a frame pointer was created, use it
377 instead of the stack pointer. */
378 for (pifsr_tmp
= pi
->pifsrs
; pifsr_tmp
&& pifsr_tmp
!= pifsr
; pifsr_tmp
++)
380 pifsr_tmp
->offset
-= pi
->frameoffset
- pifsr_tmp
->cur_frameoffset
;
381 pifsr_tmp
->framereg
= pi
->framereg
;
384 printf_filtered ("Saved register r%d, offset = %d, framereg = r%d\n",
385 pifsr_tmp
->reg
, pifsr_tmp
->offset
, pifsr_tmp
->framereg
);
390 printf_filtered ("Framereg = r%d, frameoffset = %d\n", pi
->framereg
, pi
->frameoffset
);
396 /* Function: init_extra_frame_info
397 Setup the frame's frame pointer, pc, and frame addresses for saved
398 registers. Most of the work is done in scan_prologue().
400 Note that when we are called for the last frame (currently active frame),
401 that fi->pc and fi->frame will already be setup. However, fi->frame will
402 be valid only if this routine uses FP. For previous frames, fi-frame will
403 always be correct (since that is derived from xfr30_frame_chain ()).
405 We can be called with the PC in the call dummy under two circumstances.
406 First, during normal backtracing, second, while figuring out the frame
407 pointer just prior to calling the target function (see run_stack_dummy). */
410 xfr30_init_extra_frame_info (fi
)
411 struct frame_info
*fi
;
413 struct prologue_info pi
;
414 struct pifsr pifsrs
[NUM_REGS
+ 1], *pifsr
;
418 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
420 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
422 /* The call dummy doesn't save any registers on the stack, so we can return
424 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
429 xfr30_scan_prologue (fi
->pc
, &pi
);
431 if (!fi
->next
&& pi
.framereg
== SP_REGNUM
)
432 fi
->frame
= read_register (pi
.framereg
) - pi
.frameoffset
;
434 for (pifsr
= pifsrs
; pifsr
->framereg
; pifsr
++)
436 fi
->fsr
.regs
[pifsr
->reg
] = pifsr
->offset
+ fi
->frame
;
438 if (pifsr
->framereg
== SP_REGNUM
)
439 fi
->fsr
.regs
[pifsr
->reg
] += pi
.frameoffset
;
443 /* Function: frame_chain
444 Figure out the frame prior to FI. Unfortunately, this involves
445 scanning the prologue of the caller, which will also be done
446 shortly by xfr30_init_extra_frame_info. For the dummy frame, we
447 just return the stack pointer that was in use at the time the
448 function call was made. */
451 xfr30_frame_chain (fi
)
452 struct frame_info
*fi
;
454 struct prologue_info pi
;
455 CORE_ADDR callers_pc
, fp
;
457 /* First, find out who called us */
458 callers_pc
= FRAME_SAVED_PC (fi
);
459 /* If caller is a call-dummy, then our FP bears no relation to his FP! */
460 fp
= xfr30_find_callers_reg (fi
, FP_RAW_REGNUM
);
461 if (PC_IN_CALL_DUMMY(callers_pc
, fp
, fp
))
462 return fp
; /* caller is call-dummy: return oldest value of FP */
464 /* Caller is NOT a call-dummy, so everything else should just work.
465 Even if THIS frame is a call-dummy! */
468 xfr30_scan_prologue (callers_pc
, &pi
);
470 if (pi
.start_function
)
471 return 0; /* Don't chain beyond the start function */
473 if (pi
.framereg
== FP_RAW_REGNUM
)
474 return xfr30_find_callers_reg (fi
, pi
.framereg
);
476 return fi
->frame
- pi
.frameoffset
;
479 /* Function: find_callers_reg
480 Find REGNUM on the stack. Otherwise, it's in an active register.
481 One thing we might want to do here is to check REGNUM against the
482 clobber mask, and somehow flag it as invalid if it isn't saved on
483 the stack somewhere. This would provide a graceful failure mode
484 when trying to get the value of caller-saves registers for an inner
488 xfr30_find_callers_reg (fi
, regnum
)
489 struct frame_info
*fi
;
492 for (; fi
; fi
= fi
->next
)
493 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
494 return generic_read_register_dummy (fi
->pc
, fi
->frame
, regnum
);
495 else if (fi
->fsr
.regs
[regnum
] != 0)
496 return read_memory_unsigned_integer (fi
->fsr
.regs
[regnum
],
497 REGISTER_RAW_SIZE(regnum
));
499 return read_register (regnum
);
502 /* Function: skip_prologue
503 Return the address of the first code past the prologue of the function. */
506 xfr30_skip_prologue (pc
)
509 CORE_ADDR func_addr
, func_end
;
511 /* See what the symbol table says */
513 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
515 struct symtab_and_line sal
;
517 sal
= find_pc_line (func_addr
, 0);
519 if (sal
.line
!= 0 && sal
.end
< func_end
)
522 /* Either there's no line info, or the line after the prologue is after
523 the end of the function. In this case, there probably isn't a
528 /* We can't find the start of this function, so there's nothing we can do. */
532 /* Function: pop_frame
533 This routine gets called when either the user uses the `return'
534 command, or the call dummy breakpoint gets hit. */
537 xfr30_pop_frame (frame
)
538 struct frame_info
*frame
;
542 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
543 generic_pop_dummy_frame ();
546 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
548 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
549 if (frame
->fsr
.regs
[regnum
] != 0)
550 write_register (regnum
,
551 read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
552 REGISTER_RAW_SIZE(regnum
)));
554 write_register (SP_REGNUM
, FRAME_FP (frame
));
557 flush_cached_frames ();
560 /* Function: push_arguments
561 Setup arguments and RP for a call to the target. First four args
562 go in R6->R9, subsequent args go into sp + 16 -> sp + ... Structs
563 are passed by reference. 64 bit quantities (doubles and long
564 longs) may be split between the regs and the stack. When calling a
565 function that returns a struct, a pointer to the struct is passed
566 in as a secret first argument (always in R6).
568 Stack space for the args has NOT been allocated: that job is up to us.
572 xfr30_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
576 unsigned char struct_return
;
577 CORE_ADDR struct_addr
;
584 /* First, just for safety, make sure stack is aligned */
587 /* Now make space on the stack for the args. */
588 for (argnum
= 0; argnum
< nargs
; argnum
++)
589 len
+= ((TYPE_LENGTH(VALUE_TYPE(args
[argnum
])) + 3) & ~3);
590 sp
-= len
; /* possibly over-allocating, but it works... */
591 /* (you might think we could allocate 16 bytes */
592 /* less, but the ABI seems to use it all! ) */
593 argreg
= ARG0_REGNUM
;
595 /* the struct_return pointer occupies the first parameter-passing reg */
597 write_register (argreg
++, struct_addr
);
600 /* The offset onto the stack at which we will start copying parameters
601 (after the registers are used up) begins at 16 rather than at zero.
602 I don't really know why, that's just the way it seems to work. */
604 /* Now load as many as possible of the first arguments into
605 registers, and push the rest onto the stack. There are 16 bytes
606 in four registers available. Loop thru args from first to last. */
607 for (argnum
= 0; argnum
< nargs
; argnum
++)
611 char valbuf
[REGISTER_RAW_SIZE(ARG0_REGNUM
)];
613 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
614 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
616 store_address (valbuf
, 4, VALUE_ADDRESS (*args
));
622 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
623 val
= (char *)VALUE_CONTENTS (*args
);
627 if (argreg
<= ARGLAST_REGNUM
)
631 regval
= extract_address (val
, REGISTER_RAW_SIZE (argreg
));
632 write_register (argreg
, regval
);
634 len
-= REGISTER_RAW_SIZE (argreg
);
635 val
+= REGISTER_RAW_SIZE (argreg
);
640 write_memory (sp
+ stack_offset
, val
, 4);
651 /* Function: push_return_address (pc)
652 Set up the return address for the inferior function call.
653 Needed for targets where we don't actually execute a JSR/BSR instruction */
656 xfr30_push_return_address (pc
, sp
)
660 write_register (RP_REGNUM
, CALL_DUMMY_ADDRESS ());
664 /* Function: frame_saved_pc
665 Find the caller of this frame. We do this by seeing if RP_REGNUM
666 is saved in the stack anywhere, otherwise we get it from the
667 registers. If the inner frame is a dummy frame, return its PC
668 instead of RP, because that's where "caller" of the dummy-frame
672 xfr30_frame_saved_pc (fi
)
673 struct frame_info
*fi
;
675 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
676 return generic_read_register_dummy(fi
->pc
, fi
->frame
, PC_REGNUM
);
678 return xfr30_find_callers_reg (fi
, RP_REGNUM
);
682 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
686 struct frame_info
*frame
;
688 enum lval_type
*lval
;
690 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
691 frame
, regnum
, lval
);
695 /* Function: fix_call_dummy
696 Pokes the callee function's address into the CALL_DUMMY assembly stub.
697 Assumes that the CALL_DUMMY looks like this:
703 xfr30_fix_call_dummy (dummy
, sp
, fun
, nargs
, args
, type
, gcc_p
)
714 offset24
= (long) fun
- (long) entry_point_address ();
715 offset24
&= 0x3fffff;
716 offset24
|= 0xff800000; /* jarl <offset24>, r31 */
718 store_unsigned_integer ((unsigned int *)&dummy
[2], 2, offset24
& 0xffff);
719 store_unsigned_integer ((unsigned int *)&dummy
[0], 2, offset24
>> 16);