1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
3 Copyright (C) 1996-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "frame-base.h"
23 #include "trad-frame.h"
24 #include "frame-unwind.h"
25 #include "dwarf2-frame.h"
28 #include "gdb_string.h"
29 #include "gdb_assert.h"
31 #include "arch-utils.h"
41 E_R3_REGNUM
, E_SP_REGNUM
= E_R3_REGNUM
,
44 E_R6_REGNUM
, E_ARG0_REGNUM
= E_R6_REGNUM
,
47 E_R9_REGNUM
, E_ARGLAST_REGNUM
= E_R9_REGNUM
,
48 E_R10_REGNUM
, E_V0_REGNUM
= E_R10_REGNUM
,
49 E_R11_REGNUM
, E_V1_REGNUM
= E_R11_REGNUM
,
67 E_R29_REGNUM
, E_FP_REGNUM
= E_R29_REGNUM
,
68 E_R30_REGNUM
, E_EP_REGNUM
= E_R30_REGNUM
,
69 E_R31_REGNUM
, E_LP_REGNUM
= E_R31_REGNUM
,
70 E_R32_REGNUM
, E_SR0_REGNUM
= E_R32_REGNUM
,
75 E_R37_REGNUM
, E_PS_REGNUM
= E_R37_REGNUM
,
90 E_R52_REGNUM
, E_CTBP_REGNUM
= E_R52_REGNUM
,
102 E_R64_REGNUM
, E_PC_REGNUM
= E_R64_REGNUM
,
105 E_NUM_OF_V850E_REGS
= E_NUM_OF_V850_REGS
,
107 /* mpu0 system registers */
108 E_R66_REGNUM
= E_NUM_OF_V850_REGS
,
137 /* mpu1 system registers */
168 /* fpu system registers */
175 E_R128_REGNUM
, E_FPSR_REGNUM
= E_R128_REGNUM
,
176 E_R129_REGNUM
, E_FPEPC_REGNUM
= E_R129_REGNUM
,
177 E_R130_REGNUM
, E_FPST_REGNUM
= E_R130_REGNUM
,
178 E_R131_REGNUM
, E_FPCC_REGNUM
= E_R131_REGNUM
,
179 E_R132_REGNUM
, E_FPCFG_REGNUM
= E_R132_REGNUM
,
204 /* Size of return datatype which fits into all return registers. */
207 E_MAX_RETTYPE_SIZE_IN_REGS
= 2 * v850_reg_size
210 struct v850_frame_cache
217 /* Flag showing that a frame has been created in the prologue code. */
220 /* Saved registers. */
221 struct trad_frame_saved_reg
*saved_regs
;
224 /* Info gleaned from scanning a function's prologue. */
225 struct pifsr
/* Info about one saved register. */
227 int offset
; /* Offset from sp or fp. */
228 int cur_frameoffset
; /* Current frameoffset. */
229 int reg
; /* Saved register number. */
233 v850_register_name (struct gdbarch
*gdbarch
, int regnum
)
235 static const char *v850_reg_names
[] =
236 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
237 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
238 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
239 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
240 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
241 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
242 "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
243 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
246 if (regnum
< 0 || regnum
> E_NUM_OF_V850_REGS
)
248 return v850_reg_names
[regnum
];
252 v850e_register_name (struct gdbarch
*gdbarch
, int regnum
)
254 static const char *v850e_reg_names
[] =
256 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
257 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
258 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
259 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
260 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
261 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
262 "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
263 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
266 if (regnum
< 0 || regnum
> E_NUM_OF_V850E_REGS
)
268 return v850e_reg_names
[regnum
];
272 v850e2_register_name (struct gdbarch
*gdbarch
, int regnum
)
274 static const char *v850e2_reg_names
[] =
276 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
277 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
278 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
279 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
281 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
282 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
283 "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
284 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
287 /* mpu0 system registers */
288 "vip", "sr33", "sr34", "sr35", "vmecr", "vmtid", "vmadr", "sr39",
289 "vpecr", "vptid", "vpadr", "sr43", "vdecr", "vdtid", "sr46", "sr47",
290 "sr48", "sr49", "sr50", "sr51", "sr52", "sr53", "sr54", "sr55",
291 "sr56", "sr57", "sr58", "sr59",
293 /* mpu1 system registers */
294 "mpm", "mpc", "tid", "ppa", "ppm", "ppc", "dcc", "dcv0",
295 "dcv1", "sr69", "spal", "spau", "ipa0l", "ipa0u", "ipa1l", "ipa1u",
296 "iap2l", "ipa2u", "ipa3l", "ipa3u", "dpa0l", "dpa0u", "dpa1l", "dpa1u",
297 "dpa2l", "dpa2u", "dpa3l", "dpa3u",
299 /* fpu system registers */
300 "sr88", "sr89", "sr90", "sr91", "sr92", "sr93", "fpsr", "fpepc",
301 "fpst", "fpcc", "fpcfg", "sr99", "sr100", "sr101", "sr102", "sr103",
302 "sr104", "sr105", "sr106", "sr107", "sr108", "sr109", "sr110", "sr111",
303 "sr112", "sr113", "sr114", "sr115"
305 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
307 return v850e2_reg_names
[regnum
];
310 /* Returns the default type for register N. */
313 v850_register_type (struct gdbarch
*gdbarch
, int regnum
)
315 if (regnum
== E_PC_REGNUM
)
316 return builtin_type (gdbarch
)->builtin_func_ptr
;
317 return builtin_type (gdbarch
)->builtin_int32
;
321 v850_type_is_scalar (struct type
*t
)
323 return (TYPE_CODE (t
) != TYPE_CODE_STRUCT
324 && TYPE_CODE (t
) != TYPE_CODE_UNION
325 && TYPE_CODE (t
) != TYPE_CODE_ARRAY
);
328 /* Should call_function allocate stack space for a struct return? */
330 v850_use_struct_convention (struct type
*type
)
333 struct type
*fld_type
, *tgt_type
;
335 /* 1. The value is greater than 8 bytes -> returned by copying. */
336 if (TYPE_LENGTH (type
) > 8)
339 /* 2. The value is a single basic type -> returned in register. */
340 if (v850_type_is_scalar (type
))
343 /* The value is a structure or union with a single element and that
344 element is either a single basic type or an array of a single basic
345 type whose size is greater than or equal to 4 -> returned in register. */
346 if ((TYPE_CODE (type
) == TYPE_CODE_STRUCT
347 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
348 && TYPE_NFIELDS (type
) == 1)
350 fld_type
= TYPE_FIELD_TYPE (type
, 0);
351 if (v850_type_is_scalar (fld_type
) && TYPE_LENGTH (fld_type
) >= 4)
354 if (TYPE_CODE (fld_type
) == TYPE_CODE_ARRAY
)
356 tgt_type
= TYPE_TARGET_TYPE (fld_type
);
357 if (v850_type_is_scalar (tgt_type
) && TYPE_LENGTH (tgt_type
) >= 4)
362 /* The value is a structure whose first element is an integer or a float,
363 and which contains no arrays of more than two elements -> returned in
365 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
366 && v850_type_is_scalar (TYPE_FIELD_TYPE (type
, 0))
367 && TYPE_LENGTH (TYPE_FIELD_TYPE (type
, 0)) == 4)
369 for (i
= 1; i
< TYPE_NFIELDS (type
); ++i
)
371 fld_type
= TYPE_FIELD_TYPE (type
, 0);
372 if (TYPE_CODE (fld_type
) == TYPE_CODE_ARRAY
)
374 tgt_type
= TYPE_TARGET_TYPE (fld_type
);
375 if (TYPE_LENGTH (fld_type
) >= 0 && TYPE_LENGTH (tgt_type
) >= 0
376 && TYPE_LENGTH (fld_type
) / TYPE_LENGTH (tgt_type
) > 2)
383 /* The value is a union which contains at least one field which
384 would be returned in registers according to these rules ->
385 returned in register. */
386 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
388 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
390 fld_type
= TYPE_FIELD_TYPE (type
, 0);
391 if (!v850_use_struct_convention (fld_type
))
399 /* Structure for mapping bits in register lists to register numbers. */
406 /* Helper function for v850_scan_prologue to handle prepare instruction. */
409 v850_handle_prepare (int insn
, int insn2
, CORE_ADDR
* current_pc_ptr
,
410 struct v850_frame_cache
*pi
, struct pifsr
**pifsr_ptr
)
412 CORE_ADDR current_pc
= *current_pc_ptr
;
413 struct pifsr
*pifsr
= *pifsr_ptr
;
414 long next
= insn2
& 0xffff;
415 long list12
= ((insn
& 1) << 16) + (next
& 0xffe0);
416 long offset
= (insn
& 0x3e) << 1;
417 static struct reg_list reg_table
[] =
419 {0x00800, 20}, /* r20 */
420 {0x00400, 21}, /* r21 */
421 {0x00200, 22}, /* r22 */
422 {0x00100, 23}, /* r23 */
423 {0x08000, 24}, /* r24 */
424 {0x04000, 25}, /* r25 */
425 {0x02000, 26}, /* r26 */
426 {0x01000, 27}, /* r27 */
427 {0x00080, 28}, /* r28 */
428 {0x00040, 29}, /* r29 */
429 {0x10000, 30}, /* ep */
430 {0x00020, 31}, /* lp */
431 {0, 0} /* end of table */
435 if ((next
& 0x1f) == 0x0b) /* skip imm16 argument */
437 else if ((next
& 0x1f) == 0x13) /* skip imm16 argument */
439 else if ((next
& 0x1f) == 0x1b) /* skip imm32 argument */
442 /* Calculate the total size of the saved registers, and add it to the
443 immediate value used to adjust SP. */
444 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
445 if (list12
& reg_table
[i
].mask
)
446 offset
+= v850_reg_size
;
447 pi
->sp_offset
-= offset
;
449 /* Calculate the offsets of the registers relative to the value the SP
450 will have after the registers have been pushed and the imm5 value has
451 been subtracted from it. */
454 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
456 if (list12
& reg_table
[i
].mask
)
458 int reg
= reg_table
[i
].regno
;
459 offset
-= v850_reg_size
;
461 pifsr
->offset
= offset
;
462 pifsr
->cur_frameoffset
= pi
->sp_offset
;
468 /* Set result parameters. */
469 *current_pc_ptr
= current_pc
;
474 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
475 The SR bit of the register list is not supported. gcc does not generate
479 v850_handle_pushm (int insn
, int insn2
, struct v850_frame_cache
*pi
,
480 struct pifsr
**pifsr_ptr
)
482 struct pifsr
*pifsr
= *pifsr_ptr
;
483 long list12
= ((insn
& 0x0f) << 16) + (insn2
& 0xfff0);
485 static struct reg_list pushml_reg_table
[] =
487 {0x80000, E_PS_REGNUM
}, /* PSW */
488 {0x40000, 1}, /* r1 */
489 {0x20000, 2}, /* r2 */
490 {0x10000, 3}, /* r3 */
491 {0x00800, 4}, /* r4 */
492 {0x00400, 5}, /* r5 */
493 {0x00200, 6}, /* r6 */
494 {0x00100, 7}, /* r7 */
495 {0x08000, 8}, /* r8 */
496 {0x04000, 9}, /* r9 */
497 {0x02000, 10}, /* r10 */
498 {0x01000, 11}, /* r11 */
499 {0x00080, 12}, /* r12 */
500 {0x00040, 13}, /* r13 */
501 {0x00020, 14}, /* r14 */
502 {0x00010, 15}, /* r15 */
503 {0, 0} /* end of table */
505 static struct reg_list pushmh_reg_table
[] =
507 {0x80000, 16}, /* r16 */
508 {0x40000, 17}, /* r17 */
509 {0x20000, 18}, /* r18 */
510 {0x10000, 19}, /* r19 */
511 {0x00800, 20}, /* r20 */
512 {0x00400, 21}, /* r21 */
513 {0x00200, 22}, /* r22 */
514 {0x00100, 23}, /* r23 */
515 {0x08000, 24}, /* r24 */
516 {0x04000, 25}, /* r25 */
517 {0x02000, 26}, /* r26 */
518 {0x01000, 27}, /* r27 */
519 {0x00080, 28}, /* r28 */
520 {0x00040, 29}, /* r29 */
521 {0x00010, 30}, /* r30 */
522 {0x00020, 31}, /* r31 */
523 {0, 0} /* end of table */
525 struct reg_list
*reg_table
;
528 /* Is this a pushml or a pushmh? */
529 if ((insn2
& 7) == 1)
530 reg_table
= pushml_reg_table
;
532 reg_table
= pushmh_reg_table
;
534 /* Calculate the total size of the saved registers, and add it to the
535 immediate value used to adjust SP. */
536 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
537 if (list12
& reg_table
[i
].mask
)
538 offset
+= v850_reg_size
;
539 pi
->sp_offset
-= offset
;
541 /* Calculate the offsets of the registers relative to the value the SP
542 will have after the registers have been pushed and the imm5 value is
543 subtracted from it. */
546 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
548 if (list12
& reg_table
[i
].mask
)
550 int reg
= reg_table
[i
].regno
;
551 offset
-= v850_reg_size
;
553 pifsr
->offset
= offset
;
554 pifsr
->cur_frameoffset
= pi
->sp_offset
;
560 /* Set result parameters. */
564 /* Helper function to evaluate if register is one of the "save" registers.
565 This allows to simplify conditionals in v850_analyze_prologue a lot. */
568 v850_is_save_register (int reg
)
570 /* The caller-save registers are R2, R20 - R29 and R31. All other
571 registers are either special purpose (PC, SP), argument registers,
572 or just considered free for use in the caller. */
573 return reg
== E_R2_REGNUM
574 || (reg
>= E_R20_REGNUM
&& reg
<= E_R29_REGNUM
)
575 || reg
== E_R31_REGNUM
;
578 /* Scan the prologue of the function that contains PC, and record what
579 we find in PI. Returns the pc after the prologue. Note that the
580 addresses saved in frame->saved_regs are just frame relative (negative
581 offsets from the frame pointer). This is because we don't know the
582 actual value of the frame pointer yet. In some circumstances, the
583 frame pointer can't be determined till after we have scanned the
587 v850_analyze_prologue (struct gdbarch
*gdbarch
,
588 CORE_ADDR func_addr
, CORE_ADDR pc
,
589 struct v850_frame_cache
*pi
, ULONGEST ctbp
)
591 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
592 CORE_ADDR prologue_end
, current_pc
;
593 struct pifsr pifsrs
[E_NUM_REGS
+ 1];
594 struct pifsr
*pifsr
, *pifsr_tmp
;
597 CORE_ADDR save_pc
, save_end
;
601 memset (&pifsrs
, 0, sizeof pifsrs
);
606 /* Now, search the prologue looking for instructions that setup fp, save
607 rp, adjust sp and such. We also record the frame offset of any saved
618 for (current_pc
= func_addr
; current_pc
< prologue_end
;)
621 int insn2
= -1; /* dummy value */
623 insn
= read_memory_integer (current_pc
, 2, byte_order
);
625 if ((insn
& 0x0780) >= 0x0600) /* Four byte instruction? */
627 insn2
= read_memory_integer (current_pc
, 2, byte_order
);
631 if ((insn
& 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p
)
632 { /* jarl <func>,10 */
633 long low_disp
= insn2
& ~(long) 1;
634 long disp
= (((((insn
& 0x3f) << 16) + low_disp
)
635 & ~(long) 1) ^ 0x00200000) - 0x00200000;
637 save_pc
= current_pc
;
638 save_end
= prologue_end
;
640 current_pc
+= disp
- 4;
641 prologue_end
= (current_pc
642 + (2 * 3) /* moves to/from ep */
643 + 4 /* addi <const>,sp,sp */
645 + (2 * 12) /* sst.w to save r2, r20-r29, r31 */
646 + 20); /* slop area */
648 else if ((insn
& 0xffc0) == 0x0200 && !regsave_func_p
)
650 long adr
= ctbp
+ ((insn
& 0x3f) << 1);
652 save_pc
= current_pc
;
653 save_end
= prologue_end
;
655 current_pc
= ctbp
+ (read_memory_unsigned_integer (adr
, 2, byte_order
)
657 prologue_end
= (current_pc
658 + (2 * 3) /* prepare list2,imm5,sp/imm */
660 + 20); /* slop area */
663 else if ((insn
& 0xffc0) == 0x0780) /* prepare list2,imm5 */
665 v850_handle_prepare (insn
, insn2
, ¤t_pc
, pi
, &pifsr
);
668 else if (insn
== 0x07e0 && regsave_func_p
&& insn2
== 0x0144)
669 { /* ctret after processing register save. */
670 current_pc
= save_pc
;
671 prologue_end
= save_end
;
675 else if ((insn
& 0xfff0) == 0x07e0 && (insn2
& 5) == 1)
676 { /* pushml, pushmh */
677 v850_handle_pushm (insn
, insn2
, pi
, &pifsr
);
680 else if ((insn
& 0xffe0) == 0x0060 && regsave_func_p
)
681 { /* jmp after processing register save. */
682 current_pc
= save_pc
;
683 prologue_end
= save_end
;
687 else if ((insn
& 0x07c0) == 0x0780 /* jarl or jr */
688 || (insn
& 0xffe0) == 0x0060 /* jmp */
689 || (insn
& 0x0780) == 0x0580) /* branch */
691 break; /* Ran into end of prologue. */
694 else if ((insn
& 0xffe0) == ((E_SP_REGNUM
<< 11) | 0x0240))
696 pi
->sp_offset
+= ((insn
& 0x1f) ^ 0x10) - 0x10;
697 else if (insn
== ((E_SP_REGNUM
<< 11) | 0x0600 | E_SP_REGNUM
))
698 /* addi <imm>,sp,sp */
699 pi
->sp_offset
+= insn2
;
700 else if (insn
== ((E_FP_REGNUM
<< 11) | 0x0000 | E_SP_REGNUM
))
703 else if (insn
== ((E_R12_REGNUM
<< 11) | 0x0640 | E_R0_REGNUM
))
704 /* movhi hi(const),r0,r12 */
705 r12_tmp
= insn2
<< 16;
706 else if (insn
== ((E_R12_REGNUM
<< 11) | 0x0620 | E_R12_REGNUM
))
707 /* movea lo(const),r12,r12 */
709 else if (insn
== ((E_SP_REGNUM
<< 11) | 0x01c0 | E_R12_REGNUM
) && r12_tmp
)
711 pi
->sp_offset
+= r12_tmp
;
712 else if (insn
== ((E_EP_REGNUM
<< 11) | 0x0000 | E_SP_REGNUM
))
715 else if (insn
== ((E_EP_REGNUM
<< 11) | 0x0000 | E_R1_REGNUM
))
718 else if (((insn
& 0x07ff) == (0x0760 | E_SP_REGNUM
)
720 && (insn
& 0x07ff) == (0x0760 | E_FP_REGNUM
)))
722 && v850_is_save_register (reg
= (insn
>> 11) & 0x1f))
724 /* st.w <reg>,<offset>[sp] or st.w <reg>,<offset>[fp] */
726 pifsr
->offset
= insn2
& ~1;
727 pifsr
->cur_frameoffset
= pi
->sp_offset
;
731 && ((insn
& 0x0781) == 0x0501)
733 && v850_is_save_register (reg
= (insn
>> 11) & 0x1f))
735 /* sst.w <reg>,<offset>[ep] */
737 pifsr
->offset
= (insn
& 0x007e) << 1;
738 pifsr
->cur_frameoffset
= pi
->sp_offset
;
743 /* Fix up any offsets to the final offset. If a frame pointer was created,
744 use it instead of the stack pointer. */
745 for (pifsr_tmp
= pifsrs
; pifsr_tmp
!= pifsr
; pifsr_tmp
++)
747 pifsr_tmp
->offset
-= pi
->sp_offset
- pifsr_tmp
->cur_frameoffset
;
748 pi
->saved_regs
[pifsr_tmp
->reg
].addr
= pifsr_tmp
->offset
;
754 /* Return the address of the first code past the prologue of the function. */
757 v850_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
759 CORE_ADDR func_addr
, func_end
;
761 /* See what the symbol table says. */
763 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
765 struct symtab_and_line sal
;
767 sal
= find_pc_line (func_addr
, 0);
768 if (sal
.line
!= 0 && sal
.end
< func_end
)
771 /* Either there's no line info, or the line after the prologue is after
772 the end of the function. In this case, there probably isn't a
777 /* We can't find the start of this function, so there's nothing we
783 v850_frame_align (struct gdbarch
*ignore
, CORE_ADDR sp
)
788 /* Setup arguments and LP for a call to the target. First four args
789 go in R6->R9, subsequent args go into sp + 16 -> sp + ... Structs
790 are passed by reference. 64 bit quantities (doubles and long longs)
791 may be split between the regs and the stack. When calling a function
792 that returns a struct, a pointer to the struct is passed in as a secret
793 first argument (always in R6).
795 Stack space for the args has NOT been allocated: that job is up to us. */
798 v850_push_dummy_call (struct gdbarch
*gdbarch
,
799 struct value
*function
,
800 struct regcache
*regcache
,
806 CORE_ADDR struct_addr
)
808 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
814 /* The offset onto the stack at which we will start copying parameters
815 (after the registers are used up) begins at 16 rather than at zero.
816 That's how the ABI is defined, though there's no indication that these
817 16 bytes are used for anything, not even for saving incoming
818 argument registers. */
821 /* Now make space on the stack for the args. */
822 for (argnum
= 0; argnum
< nargs
; argnum
++)
823 len
+= ((TYPE_LENGTH (value_type (args
[argnum
])) + 3) & ~3);
824 sp
-= len
+ stack_offset
;
826 argreg
= E_ARG0_REGNUM
;
827 /* The struct_return pointer occupies the first parameter register. */
829 regcache_cooked_write_unsigned (regcache
, argreg
++, struct_addr
);
831 /* Now load as many as possible of the first arguments into
832 registers, and push the rest onto the stack. There are 16 bytes
833 in four registers available. Loop thru args from first to last. */
834 for (argnum
= 0; argnum
< nargs
; argnum
++)
838 gdb_byte valbuf
[v850_reg_size
];
840 if (!v850_type_is_scalar (value_type (*args
))
841 && TYPE_LENGTH (value_type (*args
)) > E_MAX_RETTYPE_SIZE_IN_REGS
)
843 store_unsigned_integer (valbuf
, 4, byte_order
,
844 value_address (*args
));
850 len
= TYPE_LENGTH (value_type (*args
));
851 val
= (gdb_byte
*) value_contents (*args
);
855 if (argreg
<= E_ARGLAST_REGNUM
)
859 regval
= extract_unsigned_integer (val
, v850_reg_size
, byte_order
);
860 regcache_cooked_write_unsigned (regcache
, argreg
, regval
);
862 len
-= v850_reg_size
;
863 val
+= v850_reg_size
;
868 write_memory (sp
+ stack_offset
, val
, 4);
877 /* Store return address. */
878 regcache_cooked_write_unsigned (regcache
, E_LP_REGNUM
, bp_addr
);
880 /* Update stack pointer. */
881 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
887 v850_extract_return_value (struct type
*type
, struct regcache
*regcache
,
890 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
891 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
892 int len
= TYPE_LENGTH (type
);
894 if (len
<= v850_reg_size
)
898 regcache_cooked_read_unsigned (regcache
, E_V0_REGNUM
, &val
);
899 store_unsigned_integer (valbuf
, len
, byte_order
, val
);
901 else if (len
<= 2 * v850_reg_size
)
903 int i
, regnum
= E_V0_REGNUM
;
904 gdb_byte buf
[v850_reg_size
];
905 for (i
= 0; len
> 0; i
+= 4, len
-= 4)
907 regcache_raw_read (regcache
, regnum
++, buf
);
908 memcpy (valbuf
+ i
, buf
, len
> 4 ? 4 : len
);
914 v850_store_return_value (struct type
*type
, struct regcache
*regcache
,
915 const gdb_byte
*valbuf
)
917 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
918 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
919 int len
= TYPE_LENGTH (type
);
921 if (len
<= v850_reg_size
)
922 regcache_cooked_write_unsigned
923 (regcache
, E_V0_REGNUM
,
924 extract_unsigned_integer (valbuf
, len
, byte_order
));
925 else if (len
<= 2 * v850_reg_size
)
927 int i
, regnum
= E_V0_REGNUM
;
928 for (i
= 0; i
< len
; i
+= 4)
929 regcache_raw_write (regcache
, regnum
++, valbuf
+ i
);
933 static enum return_value_convention
934 v850_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
935 struct type
*type
, struct regcache
*regcache
,
936 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
938 if (v850_use_struct_convention (type
))
939 return RETURN_VALUE_STRUCT_CONVENTION
;
941 v850_store_return_value (type
, regcache
, writebuf
);
943 v850_extract_return_value (type
, regcache
, readbuf
);
944 return RETURN_VALUE_REGISTER_CONVENTION
;
947 const static unsigned char *
948 v850_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
950 static unsigned char breakpoint
[] = { 0x85, 0x05 };
951 *lenptr
= sizeof (breakpoint
);
955 static struct v850_frame_cache
*
956 v850_alloc_frame_cache (struct frame_info
*this_frame
)
958 struct v850_frame_cache
*cache
;
960 cache
= FRAME_OBSTACK_ZALLOC (struct v850_frame_cache
);
961 cache
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
965 cache
->sp_offset
= 0;
968 /* Frameless until proven otherwise. */
974 static struct v850_frame_cache
*
975 v850_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
977 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
978 struct v850_frame_cache
*cache
;
979 CORE_ADDR current_pc
;
985 cache
= v850_alloc_frame_cache (this_frame
);
988 /* In principle, for normal frames, fp holds the frame pointer,
989 which holds the base address for the current stack frame.
990 However, for functions that don't need it, the frame pointer is
991 optional. For these "frameless" functions the frame pointer is
992 actually the frame pointer of the calling frame. */
993 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
994 if (cache
->base
== 0)
997 cache
->pc
= get_frame_func (this_frame
);
998 current_pc
= get_frame_pc (this_frame
);
1002 ctbp
= get_frame_register_unsigned (this_frame
, E_CTBP_REGNUM
);
1003 v850_analyze_prologue (gdbarch
, cache
->pc
, current_pc
, cache
, ctbp
);
1006 if (!cache
->uses_fp
)
1008 /* We didn't find a valid frame, which means that CACHE->base
1009 currently holds the frame pointer for our calling frame. If
1010 we're at the start of a function, or somewhere half-way its
1011 prologue, the function's frame probably hasn't been fully
1012 setup yet. Try to reconstruct the base address for the stack
1013 frame by looking at the stack pointer. For truly "frameless"
1014 functions this might work too. */
1015 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
1018 /* Now that we have the base address for the stack frame we can
1019 calculate the value of sp in the calling frame. */
1020 trad_frame_set_value (cache
->saved_regs
, E_SP_REGNUM
,
1021 cache
->base
- cache
->sp_offset
);
1023 /* Adjust all the saved registers such that they contain addresses
1024 instead of offsets. */
1025 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1026 if (trad_frame_addr_p (cache
->saved_regs
, i
))
1027 cache
->saved_regs
[i
].addr
+= cache
->base
;
1029 /* The call instruction moves the caller's PC in the callee's LP.
1030 Since this is an unwind, do the reverse. Copy the location of LP
1031 into PC (the address / regnum) so that a request for PC will be
1032 converted into a request for the LP. */
1034 cache
->saved_regs
[E_PC_REGNUM
] = cache
->saved_regs
[E_LP_REGNUM
];
1040 static struct value
*
1041 v850_frame_prev_register (struct frame_info
*this_frame
,
1042 void **this_cache
, int regnum
)
1044 struct v850_frame_cache
*cache
= v850_frame_cache (this_frame
, this_cache
);
1046 gdb_assert (regnum
>= 0);
1048 return trad_frame_get_prev_register (this_frame
, cache
->saved_regs
, regnum
);
1052 v850_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1053 struct frame_id
*this_id
)
1055 struct v850_frame_cache
*cache
= v850_frame_cache (this_frame
, this_cache
);
1057 /* This marks the outermost frame. */
1058 if (cache
->base
== 0)
1061 *this_id
= frame_id_build (cache
->saved_regs
[E_SP_REGNUM
].addr
, cache
->pc
);
1064 static const struct frame_unwind v850_frame_unwind
= {
1066 default_frame_unwind_stop_reason
,
1068 v850_frame_prev_register
,
1070 default_frame_sniffer
1074 v850_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1076 return frame_unwind_register_unsigned (next_frame
,
1077 gdbarch_sp_regnum (gdbarch
));
1081 v850_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1083 return frame_unwind_register_unsigned (next_frame
,
1084 gdbarch_pc_regnum (gdbarch
));
1087 static struct frame_id
1088 v850_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1090 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
,
1091 gdbarch_sp_regnum (gdbarch
));
1092 return frame_id_build (sp
, get_frame_pc (this_frame
));
1096 v850_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1098 struct v850_frame_cache
*cache
= v850_frame_cache (this_frame
, this_cache
);
1103 static const struct frame_base v850_frame_base
= {
1105 v850_frame_base_address
,
1106 v850_frame_base_address
,
1107 v850_frame_base_address
1110 static struct gdbarch
*
1111 v850_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1113 struct gdbarch
*gdbarch
;
1115 /* Change the register names based on the current machine type. */
1116 if (info
.bfd_arch_info
->arch
!= bfd_arch_v850
)
1119 gdbarch
= gdbarch_alloc (&info
, NULL
);
1121 switch (info
.bfd_arch_info
->mach
)
1124 set_gdbarch_register_name (gdbarch
, v850_register_name
);
1125 set_gdbarch_num_regs (gdbarch
, E_NUM_OF_V850_REGS
);
1127 case bfd_mach_v850e
:
1128 case bfd_mach_v850e1
:
1129 set_gdbarch_register_name (gdbarch
, v850e_register_name
);
1130 set_gdbarch_num_regs (gdbarch
, E_NUM_OF_V850E_REGS
);
1132 case bfd_mach_v850e2
:
1133 case bfd_mach_v850e2v3
:
1134 set_gdbarch_register_name (gdbarch
, v850e2_register_name
);
1135 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
1139 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
1140 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1141 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1142 set_gdbarch_fp0_regnum (gdbarch
, -1);
1144 set_gdbarch_register_type (gdbarch
, v850_register_type
);
1146 set_gdbarch_char_signed (gdbarch
, 1);
1147 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1148 set_gdbarch_int_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1149 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1150 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1152 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1153 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1154 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1156 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1157 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1159 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1160 set_gdbarch_breakpoint_from_pc (gdbarch
, v850_breakpoint_from_pc
);
1162 set_gdbarch_return_value (gdbarch
, v850_return_value
);
1163 set_gdbarch_push_dummy_call (gdbarch
, v850_push_dummy_call
);
1164 set_gdbarch_skip_prologue (gdbarch
, v850_skip_prologue
);
1166 set_gdbarch_print_insn (gdbarch
, print_insn_v850
);
1168 set_gdbarch_frame_align (gdbarch
, v850_frame_align
);
1169 set_gdbarch_unwind_sp (gdbarch
, v850_unwind_sp
);
1170 set_gdbarch_unwind_pc (gdbarch
, v850_unwind_pc
);
1171 set_gdbarch_dummy_id (gdbarch
, v850_dummy_id
);
1172 frame_base_set_default (gdbarch
, &v850_frame_base
);
1174 /* Hook in ABI-specific overrides, if they have been registered. */
1175 gdbarch_init_osabi (info
, gdbarch
);
1177 dwarf2_append_unwinders (gdbarch
);
1178 frame_unwind_append_unwinder (gdbarch
, &v850_frame_unwind
);
1183 extern initialize_file_ftype _initialize_v850_tdep
; /* -Wmissing-prototypes */
1186 _initialize_v850_tdep (void)
1188 register_gdbarch_init (bfd_arch_v850
, v850_gdbarch_init
);