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