gdb/
[external/binutils.git] / gdb / v850-tdep.c
1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
2
3    Copyright (C) 1996, 1998-2005, 2007-2012 Free Software Foundation,
4    Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21 #include "defs.h"
22 #include "frame.h"
23 #include "frame-base.h"
24 #include "trad-frame.h"
25 #include "frame-unwind.h"
26 #include "dwarf2-frame.h"
27 #include "gdbtypes.h"
28 #include "inferior.h"
29 #include "gdb_string.h"
30 #include "gdb_assert.h"
31 #include "gdbcore.h"
32 #include "arch-utils.h"
33 #include "regcache.h"
34 #include "dis-asm.h"
35 #include "osabi.h"
36
37 enum
38   {
39     E_R0_REGNUM,
40     E_R1_REGNUM,
41     E_R2_REGNUM,
42     E_R3_REGNUM, E_SP_REGNUM = E_R3_REGNUM,
43     E_R4_REGNUM,
44     E_R5_REGNUM,
45     E_R6_REGNUM, E_ARG0_REGNUM = E_R6_REGNUM,
46     E_R7_REGNUM,
47     E_R8_REGNUM,
48     E_R9_REGNUM, E_ARGLAST_REGNUM = E_R9_REGNUM,
49     E_R10_REGNUM, E_V0_REGNUM = E_R10_REGNUM,
50     E_R11_REGNUM, E_V1_REGNUM = E_R11_REGNUM,
51     E_R12_REGNUM,
52     E_R13_REGNUM,
53     E_R14_REGNUM,
54     E_R15_REGNUM,
55     E_R16_REGNUM,
56     E_R17_REGNUM,
57     E_R18_REGNUM,
58     E_R19_REGNUM,
59     E_R20_REGNUM,
60     E_R21_REGNUM,
61     E_R22_REGNUM,
62     E_R23_REGNUM,
63     E_R24_REGNUM,
64     E_R25_REGNUM,
65     E_R26_REGNUM,
66     E_R27_REGNUM,
67     E_R28_REGNUM,
68     E_R29_REGNUM, E_FP_REGNUM = E_R29_REGNUM,
69     E_R30_REGNUM, E_EP_REGNUM = E_R30_REGNUM,
70     E_R31_REGNUM, E_LP_REGNUM = E_R31_REGNUM,
71     E_R32_REGNUM, E_SR0_REGNUM = E_R32_REGNUM,
72     E_R33_REGNUM,
73     E_R34_REGNUM,
74     E_R35_REGNUM,
75     E_R36_REGNUM,
76     E_R37_REGNUM, E_PS_REGNUM = E_R37_REGNUM,
77     E_R38_REGNUM,
78     E_R39_REGNUM,
79     E_R40_REGNUM,
80     E_R41_REGNUM,
81     E_R42_REGNUM,
82     E_R43_REGNUM,
83     E_R44_REGNUM,
84     E_R45_REGNUM,
85     E_R46_REGNUM,
86     E_R47_REGNUM,
87     E_R48_REGNUM,
88     E_R49_REGNUM,
89     E_R50_REGNUM,
90     E_R51_REGNUM,
91     E_R52_REGNUM, E_CTBP_REGNUM = E_R52_REGNUM,
92     E_R53_REGNUM,
93     E_R54_REGNUM,
94     E_R55_REGNUM,
95     E_R56_REGNUM,
96     E_R57_REGNUM,
97     E_R58_REGNUM,
98     E_R59_REGNUM,
99     E_R60_REGNUM,
100     E_R61_REGNUM,
101     E_R62_REGNUM,
102     E_R63_REGNUM,
103     E_R64_REGNUM, E_PC_REGNUM = E_R64_REGNUM,
104     E_R65_REGNUM,
105     E_NUM_OF_V850_REGS,
106     E_NUM_OF_V850E_REGS = E_NUM_OF_V850_REGS,
107
108     /* mpu0 system registers */
109     E_R66_REGNUM = E_NUM_OF_V850_REGS,
110     E_R67_REGNUM,
111     E_R68_REGNUM,
112     E_R69_REGNUM,
113     E_R70_REGNUM,
114     E_R71_REGNUM,
115     E_R72_REGNUM,
116     E_R73_REGNUM,
117     E_R74_REGNUM,
118     E_R75_REGNUM,
119     E_R76_REGNUM,
120     E_R77_REGNUM,
121     E_R78_REGNUM,
122     E_R79_REGNUM,
123     E_R80_REGNUM,
124     E_R81_REGNUM,
125     E_R82_REGNUM,
126     E_R83_REGNUM,
127     E_R84_REGNUM,
128     E_R85_REGNUM,
129     E_R86_REGNUM,
130     E_R87_REGNUM,
131     E_R88_REGNUM,
132     E_R89_REGNUM,
133     E_R90_REGNUM,
134     E_R91_REGNUM,
135     E_R92_REGNUM,
136     E_R93_REGNUM,
137
138     /* mpu1 system registers */
139
140     E_R94_REGNUM,
141     E_R95_REGNUM,
142     E_R96_REGNUM,
143     E_R97_REGNUM,
144     E_R98_REGNUM,
145     E_R99_REGNUM,
146     E_R100_REGNUM,
147     E_R101_REGNUM,
148     E_R102_REGNUM,
149     E_R103_REGNUM,
150     E_R104_REGNUM,
151     E_R105_REGNUM,
152     E_R106_REGNUM,
153     E_R107_REGNUM,
154     E_R108_REGNUM,
155     E_R109_REGNUM,
156     E_R110_REGNUM,
157     E_R111_REGNUM,
158     E_R112_REGNUM,
159     E_R113_REGNUM,
160     E_R114_REGNUM,
161     E_R115_REGNUM,
162     E_R116_REGNUM,
163     E_R117_REGNUM,
164     E_R118_REGNUM,
165     E_R119_REGNUM,
166     E_R120_REGNUM,
167     E_R121_REGNUM,
168
169     /* fpu system registers */
170     E_R122_REGNUM,
171     E_R123_REGNUM,
172     E_R124_REGNUM,
173     E_R125_REGNUM,
174     E_R126_REGNUM,
175     E_R127_REGNUM,
176     E_R128_REGNUM, E_FPSR_REGNUM = E_R128_REGNUM,
177     E_R129_REGNUM, E_FPEPC_REGNUM = E_R129_REGNUM,
178     E_R130_REGNUM, E_FPST_REGNUM = E_R130_REGNUM,
179     E_R131_REGNUM, E_FPCC_REGNUM = E_R131_REGNUM,
180     E_R132_REGNUM, E_FPCFG_REGNUM = E_R132_REGNUM,
181     E_R133_REGNUM,
182     E_R134_REGNUM,
183     E_R135_REGNUM,
184     E_R136_REGNUM,
185     E_R137_REGNUM,
186     E_R138_REGNUM,
187     E_R139_REGNUM,
188     E_R140_REGNUM,
189     E_R141_REGNUM,
190     E_R142_REGNUM,
191     E_R143_REGNUM,
192     E_R144_REGNUM,
193     E_R145_REGNUM,
194     E_R146_REGNUM,
195     E_R147_REGNUM,
196     E_R148_REGNUM,
197     E_NUM_REGS
198   };
199
200 enum
201 {
202   v850_reg_size = 4
203 };
204
205 /* Size of return datatype which fits into all return registers.  */
206 enum
207 {
208   E_MAX_RETTYPE_SIZE_IN_REGS = 2 * v850_reg_size
209 };
210
211 struct v850_frame_cache
212
213   /* Base address.  */
214   CORE_ADDR base;
215   LONGEST sp_offset;
216   CORE_ADDR pc;
217   
218   /* Flag showing that a frame has been created in the prologue code.  */
219   int uses_fp;
220   
221   /* Saved registers.  */
222   struct trad_frame_saved_reg *saved_regs;
223 };
224
225 /* Info gleaned from scanning a function's prologue.  */
226 struct pifsr            /* Info about one saved register.  */
227 {
228   int offset;           /* Offset from sp or fp.  */
229   int cur_frameoffset;  /* Current frameoffset.  */
230   int reg;              /* Saved register number.  */
231 };
232
233 static const char *
234 v850_register_name (struct gdbarch *gdbarch, int regnum)
235 {
236   static const char *v850_reg_names[] =
237   { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 
238     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 
239     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 
240     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
241     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
242     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
243     "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
244     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
245     "pc", "fp"
246   };
247   if (regnum < 0 || regnum > E_NUM_OF_V850_REGS)
248     return NULL;
249   return v850_reg_names[regnum];
250 }
251
252 static const char *
253 v850e_register_name (struct gdbarch *gdbarch, int regnum)
254 {
255   static const char *v850e_reg_names[] =
256   {
257     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
258     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
259     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
260     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
261     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
262     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
263     "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
264     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
265     "pc", "fp"
266   };
267   if (regnum < 0 || regnum > E_NUM_OF_V850E_REGS)
268     return NULL;
269   return v850e_reg_names[regnum];
270 }
271
272 static const char *
273 v850e2_register_name (struct gdbarch *gdbarch, int regnum)
274 {
275   static const char *v850e2_reg_names[] =
276   {
277     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
278     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
279     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
280     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
281
282     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
283     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
284     "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
285     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
286     "pc", "fp"
287
288     /* mpu0 system registers */
289     "vip", "sr33", "sr34", "sr35", "vmecr", "vmtid", "vmadr", "sr39",
290     "vpecr", "vptid", "vpadr", "sr43", "vdecr", "vdtid", "sr46", "sr47",
291     "sr48", "sr49", "sr50", "sr51", "sr52", "sr53", "sr54", "sr55",
292     "sr56", "sr57", "sr58", "sr59",
293
294     /* mpu1 system registers */
295     "mpm", "mpc", "tid", "ppa", "ppm", "ppc", "dcc", "dcv0",
296     "dcv1", "sr69", "spal", "spau", "ipa0l", "ipa0u", "ipa1l", "ipa1u",
297     "iap2l", "ipa2u", "ipa3l", "ipa3u", "dpa0l", "dpa0u", "dpa1l", "dpa1u",
298     "dpa2l", "dpa2u", "dpa3l", "dpa3u",
299
300     /* fpu system registers */
301     "sr88", "sr89", "sr90", "sr91", "sr92", "sr93", "fpsr", "fpepc",
302     "fpst", "fpcc", "fpcfg", "sr99", "sr100", "sr101", "sr102", "sr103",
303     "sr104", "sr105", "sr106", "sr107", "sr108", "sr109", "sr110", "sr111",
304     "sr112", "sr113", "sr114", "sr115"
305   };
306   if (regnum < 0 || regnum >= E_NUM_REGS)
307     return NULL;
308   return v850e2_reg_names[regnum];
309 }
310
311 /* Returns the default type for register N.  */
312
313 static struct type *
314 v850_register_type (struct gdbarch *gdbarch, int regnum)
315 {
316   if (regnum == E_PC_REGNUM)
317     return builtin_type (gdbarch)->builtin_func_ptr;
318   return builtin_type (gdbarch)->builtin_int32;
319 }
320
321 static int
322 v850_type_is_scalar (struct type *t)
323 {
324   return (TYPE_CODE (t) != TYPE_CODE_STRUCT
325           && TYPE_CODE (t) != TYPE_CODE_UNION
326           && TYPE_CODE (t) != TYPE_CODE_ARRAY);
327 }
328
329 /* Should call_function allocate stack space for a struct return?  */
330 static int
331 v850_use_struct_convention (struct type *type)
332 {
333   int i;
334   struct type *fld_type, *tgt_type;
335
336   /* 1. The value is greater than 8 bytes -> returned by copying.  */
337   if (TYPE_LENGTH (type) > 8)
338     return 1;
339
340   /* 2. The value is a single basic type -> returned in register.  */
341   if (v850_type_is_scalar (type))
342     return 0;
343
344   /* The value is a structure or union with a single element and that
345      element is either a single basic type or an array of a single basic
346      type whose size is greater than or equal to 4 -> returned in register.  */
347   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
348        || TYPE_CODE (type) == TYPE_CODE_UNION)
349        && TYPE_NFIELDS (type) == 1)
350     {
351       fld_type = TYPE_FIELD_TYPE (type, 0);
352       if (v850_type_is_scalar (fld_type) && TYPE_LENGTH (fld_type) >= 4)
353         return 0;
354
355       if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
356         {
357           tgt_type = TYPE_TARGET_TYPE (fld_type);
358           if (v850_type_is_scalar (tgt_type) && TYPE_LENGTH (tgt_type) >= 4)
359             return 0;
360         }
361     }
362
363   /* The value is a structure whose first element is an integer or a float,
364      and which contains no arrays of more than two elements -> returned in
365      register.  */
366   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
367       && v850_type_is_scalar (TYPE_FIELD_TYPE (type, 0))
368       && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
369     {
370       for (i = 1; i < TYPE_NFIELDS (type); ++i)
371         {
372           fld_type = TYPE_FIELD_TYPE (type, 0);
373           if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
374             {
375               tgt_type = TYPE_TARGET_TYPE (fld_type);
376               if (TYPE_LENGTH (fld_type) >= 0 && TYPE_LENGTH (tgt_type) >= 0
377                   && TYPE_LENGTH (fld_type) / TYPE_LENGTH (tgt_type) > 2)
378                 return 1;
379             }
380         }
381       return 0;
382     }
383     
384   /* The value is a union which contains at least one field which
385      would be returned in registers according to these rules ->
386      returned in register.  */
387   if (TYPE_CODE (type) == TYPE_CODE_UNION)
388     {
389       for (i = 0; i < TYPE_NFIELDS (type); ++i)
390         {
391           fld_type = TYPE_FIELD_TYPE (type, 0);
392           if (!v850_use_struct_convention (fld_type))
393             return 0;
394         }
395     }
396
397   return 1;
398 }
399
400 /* Structure for mapping bits in register lists to register numbers.  */
401 struct reg_list
402 {
403   long mask;
404   int regno;
405 };
406
407 /* Helper function for v850_scan_prologue to handle prepare instruction.  */
408
409 static void
410 v850_handle_prepare (int insn, int insn2, CORE_ADDR * current_pc_ptr,
411                      struct v850_frame_cache *pi, struct pifsr **pifsr_ptr)
412 {
413   CORE_ADDR current_pc = *current_pc_ptr;
414   struct pifsr *pifsr = *pifsr_ptr;
415   long next = insn2 & 0xffff;
416   long list12 = ((insn & 1) << 16) + (next & 0xffe0);
417   long offset = (insn & 0x3e) << 1;
418   static struct reg_list reg_table[] =
419   {
420     {0x00800, 20},              /* r20 */
421     {0x00400, 21},              /* r21 */
422     {0x00200, 22},              /* r22 */
423     {0x00100, 23},              /* r23 */
424     {0x08000, 24},              /* r24 */
425     {0x04000, 25},              /* r25 */
426     {0x02000, 26},              /* r26 */
427     {0x01000, 27},              /* r27 */
428     {0x00080, 28},              /* r28 */
429     {0x00040, 29},              /* r29 */
430     {0x10000, 30},              /* ep */
431     {0x00020, 31},              /* lp */
432     {0, 0}                      /* end of table */
433   };
434   int i;
435
436   if ((next & 0x1f) == 0x0b)            /* skip imm16 argument */
437     current_pc += 2;
438   else if ((next & 0x1f) == 0x13)       /* skip imm16 argument */
439     current_pc += 2;
440   else if ((next & 0x1f) == 0x1b)       /* skip imm32 argument */
441     current_pc += 4;
442
443   /* Calculate the total size of the saved registers, and add it to the
444      immediate value used to adjust SP.  */
445   for (i = 0; reg_table[i].mask != 0; i++)
446     if (list12 & reg_table[i].mask)
447       offset += v850_reg_size;
448   pi->sp_offset -= offset;
449
450   /* Calculate the offsets of the registers relative to the value the SP
451      will have after the registers have been pushed and the imm5 value has
452      been subtracted from it.  */
453   if (pifsr)
454     {
455       for (i = 0; reg_table[i].mask != 0; i++)
456         {
457           if (list12 & reg_table[i].mask)
458             {
459               int reg = reg_table[i].regno;
460               offset -= v850_reg_size;
461               pifsr->reg = reg;
462               pifsr->offset = offset;
463               pifsr->cur_frameoffset = pi->sp_offset;
464               pifsr++;
465             }
466         }
467     }
468
469   /* Set result parameters.  */
470   *current_pc_ptr = current_pc;
471   *pifsr_ptr = pifsr;
472 }
473
474
475 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
476    The SR bit of the register list is not supported.  gcc does not generate
477    this bit.  */
478
479 static void
480 v850_handle_pushm (int insn, int insn2, struct v850_frame_cache *pi,
481                    struct pifsr **pifsr_ptr)
482 {
483   struct pifsr *pifsr = *pifsr_ptr;
484   long list12 = ((insn & 0x0f) << 16) + (insn2 & 0xfff0);
485   long offset = 0;
486   static struct reg_list pushml_reg_table[] =
487   {
488     {0x80000, E_PS_REGNUM},     /* PSW */
489     {0x40000, 1},               /* r1 */
490     {0x20000, 2},               /* r2 */
491     {0x10000, 3},               /* r3 */
492     {0x00800, 4},               /* r4 */
493     {0x00400, 5},               /* r5 */
494     {0x00200, 6},               /* r6 */
495     {0x00100, 7},               /* r7 */
496     {0x08000, 8},               /* r8 */
497     {0x04000, 9},               /* r9 */
498     {0x02000, 10},              /* r10 */
499     {0x01000, 11},              /* r11 */
500     {0x00080, 12},              /* r12 */
501     {0x00040, 13},              /* r13 */
502     {0x00020, 14},              /* r14 */
503     {0x00010, 15},              /* r15 */
504     {0, 0}                      /* end of table */
505   };
506   static struct reg_list pushmh_reg_table[] =
507   {
508     {0x80000, 16},              /* r16 */
509     {0x40000, 17},              /* r17 */
510     {0x20000, 18},              /* r18 */
511     {0x10000, 19},              /* r19 */
512     {0x00800, 20},              /* r20 */
513     {0x00400, 21},              /* r21 */
514     {0x00200, 22},              /* r22 */
515     {0x00100, 23},              /* r23 */
516     {0x08000, 24},              /* r24 */
517     {0x04000, 25},              /* r25 */
518     {0x02000, 26},              /* r26 */
519     {0x01000, 27},              /* r27 */
520     {0x00080, 28},              /* r28 */
521     {0x00040, 29},              /* r29 */
522     {0x00010, 30},              /* r30 */
523     {0x00020, 31},              /* r31 */
524     {0, 0}                      /* end of table */
525   };
526   struct reg_list *reg_table;
527   int i;
528
529   /* Is this a pushml or a pushmh?  */
530   if ((insn2 & 7) == 1)
531     reg_table = pushml_reg_table;
532   else
533     reg_table = pushmh_reg_table;
534
535   /* Calculate the total size of the saved registers, and add it to the
536      immediate value used to adjust SP.  */
537   for (i = 0; reg_table[i].mask != 0; i++)
538     if (list12 & reg_table[i].mask)
539       offset += v850_reg_size;
540   pi->sp_offset -= offset;
541
542   /* Calculate the offsets of the registers relative to the value the SP
543      will have after the registers have been pushed and the imm5 value is
544      subtracted from it.  */
545   if (pifsr)
546     {
547       for (i = 0; reg_table[i].mask != 0; i++)
548         {
549           if (list12 & reg_table[i].mask)
550             {
551               int reg = reg_table[i].regno;
552               offset -= v850_reg_size;
553               pifsr->reg = reg;
554               pifsr->offset = offset;
555               pifsr->cur_frameoffset = pi->sp_offset;
556               pifsr++;
557             }
558         }
559     }
560
561   /* Set result parameters.  */
562   *pifsr_ptr = pifsr;
563 }
564
565 /* Helper function to evaluate if register is one of the "save" registers.
566    This allows to simplify conditionals in v850_analyze_prologue a lot.  */
567
568 static int
569 v850_is_save_register (int reg)
570 {
571  /* The caller-save registers are R2, R20 - R29 and R31.  All other
572     registers are either special purpose (PC, SP), argument registers,
573     or just considered free for use in the caller.  */
574  return reg == E_R2_REGNUM
575         || (reg >= E_R20_REGNUM && reg <= E_R29_REGNUM)
576         || reg == E_R31_REGNUM;
577 }
578
579 /* Scan the prologue of the function that contains PC, and record what
580    we find in PI.  Returns the pc after the prologue.  Note that the
581    addresses saved in frame->saved_regs are just frame relative (negative
582    offsets from the frame pointer).  This is because we don't know the
583    actual value of the frame pointer yet.  In some circumstances, the
584    frame pointer can't be determined till after we have scanned the
585    prologue.  */
586
587 static CORE_ADDR
588 v850_analyze_prologue (struct gdbarch *gdbarch,
589                        CORE_ADDR func_addr, CORE_ADDR pc,
590                        struct v850_frame_cache *pi, ULONGEST ctbp)
591 {
592   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
593   CORE_ADDR prologue_end, current_pc;
594   struct pifsr pifsrs[E_NUM_REGS + 1];
595   struct pifsr *pifsr, *pifsr_tmp;
596   int fp_used;
597   int ep_used;
598   int reg;
599   CORE_ADDR save_pc, save_end;
600   int regsave_func_p;
601   int r12_tmp;
602
603   memset (&pifsrs, 0, sizeof pifsrs);
604   pifsr = &pifsrs[0];
605
606   prologue_end = pc;
607
608   /* Now, search the prologue looking for instructions that setup fp, save
609      rp, adjust sp and such.  We also record the frame offset of any saved
610      registers.  */
611
612   pi->sp_offset = 0;
613   pi->uses_fp = 0;
614   ep_used = 0;
615   regsave_func_p = 0;
616   save_pc = 0;
617   save_end = 0;
618   r12_tmp = 0;
619
620   for (current_pc = func_addr; current_pc < prologue_end;)
621     {
622       int insn;
623       int insn2 = -1; /* dummy value */
624
625       insn = read_memory_integer (current_pc, 2, byte_order);
626       current_pc += 2;
627       if ((insn & 0x0780) >= 0x0600)    /* Four byte instruction?  */
628         {
629           insn2 = read_memory_integer (current_pc, 2, byte_order);
630           current_pc += 2;
631         }
632
633       if ((insn & 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p)
634         {                       /* jarl <func>,10 */
635           long low_disp = insn2 & ~(long) 1;
636           long disp = (((((insn & 0x3f) << 16) + low_disp)
637                         & ~(long) 1) ^ 0x00200000) - 0x00200000;
638
639           save_pc = current_pc;
640           save_end = prologue_end;
641           regsave_func_p = 1;
642           current_pc += disp - 4;
643           prologue_end = (current_pc
644                           + (2 * 3)     /* moves to/from ep */
645                           + 4           /* addi <const>,sp,sp */
646                           + 2           /* jmp [r10] */
647                           + (2 * 12)    /* sst.w to save r2, r20-r29, r31 */
648                           + 20);        /* slop area */
649         }
650       else if ((insn & 0xffc0) == 0x0200 && !regsave_func_p)
651         {                       /* callt <imm6> */
652           long adr = ctbp + ((insn & 0x3f) << 1);
653
654           save_pc = current_pc;
655           save_end = prologue_end;
656           regsave_func_p = 1;
657           current_pc = ctbp + (read_memory_unsigned_integer (adr, 2, byte_order)
658                                & 0xffff);
659           prologue_end = (current_pc
660                           + (2 * 3)     /* prepare list2,imm5,sp/imm */
661                           + 4           /* ctret */
662                           + 20);        /* slop area */
663           continue;
664         }
665       else if ((insn & 0xffc0) == 0x0780)       /* prepare list2,imm5 */
666         {
667           v850_handle_prepare (insn, insn2, &current_pc, pi, &pifsr);
668           continue;
669         }
670       else if (insn == 0x07e0 && regsave_func_p && insn2 == 0x0144)
671         {                       /* ctret after processing register save.  */
672           current_pc = save_pc;
673           prologue_end = save_end;
674           regsave_func_p = 0;
675           continue;
676         }
677       else if ((insn & 0xfff0) == 0x07e0 && (insn2 & 5) == 1)
678         {                       /* pushml, pushmh */
679           v850_handle_pushm (insn, insn2, pi, &pifsr);
680           continue;
681         }
682       else if ((insn & 0xffe0) == 0x0060 && regsave_func_p)
683         {                       /* jmp after processing register save.  */
684           current_pc = save_pc;
685           prologue_end = save_end;
686           regsave_func_p = 0;
687           continue;
688         }
689       else if ((insn & 0x07c0) == 0x0780        /* jarl or jr */
690                || (insn & 0xffe0) == 0x0060     /* jmp */
691                || (insn & 0x0780) == 0x0580)    /* branch */
692         {
693           break;                /* Ran into end of prologue.  */
694         }
695
696       else if ((insn & 0xffe0) == ((E_SP_REGNUM << 11) | 0x0240))
697         /* add <imm>,sp */
698         pi->sp_offset += ((insn & 0x1f) ^ 0x10) - 0x10;
699       else if (insn == ((E_SP_REGNUM << 11) | 0x0600 | E_SP_REGNUM))
700         /* addi <imm>,sp,sp */
701         pi->sp_offset += insn2;
702       else if (insn == ((E_FP_REGNUM << 11) | 0x0000 | E_SP_REGNUM))
703         /* mov sp,fp */
704         pi->uses_fp = 1;
705       else if (insn == ((E_R12_REGNUM << 11) | 0x0640 | E_R0_REGNUM))
706         /* movhi hi(const),r0,r12 */
707         r12_tmp = insn2 << 16;
708       else if (insn == ((E_R12_REGNUM << 11) | 0x0620 | E_R12_REGNUM))
709         /* movea lo(const),r12,r12 */
710         r12_tmp += insn2;
711       else if (insn == ((E_SP_REGNUM << 11) | 0x01c0 | E_R12_REGNUM) && r12_tmp)
712         /* add r12,sp */
713         pi->sp_offset += r12_tmp;
714       else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_SP_REGNUM))
715         /* mov sp,ep */
716         ep_used = 1;
717       else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_R1_REGNUM))
718         /* mov r1,ep */
719         ep_used = 0;
720       else if (((insn & 0x07ff) == (0x0760 | E_SP_REGNUM)       
721                 || (pi->uses_fp
722                     && (insn & 0x07ff) == (0x0760 | E_FP_REGNUM)))
723                && pifsr
724                && v850_is_save_register (reg = (insn >> 11) & 0x1f))
725         {
726           /* st.w <reg>,<offset>[sp] or st.w <reg>,<offset>[fp] */
727           pifsr->reg = reg;
728           pifsr->offset = insn2 & ~1;
729           pifsr->cur_frameoffset = pi->sp_offset;
730           pifsr++;
731         }
732       else if (ep_used
733                && ((insn & 0x0781) == 0x0501)
734                && pifsr
735                && v850_is_save_register (reg = (insn >> 11) & 0x1f))
736         {
737           /* sst.w <reg>,<offset>[ep] */
738           pifsr->reg = reg;
739           pifsr->offset = (insn & 0x007e) << 1;
740           pifsr->cur_frameoffset = pi->sp_offset;
741           pifsr++;
742         }
743     }
744
745   /* Fix up any offsets to the final offset.  If a frame pointer was created,
746      use it instead of the stack pointer.  */
747   for (pifsr_tmp = pifsrs; pifsr_tmp != pifsr; pifsr_tmp++)
748     {
749       pifsr_tmp->offset -= pi->sp_offset - pifsr_tmp->cur_frameoffset;
750       pi->saved_regs[pifsr_tmp->reg].addr = pifsr_tmp->offset;
751     }
752
753   return current_pc;
754 }
755
756 /* Return the address of the first code past the prologue of the function.  */
757
758 static CORE_ADDR
759 v850_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
760 {
761   CORE_ADDR func_addr, func_end;
762
763   /* See what the symbol table says.  */
764
765   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
766     {
767       struct symtab_and_line sal;
768
769       sal = find_pc_line (func_addr, 0);
770       if (sal.line != 0 && sal.end < func_end)
771         return sal.end;
772
773       /* Either there's no line info, or the line after the prologue is after
774          the end of the function.  In this case, there probably isn't a
775          prologue.  */
776       return pc;
777     }
778
779   /* We can't find the start of this function, so there's nothing we
780      can do.  */
781   return pc;
782 }
783
784 static CORE_ADDR
785 v850_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
786 {
787   return sp & ~3;
788 }
789
790 /* Setup arguments and LP for a call to the target.  First four args
791    go in R6->R9, subsequent args go into sp + 16 -> sp + ...  Structs
792    are passed by reference.  64 bit quantities (doubles and long longs)
793    may be split between the regs and the stack.  When calling a function
794    that returns a struct, a pointer to the struct is passed in as a secret
795    first argument (always in R6).
796
797    Stack space for the args has NOT been allocated: that job is up to us.  */
798
799 static CORE_ADDR
800 v850_push_dummy_call (struct gdbarch *gdbarch,
801                       struct value *function,
802                       struct regcache *regcache,
803                       CORE_ADDR bp_addr,
804                       int nargs,
805                       struct value **args,
806                       CORE_ADDR sp,
807                       int struct_return,
808                       CORE_ADDR struct_addr)
809 {
810   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
811   int argreg;
812   int argnum;
813   int len = 0;
814   int stack_offset;
815
816   /* The offset onto the stack at which we will start copying parameters
817      (after the registers are used up) begins at 16 rather than at zero.
818      That's how the ABI is defined, though there's no indication that these
819      16 bytes are used for anything, not even for saving incoming
820      argument registers.  */
821   stack_offset = 16;
822
823   /* Now make space on the stack for the args.  */
824   for (argnum = 0; argnum < nargs; argnum++)
825     len += ((TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3);
826   sp -= len + stack_offset;
827
828   argreg = E_ARG0_REGNUM;
829   /* The struct_return pointer occupies the first parameter register.  */
830   if (struct_return)
831     regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
832
833   /* Now load as many as possible of the first arguments into
834      registers, and push the rest onto the stack.  There are 16 bytes
835      in four registers available.  Loop thru args from first to last.  */
836   for (argnum = 0; argnum < nargs; argnum++)
837     {
838       int len;
839       gdb_byte *val;
840       gdb_byte valbuf[v850_reg_size];
841
842       if (!v850_type_is_scalar (value_type (*args))
843           && TYPE_LENGTH (value_type (*args)) > E_MAX_RETTYPE_SIZE_IN_REGS)
844         {
845           store_unsigned_integer (valbuf, 4, byte_order,
846                                   value_address (*args));
847           len = 4;
848           val = valbuf;
849         }
850       else
851         {
852           len = TYPE_LENGTH (value_type (*args));
853           val = (gdb_byte *) value_contents (*args);
854         }
855
856       while (len > 0)
857         if (argreg <= E_ARGLAST_REGNUM)
858           {
859             CORE_ADDR regval;
860
861             regval = extract_unsigned_integer (val, v850_reg_size, byte_order);
862             regcache_cooked_write_unsigned (regcache, argreg, regval);
863
864             len -= v850_reg_size;
865             val += v850_reg_size;
866             argreg++;
867           }
868         else
869           {
870             write_memory (sp + stack_offset, val, 4);
871
872             len -= 4;
873             val += 4;
874             stack_offset += 4;
875           }
876       args++;
877     }
878
879   /* Store return address.  */
880   regcache_cooked_write_unsigned (regcache, E_LP_REGNUM, bp_addr);
881
882   /* Update stack pointer.  */
883   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
884
885   return sp;
886 }
887
888 static void
889 v850_extract_return_value (struct type *type, struct regcache *regcache,
890                            gdb_byte *valbuf)
891 {
892   struct gdbarch *gdbarch = get_regcache_arch (regcache);
893   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
894   int len = TYPE_LENGTH (type);
895
896   if (len <= v850_reg_size)
897     {
898       ULONGEST val;
899
900       regcache_cooked_read_unsigned (regcache, E_V0_REGNUM, &val);
901       store_unsigned_integer (valbuf, len, byte_order, val);
902     }
903   else if (len <= 2 * v850_reg_size)
904     {
905       int i, regnum = E_V0_REGNUM;
906       gdb_byte buf[v850_reg_size];
907       for (i = 0; len > 0; i += 4, len -= 4)
908         {
909           regcache_raw_read (regcache, regnum++, buf);
910           memcpy (valbuf + i, buf, len > 4 ? 4 : len);
911         }
912     }
913 }
914
915 static void
916 v850_store_return_value (struct type *type, struct regcache *regcache,
917                          const gdb_byte *valbuf)
918 {
919   struct gdbarch *gdbarch = get_regcache_arch (regcache);
920   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
921   int len = TYPE_LENGTH (type);
922
923   if (len <= v850_reg_size)
924       regcache_cooked_write_unsigned
925         (regcache, E_V0_REGNUM,
926          extract_unsigned_integer (valbuf, len, byte_order));
927   else if (len <= 2 * v850_reg_size)
928     {
929       int i, regnum = E_V0_REGNUM;
930       for (i = 0; i < len; i += 4)
931         regcache_raw_write (regcache, regnum++, valbuf + i);
932     }
933 }
934
935 static enum return_value_convention
936 v850_return_value (struct gdbarch *gdbarch, struct value *function,
937                    struct type *type, struct regcache *regcache,
938                    gdb_byte *readbuf, const gdb_byte *writebuf)
939 {
940   if (v850_use_struct_convention (type))
941     return RETURN_VALUE_STRUCT_CONVENTION;
942   if (writebuf)
943     v850_store_return_value (type, regcache, writebuf);
944   else if (readbuf)
945     v850_extract_return_value (type, regcache, readbuf);
946   return RETURN_VALUE_REGISTER_CONVENTION;
947 }
948
949 const static unsigned char *
950 v850_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
951 {
952   static unsigned char breakpoint[] = { 0x85, 0x05 };
953   *lenptr = sizeof (breakpoint);
954   return breakpoint;
955 }
956
957 static struct v850_frame_cache *
958 v850_alloc_frame_cache (struct frame_info *this_frame)
959 {
960   struct v850_frame_cache *cache;
961   int i;
962
963   cache = FRAME_OBSTACK_ZALLOC (struct v850_frame_cache);
964   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
965
966   /* Base address.  */
967   cache->base = 0;
968   cache->sp_offset = 0;
969   cache->pc = 0;
970
971   /* Frameless until proven otherwise.  */
972   cache->uses_fp = 0;
973
974   return cache;
975 }
976
977 static struct v850_frame_cache *
978 v850_frame_cache (struct frame_info *this_frame, void **this_cache)
979 {
980   struct gdbarch *gdbarch = get_frame_arch (this_frame);
981   struct v850_frame_cache *cache;
982   CORE_ADDR current_pc;
983   int i;
984
985   if (*this_cache)
986     return *this_cache;
987
988   cache = v850_alloc_frame_cache (this_frame);
989   *this_cache = cache;
990
991   /* In principle, for normal frames, fp holds the frame pointer,
992      which holds the base address for the current stack frame.
993      However, for functions that don't need it, the frame pointer is
994      optional.  For these "frameless" functions the frame pointer is
995      actually the frame pointer of the calling frame.  */
996   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
997   if (cache->base == 0)
998     return cache;
999
1000   cache->pc = get_frame_func (this_frame);
1001   current_pc = get_frame_pc (this_frame);
1002   if (cache->pc != 0)
1003     {
1004       ULONGEST ctbp;
1005       ctbp = get_frame_register_unsigned (this_frame, E_CTBP_REGNUM);
1006       v850_analyze_prologue (gdbarch, cache->pc, current_pc, cache, ctbp);
1007     }
1008
1009   if (!cache->uses_fp)
1010     {
1011       /* We didn't find a valid frame, which means that CACHE->base
1012          currently holds the frame pointer for our calling frame.  If
1013          we're at the start of a function, or somewhere half-way its
1014          prologue, the function's frame probably hasn't been fully
1015          setup yet.  Try to reconstruct the base address for the stack
1016          frame by looking at the stack pointer.  For truly "frameless"
1017          functions this might work too.  */
1018       cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
1019     }
1020
1021   /* Now that we have the base address for the stack frame we can
1022      calculate the value of sp in the calling frame.  */
1023   trad_frame_set_value (cache->saved_regs, E_SP_REGNUM,
1024                         cache->base - cache->sp_offset);
1025
1026   /* Adjust all the saved registers such that they contain addresses
1027      instead of offsets.  */
1028   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
1029     if (trad_frame_addr_p (cache->saved_regs, i))
1030       cache->saved_regs[i].addr += cache->base;
1031
1032   /* The call instruction moves the caller's PC in the callee's LP.
1033      Since this is an unwind, do the reverse.  Copy the location of LP
1034      into PC (the address / regnum) so that a request for PC will be
1035      converted into a request for the LP.  */
1036
1037   cache->saved_regs[E_PC_REGNUM] = cache->saved_regs[E_LP_REGNUM];
1038
1039   return cache;
1040 }
1041
1042
1043 static struct value *
1044 v850_frame_prev_register (struct frame_info *this_frame,
1045                           void **this_cache, int regnum)
1046 {
1047   struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
1048
1049   gdb_assert (regnum >= 0);
1050
1051   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
1052 }
1053
1054 static void
1055 v850_frame_this_id (struct frame_info *this_frame, void **this_cache,
1056                     struct frame_id *this_id)
1057 {
1058   struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
1059
1060   /* This marks the outermost frame.  */
1061   if (cache->base == 0)
1062     return;
1063
1064   *this_id = frame_id_build (cache->saved_regs[E_SP_REGNUM].addr, cache->pc);
1065 }
1066
1067 static const struct frame_unwind v850_frame_unwind = {
1068   NORMAL_FRAME,
1069   default_frame_unwind_stop_reason,
1070   v850_frame_this_id,
1071   v850_frame_prev_register,
1072   NULL,
1073   default_frame_sniffer
1074 };
1075
1076 static CORE_ADDR
1077 v850_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1078 {
1079   return frame_unwind_register_unsigned (next_frame,
1080                                          gdbarch_sp_regnum (gdbarch));
1081
1082
1083 static CORE_ADDR
1084 v850_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1085 {
1086   return frame_unwind_register_unsigned (next_frame,
1087                                          gdbarch_pc_regnum (gdbarch));
1088 }
1089
1090 static struct frame_id
1091 v850_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1092 {
1093   CORE_ADDR sp = get_frame_register_unsigned (this_frame,
1094                                               gdbarch_sp_regnum (gdbarch));
1095   return frame_id_build (sp, get_frame_pc (this_frame));
1096 }
1097   
1098 static CORE_ADDR
1099 v850_frame_base_address (struct frame_info *this_frame, void **this_cache)
1100 {
1101   struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
1102
1103   return cache->base;
1104 }
1105
1106 static const struct frame_base v850_frame_base = {
1107   &v850_frame_unwind,
1108   v850_frame_base_address,
1109   v850_frame_base_address,
1110   v850_frame_base_address
1111 };
1112
1113 static struct gdbarch *
1114 v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1115 {
1116   struct gdbarch *gdbarch;
1117
1118   /* Change the register names based on the current machine type.  */
1119   if (info.bfd_arch_info->arch != bfd_arch_v850)
1120     return NULL;
1121
1122   gdbarch = gdbarch_alloc (&info, NULL);
1123
1124   switch (info.bfd_arch_info->mach)
1125     {
1126     case bfd_mach_v850:
1127       set_gdbarch_register_name (gdbarch, v850_register_name);
1128       set_gdbarch_num_regs (gdbarch, E_NUM_OF_V850_REGS);
1129       break;
1130     case bfd_mach_v850e:
1131     case bfd_mach_v850e1:
1132       set_gdbarch_register_name (gdbarch, v850e_register_name);
1133       set_gdbarch_num_regs (gdbarch, E_NUM_OF_V850E_REGS);
1134       break;
1135     case bfd_mach_v850e2:
1136     case bfd_mach_v850e2v3:
1137       set_gdbarch_register_name (gdbarch, v850e2_register_name);
1138       set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1139       break;
1140     }
1141
1142   set_gdbarch_num_pseudo_regs (gdbarch, 0);
1143   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1144   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1145   set_gdbarch_fp0_regnum (gdbarch, -1);
1146
1147   set_gdbarch_register_type (gdbarch, v850_register_type);
1148
1149   set_gdbarch_char_signed (gdbarch, 1);
1150   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1151   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1152   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1153   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1154
1155   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1156   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1157   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1158
1159   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1160   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1161
1162   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1163   set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
1164
1165   set_gdbarch_return_value (gdbarch, v850_return_value);
1166   set_gdbarch_push_dummy_call (gdbarch, v850_push_dummy_call);
1167   set_gdbarch_skip_prologue (gdbarch, v850_skip_prologue);
1168
1169   set_gdbarch_print_insn (gdbarch, print_insn_v850);
1170
1171   set_gdbarch_frame_align (gdbarch, v850_frame_align);
1172   set_gdbarch_unwind_sp (gdbarch, v850_unwind_sp);
1173   set_gdbarch_unwind_pc (gdbarch, v850_unwind_pc);
1174   set_gdbarch_dummy_id (gdbarch, v850_dummy_id);
1175   frame_base_set_default (gdbarch, &v850_frame_base);
1176
1177   /* Hook in ABI-specific overrides, if they have been registered.  */
1178   gdbarch_init_osabi (info, gdbarch);
1179
1180   dwarf2_append_unwinders (gdbarch);
1181   frame_unwind_append_unwinder (gdbarch, &v850_frame_unwind);
1182
1183   return gdbarch;
1184 }
1185
1186 extern initialize_file_ftype _initialize_v850_tdep; /* -Wmissing-prototypes */
1187
1188 void
1189 _initialize_v850_tdep (void)
1190 {
1191   register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);
1192 }