projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* h8300s now new target, not alias of h8300h
[deliverable/binutils-gdb.git] / gdb / v850-tdep.c
CommitLineData
c906108c 1/* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
435e042a 2 Copyright 1996, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
c906108c 3
c5aa993b 4 This file is part of GDB.
c906108c 5
c5aa993b
JM		 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.
c906108c 10
c5aa993b
JM		 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.
c906108c 15
c5aa993b
JM		 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. */
c906108c
SS		 20
21#include "defs.h"
22#include "frame.h"
23#include "inferior.h"
24#include "obstack.h"
25#include "target.h"
26#include "value.h"
27#include "bfd.h"
28#include "gdb_string.h"
29#include "gdbcore.h"
30#include "symfile.h"
b4a20239 31#include "arch-utils.h"
4e052eda 32#include "regcache.h"
435e042a 33#include "symtab.h"
c906108c 34
435e042a
CV		 35struct gdbarch_tdep
36{
37 /* gdbarch target dependent data here. Currently unused for v850. */
38};
39
40/* Extra info which is saved in each frame_info. */
41struct frame_extra_info
42{
43};
c906108c 44
435e042a
CV		 45enum {
46 E_R0_REGNUM,
47 E_R1_REGNUM,
48 E_R2_REGNUM, E_SAVE1_START_REGNUM = E_R2_REGNUM, E_SAVE1_END_REGNUM = E_R2_REGNUM,
49 E_R3_REGNUM, E_SP_REGNUM = E_R3_REGNUM,
50 E_R4_REGNUM,
51 E_R5_REGNUM,
52 E_R6_REGNUM, E_ARG0_REGNUM = E_R6_REGNUM,
53 E_R7_REGNUM,
54 E_R8_REGNUM,
55 E_R9_REGNUM, E_ARGLAST_REGNUM = E_R9_REGNUM,
56 E_R10_REGNUM, E_V0_REGNUM = E_R10_REGNUM,
57 E_R11_REGNUM, E_V1_REGNUM = E_R11_REGNUM,
58 E_R12_REGNUM,
59 E_R13_REGNUM,
60 E_R14_REGNUM,
61 E_R15_REGNUM,
62 E_R16_REGNUM,
63 E_R17_REGNUM,
64 E_R18_REGNUM,
65 E_R19_REGNUM,
66 E_R20_REGNUM, E_SAVE2_START_REGNUM = E_R20_REGNUM,
67 E_R21_REGNUM,
68 E_R22_REGNUM,
69 E_R23_REGNUM,
70 E_R24_REGNUM,
71 E_R25_REGNUM,
72 E_R26_REGNUM,
73 E_R27_REGNUM,
74 E_R28_REGNUM,
75 E_R29_REGNUM, E_SAVE2_END_REGNUM = E_R29_REGNUM, E_FP_RAW_REGNUM = E_R29_REGNUM,
76 E_R30_REGNUM, E_EP_REGNUM = E_R30_REGNUM,
77 E_R31_REGNUM, E_SAVE3_START_REGNUM = E_R31_REGNUM, E_SAVE3_END_REGNUM = E_R31_REGNUM, E_RP_REGNUM = E_R31_REGNUM,
78 E_R32_REGNUM, E_SR0_REGNUM = E_R32_REGNUM,
79 E_R33_REGNUM,
80 E_R34_REGNUM,
81 E_R35_REGNUM,
82 E_R36_REGNUM,
83 E_R37_REGNUM, E_PS_REGNUM = E_R37_REGNUM,
84 E_R38_REGNUM,
85 E_R39_REGNUM,
86 E_R40_REGNUM,
87 E_R41_REGNUM,
88 E_R42_REGNUM,
89 E_R43_REGNUM,
90 E_R44_REGNUM,
91 E_R45_REGNUM,
92 E_R46_REGNUM,
93 E_R47_REGNUM,
94 E_R48_REGNUM,
95 E_R49_REGNUM,
96 E_R50_REGNUM,
97 E_R51_REGNUM,
98 E_R52_REGNUM, E_CTBP_REGNUM = E_R52_REGNUM,
99 E_R53_REGNUM,
100 E_R54_REGNUM,
101 E_R55_REGNUM,
102 E_R56_REGNUM,
103 E_R57_REGNUM,
104 E_R58_REGNUM,
105 E_R59_REGNUM,
106 E_R60_REGNUM,
107 E_R61_REGNUM,
108 E_R62_REGNUM,
109 E_R63_REGNUM,
110 E_R64_REGNUM, E_PC_REGNUM = E_R64_REGNUM,
111 E_R65_REGNUM, E_FP_REGNUM = E_R65_REGNUM,
112 E_NUM_REGS
113};
114
115enum
116{
117 v850_reg_size = 4
118};
119
120/* Size of all registers as a whole. */
121enum
122{
123 E_ALL_REGS_SIZE = (E_NUM_REGS) * v850_reg_size
124};
125
126static LONGEST call_dummy_nil[] = {0};
127
128static char *v850_generic_reg_names[] =
129{ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
130 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
131 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
132 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
133 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
134 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
135 "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
136 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
137 "pc", "fp"
138};
c906108c
SS		 139
140static char *v850e_reg_names[] =
141{
142 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
143 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
144 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
145 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
146 "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
147 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
148 "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
149 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
150 "pc", "fp"
151};
152
153char **v850_register_names = v850_generic_reg_names;
154
155struct
c5aa993b
JM		 156 {
157 char **regnames;
158 int mach;
159 }
160v850_processor_type_table[] =
c906108c 161{
c5aa993b
JM		 162 {
163 v850_generic_reg_names, bfd_mach_v850
164 }
165 ,
166 {
167 v850e_reg_names, bfd_mach_v850e
168 }
169 ,
170 {
171 v850e_reg_names, bfd_mach_v850ea
172 }
173 ,
174 {
175 NULL, 0
176 }
c906108c
SS		 177};
178
179/* Info gleaned from scanning a function's prologue. */
180
181struct pifsr /* Info about one saved reg */
c5aa993b
JM		 182 {
183 int framereg; /* Frame reg (SP or FP) */
184 int offset; /* Offset from framereg */
185 int cur_frameoffset; /* Current frameoffset */
186 int reg; /* Saved register number */
187 };
c906108c
SS		 188
189struct prologue_info
c5aa993b
JM		 190 {
191 int framereg;
192 int frameoffset;
193 int start_function;
194 struct pifsr *pifsrs;
195 };
c906108c 196
a14ed312 197static CORE_ADDR v850_scan_prologue (CORE_ADDR pc, struct prologue_info *fs);
c906108c 198
435e042a
CV		 199/* Function: v850_register_name
200 Returns the name of the v850/v850e register N. */
201
202static char *
203v850_register_name (int regnum)
204{
205 if (regnum < 0 || regnum >= E_NUM_REGS)
206 internal_error (__FILE__, __LINE__,
207 "v850_register_name: illegal register number %d",
208 regnum);
209 else
210 return v850_register_names[regnum];
211
212}
213
214/* Function: v850_register_byte
215 Returns the byte position in the register cache for register N. */
216
217static int
218v850_register_byte (int regnum)
219{
220 if (regnum < 0 || regnum >= E_NUM_REGS)
221 internal_error (__FILE__, __LINE__,
222 "v850_register_byte: illegal register number %d",
223 regnum);
224 else
225 return regnum * v850_reg_size;
226}
227
228/* Function: v850_register_raw_size
229 Returns the number of bytes occupied by the register on the target. */
230
231static int
232v850_register_raw_size (int regnum)
233{
234 if (regnum < 0 || regnum >= E_NUM_REGS)
235 internal_error (__FILE__, __LINE__,
236 "v850_register_raw_size: illegal register number %d",
237 regnum);
238 /* Only the PC has 4 Byte, all other registers 2 Byte. */
239 else
240 return v850_reg_size;
241}
242
243/* Function: v850_register_virtual_size
244 Returns the number of bytes occupied by the register as represented
245 internally by gdb. */
246
247static int
248v850_register_virtual_size (int regnum)
249{
250 return v850_register_raw_size (regnum);
251}
252
253/* Function: v850_reg_virtual_type
254 Returns the default type for register N. */
255
256static struct type *
257v850_reg_virtual_type (int regnum)
258{
259 if (regnum < 0 || regnum >= E_NUM_REGS)
260 internal_error (__FILE__, __LINE__,
261 "v850_register_virtual_type: illegal register number %d",
262 regnum);
263 else if (regnum == E_PC_REGNUM)
264 return builtin_type_uint32;
265 else
266 return builtin_type_int32;
267}
c906108c
SS		 268
269/* Should call_function allocate stack space for a struct return? */
270int
fba45db2 271v850_use_struct_convention (int gcc_p, struct type *type)
c906108c
SS		 272{
273 return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 4);
274}
c906108c
SS		 275\f
276
c5aa993b 277
c906108c 278/* Structure for mapping bits in register lists to register numbers. */
c5aa993b 279struct reg_list
c906108c
SS		 280{
281 long mask;
282 int regno;
283};
284
285/* Helper function for v850_scan_prologue to handle prepare instruction. */
286
287static void
c5aa993b 288handle_prepare (int insn, int insn2, CORE_ADDR * current_pc_ptr,
c906108c 289 struct prologue_info *pi, struct pifsr **pifsr_ptr)
c906108c
SS		 290{
291 CORE_ADDR current_pc = *current_pc_ptr;
292 struct pifsr *pifsr = *pifsr_ptr;
293 long next = insn2 & 0xffff;
294 long list12 = ((insn & 1) << 16) + (next & 0xffe0);
295 long offset = (insn & 0x3e) << 1;
c5aa993b 296 static struct reg_list reg_table[] =
c906108c 297 {
c5aa993b
JM		 298 {0x00800, 20}, /* r20 */
299 {0x00400, 21}, /* r21 */
300 {0x00200, 22}, /* r22 */
301 {0x00100, 23}, /* r23 */
302 {0x08000, 24}, /* r24 */
303 {0x04000, 25}, /* r25 */
304 {0x02000, 26}, /* r26 */
305 {0x01000, 27}, /* r27 */
306 {0x00080, 28}, /* r28 */
307 {0x00040, 29}, /* r29 */
308 {0x10000, 30}, /* ep */
309 {0x00020, 31}, /* lp */
310 {0, 0} /* end of table */
c906108c
SS		 311 };
312 int i;
313
c5aa993b 314 if ((next & 0x1f) == 0x0b) /* skip imm16 argument */
c906108c
SS		 315 current_pc += 2;
316 else if ((next & 0x1f) == 0x13) /* skip imm16 argument */
317 current_pc += 2;
318 else if ((next & 0x1f) == 0x1b) /* skip imm32 argument */
319 current_pc += 4;
320
321 /* Calculate the total size of the saved registers, and add it
322 it to the immediate value used to adjust SP. */
323 for (i = 0; reg_table[i].mask != 0; i++)
324 if (list12 & reg_table[i].mask)
435e042a 325 offset += v850_register_raw_size (reg_table[i].regno);
c906108c
SS		 326 pi->frameoffset -= offset;
327
328 /* Calculate the offsets of the registers relative to the value
329 the SP will have after the registers have been pushed and the
330 imm5 value has been subtracted from it. */
331 if (pifsr)
332 {
333 for (i = 0; reg_table[i].mask != 0; i++)
334 {
335 if (list12 & reg_table[i].mask)
336 {
337 int reg = reg_table[i].regno;
435e042a 338 offset -= v850_register_raw_size (reg);
c906108c
SS		 339 pifsr->reg = reg;
340 pifsr->offset = offset;
341 pifsr->cur_frameoffset = pi->frameoffset;
c5aa993b 342#ifdef DEBUG
c906108c 343 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
c5aa993b 344#endif
c906108c
SS		 345 pifsr++;
346 }
347 }
348 }
349#ifdef DEBUG
350 printf_filtered ("\tfound ctret after regsave func");
351#endif
352
353 /* Set result parameters. */
354 *current_pc_ptr = current_pc;
355 *pifsr_ptr = pifsr;
356}
357
358
359/* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
360 FIXME: the SR bit of the register list is not supported; must check
361 that the compiler does not ever generate this bit. */
362
363static void
364handle_pushm (int insn, int insn2, struct prologue_info *pi,
c5aa993b 365 struct pifsr **pifsr_ptr)
c906108c
SS		 366{
367 struct pifsr *pifsr = *pifsr_ptr;
368 long list12 = ((insn & 0x0f) << 16) + (insn2 & 0xfff0);
369 long offset = 0;
c5aa993b 370 static struct reg_list pushml_reg_table[] =
c906108c 371 {
435e042a 372 {0x80000, E_PS_REGNUM}, /* PSW */
c5aa993b
JM		 373 {0x40000, 1}, /* r1 */
374 {0x20000, 2}, /* r2 */
375 {0x10000, 3}, /* r3 */
376 {0x00800, 4}, /* r4 */
377 {0x00400, 5}, /* r5 */
378 {0x00200, 6}, /* r6 */
379 {0x00100, 7}, /* r7 */
380 {0x08000, 8}, /* r8 */
381 {0x04000, 9}, /* r9 */
382 {0x02000, 10}, /* r10 */
383 {0x01000, 11}, /* r11 */
384 {0x00080, 12}, /* r12 */
385 {0x00040, 13}, /* r13 */
386 {0x00020, 14}, /* r14 */
387 {0x00010, 15}, /* r15 */
388 {0, 0} /* end of table */
c906108c 389 };
c5aa993b 390 static struct reg_list pushmh_reg_table[] =
c906108c 391 {
c5aa993b
JM		 392 {0x80000, 16}, /* r16 */
393 {0x40000, 17}, /* r17 */
394 {0x20000, 18}, /* r18 */
395 {0x10000, 19}, /* r19 */
396 {0x00800, 20}, /* r20 */
397 {0x00400, 21}, /* r21 */
398 {0x00200, 22}, /* r22 */
399 {0x00100, 23}, /* r23 */
400 {0x08000, 24}, /* r24 */
401 {0x04000, 25}, /* r25 */
402 {0x02000, 26}, /* r26 */
403 {0x01000, 27}, /* r27 */
404 {0x00080, 28}, /* r28 */
405 {0x00040, 29}, /* r29 */
406 {0x00010, 30}, /* r30 */
407 {0x00020, 31}, /* r31 */
408 {0, 0} /* end of table */
c906108c
SS		 409 };
410 struct reg_list *reg_table;
411 int i;
412
413 /* Is this a pushml or a pushmh? */
414 if ((insn2 & 7) == 1)
415 reg_table = pushml_reg_table;
416 else
417 reg_table = pushmh_reg_table;
418
419 /* Calculate the total size of the saved registers, and add it
420 it to the immediate value used to adjust SP. */
421 for (i = 0; reg_table[i].mask != 0; i++)
422 if (list12 & reg_table[i].mask)
435e042a 423 offset += v850_register_raw_size (reg_table[i].regno);
c906108c
SS		 424 pi->frameoffset -= offset;
425
426 /* Calculate the offsets of the registers relative to the value
427 the SP will have after the registers have been pushed and the
428 imm5 value is subtracted from it. */
429 if (pifsr)
430 {
431 for (i = 0; reg_table[i].mask != 0; i++)
432 {
433 if (list12 & reg_table[i].mask)
434 {
435 int reg = reg_table[i].regno;
435e042a 436 offset -= v850_register_raw_size (reg);
c906108c
SS		 437 pifsr->reg = reg;
438 pifsr->offset = offset;
439 pifsr->cur_frameoffset = pi->frameoffset;
c5aa993b 440#ifdef DEBUG
c906108c 441 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
c5aa993b 442#endif
c906108c
SS		 443 pifsr++;
444 }
445 }
446 }
447#ifdef DEBUG
448 printf_filtered ("\tfound ctret after regsave func");
449#endif
450
451 /* Set result parameters. */
452 *pifsr_ptr = pifsr;
453}
c5aa993b 454\f
c906108c
SS		 455
456
457
c906108c
SS		 458/* Function: scan_prologue
459 Scan the prologue of the function that contains PC, and record what
3a06899a
CV		 460 we find in PI. Returns the pc after the prologue. Note that the
461 addresses saved in frame->saved_regs are just frame relative (negative
462 offsets from the frame pointer). This is because we don't know the
463 actual value of the frame pointer yet. In some circumstances, the
464 frame pointer can't be determined till after we have scanned the
465 prologue. */
c906108c
SS		 466
467static CORE_ADDR
fba45db2 468v850_scan_prologue (CORE_ADDR pc, struct prologue_info *pi)
c906108c
SS		 469{
470 CORE_ADDR func_addr, prologue_end, current_pc;
471 struct pifsr *pifsr, *pifsr_tmp;
472 int fp_used;
473 int ep_used;
474 int reg;
475 CORE_ADDR save_pc, save_end;
476 int regsave_func_p;
477 int r12_tmp;
478
479 /* First, figure out the bounds of the prologue so that we can limit the
480 search to something reasonable. */
481
482 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
483 {
484 struct symtab_and_line sal;
485
486 sal = find_pc_line (func_addr, 0);
487
488 if (func_addr == entry_point_address ())
489 pi->start_function = 1;
490 else
491 pi->start_function = 0;
492
493#if 0
494 if (sal.line == 0)
495 prologue_end = pc;
496 else
497 prologue_end = sal.end;
498#else
499 prologue_end = pc;
500#endif
501 }
502 else
503 { /* We're in the boondocks */
504 func_addr = pc - 100;
505 prologue_end = pc;
506 }
507
508 prologue_end = min (prologue_end, pc);
509
510 /* Now, search the prologue looking for instructions that setup fp, save
511 rp, adjust sp and such. We also record the frame offset of any saved
c5aa993b 512 registers. */
c906108c
SS		 513
514 pi->frameoffset = 0;
435e042a 515 pi->framereg = E_SP_REGNUM;
c906108c
SS		 516 fp_used = 0;
517 ep_used = 0;
518 pifsr = pi->pifsrs;
519 regsave_func_p = 0;
520 save_pc = 0;
521 save_end = 0;
522 r12_tmp = 0;
523
524#ifdef DEBUG
525 printf_filtered ("Current_pc = 0x%.8lx, prologue_end = 0x%.8lx\n",
c5aa993b 526 (long) func_addr, (long) prologue_end);
c906108c
SS		 527#endif
528
c5aa993b 529 for (current_pc = func_addr; current_pc < prologue_end;)
c906108c 530 {
93d56215
AC		 531 int insn;
532 int insn2 = -1; /* dummy value */
c906108c
SS		 533
534#ifdef DEBUG
c5aa993b 535 printf_filtered ("0x%.8lx ", (long) current_pc);
2bf0cb65 536 TARGET_PRINT_INSN (current_pc, &tm_print_insn_info);
c906108c
SS		 537#endif
538
539 insn = read_memory_unsigned_integer (current_pc, 2);
540 current_pc += 2;
c5aa993b 541 if ((insn & 0x0780) >= 0x0600) /* Four byte instruction? */
c906108c
SS		 542 {
543 insn2 = read_memory_unsigned_integer (current_pc, 2);
544 current_pc += 2;
545 }
546
547 if ((insn & 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p)
548 { /* jarl <func>,10 */
c5aa993b 549 long low_disp = insn2 & ~(long) 1;
c906108c 550 long disp = (((((insn & 0x3f) << 16) + low_disp)
c5aa993b 551 & ~(long) 1) ^ 0x00200000) - 0x00200000;
c906108c
SS		 552
553 save_pc = current_pc;
554 save_end = prologue_end;
555 regsave_func_p = 1;
556 current_pc += disp - 4;
557 prologue_end = (current_pc
558 + (2 * 3) /* moves to/from ep */
c5aa993b
JM		 559 + 4 /* addi <const>,sp,sp */
560 + 2 /* jmp [r10] */
c906108c
SS		 561 + (2 * 12) /* sst.w to save r2, r20-r29, r31 */
562 + 20); /* slop area */
563
564#ifdef DEBUG
565 printf_filtered ("\tfound jarl <func>,r10, disp = %ld, low_disp = %ld, new pc = 0x%.8lx\n",
c5aa993b 566 disp, low_disp, (long) current_pc + 2);
c906108c
SS		 567#endif
568 continue;
569 }
570 else if ((insn & 0xffc0) == 0x0200 && !regsave_func_p)
571 { /* callt <imm6> */
435e042a 572 long ctbp = read_register (E_CTBP_REGNUM);
c906108c
SS		 573 long adr = ctbp + ((insn & 0x3f) << 1);
574
575 save_pc = current_pc;
576 save_end = prologue_end;
577 regsave_func_p = 1;
578 current_pc = ctbp + (read_memory_unsigned_integer (adr, 2) & 0xffff);
579 prologue_end = (current_pc
580 + (2 * 3) /* prepare list2,imm5,sp/imm */
c5aa993b 581 + 4 /* ctret */
c906108c
SS		 582 + 20); /* slop area */
583
584#ifdef DEBUG
585 printf_filtered ("\tfound callt, ctbp = 0x%.8lx, adr = %.8lx, new pc = 0x%.8lx\n",
c5aa993b 586 ctbp, adr, (long) current_pc);
c906108c
SS		 587#endif
588 continue;
589 }
590 else if ((insn & 0xffc0) == 0x0780) /* prepare list2,imm5 */
591 {
592 handle_prepare (insn, insn2, &current_pc, pi, &pifsr);
593 continue;
594 }
595 else if (insn == 0x07e0 && regsave_func_p && insn2 == 0x0144)
596 { /* ctret after processing register save function */
597 current_pc = save_pc;
598 prologue_end = save_end;
599 regsave_func_p = 0;
600#ifdef DEBUG
601 printf_filtered ("\tfound ctret after regsave func");
602#endif
603 continue;
604 }
605 else if ((insn & 0xfff0) == 0x07e0 && (insn2 & 5) == 1)
606 { /* pushml, pushmh */
607 handle_pushm (insn, insn2, pi, &pifsr);
608 continue;
609 }
610 else if ((insn & 0xffe0) == 0x0060 && regsave_func_p)
611 { /* jmp after processing register save function */
612 current_pc = save_pc;
613 prologue_end = save_end;
614 regsave_func_p = 0;
615#ifdef DEBUG
616 printf_filtered ("\tfound jmp after regsave func");
617#endif
618 continue;
619 }
620 else if ((insn & 0x07c0) == 0x0780 /* jarl or jr */
621 || (insn & 0xffe0) == 0x0060 /* jmp */
622 || (insn & 0x0780) == 0x0580) /* branch */
623 {
624#ifdef DEBUG
625 printf_filtered ("\n");
626#endif
c5aa993b 627 break; /* Ran into end of prologue */
c906108c
SS		 628 }
629
435e042a 630 else if ((insn & 0xffe0) == ((E_SP_REGNUM << 11) | 0x0240)) /* add <imm>,sp */
c906108c 631 pi->frameoffset += ((insn & 0x1f) ^ 0x10) - 0x10;
435e042a 632 else if (insn == ((E_SP_REGNUM << 11) | 0x0600 | E_SP_REGNUM)) /* addi <imm>,sp,sp */
c906108c 633 pi->frameoffset += insn2;
435e042a 634 else if (insn == ((E_FP_RAW_REGNUM << 11) | 0x0000 | E_SP_REGNUM)) /* mov sp,fp */
c906108c
SS		 635 {
636 fp_used = 1;
435e042a 637 pi->framereg = E_FP_RAW_REGNUM;
c906108c
SS		 638 }
639
435e042a 640 else if (insn == ((E_R12_REGNUM << 11) | 0x0640 | E_R0_REGNUM)) /* movhi hi(const),r0,r12 */
c906108c 641 r12_tmp = insn2 << 16;
435e042a 642 else if (insn == ((E_R12_REGNUM << 11) | 0x0620 | E_R12_REGNUM)) /* movea lo(const),r12,r12 */
c906108c 643 r12_tmp += insn2;
435e042a 644 else if (insn == ((E_SP_REGNUM << 11) | 0x01c0 | E_R12_REGNUM) && r12_tmp) /* add r12,sp */
c906108c 645 pi->frameoffset = r12_tmp;
435e042a 646 else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_SP_REGNUM)) /* mov sp,ep */
c906108c 647 ep_used = 1;
435e042a 648 else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_R1_REGNUM)) /* mov r1,ep */
c906108c 649 ep_used = 0;
435e042a 650 else if (((insn & 0x07ff) == (0x0760 | E_SP_REGNUM) /* st.w <reg>,<offset>[sp] */
c906108c 651 || (fp_used
435e042a 652 && (insn & 0x07ff) == (0x0760 | E_FP_RAW_REGNUM))) /* st.w <reg>,<offset>[fp] */
c906108c 653 && pifsr
435e042a
CV		 654 && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
655 || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
656 || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
c906108c
SS		 657 {
658 pifsr->reg = reg;
659 pifsr->offset = insn2 & ~1;
660 pifsr->cur_frameoffset = pi->frameoffset;
661#ifdef DEBUG
662 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
663#endif
664 pifsr++;
665 }
666
c5aa993b 667 else if (ep_used /* sst.w <reg>,<offset>[ep] */
c906108c
SS		 668 && ((insn & 0x0781) == 0x0501)
669 && pifsr
435e042a
CV		 670 && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
671 || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
672 || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
c906108c
SS		 673 {
674 pifsr->reg = reg;
675 pifsr->offset = (insn & 0x007e) << 1;
676 pifsr->cur_frameoffset = pi->frameoffset;
677#ifdef DEBUG
678 printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
679#endif
680 pifsr++;
681 }
682
683#ifdef DEBUG
684 printf_filtered ("\n");
685#endif
686 }
687
688 if (pifsr)
689 pifsr->framereg = 0; /* Tie off last entry */
690
691 /* Fix up any offsets to the final offset. If a frame pointer was created, use it
692 instead of the stack pointer. */
693 for (pifsr_tmp = pi->pifsrs; pifsr_tmp && pifsr_tmp != pifsr; pifsr_tmp++)
694 {
695 pifsr_tmp->offset -= pi->frameoffset - pifsr_tmp->cur_frameoffset;
696 pifsr_tmp->framereg = pi->framereg;
697
698#ifdef DEBUG
699 printf_filtered ("Saved register r%d, offset = %d, framereg = r%d\n",
c5aa993b 700 pifsr_tmp->reg, pifsr_tmp->offset, pifsr_tmp->framereg);
c906108c
SS		 701#endif
702 }
703
704#ifdef DEBUG
705 printf_filtered ("Framereg = r%d, frameoffset = %d\n", pi->framereg, pi->frameoffset);
706#endif
707
708 return current_pc;
709}
710
435e042a
CV		 711/* Function: find_callers_reg
712 Find REGNUM on the stack. Otherwise, it's in an active register.
713 One thing we might want to do here is to check REGNUM against the
714 clobber mask, and somehow flag it as invalid if it isn't saved on
715 the stack somewhere. This would provide a graceful failure mode
716 when trying to get the value of caller-saves registers for an inner
717 frame. */
c906108c 718
435e042a
CV		 719CORE_ADDR
720v850_find_callers_reg (struct frame_info *fi, int regnum)
c906108c 721{
435e042a
CV		 722 for (; fi; fi = fi->next)
723 if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
724 return generic_read_register_dummy (fi->pc, fi->frame, regnum);
725 else if (fi->saved_regs[regnum] != 0)
726 return read_memory_unsigned_integer (fi->saved_regs[regnum],
727 v850_register_raw_size (regnum));
c906108c 728
435e042a 729 return read_register (regnum);
c906108c
SS		 730}
731
732/* Function: frame_chain
733 Figure out the frame prior to FI. Unfortunately, this involves
734 scanning the prologue of the caller, which will also be done
735 shortly by v850_init_extra_frame_info. For the dummy frame, we
736 just return the stack pointer that was in use at the time the
737 function call was made. */
738
739CORE_ADDR
fba45db2 740v850_frame_chain (struct frame_info *fi)
c906108c
SS		 741{
742 struct prologue_info pi;
743 CORE_ADDR callers_pc, fp;
744
745 /* First, find out who called us */
746 callers_pc = FRAME_SAVED_PC (fi);
747 /* If caller is a call-dummy, then our FP bears no relation to his FP! */
435e042a 748 fp = v850_find_callers_reg (fi, E_FP_RAW_REGNUM);
c5aa993b
JM		 749 if (PC_IN_CALL_DUMMY (callers_pc, fp, fp))
750 return fp; /* caller is call-dummy: return oldest value of FP */
c906108c
SS		 751
752 /* Caller is NOT a call-dummy, so everything else should just work.
753 Even if THIS frame is a call-dummy! */
754 pi.pifsrs = NULL;
755
756 v850_scan_prologue (callers_pc, &pi);
757
758 if (pi.start_function)
759 return 0; /* Don't chain beyond the start function */
760
435e042a 761 if (pi.framereg == E_FP_RAW_REGNUM)
c906108c
SS		 762 return v850_find_callers_reg (fi, pi.framereg);
763
764 return fi->frame - pi.frameoffset;
765}
766
c906108c
SS		 767/* Function: skip_prologue
768 Return the address of the first code past the prologue of the function. */
769
770CORE_ADDR
fba45db2 771v850_skip_prologue (CORE_ADDR pc)
c906108c
SS		 772{
773 CORE_ADDR func_addr, func_end;
774
775 /* See what the symbol table says */
776
777 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
778 {
779 struct symtab_and_line sal;
780
781 sal = find_pc_line (func_addr, 0);
782
783 if (sal.line != 0 && sal.end < func_end)
784 return sal.end;
785 else
786 /* Either there's no line info, or the line after the prologue is after
787 the end of the function. In this case, there probably isn't a
788 prologue. */
789 return pc;
790 }
791
792/* We can't find the start of this function, so there's nothing we can do. */
793 return pc;
794}
795
796/* Function: pop_frame
797 This routine gets called when either the user uses the `return'
798 command, or the call dummy breakpoint gets hit. */
799
800void
435e042a 801v850_pop_frame (void)
c906108c 802{
435e042a 803 struct frame_info *frame = get_current_frame ();
c906108c
SS		 804 int regnum;
805
c5aa993b 806 if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
c906108c
SS		 807 generic_pop_dummy_frame ();
808 else
809 {
435e042a 810 write_register (E_PC_REGNUM, FRAME_SAVED_PC (frame));
c906108c 811
435e042a 812 for (regnum = 0; regnum < E_NUM_REGS; regnum++)
3a06899a 813 if (frame->saved_regs[regnum] != 0)
c906108c 814 write_register (regnum,
3a06899a 815 read_memory_unsigned_integer (frame->saved_regs[regnum],
435e042a 816 v850_register_raw_size (regnum)));
c906108c 817
435e042a 818 write_register (E_SP_REGNUM, FRAME_FP (frame));
c906108c
SS		 819 }
820
821 flush_cached_frames ();
822}
823
824/* Function: push_arguments
825 Setup arguments and RP for a call to the target. First four args
826 go in R6->R9, subsequent args go into sp + 16 -> sp + ... Structs
827 are passed by reference. 64 bit quantities (doubles and long
828 longs) may be split between the regs and the stack. When calling a
829 function that returns a struct, a pointer to the struct is passed
830 in as a secret first argument (always in R6).
831
832 Stack space for the args has NOT been allocated: that job is up to us.
c5aa993b 833 */
c906108c
SS		 834
835CORE_ADDR
ea7c478f 836v850_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
435e042a 837 int struct_return, CORE_ADDR struct_addr)
c906108c
SS		 838{
839 int argreg;
840 int argnum;
841 int len = 0;
842 int stack_offset;
843
844 /* First, just for safety, make sure stack is aligned */
845 sp &= ~3;
846
847 /* Now make space on the stack for the args. */
848 for (argnum = 0; argnum < nargs; argnum++)
c5aa993b
JM		 849 len += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
850 sp -= len; /* possibly over-allocating, but it works... */
851 /* (you might think we could allocate 16 bytes */
852 /* less, but the ABI seems to use it all! ) */
435e042a 853 argreg = E_ARG0_REGNUM;
c906108c
SS		 854
855 /* the struct_return pointer occupies the first parameter-passing reg */
856 if (struct_return)
c5aa993b 857 write_register (argreg++, struct_addr);
c906108c
SS		 858
859 stack_offset = 16;
860 /* The offset onto the stack at which we will start copying parameters
861 (after the registers are used up) begins at 16 rather than at zero.
862 I don't really know why, that's just the way it seems to work. */
863
864 /* Now load as many as possible of the first arguments into
865 registers, and push the rest onto the stack. There are 16 bytes
866 in four registers available. Loop thru args from first to last. */
867 for (argnum = 0; argnum < nargs; argnum++)
868 {
869 int len;
870 char *val;
435e042a 871 char valbuf[v850_register_raw_size (E_ARG0_REGNUM)];
c906108c
SS		 872
873 if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
874 && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
875 {
876 store_address (valbuf, 4, VALUE_ADDRESS (*args));
877 len = 4;
878 val = valbuf;
879 }
880 else
881 {
882 len = TYPE_LENGTH (VALUE_TYPE (*args));
c5aa993b 883 val = (char *) VALUE_CONTENTS (*args);
c906108c
SS		 884 }
885
886 while (len > 0)
435e042a 887 if (argreg <= E_ARGLAST_REGNUM)
c906108c
SS		 888 {
889 CORE_ADDR regval;
890
435e042a 891 regval = extract_address (val, v850_register_raw_size (argreg));
c906108c
SS		 892 write_register (argreg, regval);
893
435e042a
CV		 894 len -= v850_register_raw_size (argreg);
895 val += v850_register_raw_size (argreg);
c906108c
SS		 896 argreg++;
897 }
898 else
899 {
900 write_memory (sp + stack_offset, val, 4);
901
902 len -= 4;
903 val += 4;
904 stack_offset += 4;
905 }
906 args++;
907 }
908 return sp;
909}
910
911/* Function: push_return_address (pc)
912 Set up the return address for the inferior function call.
913 Needed for targets where we don't actually execute a JSR/BSR instruction */
c5aa993b 914
c906108c 915CORE_ADDR
fba45db2 916v850_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
c906108c 917{
435e042a 918 write_register (E_RP_REGNUM, CALL_DUMMY_ADDRESS ());
c906108c
SS		 919 return sp;
920}
c5aa993b 921
c906108c 922/* Function: frame_saved_pc
435e042a 923 Find the caller of this frame. We do this by seeing if E_RP_REGNUM
c906108c
SS		 924 is saved in the stack anywhere, otherwise we get it from the
925 registers. If the inner frame is a dummy frame, return its PC
926 instead of RP, because that's where "caller" of the dummy-frame
927 will be found. */
928
929CORE_ADDR
fba45db2 930v850_frame_saved_pc (struct frame_info *fi)
c906108c 931{
c5aa993b 932 if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
435e042a 933 return generic_read_register_dummy (fi->pc, fi->frame, E_PC_REGNUM);
c906108c 934 else
435e042a 935 return v850_find_callers_reg (fi, E_RP_REGNUM);
c906108c
SS		 936}
937
c906108c
SS		 938
939/* Function: fix_call_dummy
940 Pokes the callee function's address into the CALL_DUMMY assembly stub.
941 Assumes that the CALL_DUMMY looks like this:
c5aa993b
JM		 942 jarl <offset24>, r31
943 trap
944 */
c906108c 945
435e042a 946void
fba45db2 947v850_fix_call_dummy (char *dummy, CORE_ADDR sp, CORE_ADDR fun, int nargs,
ea7c478f 948 struct value **args, struct type *type, int gcc_p)
c906108c
SS		 949{
950 long offset24;
951
952 offset24 = (long) fun - (long) entry_point_address ();
953 offset24 &= 0x3fffff;
954 offset24 |= 0xff800000; /* jarl <offset24>, r31 */
955
c5aa993b
JM		 956 store_unsigned_integer ((unsigned int *) &dummy[2], 2, offset24 & 0xffff);
957 store_unsigned_integer ((unsigned int *) &dummy[0], 2, offset24 >> 16);
435e042a
CV		 958}
959
960static CORE_ADDR
961v850_saved_pc_after_call (struct frame_info *ignore)
962{
963 return read_register (E_RP_REGNUM);
964}
965
966static void
967v850_extract_return_value (struct type *type, char *regbuf, char *valbuf)
968{
969 memcpy (valbuf, regbuf + v850_register_byte (E_V0_REGNUM),
970 TYPE_LENGTH (type));
971}
972
973const static unsigned char *
974v850_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
975{
976 static unsigned char breakpoint[] = { 0x85, 0x05 };
977 *lenptr = sizeof (breakpoint);
978 return breakpoint;
979}
980
981static CORE_ADDR
982v850_extract_struct_value_address (char *regbuf)
983{
984 return extract_address (regbuf + v850_register_byte (E_V0_REGNUM),
985 v850_register_raw_size (E_V0_REGNUM));
986}
987
988static void
989v850_store_return_value (struct type *type, char *valbuf)
990{
991 write_register_bytes(v850_register_byte (E_V0_REGNUM), valbuf,
992 TYPE_LENGTH (type));
993}
994
995static void
996v850_frame_init_saved_regs (struct frame_info *fi)
997{
998 struct prologue_info pi;
999 struct pifsr pifsrs[E_NUM_REGS + 1], *pifsr;
1000 CORE_ADDR func_addr, func_end;
1001
1002 if (!fi->saved_regs)
1003 {
1004 frame_saved_regs_zalloc (fi);
1005
1006 /* The call dummy doesn't save any registers on the stack, so we
1007 can return now. */
1008 if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
1009 return;
1010
1011 /* Find the beginning of this function, so we can analyze its
1012 prologue. */
1013 if (find_pc_partial_function (fi->pc, NULL, &func_addr, &func_end))
1014 {
1015 pi.pifsrs = pifsrs;
1016
1017 v850_scan_prologue (fi->pc, &pi);
1018
1019 if (!fi->next && pi.framereg == E_SP_REGNUM)
1020 fi->frame = read_register (pi.framereg) - pi.frameoffset;
1021
1022 for (pifsr = pifsrs; pifsr->framereg; pifsr++)
1023 {
1024 fi->saved_regs[pifsr->reg] = pifsr->offset + fi->frame;
1025
1026 if (pifsr->framereg == E_SP_REGNUM)
1027 fi->saved_regs[pifsr->reg] += pi.frameoffset;
1028 }
1029 }
1030 /* Else we're out of luck (can't debug completely stripped code).
1031 FIXME. */
1032 }
1033}
1034
1035/* Function: init_extra_frame_info
1036 Setup the frame's frame pointer, pc, and frame addresses for saved
1037 registers. Most of the work is done in scan_prologue().
1038
1039 Note that when we are called for the last frame (currently active frame),
1040 that fi->pc and fi->frame will already be setup. However, fi->frame will
1041 be valid only if this routine uses FP. For previous frames, fi-frame will
1042 always be correct (since that is derived from v850_frame_chain ()).
1043
1044 We can be called with the PC in the call dummy under two circumstances.
1045 First, during normal backtracing, second, while figuring out the frame
1046 pointer just prior to calling the target function (see run_stack_dummy). */
1047
1048static void
1049v850_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1050{
1051 struct prologue_info pi;
1052
1053 if (fi->next)
1054 fi->pc = FRAME_SAVED_PC (fi->next);
1055
1056 v850_frame_init_saved_regs (fi);
1057}
1058
1059static void
1060v850_store_struct_return (CORE_ADDR a, CORE_ADDR b)
1061{
1062}
1063
1064static CORE_ADDR
1065v850_target_read_fp (void)
1066{
1067 return read_register (E_FP_RAW_REGNUM);
c906108c
SS		 1068}
1069
6ed14b0e
CV		 1070static struct gdbarch *
1071v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
c906108c 1072{
435e042a 1073 static LONGEST call_dummy_words[1] = { 0 };
6ed14b0e
CV		 1074 struct gdbarch_tdep *tdep = NULL;
1075 struct gdbarch *gdbarch;
1076 int i;
1077
1078 /* find a candidate among the list of pre-declared architectures. */
1079 arches = gdbarch_list_lookup_by_info (arches, &info);
1080 if (arches != NULL)
1081 return (arches->gdbarch);
c906108c 1082
6ed14b0e
CV		 1083#if 0
1084 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1085#endif
1086
435e042a 1087 /* Change the register names based on the current machine type. */
6ed14b0e 1088 if (info.bfd_arch_info->arch != bfd_arch_v850)
c906108c
SS		 1089 return 0;
1090
6ed14b0e
CV		 1091 gdbarch = gdbarch_alloc (&info, 0);
1092
c906108c
SS		 1093 for (i = 0; v850_processor_type_table[i].regnames != NULL; i++)
1094 {
6ed14b0e 1095 if (v850_processor_type_table[i].mach == info.bfd_arch_info->mach)
435e042a
CV		 1096 {
1097 v850_register_names = v850_processor_type_table[i].regnames;
1098 tm_print_insn_info.mach = info.bfd_arch_info->mach;
1099 break;
1100 }
c906108c
SS		 1101 }
1102
435e042a
CV		 1103 /*
1104 * Basic register fields and methods.
1105 */
1106 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1107 set_gdbarch_num_pseudo_regs (gdbarch, 0);
1108 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1109 set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
1110 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1111 set_gdbarch_register_name (gdbarch, v850_register_name);
1112 set_gdbarch_register_size (gdbarch, v850_reg_size);
1113 set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE);
1114 set_gdbarch_register_byte (gdbarch, v850_register_byte);
1115 set_gdbarch_register_raw_size (gdbarch, v850_register_raw_size);
1116 set_gdbarch_max_register_raw_size (gdbarch, v850_reg_size);
1117 set_gdbarch_register_virtual_size (gdbarch, v850_register_raw_size);
1118 set_gdbarch_max_register_virtual_size (gdbarch, v850_reg_size);
1119 set_gdbarch_register_virtual_type (gdbarch, v850_reg_virtual_type);
1120
1121 set_gdbarch_read_fp (gdbarch, v850_target_read_fp);
1122
1123 /*
1124 * Frame Info
1125 */
1126 set_gdbarch_init_extra_frame_info (gdbarch, v850_init_extra_frame_info);
1127 set_gdbarch_frame_init_saved_regs (gdbarch, v850_frame_init_saved_regs);
1128 set_gdbarch_frame_chain (gdbarch, v850_frame_chain);
1129 set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
1130 set_gdbarch_saved_pc_after_call (gdbarch, v850_saved_pc_after_call);
1131 set_gdbarch_frame_saved_pc (gdbarch, v850_frame_saved_pc);
1132 set_gdbarch_skip_prologue (gdbarch, v850_skip_prologue);
1133 set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
1134 set_gdbarch_frame_args_address (gdbarch, default_frame_address);
1135 set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
1136
1137 /*
1138 * Miscelany
1139 */
1140 /* Stack grows up. */
1141 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1142 /* PC stops zero byte after a trap instruction
1143 (which means: exactly on trap instruction). */
1144 set_gdbarch_decr_pc_after_break (gdbarch, 0);
1145 /* This value is almost never non-zero... */
1146 set_gdbarch_function_start_offset (gdbarch, 0);
1147 /* This value is almost never non-zero... */
1148 set_gdbarch_frame_args_skip (gdbarch, 0);
1149 /* OK to default this value to 'unknown'. */
1150 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1151 /* W/o prototype, coerce float args to double. */
1152 set_gdbarch_coerce_float_to_double (gdbarch, standard_coerce_float_to_double);
1153
1154 /*
1155 * Call Dummies
1156 *
1157 * These values and methods are used when gdb calls a target function. */
1158 set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
1159 set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1160 set_gdbarch_push_return_address (gdbarch, v850_push_return_address);
1161 set_gdbarch_extract_return_value (gdbarch, v850_extract_return_value);
1162 set_gdbarch_push_arguments (gdbarch, v850_push_arguments);
1163 set_gdbarch_pop_frame (gdbarch, v850_pop_frame);
1164 set_gdbarch_store_struct_return (gdbarch, v850_store_struct_return);
1165 set_gdbarch_store_return_value (gdbarch, v850_store_return_value);
1166 set_gdbarch_extract_struct_value_address (gdbarch, v850_extract_struct_value_address);
1167 set_gdbarch_use_struct_convention (gdbarch, v850_use_struct_convention);
1168 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1169 set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1170 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1171 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1172 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1173 set_gdbarch_call_dummy_length (gdbarch, 0);
1174 set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
1175 set_gdbarch_call_dummy_p (gdbarch, 1);
1176 set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
1177 set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
1178 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1179 /* set_gdbarch_call_dummy_stack_adjust */
1180 set_gdbarch_fix_call_dummy (gdbarch, v850_fix_call_dummy);
1181 set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
1182
1183 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1184 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1185 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1186 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1187
1188 set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
1189
6ed14b0e 1190 return gdbarch;
c906108c
SS		 1191}
1192
1193void
fba45db2 1194_initialize_v850_tdep (void)
c906108c
SS		 1195{
1196 tm_print_insn = print_insn_v850;
6ed14b0e 1197 register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);
c906108c 1198}
GDB Binutils - Deliverables
This page took 0.293359 seconds and 4 git commands to generate.