1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
2 Copyright 1996, Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
28 #include "gdb_string.h"
33 static char *v850_generic_reg_names
[] = REGISTER_NAMES
;
35 static char *v850e_reg_names
[] =
37 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
38 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
39 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
40 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
41 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
42 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
43 "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
44 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
48 char **v850_register_names
= v850_generic_reg_names
;
55 v850_processor_type_table
[] =
58 v850_generic_reg_names
, bfd_mach_v850
62 v850e_reg_names
, bfd_mach_v850e
66 v850e_reg_names
, bfd_mach_v850ea
74 /* Info gleaned from scanning a function's prologue. */
76 struct pifsr
/* Info about one saved reg */
78 int framereg
; /* Frame reg (SP or FP) */
79 int offset
; /* Offset from framereg */
80 int cur_frameoffset
; /* Current frameoffset */
81 int reg
; /* Saved register number */
92 static CORE_ADDR
v850_scan_prologue (CORE_ADDR pc
, struct prologue_info
*fs
);
95 /* Should call_function allocate stack space for a struct return? */
97 v850_use_struct_convention (gcc_p
, type
)
101 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 4);
106 /* Structure for mapping bits in register lists to register numbers. */
113 /* Helper function for v850_scan_prologue to handle prepare instruction. */
116 handle_prepare (int insn
, int insn2
, CORE_ADDR
* current_pc_ptr
,
117 struct prologue_info
*pi
, struct pifsr
**pifsr_ptr
)
120 CORE_ADDR current_pc
= *current_pc_ptr
;
121 struct pifsr
*pifsr
= *pifsr_ptr
;
122 long next
= insn2
& 0xffff;
123 long list12
= ((insn
& 1) << 16) + (next
& 0xffe0);
124 long offset
= (insn
& 0x3e) << 1;
125 static struct reg_list reg_table
[] =
127 {0x00800, 20}, /* r20 */
128 {0x00400, 21}, /* r21 */
129 {0x00200, 22}, /* r22 */
130 {0x00100, 23}, /* r23 */
131 {0x08000, 24}, /* r24 */
132 {0x04000, 25}, /* r25 */
133 {0x02000, 26}, /* r26 */
134 {0x01000, 27}, /* r27 */
135 {0x00080, 28}, /* r28 */
136 {0x00040, 29}, /* r29 */
137 {0x10000, 30}, /* ep */
138 {0x00020, 31}, /* lp */
139 {0, 0} /* end of table */
143 if ((next
& 0x1f) == 0x0b) /* skip imm16 argument */
145 else if ((next
& 0x1f) == 0x13) /* skip imm16 argument */
147 else if ((next
& 0x1f) == 0x1b) /* skip imm32 argument */
150 /* Calculate the total size of the saved registers, and add it
151 it to the immediate value used to adjust SP. */
152 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
153 if (list12
& reg_table
[i
].mask
)
154 offset
+= REGISTER_RAW_SIZE (regtable
[i
].regno
);
155 pi
->frameoffset
-= offset
;
157 /* Calculate the offsets of the registers relative to the value
158 the SP will have after the registers have been pushed and the
159 imm5 value has been subtracted from it. */
162 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
164 if (list12
& reg_table
[i
].mask
)
166 int reg
= reg_table
[i
].regno
;
167 offset
-= REGISTER_RAW_SIZE (reg
);
169 pifsr
->offset
= offset
;
170 pifsr
->cur_frameoffset
= pi
->frameoffset
;
172 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
179 printf_filtered ("\tfound ctret after regsave func");
182 /* Set result parameters. */
183 *current_pc_ptr
= current_pc
;
188 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
189 FIXME: the SR bit of the register list is not supported; must check
190 that the compiler does not ever generate this bit. */
193 handle_pushm (int insn
, int insn2
, struct prologue_info
*pi
,
194 struct pifsr
**pifsr_ptr
)
197 struct pifsr
*pifsr
= *pifsr_ptr
;
198 long list12
= ((insn
& 0x0f) << 16) + (insn2
& 0xfff0);
200 static struct reg_list pushml_reg_table
[] =
202 {0x80000, PS_REGNUM
}, /* PSW */
203 {0x40000, 1}, /* r1 */
204 {0x20000, 2}, /* r2 */
205 {0x10000, 3}, /* r3 */
206 {0x00800, 4}, /* r4 */
207 {0x00400, 5}, /* r5 */
208 {0x00200, 6}, /* r6 */
209 {0x00100, 7}, /* r7 */
210 {0x08000, 8}, /* r8 */
211 {0x04000, 9}, /* r9 */
212 {0x02000, 10}, /* r10 */
213 {0x01000, 11}, /* r11 */
214 {0x00080, 12}, /* r12 */
215 {0x00040, 13}, /* r13 */
216 {0x00020, 14}, /* r14 */
217 {0x00010, 15}, /* r15 */
218 {0, 0} /* end of table */
220 static struct reg_list pushmh_reg_table
[] =
222 {0x80000, 16}, /* r16 */
223 {0x40000, 17}, /* r17 */
224 {0x20000, 18}, /* r18 */
225 {0x10000, 19}, /* r19 */
226 {0x00800, 20}, /* r20 */
227 {0x00400, 21}, /* r21 */
228 {0x00200, 22}, /* r22 */
229 {0x00100, 23}, /* r23 */
230 {0x08000, 24}, /* r24 */
231 {0x04000, 25}, /* r25 */
232 {0x02000, 26}, /* r26 */
233 {0x01000, 27}, /* r27 */
234 {0x00080, 28}, /* r28 */
235 {0x00040, 29}, /* r29 */
236 {0x00010, 30}, /* r30 */
237 {0x00020, 31}, /* r31 */
238 {0, 0} /* end of table */
240 struct reg_list
*reg_table
;
243 /* Is this a pushml or a pushmh? */
244 if ((insn2
& 7) == 1)
245 reg_table
= pushml_reg_table
;
247 reg_table
= pushmh_reg_table
;
249 /* Calculate the total size of the saved registers, and add it
250 it to the immediate value used to adjust SP. */
251 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
252 if (list12
& reg_table
[i
].mask
)
253 offset
+= REGISTER_RAW_SIZE (regtable
[i
].regno
);
254 pi
->frameoffset
-= offset
;
256 /* Calculate the offsets of the registers relative to the value
257 the SP will have after the registers have been pushed and the
258 imm5 value is subtracted from it. */
261 for (i
= 0; reg_table
[i
].mask
!= 0; i
++)
263 if (list12
& reg_table
[i
].mask
)
265 int reg
= reg_table
[i
].regno
;
266 offset
-= REGISTER_RAW_SIZE (reg
);
268 pifsr
->offset
= offset
;
269 pifsr
->cur_frameoffset
= pi
->frameoffset
;
271 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
278 printf_filtered ("\tfound ctret after regsave func");
281 /* Set result parameters. */
288 /* Function: scan_prologue
289 Scan the prologue of the function that contains PC, and record what
290 we find in PI. PI->fsr must be zeroed by the called. Returns the
291 pc after the prologue. Note that the addresses saved in pi->fsr
292 are actually just frame relative (negative offsets from the frame
293 pointer). This is because we don't know the actual value of the
294 frame pointer yet. In some circumstances, the frame pointer can't
295 be determined till after we have scanned the prologue. */
298 v850_scan_prologue (pc
, pi
)
300 struct prologue_info
*pi
;
302 CORE_ADDR func_addr
, prologue_end
, current_pc
;
303 struct pifsr
*pifsr
, *pifsr_tmp
;
307 CORE_ADDR save_pc
, save_end
;
311 /* First, figure out the bounds of the prologue so that we can limit the
312 search to something reasonable. */
314 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
316 struct symtab_and_line sal
;
318 sal
= find_pc_line (func_addr
, 0);
320 if (func_addr
== entry_point_address ())
321 pi
->start_function
= 1;
323 pi
->start_function
= 0;
329 prologue_end
= sal
.end
;
335 { /* We're in the boondocks */
336 func_addr
= pc
- 100;
340 prologue_end
= min (prologue_end
, pc
);
342 /* Now, search the prologue looking for instructions that setup fp, save
343 rp, adjust sp and such. We also record the frame offset of any saved
347 pi
->framereg
= SP_REGNUM
;
357 printf_filtered ("Current_pc = 0x%.8lx, prologue_end = 0x%.8lx\n",
358 (long) func_addr
, (long) prologue_end
);
361 for (current_pc
= func_addr
; current_pc
< prologue_end
;)
366 printf_filtered ("0x%.8lx ", (long) current_pc
);
367 (*tm_print_insn
) (current_pc
, &tm_print_insn_info
);
370 insn
= read_memory_unsigned_integer (current_pc
, 2);
372 if ((insn
& 0x0780) >= 0x0600) /* Four byte instruction? */
374 insn2
= read_memory_unsigned_integer (current_pc
, 2);
378 if ((insn
& 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p
)
379 { /* jarl <func>,10 */
380 long low_disp
= insn2
& ~(long) 1;
381 long disp
= (((((insn
& 0x3f) << 16) + low_disp
)
382 & ~(long) 1) ^ 0x00200000) - 0x00200000;
384 save_pc
= current_pc
;
385 save_end
= prologue_end
;
387 current_pc
+= disp
- 4;
388 prologue_end
= (current_pc
389 + (2 * 3) /* moves to/from ep */
390 + 4 /* addi <const>,sp,sp */
392 + (2 * 12) /* sst.w to save r2, r20-r29, r31 */
393 + 20); /* slop area */
396 printf_filtered ("\tfound jarl <func>,r10, disp = %ld, low_disp = %ld, new pc = 0x%.8lx\n",
397 disp
, low_disp
, (long) current_pc
+ 2);
401 else if ((insn
& 0xffc0) == 0x0200 && !regsave_func_p
)
403 long ctbp
= read_register (CTBP_REGNUM
);
404 long adr
= ctbp
+ ((insn
& 0x3f) << 1);
406 save_pc
= current_pc
;
407 save_end
= prologue_end
;
409 current_pc
= ctbp
+ (read_memory_unsigned_integer (adr
, 2) & 0xffff);
410 prologue_end
= (current_pc
411 + (2 * 3) /* prepare list2,imm5,sp/imm */
413 + 20); /* slop area */
416 printf_filtered ("\tfound callt, ctbp = 0x%.8lx, adr = %.8lx, new pc = 0x%.8lx\n",
417 ctbp
, adr
, (long) current_pc
);
421 else if ((insn
& 0xffc0) == 0x0780) /* prepare list2,imm5 */
423 handle_prepare (insn
, insn2
, ¤t_pc
, pi
, &pifsr
);
426 else if (insn
== 0x07e0 && regsave_func_p
&& insn2
== 0x0144)
427 { /* ctret after processing register save function */
428 current_pc
= save_pc
;
429 prologue_end
= save_end
;
432 printf_filtered ("\tfound ctret after regsave func");
436 else if ((insn
& 0xfff0) == 0x07e0 && (insn2
& 5) == 1)
437 { /* pushml, pushmh */
438 handle_pushm (insn
, insn2
, pi
, &pifsr
);
441 else if ((insn
& 0xffe0) == 0x0060 && regsave_func_p
)
442 { /* jmp after processing register save function */
443 current_pc
= save_pc
;
444 prologue_end
= save_end
;
447 printf_filtered ("\tfound jmp after regsave func");
451 else if ((insn
& 0x07c0) == 0x0780 /* jarl or jr */
452 || (insn
& 0xffe0) == 0x0060 /* jmp */
453 || (insn
& 0x0780) == 0x0580) /* branch */
456 printf_filtered ("\n");
458 break; /* Ran into end of prologue */
461 else if ((insn
& 0xffe0) == ((SP_REGNUM
<< 11) | 0x0240)) /* add <imm>,sp */
462 pi
->frameoffset
+= ((insn
& 0x1f) ^ 0x10) - 0x10;
463 else if (insn
== ((SP_REGNUM
<< 11) | 0x0600 | SP_REGNUM
)) /* addi <imm>,sp,sp */
464 pi
->frameoffset
+= insn2
;
465 else if (insn
== ((FP_RAW_REGNUM
<< 11) | 0x0000 | SP_REGNUM
)) /* mov sp,fp */
468 pi
->framereg
= FP_RAW_REGNUM
;
471 else if (insn
== ((R12_REGNUM
<< 11) | 0x0640 | R0_REGNUM
)) /* movhi hi(const),r0,r12 */
472 r12_tmp
= insn2
<< 16;
473 else if (insn
== ((R12_REGNUM
<< 11) | 0x0620 | R12_REGNUM
)) /* movea lo(const),r12,r12 */
475 else if (insn
== ((SP_REGNUM
<< 11) | 0x01c0 | R12_REGNUM
) && r12_tmp
) /* add r12,sp */
476 pi
->frameoffset
= r12_tmp
;
477 else if (insn
== ((EP_REGNUM
<< 11) | 0x0000 | SP_REGNUM
)) /* mov sp,ep */
479 else if (insn
== ((EP_REGNUM
<< 11) | 0x0000 | R1_REGNUM
)) /* mov r1,ep */
481 else if (((insn
& 0x07ff) == (0x0760 | SP_REGNUM
) /* st.w <reg>,<offset>[sp] */
483 && (insn
& 0x07ff) == (0x0760 | FP_RAW_REGNUM
))) /* st.w <reg>,<offset>[fp] */
485 && (((reg
= (insn
>> 11) & 0x1f) >= SAVE1_START_REGNUM
&& reg
<= SAVE1_END_REGNUM
)
486 || (reg
>= SAVE2_START_REGNUM
&& reg
<= SAVE2_END_REGNUM
)
487 || (reg
>= SAVE3_START_REGNUM
&& reg
<= SAVE3_END_REGNUM
)))
490 pifsr
->offset
= insn2
& ~1;
491 pifsr
->cur_frameoffset
= pi
->frameoffset
;
493 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
498 else if (ep_used
/* sst.w <reg>,<offset>[ep] */
499 && ((insn
& 0x0781) == 0x0501)
501 && (((reg
= (insn
>> 11) & 0x1f) >= SAVE1_START_REGNUM
&& reg
<= SAVE1_END_REGNUM
)
502 || (reg
>= SAVE2_START_REGNUM
&& reg
<= SAVE2_END_REGNUM
)
503 || (reg
>= SAVE3_START_REGNUM
&& reg
<= SAVE3_END_REGNUM
)))
506 pifsr
->offset
= (insn
& 0x007e) << 1;
507 pifsr
->cur_frameoffset
= pi
->frameoffset
;
509 printf_filtered ("\tSaved register r%d, offset %d", reg
, pifsr
->offset
);
515 printf_filtered ("\n");
520 pifsr
->framereg
= 0; /* Tie off last entry */
522 /* Fix up any offsets to the final offset. If a frame pointer was created, use it
523 instead of the stack pointer. */
524 for (pifsr_tmp
= pi
->pifsrs
; pifsr_tmp
&& pifsr_tmp
!= pifsr
; pifsr_tmp
++)
526 pifsr_tmp
->offset
-= pi
->frameoffset
- pifsr_tmp
->cur_frameoffset
;
527 pifsr_tmp
->framereg
= pi
->framereg
;
530 printf_filtered ("Saved register r%d, offset = %d, framereg = r%d\n",
531 pifsr_tmp
->reg
, pifsr_tmp
->offset
, pifsr_tmp
->framereg
);
536 printf_filtered ("Framereg = r%d, frameoffset = %d\n", pi
->framereg
, pi
->frameoffset
);
542 /* Function: init_extra_frame_info
543 Setup the frame's frame pointer, pc, and frame addresses for saved
544 registers. Most of the work is done in scan_prologue().
546 Note that when we are called for the last frame (currently active frame),
547 that fi->pc and fi->frame will already be setup. However, fi->frame will
548 be valid only if this routine uses FP. For previous frames, fi-frame will
549 always be correct (since that is derived from v850_frame_chain ()).
551 We can be called with the PC in the call dummy under two circumstances.
552 First, during normal backtracing, second, while figuring out the frame
553 pointer just prior to calling the target function (see run_stack_dummy). */
556 v850_init_extra_frame_info (fi
)
557 struct frame_info
*fi
;
559 struct prologue_info pi
;
560 struct pifsr pifsrs
[NUM_REGS
+ 1], *pifsr
;
563 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
565 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
567 /* The call dummy doesn't save any registers on the stack, so we can return
569 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
574 v850_scan_prologue (fi
->pc
, &pi
);
576 if (!fi
->next
&& pi
.framereg
== SP_REGNUM
)
577 fi
->frame
= read_register (pi
.framereg
) - pi
.frameoffset
;
579 for (pifsr
= pifsrs
; pifsr
->framereg
; pifsr
++)
581 fi
->fsr
.regs
[pifsr
->reg
] = pifsr
->offset
+ fi
->frame
;
583 if (pifsr
->framereg
== SP_REGNUM
)
584 fi
->fsr
.regs
[pifsr
->reg
] += pi
.frameoffset
;
588 /* Function: frame_chain
589 Figure out the frame prior to FI. Unfortunately, this involves
590 scanning the prologue of the caller, which will also be done
591 shortly by v850_init_extra_frame_info. For the dummy frame, we
592 just return the stack pointer that was in use at the time the
593 function call was made. */
596 v850_frame_chain (fi
)
597 struct frame_info
*fi
;
599 struct prologue_info pi
;
600 CORE_ADDR callers_pc
, fp
;
602 /* First, find out who called us */
603 callers_pc
= FRAME_SAVED_PC (fi
);
604 /* If caller is a call-dummy, then our FP bears no relation to his FP! */
605 fp
= v850_find_callers_reg (fi
, FP_RAW_REGNUM
);
606 if (PC_IN_CALL_DUMMY (callers_pc
, fp
, fp
))
607 return fp
; /* caller is call-dummy: return oldest value of FP */
609 /* Caller is NOT a call-dummy, so everything else should just work.
610 Even if THIS frame is a call-dummy! */
613 v850_scan_prologue (callers_pc
, &pi
);
615 if (pi
.start_function
)
616 return 0; /* Don't chain beyond the start function */
618 if (pi
.framereg
== FP_RAW_REGNUM
)
619 return v850_find_callers_reg (fi
, pi
.framereg
);
621 return fi
->frame
- pi
.frameoffset
;
624 /* Function: find_callers_reg
625 Find REGNUM on the stack. Otherwise, it's in an active register.
626 One thing we might want to do here is to check REGNUM against the
627 clobber mask, and somehow flag it as invalid if it isn't saved on
628 the stack somewhere. This would provide a graceful failure mode
629 when trying to get the value of caller-saves registers for an inner
633 v850_find_callers_reg (fi
, regnum
)
634 struct frame_info
*fi
;
637 for (; fi
; fi
= fi
->next
)
638 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
639 return generic_read_register_dummy (fi
->pc
, fi
->frame
, regnum
);
640 else if (fi
->fsr
.regs
[regnum
] != 0)
641 return read_memory_unsigned_integer (fi
->fsr
.regs
[regnum
],
642 REGISTER_RAW_SIZE (regnum
));
644 return read_register (regnum
);
647 /* Function: skip_prologue
648 Return the address of the first code past the prologue of the function. */
651 v850_skip_prologue (pc
)
654 CORE_ADDR func_addr
, func_end
;
656 /* See what the symbol table says */
658 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
660 struct symtab_and_line sal
;
662 sal
= find_pc_line (func_addr
, 0);
664 if (sal
.line
!= 0 && sal
.end
< func_end
)
667 /* Either there's no line info, or the line after the prologue is after
668 the end of the function. In this case, there probably isn't a
673 /* We can't find the start of this function, so there's nothing we can do. */
677 /* Function: pop_frame
678 This routine gets called when either the user uses the `return'
679 command, or the call dummy breakpoint gets hit. */
682 v850_pop_frame (frame
)
683 struct frame_info
*frame
;
687 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
688 generic_pop_dummy_frame ();
691 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
693 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
694 if (frame
->fsr
.regs
[regnum
] != 0)
695 write_register (regnum
,
696 read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
697 REGISTER_RAW_SIZE (regnum
)));
699 write_register (SP_REGNUM
, FRAME_FP (frame
));
702 flush_cached_frames ();
705 /* Function: push_arguments
706 Setup arguments and RP for a call to the target. First four args
707 go in R6->R9, subsequent args go into sp + 16 -> sp + ... Structs
708 are passed by reference. 64 bit quantities (doubles and long
709 longs) may be split between the regs and the stack. When calling a
710 function that returns a struct, a pointer to the struct is passed
711 in as a secret first argument (always in R6).
713 Stack space for the args has NOT been allocated: that job is up to us.
717 v850_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
721 unsigned char struct_return
;
722 CORE_ADDR struct_addr
;
729 /* First, just for safety, make sure stack is aligned */
732 /* Now make space on the stack for the args. */
733 for (argnum
= 0; argnum
< nargs
; argnum
++)
734 len
+= ((TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3);
735 sp
-= len
; /* possibly over-allocating, but it works... */
736 /* (you might think we could allocate 16 bytes */
737 /* less, but the ABI seems to use it all! ) */
738 argreg
= ARG0_REGNUM
;
740 /* the struct_return pointer occupies the first parameter-passing reg */
742 write_register (argreg
++, struct_addr
);
745 /* The offset onto the stack at which we will start copying parameters
746 (after the registers are used up) begins at 16 rather than at zero.
747 I don't really know why, that's just the way it seems to work. */
749 /* Now load as many as possible of the first arguments into
750 registers, and push the rest onto the stack. There are 16 bytes
751 in four registers available. Loop thru args from first to last. */
752 for (argnum
= 0; argnum
< nargs
; argnum
++)
756 char valbuf
[REGISTER_RAW_SIZE (ARG0_REGNUM
)];
758 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
759 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
761 store_address (valbuf
, 4, VALUE_ADDRESS (*args
));
767 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
768 val
= (char *) VALUE_CONTENTS (*args
);
772 if (argreg
<= ARGLAST_REGNUM
)
776 regval
= extract_address (val
, REGISTER_RAW_SIZE (argreg
));
777 write_register (argreg
, regval
);
779 len
-= REGISTER_RAW_SIZE (argreg
);
780 val
+= REGISTER_RAW_SIZE (argreg
);
785 write_memory (sp
+ stack_offset
, val
, 4);
796 /* Function: push_return_address (pc)
797 Set up the return address for the inferior function call.
798 Needed for targets where we don't actually execute a JSR/BSR instruction */
801 v850_push_return_address (pc
, sp
)
805 write_register (RP_REGNUM
, CALL_DUMMY_ADDRESS ());
809 /* Function: frame_saved_pc
810 Find the caller of this frame. We do this by seeing if RP_REGNUM
811 is saved in the stack anywhere, otherwise we get it from the
812 registers. If the inner frame is a dummy frame, return its PC
813 instead of RP, because that's where "caller" of the dummy-frame
817 v850_frame_saved_pc (fi
)
818 struct frame_info
*fi
;
820 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
821 return generic_read_register_dummy (fi
->pc
, fi
->frame
, PC_REGNUM
);
823 return v850_find_callers_reg (fi
, RP_REGNUM
);
827 /* Function: fix_call_dummy
828 Pokes the callee function's address into the CALL_DUMMY assembly stub.
829 Assumes that the CALL_DUMMY looks like this:
835 v850_fix_call_dummy (dummy
, sp
, fun
, nargs
, args
, type
, gcc_p
)
846 offset24
= (long) fun
- (long) entry_point_address ();
847 offset24
&= 0x3fffff;
848 offset24
|= 0xff800000; /* jarl <offset24>, r31 */
850 store_unsigned_integer ((unsigned int *) &dummy
[2], 2, offset24
& 0xffff);
851 store_unsigned_integer ((unsigned int *) &dummy
[0], 2, offset24
>> 16);
855 /* Change the register names based on the current machine type. */
858 v850_target_architecture_hook (ap
)
859 const bfd_arch_info_type
*ap
;
863 if (ap
->arch
!= bfd_arch_v850
)
866 for (i
= 0; v850_processor_type_table
[i
].regnames
!= NULL
; i
++)
868 if (v850_processor_type_table
[i
].mach
== ap
->mach
)
870 v850_register_names
= v850_processor_type_table
[i
].regnames
;
871 tm_print_insn_info
.mach
= ap
->mach
;
876 internal_error ("Architecture `%s' unreconized", ap
->printable_name
);
880 _initialize_v850_tdep ()
882 tm_print_insn
= print_insn_v850
;
883 target_architecture_hook
= v850_target_architecture_hook
;