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