-Wwrite-strings: The Rest
[external/binutils.git] / gdb / xstormy16-tdep.c
1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
2
3    Copyright (C) 2001-2017 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "frame.h"
22 #include "frame-base.h"
23 #include "frame-unwind.h"
24 #include "dwarf2-frame.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "gdbcmd.h"
28 #include "gdbcore.h"
29 #include "value.h"
30 #include "dis-asm.h"
31 #include "inferior.h"
32 #include "arch-utils.h"
33 #include "floatformat.h"
34 #include "regcache.h"
35 #include "doublest.h"
36 #include "osabi.h"
37 #include "objfiles.h"
38
39 enum gdb_regnum
40 {
41   /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
42      Functions will return their values in register R2-R7 as they fit.
43      Otherwise a hidden pointer to an big enough area is given as argument
44      to the function in r2.  Further arguments are beginning in r3 then.
45      R13 is used as frame pointer when GCC compiles w/o optimization
46      R14 is used as "PSW", displaying the CPU status.
47      R15 is used implicitely as stack pointer.  */
48   E_R0_REGNUM,
49   E_R1_REGNUM,
50   E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
51   E_R3_REGNUM,
52   E_R4_REGNUM,
53   E_R5_REGNUM,
54   E_R6_REGNUM,
55   E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
56   E_R8_REGNUM,
57   E_R9_REGNUM,
58   E_R10_REGNUM,
59   E_R11_REGNUM,
60   E_R12_REGNUM,
61   E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
62   E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
63   E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
64   E_PC_REGNUM,
65   E_NUM_REGS
66 };
67
68 /* Use an invalid address value as 'not available' marker.  */
69 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
70
71 struct xstormy16_frame_cache
72 {
73   /* Base address.  */
74   CORE_ADDR base;
75   CORE_ADDR pc;
76   LONGEST framesize;
77   int uses_fp;
78   CORE_ADDR saved_regs[E_NUM_REGS];
79   CORE_ADDR saved_sp;
80 };
81
82 /* Size of instructions, registers, etc.  */
83 enum
84 {
85   xstormy16_inst_size = 2,
86   xstormy16_reg_size = 2,
87   xstormy16_pc_size = 4
88 };
89
90 /* Size of return datatype which fits into the remaining return registers.  */
91 #define E_MAX_RETTYPE_SIZE(regnum)      ((E_LST_ARG_REGNUM - (regnum) + 1) \
92                                         * xstormy16_reg_size)
93
94 /* Size of return datatype which fits into all return registers.  */
95 enum
96 {
97   E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
98 };
99
100 /* Function: xstormy16_register_name
101    Returns the name of the standard Xstormy16 register N.  */
102
103 static const char *
104 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
105 {
106   static const char *register_names[] = {
107     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
108     "r8", "r9", "r10", "r11", "r12", "r13",
109     "psw", "sp", "pc"
110   };
111
112   if (regnum < 0 || regnum >= E_NUM_REGS)
113     internal_error (__FILE__, __LINE__,
114                     _("xstormy16_register_name: illegal register number %d"),
115                     regnum);
116   else
117     return register_names[regnum];
118
119 }
120
121 static struct type *
122 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
123 {
124   if (regnum == E_PC_REGNUM)
125     return builtin_type (gdbarch)->builtin_uint32;
126   else
127     return builtin_type (gdbarch)->builtin_uint16;
128 }
129
130 /* Function: xstormy16_type_is_scalar
131    Makes the decision if a given type is a scalar types.  Scalar
132    types are returned in the registers r2-r7 as they fit.  */
133
134 static int
135 xstormy16_type_is_scalar (struct type *t)
136 {
137   return (TYPE_CODE(t) != TYPE_CODE_STRUCT
138           && TYPE_CODE(t) != TYPE_CODE_UNION
139           && TYPE_CODE(t) != TYPE_CODE_ARRAY);
140 }
141
142 /* Function: xstormy16_use_struct_convention 
143    Returns non-zero if the given struct type will be returned using
144    a special convention, rather than the normal function return method.
145    7sed in the contexts of the "return" command, and of
146    target function calls from the debugger.  */ 
147
148 static int
149 xstormy16_use_struct_convention (struct type *type)
150 {
151   return !xstormy16_type_is_scalar (type)
152          || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
153
154
155 /* Function: xstormy16_extract_return_value
156    Find a function's return value in the appropriate registers (in
157    regbuf), and copy it into valbuf.  */
158
159 static void
160 xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
161                                 gdb_byte *valbuf)
162 {
163   int len = TYPE_LENGTH (type);
164   int i, regnum = E_1ST_ARG_REGNUM;
165
166   for (i = 0; i < len; i += xstormy16_reg_size)
167     regcache_raw_read (regcache, regnum++, valbuf + i);
168 }
169
170 /* Function: xstormy16_store_return_value
171    Copy the function return value from VALBUF into the
172    proper location for a function return. 
173    Called only in the context of the "return" command.  */
174
175 static void 
176 xstormy16_store_return_value (struct type *type, struct regcache *regcache,
177                               const gdb_byte *valbuf)
178 {
179   if (TYPE_LENGTH (type) == 1)
180     {    
181       /* Add leading zeros to the value.  */
182       gdb_byte buf[xstormy16_reg_size];
183       memset (buf, 0, xstormy16_reg_size);
184       memcpy (buf, valbuf, 1);
185       regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
186     }
187   else
188     {
189       int len = TYPE_LENGTH (type);
190       int i, regnum = E_1ST_ARG_REGNUM;
191
192       for (i = 0; i < len; i += xstormy16_reg_size)
193         regcache_raw_write (regcache, regnum++, valbuf + i);
194     }
195 }
196
197 static enum return_value_convention
198 xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
199                         struct type *type, struct regcache *regcache,
200                         gdb_byte *readbuf, const gdb_byte *writebuf)
201 {
202   if (xstormy16_use_struct_convention (type))
203     return RETURN_VALUE_STRUCT_CONVENTION;
204   if (writebuf)
205     xstormy16_store_return_value (type, regcache, writebuf);
206   else if (readbuf)
207     xstormy16_extract_return_value (type, regcache, readbuf);
208   return RETURN_VALUE_REGISTER_CONVENTION;
209 }
210
211 static CORE_ADDR
212 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
213 {
214   if (addr & 1)
215     ++addr;
216   return addr;
217 }
218
219 /* Function: xstormy16_push_dummy_call
220    Setup the function arguments for GDB to call a function in the inferior.
221    Called only in the context of a target function call from the debugger.
222    Returns the value of the SP register after the args are pushed.  */
223
224 static CORE_ADDR
225 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
226                            struct value *function,
227                            struct regcache *regcache,
228                            CORE_ADDR bp_addr, int nargs,
229                            struct value **args,
230                            CORE_ADDR sp, int struct_return,
231                            CORE_ADDR struct_addr)
232 {
233   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
234   CORE_ADDR stack_dest = sp;
235   int argreg = E_1ST_ARG_REGNUM;
236   int i, j;
237   int typelen, slacklen;
238   const gdb_byte *val;
239   gdb_byte buf[xstormy16_pc_size];
240
241   /* If struct_return is true, then the struct return address will
242      consume one argument-passing register.  */
243   if (struct_return)
244     {
245       regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
246       argreg++;
247     }
248
249   /* Arguments are passed in R2-R7 as they fit.  If an argument doesn't
250      fit in the remaining registers we're switching over to the stack.
251      No argument is put on stack partially and as soon as we switched
252      over to stack no further argument is put in a register even if it
253      would fit in the remaining unused registers.  */
254   for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
255     {
256       typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
257       if (typelen > E_MAX_RETTYPE_SIZE (argreg))
258         break;
259
260       /* Put argument into registers wordwise.  */
261       val = value_contents (args[i]);
262       for (j = 0; j < typelen; j += xstormy16_reg_size)
263         {
264           ULONGEST regval;
265           int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
266
267           regval = extract_unsigned_integer (val + j, size, byte_order);
268           regcache_cooked_write_unsigned (regcache, argreg++, regval);
269         }
270     }
271
272   /* Align SP */
273   stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
274
275   /* Loop backwards through remaining arguments and push them on the stack,
276      wordaligned.  */
277   for (j = nargs - 1; j >= i; j--)
278     {
279       gdb_byte *val;
280       struct cleanup *back_to;
281       const gdb_byte *bytes = value_contents (args[j]);
282
283       typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
284       slacklen = typelen & 1;
285       val = (gdb_byte *) xmalloc (typelen + slacklen);
286       back_to = make_cleanup (xfree, val);
287       memcpy (val, bytes, typelen);
288       memset (val + typelen, 0, slacklen);
289
290       /* Now write this data to the stack.  The stack grows upwards.  */
291       write_memory (stack_dest, val, typelen + slacklen);
292       stack_dest += typelen + slacklen;
293       do_cleanups (back_to);
294     }
295
296   store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
297   write_memory (stack_dest, buf, xstormy16_pc_size);
298   stack_dest += xstormy16_pc_size;
299
300   /* Update stack pointer.  */
301   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
302
303   /* Return the new stack pointer minus the return address slot since
304      that's what DWARF2/GCC uses as the frame's CFA.  */
305   return stack_dest - xstormy16_pc_size;
306 }
307
308 /* Function: xstormy16_scan_prologue
309    Decode the instructions within the given address range.
310    Decide when we must have reached the end of the function prologue.
311    If a frame_info pointer is provided, fill in its saved_regs etc.
312
313    Returns the address of the first instruction after the prologue.  */
314
315 static CORE_ADDR
316 xstormy16_analyze_prologue (struct gdbarch *gdbarch,
317                             CORE_ADDR start_addr, CORE_ADDR end_addr,
318                             struct xstormy16_frame_cache *cache,
319                             struct frame_info *this_frame)
320 {
321   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
322   CORE_ADDR next_addr;
323   ULONGEST inst, inst2;
324   LONGEST offset;
325   int regnum;
326
327   /* Initialize framesize with size of PC put on stack by CALLF inst.  */
328   cache->saved_regs[E_PC_REGNUM] = 0;
329   cache->framesize = xstormy16_pc_size;
330
331   if (start_addr >= end_addr)
332     return end_addr;
333
334   for (next_addr = start_addr;
335        next_addr < end_addr; next_addr += xstormy16_inst_size)
336     {
337       inst = read_memory_unsigned_integer (next_addr,
338                                            xstormy16_inst_size, byte_order);
339       inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
340                                             xstormy16_inst_size, byte_order);
341
342       if (inst >= 0x0082 && inst <= 0x008d)     /* push r2 .. push r13 */
343         {
344           regnum = inst & 0x000f;
345           cache->saved_regs[regnum] = cache->framesize;
346           cache->framesize += xstormy16_reg_size;
347         }
348
349       /* Optional stack allocation for args and local vars <= 4 byte.  */
350       else if (inst == 0x301f || inst == 0x303f)       /* inc r15, #0x1/#0x3 */
351         {
352           cache->framesize += ((inst & 0x0030) >> 4) + 1;
353         }
354
355       /* optional stack allocation for args and local vars > 4 && < 16 byte */
356       else if ((inst & 0xff0f) == 0x510f)       /* 51Hf   add r15, #0xH */
357         {
358           cache->framesize += (inst & 0x00f0) >> 4;
359         }
360
361       /* Optional stack allocation for args and local vars >= 16 byte.  */
362       else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
363         {
364           cache->framesize += inst2;
365           next_addr += xstormy16_inst_size;
366         }
367
368       else if (inst == 0x46fd)  /* mov r13, r15 */
369         {
370           cache->uses_fp = 1;
371         }
372
373       /* optional copying of args in r2-r7 to r10-r13.  */
374       /* Probably only in optimized case but legal action for prologue.  */
375       else if ((inst & 0xff00) == 0x4600        /* 46SD   mov rD, rS */
376                && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
377                && (inst & 0x000f) >= 0x000a && (inst & 0x000f) <= 0x000d)
378         ;
379
380       /* Optional copying of args in r2-r7 to stack.  */
381       /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8) 
382          (bit3 always 1, bit2-0 = reg) */
383       /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
384       else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
385         {
386           regnum = inst & 0x0007;
387           /* Only 12 of 16 bits of the argument are used for the
388              signed offset.  */
389           offset = (LONGEST) (inst2 & 0x0fff);
390           if (offset & 0x0800)
391             offset -= 0x1000;
392
393           cache->saved_regs[regnum] = cache->framesize + offset;
394           next_addr += xstormy16_inst_size;
395         }
396
397       else                      /* Not a prologue instruction.  */
398         break;
399     }
400
401   return next_addr;
402 }
403
404 /* Function: xstormy16_skip_prologue
405    If the input address is in a function prologue, 
406    returns the address of the end of the prologue;
407    else returns the input address.
408
409    Note: the input address is likely to be the function start, 
410    since this function is mainly used for advancing a breakpoint
411    to the first line, or stepping to the first line when we have
412    stepped into a function call.  */
413
414 static CORE_ADDR
415 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
416 {
417   CORE_ADDR func_addr = 0, func_end = 0;
418   const char *func_name;
419
420   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
421     {
422       struct symtab_and_line sal;
423       struct symbol *sym;
424       struct xstormy16_frame_cache cache;
425       CORE_ADDR plg_end;
426
427       memset (&cache, 0, sizeof cache);
428
429       /* Don't trust line number debug info in frameless functions.  */
430       plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
431                                             &cache, NULL);
432       if (!cache.uses_fp)
433         return plg_end;
434
435       /* Found a function.  */
436       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
437       /* Don't use line number debug info for assembly source files.  */
438       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
439         {
440           sal = find_pc_line (func_addr, 0);
441           if (sal.end && sal.end < func_end)
442             {
443               /* Found a line number, use it as end of prologue.  */
444               return sal.end;
445             }
446         }
447       /* No useable line symbol.  Use result of prologue parsing method.  */
448       return plg_end;
449     }
450
451   /* No function symbol -- just return the PC.  */
452
453   return (CORE_ADDR) pc;
454 }
455
456 /* Implement the stack_frame_destroyed_p gdbarch method.
457
458    The epilogue is defined here as the area at the end of a function,
459    either on the `ret' instruction itself or after an instruction which
460    destroys the function's stack frame.  */
461
462 static int
463 xstormy16_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
464 {
465   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
466   CORE_ADDR func_addr = 0, func_end = 0;
467
468   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
469     {
470       ULONGEST inst, inst2;
471       CORE_ADDR addr = func_end - xstormy16_inst_size;
472
473       /* The Xstormy16 epilogue is max. 14 bytes long.  */
474       if (pc < func_end - 7 * xstormy16_inst_size)
475         return 0;
476
477       /* Check if we're on a `ret' instruction.  Otherwise it's
478          too dangerous to proceed.  */
479       inst = read_memory_unsigned_integer (addr,
480                                            xstormy16_inst_size, byte_order);
481       if (inst != 0x0003)
482         return 0;
483
484       while ((addr -= xstormy16_inst_size) >= func_addr)
485         {
486           inst = read_memory_unsigned_integer (addr,
487                                                xstormy16_inst_size,
488                                                byte_order);
489           if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
490             continue;
491           if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
492             break;
493           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
494                                                 xstormy16_inst_size,
495                                                 byte_order);
496           if (inst2 == 0x314f && inst >= 0x8000)      /* add r15, neg. value */
497             {
498               addr -= xstormy16_inst_size;
499               break;
500             }
501           return 0;
502         }
503       if (pc > addr)
504         return 1;
505     }
506   return 0;
507 }
508
509 constexpr gdb_byte xstormy16_break_insn[] = { 0x06, 0x0 };
510
511 typedef BP_MANIPULATION (xstormy16_break_insn) xstormy16_breakpoint;
512
513 /* Given a pointer to a jump table entry, return the address
514    of the function it jumps to.  Return 0 if not found.  */
515 static CORE_ADDR
516 xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
517 {
518   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
519   struct obj_section *faddr_sect = find_pc_section (faddr);
520
521   if (faddr_sect)
522     {
523       LONGEST inst, inst2, addr;
524       gdb_byte buf[2 * xstormy16_inst_size];
525
526       /* Return faddr if it's not pointing into the jump table.  */
527       if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
528         return faddr;
529
530       if (!target_read_memory (faddr, buf, sizeof buf))
531         {
532           inst = extract_unsigned_integer (buf,
533                                            xstormy16_inst_size, byte_order);
534           inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
535                                             xstormy16_inst_size, byte_order);
536           addr = inst2 << 8 | (inst & 0xff);
537           return addr;
538         }
539     }
540   return 0;
541 }
542
543 /* Given a function's address, attempt to find (and return) the
544    address of the corresponding jump table entry.  Return 0 if
545    not found.  */
546 static CORE_ADDR
547 xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
548 {
549   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
550   struct obj_section *faddr_sect = find_pc_section (faddr);
551
552   if (faddr_sect)
553     {
554       struct obj_section *osect;
555
556       /* Return faddr if it's already a pointer to a jump table entry.  */
557       if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
558         return faddr;
559
560       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
561       {
562         if (!strcmp (osect->the_bfd_section->name, ".plt"))
563           break;
564       }
565
566       if (osect < faddr_sect->objfile->sections_end)
567         {
568           CORE_ADDR addr, endaddr;
569
570           addr = obj_section_addr (osect);
571           endaddr = obj_section_endaddr (osect);
572
573           for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
574             {
575               LONGEST inst, inst2, faddr2;
576               gdb_byte buf[2 * xstormy16_inst_size];
577
578               if (target_read_memory (addr, buf, sizeof buf))
579                 return 0;
580               inst = extract_unsigned_integer (buf,
581                                                xstormy16_inst_size,
582                                                byte_order);
583               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
584                                                 xstormy16_inst_size,
585                                                 byte_order);
586               faddr2 = inst2 << 8 | (inst & 0xff);
587               if (faddr == faddr2)
588                 return addr;
589             }
590         }
591     }
592   return 0;
593 }
594
595 static CORE_ADDR
596 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
597 {
598   struct gdbarch *gdbarch = get_frame_arch (frame);
599   CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
600
601   if (tmp && tmp != pc)
602     return tmp;
603   return 0;
604 }
605
606 /* Function pointers are 16 bit.  The address space is 24 bit, using
607    32 bit addresses.  Pointers to functions on the XStormy16 are implemented
608    by using 16 bit pointers, which are either direct pointers in case the
609    function begins below 0x10000, or indirect pointers into a jump table.
610    The next two functions convert 16 bit pointers into 24 (32) bit addresses
611    and vice versa.  */
612
613 static CORE_ADDR
614 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
615                               struct type *type, const gdb_byte *buf)
616 {
617   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
618   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
619   CORE_ADDR addr
620     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
621
622   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
623     {
624       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
625       if (addr2)
626         addr = addr2;
627     }
628
629   return addr;
630 }
631
632 static void
633 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
634                               struct type *type, gdb_byte *buf, CORE_ADDR addr)
635 {
636   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
637   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
638
639   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
640     {
641       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
642       if (addr2)
643         addr = addr2;
644     }
645   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
646 }
647
648 static struct xstormy16_frame_cache *
649 xstormy16_alloc_frame_cache (void)
650 {
651   struct xstormy16_frame_cache *cache;
652   int i;
653
654   cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
655
656   cache->base = 0;
657   cache->saved_sp = 0;
658   cache->pc = 0;
659   cache->uses_fp = 0;
660   cache->framesize = 0;
661   for (i = 0; i < E_NUM_REGS; ++i)
662     cache->saved_regs[i] = REG_UNAVAIL;
663
664   return cache;
665 }
666
667 static struct xstormy16_frame_cache *
668 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
669 {
670   struct gdbarch *gdbarch = get_frame_arch (this_frame);
671   struct xstormy16_frame_cache *cache;
672   CORE_ADDR current_pc;
673   int i;
674
675   if (*this_cache)
676     return (struct xstormy16_frame_cache *) *this_cache;
677
678   cache = xstormy16_alloc_frame_cache ();
679   *this_cache = cache;
680
681   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
682   if (cache->base == 0)
683     return cache;
684
685   cache->pc = get_frame_func (this_frame);
686   current_pc = get_frame_pc (this_frame);
687   if (cache->pc)
688     xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
689                                 cache, this_frame);
690
691   if (!cache->uses_fp)
692     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
693
694   cache->saved_sp = cache->base - cache->framesize;
695
696   for (i = 0; i < E_NUM_REGS; ++i)
697     if (cache->saved_regs[i] != REG_UNAVAIL)
698       cache->saved_regs[i] += cache->saved_sp;
699
700   return cache;
701 }
702
703 static struct value *
704 xstormy16_frame_prev_register (struct frame_info *this_frame, 
705                                void **this_cache, int regnum)
706 {
707   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
708                                                                this_cache);
709   gdb_assert (regnum >= 0);
710
711   if (regnum == E_SP_REGNUM && cache->saved_sp)
712     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
713
714   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
715     return frame_unwind_got_memory (this_frame, regnum,
716                                     cache->saved_regs[regnum]);
717
718   return frame_unwind_got_register (this_frame, regnum, regnum);
719 }
720
721 static void
722 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
723                          struct frame_id *this_id)
724 {
725   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
726                                                                this_cache);
727
728   /* This marks the outermost frame.  */
729   if (cache->base == 0)
730     return;
731
732   *this_id = frame_id_build (cache->saved_sp, cache->pc);
733 }
734
735 static CORE_ADDR
736 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
737 {
738   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
739                                                                this_cache);
740   return cache->base;
741 }
742
743 static const struct frame_unwind xstormy16_frame_unwind = {
744   NORMAL_FRAME,
745   default_frame_unwind_stop_reason,
746   xstormy16_frame_this_id,
747   xstormy16_frame_prev_register,
748   NULL,
749   default_frame_sniffer
750 };
751
752 static const struct frame_base xstormy16_frame_base = {
753   &xstormy16_frame_unwind,
754   xstormy16_frame_base_address,
755   xstormy16_frame_base_address,
756   xstormy16_frame_base_address
757 };
758
759 static CORE_ADDR
760 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
761 {
762   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
763 }
764
765 static CORE_ADDR
766 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
767 {
768   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
769 }
770
771 static struct frame_id
772 xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
773 {
774   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
775   return frame_id_build (sp, get_frame_pc (this_frame));
776 }
777
778
779 /* Function: xstormy16_gdbarch_init
780    Initializer function for the xstormy16 gdbarch vector.
781    Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */
782
783 static struct gdbarch *
784 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
785 {
786   struct gdbarch *gdbarch;
787
788   /* find a candidate among the list of pre-declared architectures.  */
789   arches = gdbarch_list_lookup_by_info (arches, &info);
790   if (arches != NULL)
791     return (arches->gdbarch);
792
793   gdbarch = gdbarch_alloc (&info, NULL);
794
795   /*
796    * Basic register fields and methods, datatype sizes and stuff.
797    */
798
799   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
800   set_gdbarch_num_pseudo_regs (gdbarch, 0);
801   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
802   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
803   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
804   set_gdbarch_register_type (gdbarch, xstormy16_register_type);
805
806   set_gdbarch_char_signed (gdbarch, 0);
807   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
808   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
809   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
810   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
811
812   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
813   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
814   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
815
816   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
817   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
818   set_gdbarch_dwarf2_addr_size (gdbarch, 4);
819
820   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
821   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
822
823   /* Stack grows up.  */
824   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
825
826   /*
827    * Frame Info
828    */
829   set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
830   set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
831   set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
832   set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
833   frame_base_set_default (gdbarch, &xstormy16_frame_base);
834
835   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
836   set_gdbarch_stack_frame_destroyed_p (gdbarch,
837                                        xstormy16_stack_frame_destroyed_p);
838
839   /* These values and methods are used when gdb calls a target function.  */
840   set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
841   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
842                                        xstormy16_breakpoint::kind_from_pc);
843   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
844                                        xstormy16_breakpoint::bp_from_kind);
845   set_gdbarch_return_value (gdbarch, xstormy16_return_value);
846
847   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
848
849   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
850
851   gdbarch_init_osabi (info, gdbarch);
852
853   dwarf2_append_unwinders (gdbarch);
854   frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
855
856   return gdbarch;
857 }
858
859 /* Function: _initialize_xstormy16_tdep
860    Initializer function for the Sanyo Xstormy16a module.
861    Called by gdb at start-up.  */
862
863 /* -Wmissing-prototypes */
864 extern initialize_file_ftype _initialize_xstormy16_tdep;
865
866 void
867 _initialize_xstormy16_tdep (void)
868 {
869   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
870 }