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_reg_virtual_type
252 Returns the default type for register N. */
255 v850_reg_virtual_type (int regnum)
257 if (regnum < 0 || regnum >= E_NUM_REGS)
258 internal_error (__FILE__, __LINE__,
259 "v850_register_virtual_type: illegal register number %d",
261 else if (regnum == E_PC_REGNUM)
262 return builtin_type_uint32;
264 return builtin_type_int32;
268 v850_type_is_scalar (struct type *t)
270 return (TYPE_CODE (t) != TYPE_CODE_STRUCT
271 && TYPE_CODE (t) != TYPE_CODE_UNION
272 && TYPE_CODE (t) != TYPE_CODE_ARRAY);
275 /* Should call_function allocate stack space for a struct return? */
277 v850_use_struct_convention (int gcc_p, struct type *type)
280 * return TYPE_LENGTH (type) > 8);
283 /* Current implementation in gcc: */
286 struct type *fld_type, *tgt_type;
288 /* 1. The value is greater than 8 bytes -> returned by copying */
289 if (TYPE_LENGTH (type) > 8)
292 /* 2. The value is a single basic type -> returned in register */
293 if (v850_type_is_scalar (type))
296 /* The value is a structure or union with a single element
297 * and that element is either a single basic type or an array of
298 * a single basic type whoes size is greater than or equal to 4
299 * -> returned in register */
300 if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
301 || TYPE_CODE (type) == TYPE_CODE_UNION)
302 && TYPE_NFIELDS (type) == 1)
304 fld_type = TYPE_FIELD_TYPE (type, 0);
305 if (v850_type_is_scalar (fld_type) && TYPE_LENGTH (fld_type) >= 4)
308 if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
310 tgt_type = TYPE_TARGET_TYPE (fld_type);
311 if (v850_type_is_scalar (tgt_type) && TYPE_LENGTH (tgt_type) >= 4)
316 /* The value is a structure whose first element is an integer or
317 * a float, and which contains no arrays of more than two elements
318 * -> returned in register */
319 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
320 && v850_type_is_scalar (TYPE_FIELD_TYPE (type, 0))
321 && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
323 for (i = 1; i < TYPE_NFIELDS (type); ++i)
325 fld_type = TYPE_FIELD_TYPE (type, 0);
326 if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
328 tgt_type = TYPE_TARGET_TYPE (fld_type);
329 if (TYPE_LENGTH (fld_type) >= 0 && TYPE_LENGTH (tgt_type) >= 0
330 && TYPE_LENGTH (fld_type) / TYPE_LENGTH (tgt_type) > 2)
337 /* The value is a union which contains at least one field which
338 * would be returned in registers according to these rules
339 * -> returned in register */
340 if (TYPE_CODE (type) == TYPE_CODE_UNION)
342 for (i = 0; i < TYPE_NFIELDS (type); ++i)
344 fld_type = TYPE_FIELD_TYPE (type, 0);
345 if (!v850_use_struct_convention (0, fld_type))
355 /* Structure for mapping bits in register lists to register numbers. */
362 /* Helper function for v850_scan_prologue to handle prepare instruction. */
365 handle_prepare (int insn, int insn2, CORE_ADDR * current_pc_ptr,
366 struct prologue_info *pi, struct pifsr **pifsr_ptr)
368 CORE_ADDR current_pc = *current_pc_ptr;
369 struct pifsr *pifsr = *pifsr_ptr;
370 long next = insn2 & 0xffff;
371 long list12 = ((insn & 1) << 16) + (next & 0xffe0);
372 long offset = (insn & 0x3e) << 1;
373 static struct reg_list reg_table[] =
375 {0x00800, 20}, /* r20 */
376 {0x00400, 21}, /* r21 */
377 {0x00200, 22}, /* r22 */
378 {0x00100, 23}, /* r23 */
379 {0x08000, 24}, /* r24 */
380 {0x04000, 25}, /* r25 */
381 {0x02000, 26}, /* r26 */
382 {0x01000, 27}, /* r27 */
383 {0x00080, 28}, /* r28 */
384 {0x00040, 29}, /* r29 */
385 {0x10000, 30}, /* ep */
386 {0x00020, 31}, /* lp */
387 {0, 0} /* end of table */
391 if ((next & 0x1f) == 0x0b) /* skip imm16 argument */
393 else if ((next & 0x1f) == 0x13) /* skip imm16 argument */
395 else if ((next & 0x1f) == 0x1b) /* skip imm32 argument */
398 /* Calculate the total size of the saved registers, and add it
399 it to the immediate value used to adjust SP. */
400 for (i = 0; reg_table[i].mask != 0; i++)
401 if (list12 & reg_table[i].mask)
402 offset += v850_register_raw_size (reg_table[i].regno);
403 pi->frameoffset -= offset;
405 /* Calculate the offsets of the registers relative to the value
406 the SP will have after the registers have been pushed and the
407 imm5 value has been subtracted from it. */
410 for (i = 0; reg_table[i].mask != 0; i++)
412 if (list12 & reg_table[i].mask)
414 int reg = reg_table[i].regno;
415 offset -= v850_register_raw_size (reg);
417 pifsr->offset = offset;
418 pifsr->cur_frameoffset = pi->frameoffset;
420 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
427 printf_filtered ("\tfound ctret after regsave func");
430 /* Set result parameters. */
431 *current_pc_ptr = current_pc;
436 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
437 FIXME: the SR bit of the register list is not supported; must check
438 that the compiler does not ever generate this bit. */
441 handle_pushm (int insn, int insn2, struct prologue_info *pi,
442 struct pifsr **pifsr_ptr)
444 struct pifsr *pifsr = *pifsr_ptr;
445 long list12 = ((insn & 0x0f) << 16) + (insn2 & 0xfff0);
447 static struct reg_list pushml_reg_table[] =
449 {0x80000, E_PS_REGNUM}, /* PSW */
450 {0x40000, 1}, /* r1 */
451 {0x20000, 2}, /* r2 */
452 {0x10000, 3}, /* r3 */
453 {0x00800, 4}, /* r4 */
454 {0x00400, 5}, /* r5 */
455 {0x00200, 6}, /* r6 */
456 {0x00100, 7}, /* r7 */
457 {0x08000, 8}, /* r8 */
458 {0x04000, 9}, /* r9 */
459 {0x02000, 10}, /* r10 */
460 {0x01000, 11}, /* r11 */
461 {0x00080, 12}, /* r12 */
462 {0x00040, 13}, /* r13 */
463 {0x00020, 14}, /* r14 */
464 {0x00010, 15}, /* r15 */
465 {0, 0} /* end of table */
467 static struct reg_list pushmh_reg_table[] =
469 {0x80000, 16}, /* r16 */
470 {0x40000, 17}, /* r17 */
471 {0x20000, 18}, /* r18 */
472 {0x10000, 19}, /* r19 */
473 {0x00800, 20}, /* r20 */
474 {0x00400, 21}, /* r21 */
475 {0x00200, 22}, /* r22 */
476 {0x00100, 23}, /* r23 */
477 {0x08000, 24}, /* r24 */
478 {0x04000, 25}, /* r25 */
479 {0x02000, 26}, /* r26 */
480 {0x01000, 27}, /* r27 */
481 {0x00080, 28}, /* r28 */
482 {0x00040, 29}, /* r29 */
483 {0x00010, 30}, /* r30 */
484 {0x00020, 31}, /* r31 */
485 {0, 0} /* end of table */
487 struct reg_list *reg_table;
490 /* Is this a pushml or a pushmh? */
491 if ((insn2 & 7) == 1)
492 reg_table = pushml_reg_table;
494 reg_table = pushmh_reg_table;
496 /* Calculate the total size of the saved registers, and add it
497 it to the immediate value used to adjust SP. */
498 for (i = 0; reg_table[i].mask != 0; i++)
499 if (list12 & reg_table[i].mask)
500 offset += v850_register_raw_size (reg_table[i].regno);
501 pi->frameoffset -= offset;
503 /* Calculate the offsets of the registers relative to the value
504 the SP will have after the registers have been pushed and the
505 imm5 value is subtracted from it. */
508 for (i = 0; reg_table[i].mask != 0; i++)
510 if (list12 & reg_table[i].mask)
512 int reg = reg_table[i].regno;
513 offset -= v850_register_raw_size (reg);
515 pifsr->offset = offset;
516 pifsr->cur_frameoffset = pi->frameoffset;
518 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
525 printf_filtered ("\tfound ctret after regsave func");
528 /* Set result parameters. */
535 /* Function: scan_prologue
536 Scan the prologue of the function that contains PC, and record what
537 we find in PI. Returns the pc after the prologue. Note that the
538 addresses saved in frame->saved_regs are just frame relative (negative
539 offsets from the frame pointer). This is because we don't know the
540 actual value of the frame pointer yet. In some circumstances, the
541 frame pointer can't be determined till after we have scanned the
545 v850_scan_prologue (CORE_ADDR pc, struct prologue_info *pi)
547 CORE_ADDR func_addr, prologue_end, current_pc;
548 struct pifsr *pifsr, *pifsr_tmp;
552 CORE_ADDR save_pc, save_end;
556 /* First, figure out the bounds of the prologue so that we can limit the
557 search to something reasonable. */
559 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
561 struct symtab_and_line sal;
563 sal = find_pc_line (func_addr, 0);
565 if (func_addr == entry_point_address ())
566 pi->start_function = 1;
568 pi->start_function = 0;
574 prologue_end = sal.end;
580 { /* We're in the boondocks */
581 func_addr = pc - 100;
585 prologue_end = min (prologue_end, pc);
587 /* Now, search the prologue looking for instructions that setup fp, save
588 rp, adjust sp and such. We also record the frame offset of any saved
592 pi->framereg = E_SP_REGNUM;
602 printf_filtered ("Current_pc = 0x%.8lx, prologue_end = 0x%.8lx\n",
603 (long) func_addr, (long) prologue_end);
606 for (current_pc = func_addr; current_pc < prologue_end;)
609 int insn2 = -1; /* dummy value */
612 fprintf_filtered (gdb_stdlog, "0x%.8lx ", (long) current_pc);
613 gdb_print_insn (current_pc, gdb_stdlog);
616 insn = read_memory_unsigned_integer (current_pc, 2);
618 if ((insn & 0x0780) >= 0x0600) /* Four byte instruction? */
620 insn2 = read_memory_unsigned_integer (current_pc, 2);
624 if ((insn & 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p)
625 { /* jarl <func>,10 */
626 long low_disp = insn2 & ~(long) 1;
627 long disp = (((((insn & 0x3f) << 16) + low_disp)
628 & ~(long) 1) ^ 0x00200000) - 0x00200000;
630 save_pc = current_pc;
631 save_end = prologue_end;
633 current_pc += disp - 4;
634 prologue_end = (current_pc
635 + (2 * 3) /* moves to/from ep */
636 + 4 /* addi <const>,sp,sp */
638 + (2 * 12) /* sst.w to save r2, r20-r29, r31 */
639 + 20); /* slop area */
642 printf_filtered ("\tfound jarl <func>,r10, disp = %ld, low_disp = %ld, new pc = 0x%.8lx\n",
643 disp, low_disp, (long) current_pc + 2);
647 else if ((insn & 0xffc0) == 0x0200 && !regsave_func_p)
649 long ctbp = read_register (E_CTBP_REGNUM);
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) & 0xffff);
656 prologue_end = (current_pc
657 + (2 * 3) /* prepare list2,imm5,sp/imm */
659 + 20); /* slop area */
662 printf_filtered ("\tfound callt, ctbp = 0x%.8lx, adr = %.8lx, new pc = 0x%.8lx\n",
663 ctbp, adr, (long) current_pc);
667 else if ((insn & 0xffc0) == 0x0780) /* prepare list2,imm5 */
669 handle_prepare (insn, insn2, ¤t_pc, pi, &pifsr);
672 else if (insn == 0x07e0 && regsave_func_p && insn2 == 0x0144)
673 { /* ctret after processing register save function */
674 current_pc = save_pc;
675 prologue_end = save_end;
678 printf_filtered ("\tfound ctret after regsave func");
682 else if ((insn & 0xfff0) == 0x07e0 && (insn2 & 5) == 1)
683 { /* pushml, pushmh */
684 handle_pushm (insn, insn2, pi, &pifsr);
687 else if ((insn & 0xffe0) == 0x0060 && regsave_func_p)
688 { /* jmp after processing register save function */
689 current_pc = save_pc;
690 prologue_end = save_end;
693 printf_filtered ("\tfound jmp after regsave func");
697 else if ((insn & 0x07c0) == 0x0780 /* jarl or jr */
698 || (insn & 0xffe0) == 0x0060 /* jmp */
699 || (insn & 0x0780) == 0x0580) /* branch */
702 printf_filtered ("\n");
704 break; /* Ran into end of prologue */
707 else if ((insn & 0xffe0) == ((E_SP_REGNUM << 11) | 0x0240)) /* add <imm>,sp */
708 pi->frameoffset += ((insn & 0x1f) ^ 0x10) - 0x10;
709 else if (insn == ((E_SP_REGNUM << 11) | 0x0600 | E_SP_REGNUM)) /* addi <imm>,sp,sp */
710 pi->frameoffset += insn2;
711 else if (insn == ((E_FP_RAW_REGNUM << 11) | 0x0000 | E_SP_REGNUM)) /* mov sp,fp */
714 pi->framereg = E_FP_RAW_REGNUM;
717 else if (insn == ((E_R12_REGNUM << 11) | 0x0640 | E_R0_REGNUM)) /* movhi hi(const),r0,r12 */
718 r12_tmp = insn2 << 16;
719 else if (insn == ((E_R12_REGNUM << 11) | 0x0620 | E_R12_REGNUM)) /* movea lo(const),r12,r12 */
721 else if (insn == ((E_SP_REGNUM << 11) | 0x01c0 | E_R12_REGNUM) && r12_tmp) /* add r12,sp */
722 pi->frameoffset = r12_tmp;
723 else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_SP_REGNUM)) /* mov sp,ep */
725 else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_R1_REGNUM)) /* mov r1,ep */
727 else if (((insn & 0x07ff) == (0x0760 | E_SP_REGNUM) /* st.w <reg>,<offset>[sp] */
729 && (insn & 0x07ff) == (0x0760 | E_FP_RAW_REGNUM))) /* st.w <reg>,<offset>[fp] */
731 && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
732 || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
733 || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
736 pifsr->offset = insn2 & ~1;
737 pifsr->cur_frameoffset = pi->frameoffset;
739 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
744 else if (ep_used /* sst.w <reg>,<offset>[ep] */
745 && ((insn & 0x0781) == 0x0501)
747 && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
748 || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
749 || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
752 pifsr->offset = (insn & 0x007e) << 1;
753 pifsr->cur_frameoffset = pi->frameoffset;
755 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
761 printf_filtered ("\n");
766 pifsr->framereg = 0; /* Tie off last entry */
768 /* Fix up any offsets to the final offset. If a frame pointer was created, use it
769 instead of the stack pointer. */
770 for (pifsr_tmp = pi->pifsrs; pifsr_tmp && pifsr_tmp != pifsr; pifsr_tmp++)
772 pifsr_tmp->offset -= pi->frameoffset - pifsr_tmp->cur_frameoffset;
773 pifsr_tmp->framereg = pi->framereg;
776 printf_filtered ("Saved register r%d, offset = %d, framereg = r%d\n",
777 pifsr_tmp->reg, pifsr_tmp->offset, pifsr_tmp->framereg);
782 printf_filtered ("Framereg = r%d, frameoffset = %d\n", pi->framereg, pi->frameoffset);
788 /* Function: find_callers_reg
789 Find REGNUM on the stack. Otherwise, it's in an active register.
790 One thing we might want to do here is to check REGNUM against the
791 clobber mask, and somehow flag it as invalid if it isn't saved on
792 the stack somewhere. This would provide a graceful failure mode
793 when trying to get the value of caller-saves registers for an inner
797 v850_find_callers_reg (struct frame_info *fi, int regnum)
799 for (; fi; fi = get_next_frame (fi))
800 if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
801 return deprecated_read_register_dummy (get_frame_pc (fi),
802 get_frame_base (fi), regnum);
803 else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0)
804 return read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[regnum],
805 v850_register_raw_size (regnum));
807 return read_register (regnum);
810 /* Function: frame_chain
811 Figure out the frame prior to FI. Unfortunately, this involves
812 scanning the prologue of the caller, which will also be done
813 shortly by v850_init_extra_frame_info. For the dummy frame, we
814 just return the stack pointer that was in use at the time the
815 function call was made. */
818 v850_frame_chain (struct frame_info *fi)
820 struct prologue_info pi;
821 CORE_ADDR callers_pc, fp;
823 /* First, find out who called us */
824 callers_pc = DEPRECATED_FRAME_SAVED_PC (fi);
825 /* If caller is a call-dummy, then our FP bears no relation to his FP! */
826 fp = v850_find_callers_reg (fi, E_FP_RAW_REGNUM);
827 if (deprecated_pc_in_call_dummy (callers_pc))
828 return fp; /* caller is call-dummy: return oldest value of FP */
830 /* Caller is NOT a call-dummy, so everything else should just work.
831 Even if THIS frame is a call-dummy! */
834 v850_scan_prologue (callers_pc, &pi);
836 if (pi.start_function)
837 return 0; /* Don't chain beyond the start function */
839 if (pi.framereg == E_FP_RAW_REGNUM)
840 return v850_find_callers_reg (fi, pi.framereg);
842 return get_frame_base (fi) - pi.frameoffset;
845 /* Function: skip_prologue
846 Return the address of the first code past the prologue of the function. */
849 v850_skip_prologue (CORE_ADDR pc)
851 CORE_ADDR func_addr, func_end;
853 /* See what the symbol table says */
855 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
857 struct symtab_and_line sal;
859 sal = find_pc_line (func_addr, 0);
861 if (sal.line != 0 && sal.end < func_end)
864 /* Either there's no line info, or the line after the prologue is after
865 the end of the function. In this case, there probably isn't a
870 /* We can't find the start of this function, so there's nothing we can do. */
874 /* Function: pop_frame
875 This routine gets called when either the user uses the `return'
876 command, or the call dummy breakpoint gets hit. */
879 v850_pop_frame (void)
881 struct frame_info *frame = get_current_frame ();
884 if (deprecated_pc_in_call_dummy (get_frame_pc (frame)))
885 deprecated_pop_dummy_frame ();
888 write_register (E_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
890 for (regnum = 0; regnum < E_NUM_REGS; regnum++)
891 if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
892 write_register (regnum,
893 read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
894 v850_register_raw_size (regnum)));
896 write_register (E_SP_REGNUM, get_frame_base (frame));
899 flush_cached_frames ();
902 /* Function: push_arguments
903 Setup arguments and RP for a call to the target. First four args
904 go in R6->R9, subsequent args go into sp + 16 -> sp + ... Structs
905 are passed by reference. 64 bit quantities (doubles and long
906 longs) may be split between the regs and the stack. When calling a
907 function that returns a struct, a pointer to the struct is passed
908 in as a secret first argument (always in R6).
910 Stack space for the args has NOT been allocated: that job is up to us.
914 v850_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
915 int struct_return, CORE_ADDR struct_addr)
922 /* First, just for safety, make sure stack is aligned */
925 /* The offset onto the stack at which we will start copying parameters
926 (after the registers are used up) begins at 16 rather than at zero.
927 I don't really know why, that's just the way it seems to work. */
930 /* Now make space on the stack for the args. */
931 for (argnum = 0; argnum < nargs; argnum++)
932 len += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
933 sp -= len + stack_offset; /* possibly over-allocating, but it works... */
934 /* (you might think we could allocate 16 bytes */
935 /* less, but the ABI seems to use it all! ) */
937 argreg = E_ARG0_REGNUM;
938 /* the struct_return pointer occupies the first parameter-passing reg */
942 /* Now load as many as possible of the first arguments into
943 registers, and push the rest onto the stack. There are 16 bytes
944 in four registers available. Loop thru args from first to last. */
945 for (argnum = 0; argnum < nargs; argnum++)
949 char valbuf[v850_register_raw_size (E_ARG0_REGNUM)];
951 if (!v850_type_is_scalar (VALUE_TYPE (*args))
952 && TYPE_LENGTH (VALUE_TYPE (*args)) > E_MAX_RETTYPE_SIZE_IN_REGS)
954 store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (*args));
960 len = TYPE_LENGTH (VALUE_TYPE (*args));
961 val = (char *) VALUE_CONTENTS (*args);
965 if (argreg <= E_ARGLAST_REGNUM)
969 regval = extract_unsigned_integer (val, v850_register_raw_size (argreg));
970 write_register (argreg, regval);
972 len -= v850_register_raw_size (argreg);
973 val += v850_register_raw_size (argreg);
978 write_memory (sp + stack_offset, val, 4);
989 /* Function: push_return_address (pc)
990 Set up the return address for the inferior function call.
991 Needed for targets where we don't actually execute a JSR/BSR instruction */
994 v850_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
996 write_register (E_RP_REGNUM, entry_point_address ());
1000 /* Function: frame_saved_pc
1001 Find the caller of this frame. We do this by seeing if E_RP_REGNUM
1002 is saved in the stack anywhere, otherwise we get it from the
1003 registers. If the inner frame is a dummy frame, return its PC
1004 instead of RP, because that's where "caller" of the dummy-frame
1008 v850_frame_saved_pc (struct frame_info *fi)
1010 if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
1011 return deprecated_read_register_dummy (get_frame_pc (fi),
1012 get_frame_base (fi), E_PC_REGNUM);
1014 return v850_find_callers_reg (fi, E_RP_REGNUM);
1019 v850_saved_pc_after_call (struct frame_info *ignore)
1021 return read_register (E_RP_REGNUM);
1025 v850_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1027 CORE_ADDR return_buffer;
1029 if (!v850_use_struct_convention (0, type))
1031 /* Scalar return values of <= 8 bytes are returned in
1032 E_V0_REGNUM to E_V1_REGNUM. */
1034 ®buf[DEPRECATED_REGISTER_BYTE (E_V0_REGNUM)],
1035 TYPE_LENGTH (type));
1039 /* Aggregates and return values > 8 bytes are returned in memory,
1040 pointed to by R6. */
1042 extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_V0_REGNUM),
1043 DEPRECATED_REGISTER_RAW_SIZE (E_V0_REGNUM));
1045 read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
1049 const static unsigned char *
1050 v850_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1052 static unsigned char breakpoint[] = { 0x85, 0x05 };
1053 *lenptr = sizeof (breakpoint);
1058 v850_store_return_value (struct type *type, char *valbuf)
1060 CORE_ADDR return_buffer;
1062 if (!v850_use_struct_convention (0, type))
1063 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_V0_REGNUM), valbuf,
1064 TYPE_LENGTH (type));
1067 return_buffer = read_register (E_V0_REGNUM);
1068 write_memory (return_buffer, valbuf, TYPE_LENGTH (type));
1073 v850_frame_init_saved_regs (struct frame_info *fi)
1075 struct prologue_info pi;
1076 struct pifsr pifsrs[E_NUM_REGS + 1], *pifsr;
1077 CORE_ADDR func_addr, func_end;
1079 if (!deprecated_get_frame_saved_regs (fi))
1081 frame_saved_regs_zalloc (fi);
1083 /* The call dummy doesn't save any registers on the stack, so we
1085 if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
1088 /* Find the beginning of this function, so we can analyze its
1090 if (find_pc_partial_function (get_frame_pc (fi), NULL, &func_addr, &func_end))
1094 v850_scan_prologue (get_frame_pc (fi), &pi);
1096 if (!get_next_frame (fi) && pi.framereg == E_SP_REGNUM)
1097 deprecated_update_frame_base_hack (fi, read_register (pi.framereg) - pi.frameoffset);
1099 for (pifsr = pifsrs; pifsr->framereg; pifsr++)
1101 deprecated_get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + get_frame_base (fi);
1103 if (pifsr->framereg == E_SP_REGNUM)
1104 deprecated_get_frame_saved_regs (fi)[pifsr->reg] += pi.frameoffset;
1107 /* Else we're out of luck (can't debug completely stripped code).
1112 /* Function: init_extra_frame_info
1113 Setup the frame's frame pointer, pc, and frame addresses for saved
1114 registers. Most of the work is done in scan_prologue().
1116 Note that when we are called for the last frame (currently active frame),
1117 that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
1118 be valid only if this routine uses FP. For previous frames, fi-frame will
1119 always be correct (since that is derived from v850_frame_chain ()).
1121 We can be called with the PC in the call dummy under two
1122 circumstances. First, during normal backtracing, second, while
1123 figuring out the frame pointer just prior to calling the target
1124 function (see call_function_by_hand). */
1127 v850_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1129 struct prologue_info pi;
1131 if (get_next_frame (fi))
1132 deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
1134 v850_frame_init_saved_regs (fi);
1138 v850_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1140 write_register (E_ARG0_REGNUM, addr);
1144 v850_target_read_fp (void)
1146 return read_register (E_FP_RAW_REGNUM);
1149 static struct gdbarch *
1150 v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1152 struct gdbarch_tdep *tdep = NULL;
1153 struct gdbarch *gdbarch;
1156 /* find a candidate among the list of pre-declared architectures. */
1157 arches = gdbarch_list_lookup_by_info (arches, &info);
1159 return (arches->gdbarch);
1162 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1165 /* Change the register names based on the current machine type. */
1166 if (info.bfd_arch_info->arch != bfd_arch_v850)
1169 gdbarch = gdbarch_alloc (&info, 0);
1171 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1172 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1173 set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
1175 for (i = 0; v850_processor_type_table[i].regnames != NULL; i++)
1177 if (v850_processor_type_table[i].mach == info.bfd_arch_info->mach)
1179 v850_register_names = v850_processor_type_table[i].regnames;
1185 * Basic register fields and methods.
1187 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1188 set_gdbarch_num_pseudo_regs (gdbarch, 0);
1189 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1190 set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
1191 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1192 set_gdbarch_register_name (gdbarch, v850_register_name);
1193 set_gdbarch_deprecated_register_size (gdbarch, v850_reg_size);
1194 set_gdbarch_deprecated_register_bytes (gdbarch, E_ALL_REGS_SIZE);
1195 set_gdbarch_deprecated_register_byte (gdbarch, v850_register_byte);
1196 set_gdbarch_deprecated_register_raw_size (gdbarch, v850_register_raw_size);
1197 set_gdbarch_deprecated_register_virtual_size (gdbarch, v850_register_raw_size);
1198 set_gdbarch_deprecated_register_virtual_type (gdbarch, v850_reg_virtual_type);
1200 set_gdbarch_deprecated_target_read_fp (gdbarch, v850_target_read_fp);
1205 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, v850_frame_init_saved_regs);
1206 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, v850_init_extra_frame_info);
1207 set_gdbarch_deprecated_frame_chain (gdbarch, v850_frame_chain);
1208 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, v850_saved_pc_after_call);
1209 set_gdbarch_deprecated_frame_saved_pc (gdbarch, v850_frame_saved_pc);
1210 set_gdbarch_skip_prologue (gdbarch, v850_skip_prologue);
1215 /* Stack grows up. */
1216 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1221 * These values and methods are used when gdb calls a target function. */
1222 set_gdbarch_deprecated_push_return_address (gdbarch, v850_push_return_address);
1223 set_gdbarch_deprecated_extract_return_value (gdbarch, v850_extract_return_value);
1224 set_gdbarch_deprecated_push_arguments (gdbarch, v850_push_arguments);
1225 set_gdbarch_deprecated_pop_frame (gdbarch, v850_pop_frame);
1226 set_gdbarch_deprecated_store_struct_return (gdbarch, v850_store_struct_return);
1227 set_gdbarch_deprecated_store_return_value (gdbarch, v850_store_return_value);
1228 set_gdbarch_use_struct_convention (gdbarch, v850_use_struct_convention);
1229 set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
1231 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1232 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1233 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1234 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1236 /* Should be using push_dummy_call. */
1237 set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1239 set_gdbarch_print_insn (gdbarch, print_insn_v850);
1244 extern initialize_file_ftype _initialize_v850_tdep; /* -Wmissing-prototypes */
1247 _initialize_v850_tdep (void)
1249 register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);