1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
3 Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
4 Software Foundation, Inc.
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"
32 #include "arch-utils.h"
39 /* gdbarch target dependent data here. Currently unused for v850. */
42 /* Extra info which is saved in each frame_info. */
43 struct frame_extra_info
50 E_R2_REGNUM
, E_SAVE1_START_REGNUM
= E_R2_REGNUM
, E_SAVE1_END_REGNUM
= E_R2_REGNUM
,
51 E_R3_REGNUM
, E_SP_REGNUM
= E_R3_REGNUM
,
54 E_R6_REGNUM
, E_ARG0_REGNUM
= E_R6_REGNUM
,
57 E_R9_REGNUM
, E_ARGLAST_REGNUM
= E_R9_REGNUM
,
58 E_R10_REGNUM
, E_V0_REGNUM
= E_R10_REGNUM
,
59 E_R11_REGNUM
, E_V1_REGNUM
= E_R11_REGNUM
,
68 E_R20_REGNUM
, E_SAVE2_START_REGNUM
= E_R20_REGNUM
,
77 E_R29_REGNUM
, E_SAVE2_END_REGNUM
= E_R29_REGNUM
, E_FP_RAW_REGNUM
= E_R29_REGNUM
,
78 E_R30_REGNUM
, E_EP_REGNUM
= E_R30_REGNUM
,
79 E_R31_REGNUM
, E_SAVE3_START_REGNUM
= E_R31_REGNUM
, E_SAVE3_END_REGNUM
= E_R31_REGNUM
, E_RP_REGNUM
= E_R31_REGNUM
,
80 E_R32_REGNUM
, E_SR0_REGNUM
= E_R32_REGNUM
,
85 E_R37_REGNUM
, E_PS_REGNUM
= E_R37_REGNUM
,
100 E_R52_REGNUM
, E_CTBP_REGNUM
= E_R52_REGNUM
,
112 E_R64_REGNUM
, E_PC_REGNUM
= E_R64_REGNUM
,
113 E_R65_REGNUM
, E_FP_REGNUM
= E_R65_REGNUM
,
122 /* Size of all registers as a whole. */
125 E_ALL_REGS_SIZE
= (E_NUM_REGS
) * v850_reg_size
128 /* Size of return datatype which fits into all return registers. */
131 E_MAX_RETTYPE_SIZE_IN_REGS
= 2 * v850_reg_size
134 static LONGEST call_dummy_nil
[] = {0};
136 static char *v850_generic_reg_names
[] =
137 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
138 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
139 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
140 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
141 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
142 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
143 "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
144 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
148 static char *v850e_reg_names
[] =
150 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
151 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
152 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
153 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
154 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
155 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
156 "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
157 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
161 char **v850_register_names
= v850_generic_reg_names
;
168 v850_processor_type_table
[] =
171 v850_generic_reg_names
, bfd_mach_v850
175 v850e_reg_names
, bfd_mach_v850e
179 v850e_reg_names
, bfd_mach_v850e1
187 /* Info gleaned from scanning a function's prologue. */
189 struct pifsr
/* Info about one saved reg */
191 int framereg
; /* Frame reg (SP or FP) */
192 int offset
; /* Offset from framereg */
193 int cur_frameoffset
; /* Current frameoffset */
194 int reg
; /* Saved register number */
202 struct pifsr
*pifsrs
;
205 static CORE_ADDR
v850_scan_prologue (CORE_ADDR pc
, struct prologue_info
*fs
);
207 /* Function: v850_register_name
208 Returns the name of the v850/v850e register N. */
211 v850_register_name (int regnum
)
213 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
214 internal_error (__FILE__
, __LINE__
,
215 "v850_register_name: illegal register number %d",
218 return v850_register_names
[regnum
];
222 /* Function: v850_register_byte
223 Returns the byte position in the register cache for register N. */
226 v850_register_byte (int regnum
)
228 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
229 internal_error (__FILE__
, __LINE__
,
230 "v850_register_byte: illegal register number %d",
233 return regnum
* v850_reg_size
;
236 /* Function: v850_register_raw_size
237 Returns the number of bytes occupied by the register on the target. */
240 v850_register_raw_size (int regnum
)
242 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
243 internal_error (__FILE__
, __LINE__
,
244 "v850_register_raw_size: illegal register number %d",
246 /* Only the PC has 4 Byte, all other registers 2 Byte. */
248 return v850_reg_size
;
251 /* Function: v850_register_virtual_size
252 Returns the number of bytes occupied by the register as represented
253 internally by gdb. */
256 v850_register_virtual_size (int regnum
)
258 return v850_register_raw_size (regnum
);
261 /* Function: v850_reg_virtual_type
262 Returns the default type for register N. */
265 v850_reg_virtual_type (int regnum
)
267 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
268 internal_error (__FILE__
, __LINE__
,
269 "v850_register_virtual_type: illegal register number %d",
271 else if (regnum
== E_PC_REGNUM
)
272 return builtin_type_uint32
;
274 return builtin_type_int32
;
278 v850_type_is_scalar (struct type
*t
)
280 return (TYPE_CODE (t
) != TYPE_CODE_STRUCT
281 && TYPE_CODE (t
) != TYPE_CODE_UNION
282 && TYPE_CODE (t
) != TYPE_CODE_ARRAY
);
285 /* Should call_function allocate stack space for a struct return? */
287 v850_use_struct_convention (int gcc_p
, struct type
*type
)
290 * return TYPE_LENGTH (type) > 8);
293 /* Current implementation in gcc: */
296 struct type
*fld_type
, *tgt_type
;
298 /* 1. The value is greater than 8 bytes -> returned by copying */
299 if (TYPE_LENGTH (type
) > 8)
302 /* 2. The value is a single basic type -> returned in register */
303 if (v850_type_is_scalar (type
))
306 /* The value is a structure or union with a single element
307 * and that element is either a single basic type or an array of
308 * a single basic type whoes size is greater than or equal to 4
309 * -> returned in register */
310 if ((TYPE_CODE (type
) == TYPE_CODE_STRUCT
311 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
312 && TYPE_NFIELDS (type
) == 1)
314 fld_type
= TYPE_FIELD_TYPE (type
, 0);
315 if (v850_type_is_scalar (fld_type
) && TYPE_LENGTH (fld_type
) >= 4)
318 if (TYPE_CODE (fld_type
) == TYPE_CODE_ARRAY
)
320 tgt_type
= TYPE_TARGET_TYPE (fld_type
);
321 if (v850_type_is_scalar (tgt_type
) && TYPE_LENGTH (tgt_type
) >= 4)
326 /* The value is a structure whose first element is an integer or
327 * a float, and which contains no arrays of more than two elements
328 * -> returned in register */
329 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
330 && v850_type_is_scalar (TYPE_FIELD_TYPE (type
, 0))
331 && TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)) == 4)
333 for (i
= 1; i
< TYPE_NFIELDS (type
); ++i
)
335 fld_type
= TYPE_FIELD_TYPE (type
, 0);
336 if (TYPE_CODE (fld_type
) == TYPE_CODE_ARRAY
)
338 tgt_type
= TYPE_TARGET_TYPE (fld_type
);
339 if (TYPE_LENGTH (fld_type
) >= 0 && TYPE_LENGTH (tgt_type
) >= 0
340 && TYPE_LENGTH (fld_type
) / TYPE_LENGTH (tgt_type
) > 2)
347 /* The value is a union which contains at least one field which
348 * would be returned in registers according to these rules
349 * -> returned in register */
350 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
352 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
354 fld_type
= TYPE_FIELD_TYPE (type
, 0);
355 if (!v850_use_struct_convention (0, fld_type
))
365 /* Structure for mapping bits in register lists to register numbers. */
372 /* Helper function for v850_scan_prologue to handle prepare instruction. */
375 handle_prepare (int insn
, int insn2
, CORE_ADDR
* current_pc_ptr
,
376 struct prologue_info
*pi
, struct pifsr
**pifsr_ptr
)
378 CORE_ADDR current_pc
= *current_pc_ptr
;
379 struct pifsr
*pifsr
= *pifsr_ptr
;
380 long next
= insn2
& 0xffff;
381 long list12
= ((insn
& 1) << 16) + (next
& 0xffe0);
382 long offset
= (insn
& 0x3e) << 1;
383 static struct reg_list reg_table
[] =
385 {0x00800, 20}, /* r20 */
386 {0x00400, 21}, /* r21 */
387 {0x00200, 22}, /* r22 */
388 {0x00100, 23}, /* r23 */
389 {0x08000, 24}, /* r24 */
390 {0x04000, 25}, /* r25 */
391 {0x02000, 26}, /* r26 */
392 {0x01000, 27}, /* r27 */
393 {0x00080, 28}, /* r28 */
394 {0x00040, 29}, /* r29 */
395 {0x10000, 30}, /* ep */
396 {0x00020, 31}, /* lp */
397 {0, 0} /* end of table */
401 if ((next
& 0x1f) == 0x0b) /* skip imm16 argument */
403 else if ((next
& 0x1f) == 0x13) /* skip imm16 argument */
405 else if ((next
& 0x1f) == 0x1b) /* skip imm32 argument */
408 /* Calculate the total size of the saved registers, and add it
409 it to the immediate value used to adjust SP. */
410 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
411 if (list12
& reg_table
[i
].mask
)
412 offset
+= v850_register_raw_size (reg_table
[i
].regno
);
413 pi
->frameoffset
-= offset
;
415 /* Calculate the offsets of the registers relative to the value
416 the SP will have after the registers have been pushed and the
417 imm5 value has been subtracted from it. */
420 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
422 if (list12
& reg_table
[i
].mask
)
424 int reg
= reg_table
[i
].regno
;
425 offset
-= v850_register_raw_size (reg
);
427 pifsr
->offset
= offset
;
428 pifsr
->cur_frameoffset
= pi
->frameoffset
;
430 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
437 printf_filtered ("\tfound ctret after regsave func");
440 /* Set result parameters. */
441 *current_pc_ptr
= current_pc
;
446 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
447 FIXME: the SR bit of the register list is not supported; must check
448 that the compiler does not ever generate this bit. */
451 handle_pushm (int insn
, int insn2
, struct prologue_info
*pi
,
452 struct pifsr
**pifsr_ptr
)
454 struct pifsr
*pifsr
= *pifsr_ptr
;
455 long list12
= ((insn
& 0x0f) << 16) + (insn2
& 0xfff0);
457 static struct reg_list pushml_reg_table
[] =
459 {0x80000, E_PS_REGNUM
}, /* PSW */
460 {0x40000, 1}, /* r1 */
461 {0x20000, 2}, /* r2 */
462 {0x10000, 3}, /* r3 */
463 {0x00800, 4}, /* r4 */
464 {0x00400, 5}, /* r5 */
465 {0x00200, 6}, /* r6 */
466 {0x00100, 7}, /* r7 */
467 {0x08000, 8}, /* r8 */
468 {0x04000, 9}, /* r9 */
469 {0x02000, 10}, /* r10 */
470 {0x01000, 11}, /* r11 */
471 {0x00080, 12}, /* r12 */
472 {0x00040, 13}, /* r13 */
473 {0x00020, 14}, /* r14 */
474 {0x00010, 15}, /* r15 */
475 {0, 0} /* end of table */
477 static struct reg_list pushmh_reg_table
[] =
479 {0x80000, 16}, /* r16 */
480 {0x40000, 17}, /* r17 */
481 {0x20000, 18}, /* r18 */
482 {0x10000, 19}, /* r19 */
483 {0x00800, 20}, /* r20 */
484 {0x00400, 21}, /* r21 */
485 {0x00200, 22}, /* r22 */
486 {0x00100, 23}, /* r23 */
487 {0x08000, 24}, /* r24 */
488 {0x04000, 25}, /* r25 */
489 {0x02000, 26}, /* r26 */
490 {0x01000, 27}, /* r27 */
491 {0x00080, 28}, /* r28 */
492 {0x00040, 29}, /* r29 */
493 {0x00010, 30}, /* r30 */
494 {0x00020, 31}, /* r31 */
495 {0, 0} /* end of table */
497 struct reg_list
*reg_table
;
500 /* Is this a pushml or a pushmh? */
501 if ((insn2
& 7) == 1)
502 reg_table
= pushml_reg_table
;
504 reg_table
= pushmh_reg_table
;
506 /* Calculate the total size of the saved registers, and add it
507 it to the immediate value used to adjust SP. */
508 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
509 if (list12
& reg_table
[i
].mask
)
510 offset
+= v850_register_raw_size (reg_table
[i
].regno
);
511 pi
->frameoffset
-= offset
;
513 /* Calculate the offsets of the registers relative to the value
514 the SP will have after the registers have been pushed and the
515 imm5 value is subtracted from it. */
518 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
520 if (list12
& reg_table
[i
].mask
)
522 int reg
= reg_table
[i
].regno
;
523 offset
-= v850_register_raw_size (reg
);
525 pifsr
->offset
= offset
;
526 pifsr
->cur_frameoffset
= pi
->frameoffset
;
528 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
535 printf_filtered ("\tfound ctret after regsave func");
538 /* Set result parameters. */
545 /* Function: scan_prologue
546 Scan the prologue of the function that contains PC, and record what
547 we find in PI. Returns the pc after the prologue. Note that the
548 addresses saved in frame->saved_regs are just frame relative (negative
549 offsets from the frame pointer). This is because we don't know the
550 actual value of the frame pointer yet. In some circumstances, the
551 frame pointer can't be determined till after we have scanned the
555 v850_scan_prologue (CORE_ADDR pc
, struct prologue_info
*pi
)
557 CORE_ADDR func_addr
, prologue_end
, current_pc
;
558 struct pifsr
*pifsr
, *pifsr_tmp
;
562 CORE_ADDR save_pc
, save_end
;
566 /* First, figure out the bounds of the prologue so that we can limit the
567 search to something reasonable. */
569 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
571 struct symtab_and_line sal
;
573 sal
= find_pc_line (func_addr
, 0);
575 if (func_addr
== entry_point_address ())
576 pi
->start_function
= 1;
578 pi
->start_function
= 0;
584 prologue_end
= sal
.end
;
590 { /* We're in the boondocks */
591 func_addr
= pc
- 100;
595 prologue_end
= min (prologue_end
, pc
);
597 /* Now, search the prologue looking for instructions that setup fp, save
598 rp, adjust sp and such. We also record the frame offset of any saved
602 pi
->framereg
= E_SP_REGNUM
;
612 printf_filtered ("Current_pc = 0x%.8lx, prologue_end = 0x%.8lx\n",
613 (long) func_addr
, (long) prologue_end
);
616 for (current_pc
= func_addr
; current_pc
< prologue_end
;)
619 int insn2
= -1; /* dummy value */
622 fprintf_filtered (gdb_stdlog
, "0x%.8lx ", (long) current_pc
);
623 gdb_print_insn (current_pc
, gdb_stdlog
);
626 insn
= read_memory_unsigned_integer (current_pc
, 2);
628 if ((insn
& 0x0780) >= 0x0600) /* Four byte instruction? */
630 insn2
= read_memory_unsigned_integer (current_pc
, 2);
634 if ((insn
& 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p
)
635 { /* jarl <func>,10 */
636 long low_disp
= insn2
& ~(long) 1;
637 long disp
= (((((insn
& 0x3f) << 16) + low_disp
)
638 & ~(long) 1) ^ 0x00200000) - 0x00200000;
640 save_pc
= current_pc
;
641 save_end
= prologue_end
;
643 current_pc
+= disp
- 4;
644 prologue_end
= (current_pc
645 + (2 * 3) /* moves to/from ep */
646 + 4 /* addi <const>,sp,sp */
648 + (2 * 12) /* sst.w to save r2, r20-r29, r31 */
649 + 20); /* slop area */
652 printf_filtered ("\tfound jarl <func>,r10, disp = %ld, low_disp = %ld, new pc = 0x%.8lx\n",
653 disp
, low_disp
, (long) current_pc
+ 2);
657 else if ((insn
& 0xffc0) == 0x0200 && !regsave_func_p
)
659 long ctbp
= read_register (E_CTBP_REGNUM
);
660 long adr
= ctbp
+ ((insn
& 0x3f) << 1);
662 save_pc
= current_pc
;
663 save_end
= prologue_end
;
665 current_pc
= ctbp
+ (read_memory_unsigned_integer (adr
, 2) & 0xffff);
666 prologue_end
= (current_pc
667 + (2 * 3) /* prepare list2,imm5,sp/imm */
669 + 20); /* slop area */
672 printf_filtered ("\tfound callt, ctbp = 0x%.8lx, adr = %.8lx, new pc = 0x%.8lx\n",
673 ctbp
, adr
, (long) current_pc
);
677 else if ((insn
& 0xffc0) == 0x0780) /* prepare list2,imm5 */
679 handle_prepare (insn
, insn2
, ¤t_pc
, pi
, &pifsr
);
682 else if (insn
== 0x07e0 && regsave_func_p
&& insn2
== 0x0144)
683 { /* ctret after processing register save function */
684 current_pc
= save_pc
;
685 prologue_end
= save_end
;
688 printf_filtered ("\tfound ctret after regsave func");
692 else if ((insn
& 0xfff0) == 0x07e0 && (insn2
& 5) == 1)
693 { /* pushml, pushmh */
694 handle_pushm (insn
, insn2
, pi
, &pifsr
);
697 else if ((insn
& 0xffe0) == 0x0060 && regsave_func_p
)
698 { /* jmp after processing register save function */
699 current_pc
= save_pc
;
700 prologue_end
= save_end
;
703 printf_filtered ("\tfound jmp after regsave func");
707 else if ((insn
& 0x07c0) == 0x0780 /* jarl or jr */
708 || (insn
& 0xffe0) == 0x0060 /* jmp */
709 || (insn
& 0x0780) == 0x0580) /* branch */
712 printf_filtered ("\n");
714 break; /* Ran into end of prologue */
717 else if ((insn
& 0xffe0) == ((E_SP_REGNUM
<< 11) | 0x0240)) /* add <imm>,sp */
718 pi
->frameoffset
+= ((insn
& 0x1f) ^ 0x10) - 0x10;
719 else if (insn
== ((E_SP_REGNUM
<< 11) | 0x0600 | E_SP_REGNUM
)) /* addi <imm>,sp,sp */
720 pi
->frameoffset
+= insn2
;
721 else if (insn
== ((E_FP_RAW_REGNUM
<< 11) | 0x0000 | E_SP_REGNUM
)) /* mov sp,fp */
724 pi
->framereg
= E_FP_RAW_REGNUM
;
727 else if (insn
== ((E_R12_REGNUM
<< 11) | 0x0640 | E_R0_REGNUM
)) /* movhi hi(const),r0,r12 */
728 r12_tmp
= insn2
<< 16;
729 else if (insn
== ((E_R12_REGNUM
<< 11) | 0x0620 | E_R12_REGNUM
)) /* movea lo(const),r12,r12 */
731 else if (insn
== ((E_SP_REGNUM
<< 11) | 0x01c0 | E_R12_REGNUM
) && r12_tmp
) /* add r12,sp */
732 pi
->frameoffset
= r12_tmp
;
733 else if (insn
== ((E_EP_REGNUM
<< 11) | 0x0000 | E_SP_REGNUM
)) /* mov sp,ep */
735 else if (insn
== ((E_EP_REGNUM
<< 11) | 0x0000 | E_R1_REGNUM
)) /* mov r1,ep */
737 else if (((insn
& 0x07ff) == (0x0760 | E_SP_REGNUM
) /* st.w <reg>,<offset>[sp] */
739 && (insn
& 0x07ff) == (0x0760 | E_FP_RAW_REGNUM
))) /* st.w <reg>,<offset>[fp] */
741 && (((reg
= (insn
>> 11) & 0x1f) >= E_SAVE1_START_REGNUM
&& reg
<= E_SAVE1_END_REGNUM
)
742 || (reg
>= E_SAVE2_START_REGNUM
&& reg
<= E_SAVE2_END_REGNUM
)
743 || (reg
>= E_SAVE3_START_REGNUM
&& reg
<= E_SAVE3_END_REGNUM
)))
746 pifsr
->offset
= insn2
& ~1;
747 pifsr
->cur_frameoffset
= pi
->frameoffset
;
749 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
754 else if (ep_used
/* sst.w <reg>,<offset>[ep] */
755 && ((insn
& 0x0781) == 0x0501)
757 && (((reg
= (insn
>> 11) & 0x1f) >= E_SAVE1_START_REGNUM
&& reg
<= E_SAVE1_END_REGNUM
)
758 || (reg
>= E_SAVE2_START_REGNUM
&& reg
<= E_SAVE2_END_REGNUM
)
759 || (reg
>= E_SAVE3_START_REGNUM
&& reg
<= E_SAVE3_END_REGNUM
)))
762 pifsr
->offset
= (insn
& 0x007e) << 1;
763 pifsr
->cur_frameoffset
= pi
->frameoffset
;
765 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
771 printf_filtered ("\n");
776 pifsr
->framereg
= 0; /* Tie off last entry */
778 /* Fix up any offsets to the final offset. If a frame pointer was created, use it
779 instead of the stack pointer. */
780 for (pifsr_tmp
= pi
->pifsrs
; pifsr_tmp
&& pifsr_tmp
!= pifsr
; pifsr_tmp
++)
782 pifsr_tmp
->offset
-= pi
->frameoffset
- pifsr_tmp
->cur_frameoffset
;
783 pifsr_tmp
->framereg
= pi
->framereg
;
786 printf_filtered ("Saved register r%d, offset = %d, framereg = r%d\n",
787 pifsr_tmp
->reg
, pifsr_tmp
->offset
, pifsr_tmp
->framereg
);
792 printf_filtered ("Framereg = r%d, frameoffset = %d\n", pi
->framereg
, pi
->frameoffset
);
798 /* Function: find_callers_reg
799 Find REGNUM on the stack. Otherwise, it's in an active register.
800 One thing we might want to do here is to check REGNUM against the
801 clobber mask, and somehow flag it as invalid if it isn't saved on
802 the stack somewhere. This would provide a graceful failure mode
803 when trying to get the value of caller-saves registers for an inner
807 v850_find_callers_reg (struct frame_info
*fi
, int regnum
)
809 for (; fi
; fi
= get_next_frame (fi
))
810 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
811 get_frame_base (fi
)))
812 return deprecated_read_register_dummy (get_frame_pc (fi
),
813 get_frame_base (fi
), regnum
);
814 else if (deprecated_get_frame_saved_regs (fi
)[regnum
] != 0)
815 return read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi
)[regnum
],
816 v850_register_raw_size (regnum
));
818 return read_register (regnum
);
821 /* Function: frame_chain
822 Figure out the frame prior to FI. Unfortunately, this involves
823 scanning the prologue of the caller, which will also be done
824 shortly by v850_init_extra_frame_info. For the dummy frame, we
825 just return the stack pointer that was in use at the time the
826 function call was made. */
829 v850_frame_chain (struct frame_info
*fi
)
831 struct prologue_info pi
;
832 CORE_ADDR callers_pc
, fp
;
834 /* First, find out who called us */
835 callers_pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
836 /* If caller is a call-dummy, then our FP bears no relation to his FP! */
837 fp
= v850_find_callers_reg (fi
, E_FP_RAW_REGNUM
);
838 if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc
, fp
, fp
))
839 return fp
; /* caller is call-dummy: return oldest value of FP */
841 /* Caller is NOT a call-dummy, so everything else should just work.
842 Even if THIS frame is a call-dummy! */
845 v850_scan_prologue (callers_pc
, &pi
);
847 if (pi
.start_function
)
848 return 0; /* Don't chain beyond the start function */
850 if (pi
.framereg
== E_FP_RAW_REGNUM
)
851 return v850_find_callers_reg (fi
, pi
.framereg
);
853 return get_frame_base (fi
) - pi
.frameoffset
;
856 /* Function: skip_prologue
857 Return the address of the first code past the prologue of the function. */
860 v850_skip_prologue (CORE_ADDR pc
)
862 CORE_ADDR func_addr
, func_end
;
864 /* See what the symbol table says */
866 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
868 struct symtab_and_line sal
;
870 sal
= find_pc_line (func_addr
, 0);
872 if (sal
.line
!= 0 && sal
.end
< func_end
)
875 /* Either there's no line info, or the line after the prologue is after
876 the end of the function. In this case, there probably isn't a
881 /* We can't find the start of this function, so there's nothing we can do. */
885 /* Function: pop_frame
886 This routine gets called when either the user uses the `return'
887 command, or the call dummy breakpoint gets hit. */
890 v850_pop_frame (void)
892 struct frame_info
*frame
= get_current_frame ();
895 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame
),
896 get_frame_base (frame
),
897 get_frame_base (frame
)))
898 generic_pop_dummy_frame ();
901 write_register (E_PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
903 for (regnum
= 0; regnum
< E_NUM_REGS
; regnum
++)
904 if (deprecated_get_frame_saved_regs (frame
)[regnum
] != 0)
905 write_register (regnum
,
906 read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame
)[regnum
],
907 v850_register_raw_size (regnum
)));
909 write_register (E_SP_REGNUM
, get_frame_base (frame
));
912 flush_cached_frames ();
915 /* Function: push_arguments
916 Setup arguments and RP for a call to the target. First four args
917 go in R6->R9, subsequent args go into sp + 16 -> sp + ... Structs
918 are passed by reference. 64 bit quantities (doubles and long
919 longs) may be split between the regs and the stack. When calling a
920 function that returns a struct, a pointer to the struct is passed
921 in as a secret first argument (always in R6).
923 Stack space for the args has NOT been allocated: that job is up to us.
927 v850_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
928 int struct_return
, CORE_ADDR struct_addr
)
935 /* First, just for safety, make sure stack is aligned */
938 /* The offset onto the stack at which we will start copying parameters
939 (after the registers are used up) begins at 16 rather than at zero.
940 I don't really know why, that's just the way it seems to work. */
943 /* Now make space on the stack for the args. */
944 for (argnum
= 0; argnum
< nargs
; argnum
++)
945 len
+= ((TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3);
946 sp
-= len
+ stack_offset
; /* possibly over-allocating, but it works... */
947 /* (you might think we could allocate 16 bytes */
948 /* less, but the ABI seems to use it all! ) */
950 argreg
= E_ARG0_REGNUM
;
951 /* the struct_return pointer occupies the first parameter-passing reg */
955 /* Now load as many as possible of the first arguments into
956 registers, and push the rest onto the stack. There are 16 bytes
957 in four registers available. Loop thru args from first to last. */
958 for (argnum
= 0; argnum
< nargs
; argnum
++)
962 char valbuf
[v850_register_raw_size (E_ARG0_REGNUM
)];
964 if (!v850_type_is_scalar (VALUE_TYPE (*args
))
965 && TYPE_LENGTH (VALUE_TYPE (*args
)) > E_MAX_RETTYPE_SIZE_IN_REGS
)
967 store_unsigned_integer (valbuf
, 4, VALUE_ADDRESS (*args
));
973 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
974 val
= (char *) VALUE_CONTENTS (*args
);
978 if (argreg
<= E_ARGLAST_REGNUM
)
982 regval
= extract_unsigned_integer (val
, v850_register_raw_size (argreg
));
983 write_register (argreg
, regval
);
985 len
-= v850_register_raw_size (argreg
);
986 val
+= v850_register_raw_size (argreg
);
991 write_memory (sp
+ stack_offset
, val
, 4);
1002 /* Function: push_return_address (pc)
1003 Set up the return address for the inferior function call.
1004 Needed for targets where we don't actually execute a JSR/BSR instruction */
1007 v850_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
1009 write_register (E_RP_REGNUM
, entry_point_address ());
1013 /* Function: frame_saved_pc
1014 Find the caller of this frame. We do this by seeing if E_RP_REGNUM
1015 is saved in the stack anywhere, otherwise we get it from the
1016 registers. If the inner frame is a dummy frame, return its PC
1017 instead of RP, because that's where "caller" of the dummy-frame
1021 v850_frame_saved_pc (struct frame_info
*fi
)
1023 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
1024 get_frame_base (fi
)))
1025 return deprecated_read_register_dummy (get_frame_pc (fi
),
1026 get_frame_base (fi
), E_PC_REGNUM
);
1028 return v850_find_callers_reg (fi
, E_RP_REGNUM
);
1032 /* Function: fix_call_dummy
1033 Pokes the callee function's address into the CALL_DUMMY assembly stub.
1034 Assumes that the CALL_DUMMY looks like this:
1035 jarl <offset24>, r31
1040 v850_fix_call_dummy (char *dummy
, CORE_ADDR sp
, CORE_ADDR fun
, int nargs
,
1041 struct value
**args
, struct type
*type
, int gcc_p
)
1045 offset24
= (long) fun
- (long) entry_point_address ();
1046 offset24
&= 0x3fffff;
1047 offset24
|= 0xff800000; /* jarl <offset24>, r31 */
1049 store_unsigned_integer ((unsigned int *) &dummy
[2], 2, offset24
& 0xffff);
1050 store_unsigned_integer ((unsigned int *) &dummy
[0], 2, offset24
>> 16);
1054 v850_saved_pc_after_call (struct frame_info
*ignore
)
1056 return read_register (E_RP_REGNUM
);
1060 v850_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
1062 CORE_ADDR return_buffer
;
1064 if (!v850_use_struct_convention (0, type
))
1066 /* Scalar return values of <= 8 bytes are returned in
1067 E_V0_REGNUM to E_V1_REGNUM. */
1069 ®buf
[DEPRECATED_REGISTER_BYTE (E_V0_REGNUM
)],
1070 TYPE_LENGTH (type
));
1074 /* Aggregates and return values > 8 bytes are returned in memory,
1075 pointed to by R6. */
1077 extract_unsigned_integer (regbuf
+ DEPRECATED_REGISTER_BYTE (E_V0_REGNUM
),
1078 DEPRECATED_REGISTER_RAW_SIZE (E_V0_REGNUM
));
1080 read_memory (return_buffer
, valbuf
, TYPE_LENGTH (type
));
1084 const static unsigned char *
1085 v850_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
1087 static unsigned char breakpoint
[] = { 0x85, 0x05 };
1088 *lenptr
= sizeof (breakpoint
);
1093 v850_store_return_value (struct type
*type
, char *valbuf
)
1095 CORE_ADDR return_buffer
;
1097 if (!v850_use_struct_convention (0, type
))
1098 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_V0_REGNUM
), valbuf
,
1099 TYPE_LENGTH (type
));
1102 return_buffer
= read_register (E_V0_REGNUM
);
1103 write_memory (return_buffer
, valbuf
, TYPE_LENGTH (type
));
1108 v850_frame_init_saved_regs (struct frame_info
*fi
)
1110 struct prologue_info pi
;
1111 struct pifsr pifsrs
[E_NUM_REGS
+ 1], *pifsr
;
1112 CORE_ADDR func_addr
, func_end
;
1114 if (!deprecated_get_frame_saved_regs (fi
))
1116 frame_saved_regs_zalloc (fi
);
1118 /* The call dummy doesn't save any registers on the stack, so we
1120 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), get_frame_base (fi
),
1121 get_frame_base (fi
)))
1124 /* Find the beginning of this function, so we can analyze its
1126 if (find_pc_partial_function (get_frame_pc (fi
), NULL
, &func_addr
, &func_end
))
1130 v850_scan_prologue (get_frame_pc (fi
), &pi
);
1132 if (!get_next_frame (fi
) && pi
.framereg
== E_SP_REGNUM
)
1133 deprecated_update_frame_base_hack (fi
, read_register (pi
.framereg
) - pi
.frameoffset
);
1135 for (pifsr
= pifsrs
; pifsr
->framereg
; pifsr
++)
1137 deprecated_get_frame_saved_regs (fi
)[pifsr
->reg
] = pifsr
->offset
+ get_frame_base (fi
);
1139 if (pifsr
->framereg
== E_SP_REGNUM
)
1140 deprecated_get_frame_saved_regs (fi
)[pifsr
->reg
] += pi
.frameoffset
;
1143 /* Else we're out of luck (can't debug completely stripped code).
1148 /* Function: init_extra_frame_info
1149 Setup the frame's frame pointer, pc, and frame addresses for saved
1150 registers. Most of the work is done in scan_prologue().
1152 Note that when we are called for the last frame (currently active frame),
1153 that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
1154 be valid only if this routine uses FP. For previous frames, fi-frame will
1155 always be correct (since that is derived from v850_frame_chain ()).
1157 We can be called with the PC in the call dummy under two
1158 circumstances. First, during normal backtracing, second, while
1159 figuring out the frame pointer just prior to calling the target
1160 function (see call_function_by_hand). */
1163 v850_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1165 struct prologue_info pi
;
1167 if (get_next_frame (fi
))
1168 deprecated_update_frame_pc_hack (fi
, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi
)));
1170 v850_frame_init_saved_regs (fi
);
1174 v850_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1176 write_register (E_ARG0_REGNUM
, addr
);
1180 v850_target_read_fp (void)
1182 return read_register (E_FP_RAW_REGNUM
);
1185 static struct gdbarch
*
1186 v850_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1188 static LONGEST call_dummy_words
[1] = { 0 };
1189 struct gdbarch_tdep
*tdep
= NULL
;
1190 struct gdbarch
*gdbarch
;
1193 /* find a candidate among the list of pre-declared architectures. */
1194 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1196 return (arches
->gdbarch
);
1199 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
1202 /* Change the register names based on the current machine type. */
1203 if (info
.bfd_arch_info
->arch
!= bfd_arch_v850
)
1206 gdbarch
= gdbarch_alloc (&info
, 0);
1208 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1209 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1210 set_gdbarch_deprecated_init_frame_pc (gdbarch
, deprecated_init_frame_pc_default
);
1212 for (i
= 0; v850_processor_type_table
[i
].regnames
!= NULL
; i
++)
1214 if (v850_processor_type_table
[i
].mach
== info
.bfd_arch_info
->mach
)
1216 v850_register_names
= v850_processor_type_table
[i
].regnames
;
1222 * Basic register fields and methods.
1224 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
1225 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
1226 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1227 set_gdbarch_deprecated_fp_regnum (gdbarch
, E_FP_REGNUM
);
1228 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1229 set_gdbarch_register_name (gdbarch
, v850_register_name
);
1230 set_gdbarch_deprecated_register_size (gdbarch
, v850_reg_size
);
1231 set_gdbarch_deprecated_register_bytes (gdbarch
, E_ALL_REGS_SIZE
);
1232 set_gdbarch_deprecated_register_byte (gdbarch
, v850_register_byte
);
1233 set_gdbarch_deprecated_register_raw_size (gdbarch
, v850_register_raw_size
);
1234 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, v850_reg_size
);
1235 set_gdbarch_deprecated_register_virtual_size (gdbarch
, v850_register_raw_size
);
1236 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, v850_reg_size
);
1237 set_gdbarch_deprecated_register_virtual_type (gdbarch
, v850_reg_virtual_type
);
1239 set_gdbarch_deprecated_target_read_fp (gdbarch
, v850_target_read_fp
);
1244 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, v850_frame_init_saved_regs
);
1245 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, v850_init_extra_frame_info
);
1246 set_gdbarch_deprecated_frame_chain (gdbarch
, v850_frame_chain
);
1247 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, v850_saved_pc_after_call
);
1248 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, v850_frame_saved_pc
);
1249 set_gdbarch_skip_prologue (gdbarch
, v850_skip_prologue
);
1254 /* Stack grows up. */
1255 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1256 /* This value is almost never non-zero... */
1257 set_gdbarch_frame_args_skip (gdbarch
, 0);
1262 * These values and methods are used when gdb calls a target function. */
1263 set_gdbarch_deprecated_push_return_address (gdbarch
, v850_push_return_address
);
1264 set_gdbarch_deprecated_extract_return_value (gdbarch
, v850_extract_return_value
);
1265 set_gdbarch_deprecated_push_arguments (gdbarch
, v850_push_arguments
);
1266 set_gdbarch_deprecated_pop_frame (gdbarch
, v850_pop_frame
);
1267 set_gdbarch_deprecated_store_struct_return (gdbarch
, v850_store_struct_return
);
1268 set_gdbarch_deprecated_store_return_value (gdbarch
, v850_store_return_value
);
1269 set_gdbarch_use_struct_convention (gdbarch
, v850_use_struct_convention
);
1270 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_nil
);
1271 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
1272 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, v850_fix_call_dummy
);
1273 set_gdbarch_breakpoint_from_pc (gdbarch
, v850_breakpoint_from_pc
);
1275 set_gdbarch_int_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1276 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1277 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1278 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1280 /* Should be using push_dummy_call. */
1281 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
1283 set_gdbarch_print_insn (gdbarch
, print_insn_v850
);
1288 extern initialize_file_ftype _initialize_v850_tdep
; /* -Wmissing-prototypes */
1291 _initialize_v850_tdep (void)
1293 register_gdbarch_init (bfd_arch_v850
, v850_gdbarch_init
);