1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
2 Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003
3 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
28 #include "gdb_string.h"
31 #include "arch-utils.h"
38 /* gdbarch target dependent data here. Currently unused for v850. */
41 /* Extra info which is saved in each frame_info. */
42 struct frame_extra_info
49 E_R2_REGNUM, E_SAVE1_START_REGNUM = E_R2_REGNUM, E_SAVE1_END_REGNUM = E_R2_REGNUM,
50 E_R3_REGNUM, E_SP_REGNUM = E_R3_REGNUM,
53 E_R6_REGNUM, E_ARG0_REGNUM = E_R6_REGNUM,
56 E_R9_REGNUM, E_ARGLAST_REGNUM = E_R9_REGNUM,
57 E_R10_REGNUM, E_V0_REGNUM = E_R10_REGNUM,
58 E_R11_REGNUM, E_V1_REGNUM = E_R11_REGNUM,
67 E_R20_REGNUM, E_SAVE2_START_REGNUM = E_R20_REGNUM,
76 E_R29_REGNUM, E_SAVE2_END_REGNUM = E_R29_REGNUM, E_FP_RAW_REGNUM = E_R29_REGNUM,
77 E_R30_REGNUM, E_EP_REGNUM = E_R30_REGNUM,
78 E_R31_REGNUM, E_SAVE3_START_REGNUM = E_R31_REGNUM, E_SAVE3_END_REGNUM = E_R31_REGNUM, E_RP_REGNUM = E_R31_REGNUM,
79 E_R32_REGNUM, E_SR0_REGNUM = E_R32_REGNUM,
84 E_R37_REGNUM, E_PS_REGNUM = E_R37_REGNUM,
99 E_R52_REGNUM, E_CTBP_REGNUM = E_R52_REGNUM,
111 E_R64_REGNUM, E_PC_REGNUM = E_R64_REGNUM,
112 E_R65_REGNUM, E_FP_REGNUM = E_R65_REGNUM,
121 /* Size of all registers as a whole. */
124 E_ALL_REGS_SIZE = (E_NUM_REGS) * v850_reg_size
127 /* Size of return datatype which fits into all return registers. */
130 E_MAX_RETTYPE_SIZE_IN_REGS = 2 * v850_reg_size
133 static LONGEST call_dummy_nil[] = {0};
135 static char *v850_generic_reg_names[] =
136 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
137 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
138 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
139 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
140 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
141 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
142 "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
143 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
147 static char *v850e_reg_names[] =
149 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
150 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
151 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
152 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
153 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
154 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
155 "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
156 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
160 char **v850_register_names = v850_generic_reg_names;
167 v850_processor_type_table[] =
170 v850_generic_reg_names, bfd_mach_v850
174 v850e_reg_names, bfd_mach_v850e
182 /* Info gleaned from scanning a function's prologue. */
184 struct pifsr /* Info about one saved reg */
186 int framereg; /* Frame reg (SP or FP) */
187 int offset; /* Offset from framereg */
188 int cur_frameoffset; /* Current frameoffset */
189 int reg; /* Saved register number */
197 struct pifsr *pifsrs;
200 static CORE_ADDR v850_scan_prologue (CORE_ADDR pc, struct prologue_info *fs);
202 /* Function: v850_register_name
203 Returns the name of the v850/v850e register N. */
206 v850_register_name (int regnum)
208 if (regnum < 0 || regnum >= E_NUM_REGS)
209 internal_error (__FILE__, __LINE__,
210 "v850_register_name: illegal register number %d",
213 return v850_register_names[regnum];
217 /* Function: v850_register_byte
218 Returns the byte position in the register cache for register N. */
221 v850_register_byte (int regnum)
223 if (regnum < 0 || regnum >= E_NUM_REGS)
224 internal_error (__FILE__, __LINE__,
225 "v850_register_byte: illegal register number %d",
228 return regnum * v850_reg_size;
231 /* Function: v850_register_raw_size
232 Returns the number of bytes occupied by the register on the target. */
235 v850_register_raw_size (int regnum)
237 if (regnum < 0 || regnum >= E_NUM_REGS)
238 internal_error (__FILE__, __LINE__,
239 "v850_register_raw_size: illegal register number %d",
241 /* Only the PC has 4 Byte, all other registers 2 Byte. */
243 return v850_reg_size;
246 /* Function: v850_register_virtual_size
247 Returns the number of bytes occupied by the register as represented
248 internally by gdb. */
251 v850_register_virtual_size (int regnum)
253 return v850_register_raw_size (regnum);
256 /* Function: v850_reg_virtual_type
257 Returns the default type for register N. */
260 v850_reg_virtual_type (int regnum)
262 if (regnum < 0 || regnum >= E_NUM_REGS)
263 internal_error (__FILE__, __LINE__,
264 "v850_register_virtual_type: illegal register number %d",
266 else if (regnum == E_PC_REGNUM)
267 return builtin_type_uint32;
269 return builtin_type_int32;
273 v850_type_is_scalar (struct type *t)
275 return (TYPE_CODE (t) != TYPE_CODE_STRUCT
276 && TYPE_CODE (t) != TYPE_CODE_UNION
277 && TYPE_CODE (t) != TYPE_CODE_ARRAY);
280 /* Should call_function allocate stack space for a struct return? */
282 v850_use_struct_convention (int gcc_p, struct type *type)
285 * return TYPE_LENGTH (type) > 8);
288 /* Current implementation in gcc: */
291 struct type *fld_type, *tgt_type;
293 /* 1. The value is greater than 8 bytes -> returned by copying */
294 if (TYPE_LENGTH (type) > 8)
297 /* 2. The value is a single basic type -> returned in register */
298 if (v850_type_is_scalar (type))
301 /* The value is a structure or union with a single element
302 * and that element is either a single basic type or an array of
303 * a single basic type whoes size is greater than or equal to 4
304 * -> returned in register */
305 if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
306 || TYPE_CODE (type) == TYPE_CODE_UNION)
307 && TYPE_NFIELDS (type) == 1)
309 fld_type = TYPE_FIELD_TYPE (type, 0);
310 if (v850_type_is_scalar (fld_type) && TYPE_LENGTH (fld_type) >= 4)
313 if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
315 tgt_type = TYPE_TARGET_TYPE (fld_type);
316 if (v850_type_is_scalar (tgt_type) && TYPE_LENGTH (tgt_type) >= 4)
321 /* The value is a structure whose first element is an integer or
322 * a float, and which contains no arrays of more than two elements
323 * -> returned in register */
324 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
325 && v850_type_is_scalar (TYPE_FIELD_TYPE (type, 0))
326 && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
328 for (i = 1; i < TYPE_NFIELDS (type); ++i)
330 fld_type = TYPE_FIELD_TYPE (type, 0);
331 if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
333 tgt_type = TYPE_TARGET_TYPE (fld_type);
334 if (TYPE_LENGTH (fld_type) >= 0 && TYPE_LENGTH (tgt_type) >= 0
335 && TYPE_LENGTH (fld_type) / TYPE_LENGTH (tgt_type) > 2)
342 /* The value is a union which contains at least one field which
343 * would be returned in registers according to these rules
344 * -> returned in register */
345 if (TYPE_CODE (type) == TYPE_CODE_UNION)
347 for (i = 0; i < TYPE_NFIELDS (type); ++i)
349 fld_type = TYPE_FIELD_TYPE (type, 0);
350 if (!v850_use_struct_convention (0, fld_type))
360 /* Structure for mapping bits in register lists to register numbers. */
367 /* Helper function for v850_scan_prologue to handle prepare instruction. */
370 handle_prepare (int insn, int insn2, CORE_ADDR * current_pc_ptr,
371 struct prologue_info *pi, struct pifsr **pifsr_ptr)
373 CORE_ADDR current_pc = *current_pc_ptr;
374 struct pifsr *pifsr = *pifsr_ptr;
375 long next = insn2 & 0xffff;
376 long list12 = ((insn & 1) << 16) + (next & 0xffe0);
377 long offset = (insn & 0x3e) << 1;
378 static struct reg_list reg_table[] =
380 {0x00800, 20}, /* r20 */
381 {0x00400, 21}, /* r21 */
382 {0x00200, 22}, /* r22 */
383 {0x00100, 23}, /* r23 */
384 {0x08000, 24}, /* r24 */
385 {0x04000, 25}, /* r25 */
386 {0x02000, 26}, /* r26 */
387 {0x01000, 27}, /* r27 */
388 {0x00080, 28}, /* r28 */
389 {0x00040, 29}, /* r29 */
390 {0x10000, 30}, /* ep */
391 {0x00020, 31}, /* lp */
392 {0, 0} /* end of table */
396 if ((next & 0x1f) == 0x0b) /* skip imm16 argument */
398 else if ((next & 0x1f) == 0x13) /* skip imm16 argument */
400 else if ((next & 0x1f) == 0x1b) /* skip imm32 argument */
403 /* Calculate the total size of the saved registers, and add it
404 it to the immediate value used to adjust SP. */
405 for (i = 0; reg_table[i].mask != 0; i++)
406 if (list12 & reg_table[i].mask)
407 offset += v850_register_raw_size (reg_table[i].regno);
408 pi->frameoffset -= offset;
410 /* Calculate the offsets of the registers relative to the value
411 the SP will have after the registers have been pushed and the
412 imm5 value has been subtracted from it. */
415 for (i = 0; reg_table[i].mask != 0; i++)
417 if (list12 & reg_table[i].mask)
419 int reg = reg_table[i].regno;
420 offset -= v850_register_raw_size (reg);
422 pifsr->offset = offset;
423 pifsr->cur_frameoffset = pi->frameoffset;
425 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
432 printf_filtered ("\tfound ctret after regsave func");
435 /* Set result parameters. */
436 *current_pc_ptr = current_pc;
441 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
442 FIXME: the SR bit of the register list is not supported; must check
443 that the compiler does not ever generate this bit. */
446 handle_pushm (int insn, int insn2, struct prologue_info *pi,
447 struct pifsr **pifsr_ptr)
449 struct pifsr *pifsr = *pifsr_ptr;
450 long list12 = ((insn & 0x0f) << 16) + (insn2 & 0xfff0);
452 static struct reg_list pushml_reg_table[] =
454 {0x80000, E_PS_REGNUM}, /* PSW */
455 {0x40000, 1}, /* r1 */
456 {0x20000, 2}, /* r2 */
457 {0x10000, 3}, /* r3 */
458 {0x00800, 4}, /* r4 */
459 {0x00400, 5}, /* r5 */
460 {0x00200, 6}, /* r6 */
461 {0x00100, 7}, /* r7 */
462 {0x08000, 8}, /* r8 */
463 {0x04000, 9}, /* r9 */
464 {0x02000, 10}, /* r10 */
465 {0x01000, 11}, /* r11 */
466 {0x00080, 12}, /* r12 */
467 {0x00040, 13}, /* r13 */
468 {0x00020, 14}, /* r14 */
469 {0x00010, 15}, /* r15 */
470 {0, 0} /* end of table */
472 static struct reg_list pushmh_reg_table[] =
474 {0x80000, 16}, /* r16 */
475 {0x40000, 17}, /* r17 */
476 {0x20000, 18}, /* r18 */
477 {0x10000, 19}, /* r19 */
478 {0x00800, 20}, /* r20 */
479 {0x00400, 21}, /* r21 */
480 {0x00200, 22}, /* r22 */
481 {0x00100, 23}, /* r23 */
482 {0x08000, 24}, /* r24 */
483 {0x04000, 25}, /* r25 */
484 {0x02000, 26}, /* r26 */
485 {0x01000, 27}, /* r27 */
486 {0x00080, 28}, /* r28 */
487 {0x00040, 29}, /* r29 */
488 {0x00010, 30}, /* r30 */
489 {0x00020, 31}, /* r31 */
490 {0, 0} /* end of table */
492 struct reg_list *reg_table;
495 /* Is this a pushml or a pushmh? */
496 if ((insn2 & 7) == 1)
497 reg_table = pushml_reg_table;
499 reg_table = pushmh_reg_table;
501 /* Calculate the total size of the saved registers, and add it
502 it to the immediate value used to adjust SP. */
503 for (i = 0; reg_table[i].mask != 0; i++)
504 if (list12 & reg_table[i].mask)
505 offset += v850_register_raw_size (reg_table[i].regno);
506 pi->frameoffset -= offset;
508 /* Calculate the offsets of the registers relative to the value
509 the SP will have after the registers have been pushed and the
510 imm5 value is subtracted from it. */
513 for (i = 0; reg_table[i].mask != 0; i++)
515 if (list12 & reg_table[i].mask)
517 int reg = reg_table[i].regno;
518 offset -= v850_register_raw_size (reg);
520 pifsr->offset = offset;
521 pifsr->cur_frameoffset = pi->frameoffset;
523 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
530 printf_filtered ("\tfound ctret after regsave func");
533 /* Set result parameters. */
540 /* Function: scan_prologue
541 Scan the prologue of the function that contains PC, and record what
542 we find in PI. Returns the pc after the prologue. Note that the
543 addresses saved in frame->saved_regs are just frame relative (negative
544 offsets from the frame pointer). This is because we don't know the
545 actual value of the frame pointer yet. In some circumstances, the
546 frame pointer can't be determined till after we have scanned the
550 v850_scan_prologue (CORE_ADDR pc, struct prologue_info *pi)
552 CORE_ADDR func_addr, prologue_end, current_pc;
553 struct pifsr *pifsr, *pifsr_tmp;
557 CORE_ADDR save_pc, save_end;
561 /* First, figure out the bounds of the prologue so that we can limit the
562 search to something reasonable. */
564 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
566 struct symtab_and_line sal;
568 sal = find_pc_line (func_addr, 0);
570 if (func_addr == entry_point_address ())
571 pi->start_function = 1;
573 pi->start_function = 0;
579 prologue_end = sal.end;
585 { /* We're in the boondocks */
586 func_addr = pc - 100;
590 prologue_end = min (prologue_end, pc);
592 /* Now, search the prologue looking for instructions that setup fp, save
593 rp, adjust sp and such. We also record the frame offset of any saved
597 pi->framereg = E_SP_REGNUM;
607 printf_filtered ("Current_pc = 0x%.8lx, prologue_end = 0x%.8lx\n",
608 (long) func_addr, (long) prologue_end);
611 for (current_pc = func_addr; current_pc < prologue_end;)
614 int insn2 = -1; /* dummy value */
617 fprintf_filtered (gdb_stdlog, "0x%.8lx ", (long) current_pc);
618 gdb_print_insn (current_pc, gdb_stdlog);
621 insn = read_memory_unsigned_integer (current_pc, 2);
623 if ((insn & 0x0780) >= 0x0600) /* Four byte instruction? */
625 insn2 = read_memory_unsigned_integer (current_pc, 2);
629 if ((insn & 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p)
630 { /* jarl <func>,10 */
631 long low_disp = insn2 & ~(long) 1;
632 long disp = (((((insn & 0x3f) << 16) + low_disp)
633 & ~(long) 1) ^ 0x00200000) - 0x00200000;
635 save_pc = current_pc;
636 save_end = prologue_end;
638 current_pc += disp - 4;
639 prologue_end = (current_pc
640 + (2 * 3) /* moves to/from ep */
641 + 4 /* addi <const>,sp,sp */
643 + (2 * 12) /* sst.w to save r2, r20-r29, r31 */
644 + 20); /* slop area */
647 printf_filtered ("\tfound jarl <func>,r10, disp = %ld, low_disp = %ld, new pc = 0x%.8lx\n",
648 disp, low_disp, (long) current_pc + 2);
652 else if ((insn & 0xffc0) == 0x0200 && !regsave_func_p)
654 long ctbp = read_register (E_CTBP_REGNUM);
655 long adr = ctbp + ((insn & 0x3f) << 1);
657 save_pc = current_pc;
658 save_end = prologue_end;
660 current_pc = ctbp + (read_memory_unsigned_integer (adr, 2) & 0xffff);
661 prologue_end = (current_pc
662 + (2 * 3) /* prepare list2,imm5,sp/imm */
664 + 20); /* slop area */
667 printf_filtered ("\tfound callt, ctbp = 0x%.8lx, adr = %.8lx, new pc = 0x%.8lx\n",
668 ctbp, adr, (long) current_pc);
672 else if ((insn & 0xffc0) == 0x0780) /* prepare list2,imm5 */
674 handle_prepare (insn, insn2, ¤t_pc, pi, &pifsr);
677 else if (insn == 0x07e0 && regsave_func_p && insn2 == 0x0144)
678 { /* ctret after processing register save function */
679 current_pc = save_pc;
680 prologue_end = save_end;
683 printf_filtered ("\tfound ctret after regsave func");
687 else if ((insn & 0xfff0) == 0x07e0 && (insn2 & 5) == 1)
688 { /* pushml, pushmh */
689 handle_pushm (insn, insn2, pi, &pifsr);
692 else if ((insn & 0xffe0) == 0x0060 && regsave_func_p)
693 { /* jmp after processing register save function */
694 current_pc = save_pc;
695 prologue_end = save_end;
698 printf_filtered ("\tfound jmp after regsave func");
702 else if ((insn & 0x07c0) == 0x0780 /* jarl or jr */
703 || (insn & 0xffe0) == 0x0060 /* jmp */
704 || (insn & 0x0780) == 0x0580) /* branch */
707 printf_filtered ("\n");
709 break; /* Ran into end of prologue */
712 else if ((insn & 0xffe0) == ((E_SP_REGNUM << 11) | 0x0240)) /* add <imm>,sp */
713 pi->frameoffset += ((insn & 0x1f) ^ 0x10) - 0x10;
714 else if (insn == ((E_SP_REGNUM << 11) | 0x0600 | E_SP_REGNUM)) /* addi <imm>,sp,sp */
715 pi->frameoffset += insn2;
716 else if (insn == ((E_FP_RAW_REGNUM << 11) | 0x0000 | E_SP_REGNUM)) /* mov sp,fp */
719 pi->framereg = E_FP_RAW_REGNUM;
722 else if (insn == ((E_R12_REGNUM << 11) | 0x0640 | E_R0_REGNUM)) /* movhi hi(const),r0,r12 */
723 r12_tmp = insn2 << 16;
724 else if (insn == ((E_R12_REGNUM << 11) | 0x0620 | E_R12_REGNUM)) /* movea lo(const),r12,r12 */
726 else if (insn == ((E_SP_REGNUM << 11) | 0x01c0 | E_R12_REGNUM) && r12_tmp) /* add r12,sp */
727 pi->frameoffset = r12_tmp;
728 else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_SP_REGNUM)) /* mov sp,ep */
730 else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_R1_REGNUM)) /* mov r1,ep */
732 else if (((insn & 0x07ff) == (0x0760 | E_SP_REGNUM) /* st.w <reg>,<offset>[sp] */
734 && (insn & 0x07ff) == (0x0760 | E_FP_RAW_REGNUM))) /* st.w <reg>,<offset>[fp] */
736 && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
737 || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
738 || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
741 pifsr->offset = insn2 & ~1;
742 pifsr->cur_frameoffset = pi->frameoffset;
744 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
749 else if (ep_used /* sst.w <reg>,<offset>[ep] */
750 && ((insn & 0x0781) == 0x0501)
752 && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
753 || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
754 || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
757 pifsr->offset = (insn & 0x007e) << 1;
758 pifsr->cur_frameoffset = pi->frameoffset;
760 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
766 printf_filtered ("\n");
771 pifsr->framereg = 0; /* Tie off last entry */
773 /* Fix up any offsets to the final offset. If a frame pointer was created, use it
774 instead of the stack pointer. */
775 for (pifsr_tmp = pi->pifsrs; pifsr_tmp && pifsr_tmp != pifsr; pifsr_tmp++)
777 pifsr_tmp->offset -= pi->frameoffset - pifsr_tmp->cur_frameoffset;
778 pifsr_tmp->framereg = pi->framereg;
781 printf_filtered ("Saved register r%d, offset = %d, framereg = r%d\n",
782 pifsr_tmp->reg, pifsr_tmp->offset, pifsr_tmp->framereg);
787 printf_filtered ("Framereg = r%d, frameoffset = %d\n", pi->framereg, pi->frameoffset);
793 /* Function: find_callers_reg
794 Find REGNUM on the stack. Otherwise, it's in an active register.
795 One thing we might want to do here is to check REGNUM against the
796 clobber mask, and somehow flag it as invalid if it isn't saved on
797 the stack somewhere. This would provide a graceful failure mode
798 when trying to get the value of caller-saves registers for an inner
802 v850_find_callers_reg (struct frame_info *fi, int regnum)
804 for (; fi; fi = get_next_frame (fi))
805 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
806 get_frame_base (fi)))
807 return deprecated_read_register_dummy (get_frame_pc (fi),
808 get_frame_base (fi), regnum);
809 else if (get_frame_saved_regs (fi)[regnum] != 0)
810 return read_memory_unsigned_integer (get_frame_saved_regs (fi)[regnum],
811 v850_register_raw_size (regnum));
813 return read_register (regnum);
816 /* Function: frame_chain
817 Figure out the frame prior to FI. Unfortunately, this involves
818 scanning the prologue of the caller, which will also be done
819 shortly by v850_init_extra_frame_info. For the dummy frame, we
820 just return the stack pointer that was in use at the time the
821 function call was made. */
824 v850_frame_chain (struct frame_info *fi)
826 struct prologue_info pi;
827 CORE_ADDR callers_pc, fp;
829 /* First, find out who called us */
830 callers_pc = DEPRECATED_FRAME_SAVED_PC (fi);
831 /* If caller is a call-dummy, then our FP bears no relation to his FP! */
832 fp = v850_find_callers_reg (fi, E_FP_RAW_REGNUM);
833 if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc, fp, fp))
834 return fp; /* caller is call-dummy: return oldest value of FP */
836 /* Caller is NOT a call-dummy, so everything else should just work.
837 Even if THIS frame is a call-dummy! */
840 v850_scan_prologue (callers_pc, &pi);
842 if (pi.start_function)
843 return 0; /* Don't chain beyond the start function */
845 if (pi.framereg == E_FP_RAW_REGNUM)
846 return v850_find_callers_reg (fi, pi.framereg);
848 return get_frame_base (fi) - pi.frameoffset;
851 /* Function: skip_prologue
852 Return the address of the first code past the prologue of the function. */
855 v850_skip_prologue (CORE_ADDR pc)
857 CORE_ADDR func_addr, func_end;
859 /* See what the symbol table says */
861 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
863 struct symtab_and_line sal;
865 sal = find_pc_line (func_addr, 0);
867 if (sal.line != 0 && sal.end < func_end)
870 /* Either there's no line info, or the line after the prologue is after
871 the end of the function. In this case, there probably isn't a
876 /* We can't find the start of this function, so there's nothing we can do. */
880 /* Function: pop_frame
881 This routine gets called when either the user uses the `return'
882 command, or the call dummy breakpoint gets hit. */
885 v850_pop_frame (void)
887 struct frame_info *frame = get_current_frame ();
890 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
891 get_frame_base (frame),
892 get_frame_base (frame)))
893 generic_pop_dummy_frame ();
896 write_register (E_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
898 for (regnum = 0; regnum < E_NUM_REGS; regnum++)
899 if (get_frame_saved_regs (frame)[regnum] != 0)
900 write_register (regnum,
901 read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
902 v850_register_raw_size (regnum)));
904 write_register (E_SP_REGNUM, get_frame_base (frame));
907 flush_cached_frames ();
910 /* Function: push_arguments
911 Setup arguments and RP for a call to the target. First four args
912 go in R6->R9, subsequent args go into sp + 16 -> sp + ... Structs
913 are passed by reference. 64 bit quantities (doubles and long
914 longs) may be split between the regs and the stack. When calling a
915 function that returns a struct, a pointer to the struct is passed
916 in as a secret first argument (always in R6).
918 Stack space for the args has NOT been allocated: that job is up to us.
922 v850_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
923 int struct_return, CORE_ADDR struct_addr)
930 /* First, just for safety, make sure stack is aligned */
933 /* The offset onto the stack at which we will start copying parameters
934 (after the registers are used up) begins at 16 rather than at zero.
935 I don't really know why, that's just the way it seems to work. */
938 /* Now make space on the stack for the args. */
939 for (argnum = 0; argnum < nargs; argnum++)
940 len += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
941 sp -= len + stack_offset; /* possibly over-allocating, but it works... */
942 /* (you might think we could allocate 16 bytes */
943 /* less, but the ABI seems to use it all! ) */
945 argreg = E_ARG0_REGNUM;
946 /* the struct_return pointer occupies the first parameter-passing reg */
950 /* Now load as many as possible of the first arguments into
951 registers, and push the rest onto the stack. There are 16 bytes
952 in four registers available. Loop thru args from first to last. */
953 for (argnum = 0; argnum < nargs; argnum++)
957 char valbuf[v850_register_raw_size (E_ARG0_REGNUM)];
959 if (!v850_type_is_scalar (VALUE_TYPE (*args))
960 && TYPE_LENGTH (VALUE_TYPE (*args)) > E_MAX_RETTYPE_SIZE_IN_REGS)
962 store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (*args));
968 len = TYPE_LENGTH (VALUE_TYPE (*args));
969 val = (char *) VALUE_CONTENTS (*args);
973 if (argreg <= E_ARGLAST_REGNUM)
977 regval = extract_unsigned_integer (val, v850_register_raw_size (argreg));
978 write_register (argreg, regval);
980 len -= v850_register_raw_size (argreg);
981 val += v850_register_raw_size (argreg);
986 write_memory (sp + stack_offset, val, 4);
997 /* Function: push_return_address (pc)
998 Set up the return address for the inferior function call.
999 Needed for targets where we don't actually execute a JSR/BSR instruction */
1002 v850_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1004 write_register (E_RP_REGNUM, entry_point_address ());
1008 /* Function: frame_saved_pc
1009 Find the caller of this frame. We do this by seeing if E_RP_REGNUM
1010 is saved in the stack anywhere, otherwise we get it from the
1011 registers. If the inner frame is a dummy frame, return its PC
1012 instead of RP, because that's where "caller" of the dummy-frame
1016 v850_frame_saved_pc (struct frame_info *fi)
1018 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
1019 get_frame_base (fi)))
1020 return deprecated_read_register_dummy (get_frame_pc (fi),
1021 get_frame_base (fi), E_PC_REGNUM);
1023 return v850_find_callers_reg (fi, E_RP_REGNUM);
1027 /* Function: fix_call_dummy
1028 Pokes the callee function's address into the CALL_DUMMY assembly stub.
1029 Assumes that the CALL_DUMMY looks like this:
1030 jarl <offset24>, r31
1035 v850_fix_call_dummy (char *dummy, CORE_ADDR sp, CORE_ADDR fun, int nargs,
1036 struct value **args, struct type *type, int gcc_p)
1040 offset24 = (long) fun - (long) entry_point_address ();
1041 offset24 &= 0x3fffff;
1042 offset24 |= 0xff800000; /* jarl <offset24>, r31 */
1044 store_unsigned_integer ((unsigned int *) &dummy[2], 2, offset24 & 0xffff);
1045 store_unsigned_integer ((unsigned int *) &dummy[0], 2, offset24 >> 16);
1049 v850_saved_pc_after_call (struct frame_info *ignore)
1051 return read_register (E_RP_REGNUM);
1055 v850_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1057 CORE_ADDR return_buffer;
1059 if (!v850_use_struct_convention (0, type))
1061 /* Scalar return values of <= 8 bytes are returned in
1062 E_V0_REGNUM to E_V1_REGNUM. */
1064 ®buf[REGISTER_BYTE (E_V0_REGNUM)],
1065 TYPE_LENGTH (type));
1069 /* Aggregates and return values > 8 bytes are returned in memory,
1070 pointed to by R6. */
1072 extract_unsigned_integer (regbuf + REGISTER_BYTE (E_V0_REGNUM),
1073 REGISTER_RAW_SIZE (E_V0_REGNUM));
1075 read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
1079 const static unsigned char *
1080 v850_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1082 static unsigned char breakpoint[] = { 0x85, 0x05 };
1083 *lenptr = sizeof (breakpoint);
1088 v850_extract_struct_value_address (char *regbuf)
1090 return extract_unsigned_integer (regbuf + v850_register_byte (E_V0_REGNUM),
1091 v850_register_raw_size (E_V0_REGNUM));
1095 v850_store_return_value (struct type *type, char *valbuf)
1097 CORE_ADDR return_buffer;
1099 if (!v850_use_struct_convention (0, type))
1100 deprecated_write_register_bytes (REGISTER_BYTE (E_V0_REGNUM), valbuf,
1101 TYPE_LENGTH (type));
1104 return_buffer = read_register (E_V0_REGNUM);
1105 write_memory (return_buffer, valbuf, TYPE_LENGTH (type));
1110 v850_frame_init_saved_regs (struct frame_info *fi)
1112 struct prologue_info pi;
1113 struct pifsr pifsrs[E_NUM_REGS + 1], *pifsr;
1114 CORE_ADDR func_addr, func_end;
1116 if (!get_frame_saved_regs (fi))
1118 frame_saved_regs_zalloc (fi);
1120 /* The call dummy doesn't save any registers on the stack, so we
1122 if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
1123 get_frame_base (fi)))
1126 /* Find the beginning of this function, so we can analyze its
1128 if (find_pc_partial_function (get_frame_pc (fi), NULL, &func_addr, &func_end))
1132 v850_scan_prologue (get_frame_pc (fi), &pi);
1134 if (!get_next_frame (fi) && pi.framereg == E_SP_REGNUM)
1135 deprecated_update_frame_base_hack (fi, read_register (pi.framereg) - pi.frameoffset);
1137 for (pifsr = pifsrs; pifsr->framereg; pifsr++)
1139 get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + get_frame_base (fi);
1141 if (pifsr->framereg == E_SP_REGNUM)
1142 get_frame_saved_regs (fi)[pifsr->reg] += pi.frameoffset;
1145 /* Else we're out of luck (can't debug completely stripped code).
1150 /* Function: init_extra_frame_info
1151 Setup the frame's frame pointer, pc, and frame addresses for saved
1152 registers. Most of the work is done in scan_prologue().
1154 Note that when we are called for the last frame (currently active frame),
1155 that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
1156 be valid only if this routine uses FP. For previous frames, fi-frame will
1157 always be correct (since that is derived from v850_frame_chain ()).
1159 We can be called with the PC in the call dummy under two
1160 circumstances. First, during normal backtracing, second, while
1161 figuring out the frame pointer just prior to calling the target
1162 function (see call_function_by_hand). */
1165 v850_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1167 struct prologue_info pi;
1169 if (get_next_frame (fi))
1170 deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
1172 v850_frame_init_saved_regs (fi);
1176 v850_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1178 write_register (E_ARG0_REGNUM, addr);
1182 v850_target_read_fp (void)
1184 return read_register (E_FP_RAW_REGNUM);
1187 static struct gdbarch *
1188 v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1190 static LONGEST call_dummy_words[1] = { 0 };
1191 struct gdbarch_tdep *tdep = NULL;
1192 struct gdbarch *gdbarch;
1195 /* find a candidate among the list of pre-declared architectures. */
1196 arches = gdbarch_list_lookup_by_info (arches, &info);
1198 return (arches->gdbarch);
1201 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1204 /* Change the register names based on the current machine type. */
1205 if (info.bfd_arch_info->arch != bfd_arch_v850)
1208 gdbarch = gdbarch_alloc (&info, 0);
1210 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1211 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1212 set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
1214 for (i = 0; v850_processor_type_table[i].regnames != NULL; i++)
1216 if (v850_processor_type_table[i].mach == info.bfd_arch_info->mach)
1218 v850_register_names = v850_processor_type_table[i].regnames;
1224 * Basic register fields and methods.
1226 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1227 set_gdbarch_num_pseudo_regs (gdbarch, 0);
1228 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1229 set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
1230 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1231 set_gdbarch_register_name (gdbarch, v850_register_name);
1232 set_gdbarch_deprecated_register_size (gdbarch, v850_reg_size);
1233 set_gdbarch_deprecated_register_bytes (gdbarch, E_ALL_REGS_SIZE);
1234 set_gdbarch_deprecated_register_byte (gdbarch, v850_register_byte);
1235 set_gdbarch_deprecated_register_raw_size (gdbarch, v850_register_raw_size);
1236 set_gdbarch_deprecated_max_register_raw_size (gdbarch, v850_reg_size);
1237 set_gdbarch_deprecated_register_virtual_size (gdbarch, v850_register_raw_size);
1238 set_gdbarch_deprecated_max_register_virtual_size (gdbarch, v850_reg_size);
1239 set_gdbarch_deprecated_register_virtual_type (gdbarch, v850_reg_virtual_type);
1241 set_gdbarch_deprecated_target_read_fp (gdbarch, v850_target_read_fp);
1246 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, v850_frame_init_saved_regs);
1247 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, v850_init_extra_frame_info);
1248 set_gdbarch_deprecated_frame_chain (gdbarch, v850_frame_chain);
1249 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, v850_saved_pc_after_call);
1250 set_gdbarch_deprecated_frame_saved_pc (gdbarch, v850_frame_saved_pc);
1251 set_gdbarch_skip_prologue (gdbarch, v850_skip_prologue);
1256 /* Stack grows up. */
1257 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1258 /* PC stops zero byte after a trap instruction
1259 (which means: exactly on trap instruction). */
1260 set_gdbarch_decr_pc_after_break (gdbarch, 0);
1261 /* This value is almost never non-zero... */
1262 set_gdbarch_function_start_offset (gdbarch, 0);
1263 /* This value is almost never non-zero... */
1264 set_gdbarch_frame_args_skip (gdbarch, 0);
1269 * These values and methods are used when gdb calls a target function. */
1270 set_gdbarch_deprecated_push_return_address (gdbarch, v850_push_return_address);
1271 set_gdbarch_deprecated_extract_return_value (gdbarch, v850_extract_return_value);
1272 set_gdbarch_deprecated_push_arguments (gdbarch, v850_push_arguments);
1273 set_gdbarch_deprecated_pop_frame (gdbarch, v850_pop_frame);
1274 set_gdbarch_deprecated_store_struct_return (gdbarch, v850_store_struct_return);
1275 set_gdbarch_deprecated_store_return_value (gdbarch, v850_store_return_value);
1276 set_gdbarch_deprecated_extract_struct_value_address (gdbarch, v850_extract_struct_value_address);
1277 set_gdbarch_use_struct_convention (gdbarch, v850_use_struct_convention);
1278 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
1279 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
1280 set_gdbarch_deprecated_fix_call_dummy (gdbarch, v850_fix_call_dummy);
1281 set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
1283 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1284 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1285 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1286 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1288 /* Should be using push_dummy_call. */
1289 set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1291 set_gdbarch_print_insn (gdbarch, print_insn_v850);
1296 extern initialize_file_ftype _initialize_v850_tdep; /* -Wmissing-prototypes */
1299 _initialize_v850_tdep (void)
1301 register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);