2004-06-10 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 "value.h"
24 #include "inferior.h"
25 #include "arch-utils.h"
26 #include "regcache.h"
27 #include "gdbcore.h"
28 #include "objfiles.h"
29 #include "dis-asm.h"
30
31 struct gdbarch_tdep
32 {
33   /* gdbarch target dependent data here. Currently unused for Xstormy16. */
34 };
35
36 /* Extra info which is saved in each frame_info. */
37 struct frame_extra_info
38 {
39   int framesize;
40   int frameless_p;
41 };
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 /* Size of instructions, registers, etc. */
73 enum
74 {
75   xstormy16_inst_size = 2,
76   xstormy16_reg_size = 2,
77   xstormy16_pc_size = 4
78 };
79
80 /* Size of return datatype which fits into the remaining return registers. */
81 #define E_MAX_RETTYPE_SIZE(regnum)      ((E_LST_ARG_REGNUM - (regnum) + 1) \
82                                         * xstormy16_reg_size)
83
84 /* Size of return datatype which fits into all return registers. */
85 enum
86 {
87   E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
88 };
89
90
91 /* Size of all registers as a whole. */
92 enum
93 {
94   E_ALL_REGS_SIZE = (E_NUM_REGS - 1) * xstormy16_reg_size + xstormy16_pc_size
95 };
96
97 /* Function: xstormy16_register_name
98    Returns the name of the standard Xstormy16 register N. */
99
100 static const char *
101 xstormy16_register_name (int regnum)
102 {
103   static char *register_names[] = {
104     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
105     "r8", "r9", "r10", "r11", "r12", "r13",
106     "psw", "sp", "pc"
107   };
108
109   if (regnum < 0 ||
110       regnum >= sizeof (register_names) / sizeof (register_names[0]))
111     internal_error (__FILE__, __LINE__,
112                     "xstormy16_register_name: illegal register number %d",
113                     regnum);
114   else
115     return register_names[regnum];
116
117 }
118
119 /* Function: xstormy16_register_byte 
120    Returns the byte position in the register cache for register N. */
121
122 static int
123 xstormy16_register_byte (int regnum)
124 {
125   if (regnum < 0 || regnum >= E_NUM_REGS)
126     internal_error (__FILE__, __LINE__,
127                     "xstormy16_register_byte: illegal register number %d",
128                     regnum);
129   else
130     /* All registers occupy 2 bytes in the regcache except for PC
131        which is the last one. Therefore the byte position is still
132        simply a multiple of 2. */
133     return regnum * xstormy16_reg_size;
134 }
135
136 /* Function: xstormy16_register_raw_size
137    Returns the number of bytes occupied by the register on the target. */
138
139 static int
140 xstormy16_register_raw_size (int regnum)
141 {
142   if (regnum < 0 || regnum >= E_NUM_REGS)
143     internal_error (__FILE__, __LINE__,
144                     "xstormy16_register_raw_size: illegal register number %d",
145                     regnum);
146   /* Only the PC has 4 Byte, all other registers 2 Byte. */
147   else if (regnum == E_PC_REGNUM)
148     return xstormy16_pc_size;
149   else
150     return xstormy16_reg_size;
151 }
152
153 /* Function: xstormy16_reg_virtual_type 
154    Returns the default type for register N. */
155
156 static struct type *
157 xstormy16_reg_virtual_type (int regnum)
158 {
159   if (regnum < 0 || regnum >= E_NUM_REGS)
160     internal_error (__FILE__, __LINE__,
161                     "xstormy16_register_virtual_type: illegal register number %d",
162                     regnum);
163   else if (regnum == E_PC_REGNUM)
164     return builtin_type_uint32;
165   else
166     return builtin_type_uint16;
167 }
168
169 /* Function: xstormy16_get_saved_register
170    Find a register's saved value on the call stack.
171
172    Find register number REGNUM relative to FRAME and put its (raw,
173    target format) contents in *RAW_BUFFER.
174
175    Set *OPTIMIZED if the variable was optimized out (and thus can't be
176    fetched).  Note that this is never set to anything other than zero
177    in this implementation.
178
179    Set *LVAL to lval_memory, lval_register, or not_lval, depending on
180    whether the value was fetched from memory, from a register, or in a
181    strange and non-modifiable way (e.g. a frame pointer which was
182    calculated rather than fetched).  We will use not_lval for values
183    fetched from generic dummy frames.
184
185    Set *ADDRP to the address, either in memory or as a
186    DEPRECATED_REGISTER_BYTE offset into the registers array.  If the
187    value is stored in a dummy frame, set *ADDRP to zero.
188
189    The argument RAW_BUFFER must point to aligned memory.
190
191    The GET_SAVED_REGISTER architecture interface is entirely
192    redundant.  New architectures should implement per-frame unwinders
193    (ref "frame-unwind.h").  */
194
195 static void
196 xstormy16_get_saved_register (char *raw_buffer, int *optimized,
197                               CORE_ADDR *addrp,
198                               struct frame_info *frame, int regnum,
199                               enum lval_type *lval)
200 {
201   if (!target_has_registers)
202     error ("No registers.");
203
204   /* Normal systems don't optimize out things with register numbers.  */
205   if (optimized != NULL)
206     *optimized = 0;
207
208   if (addrp)                    /* default assumption: not found in memory */
209     *addrp = 0;
210
211   /* Note: since the current frame's registers could only have been
212      saved by frames INTERIOR TO the current frame, we skip examining
213      the current frame itself: otherwise, we would be getting the
214      previous frame's registers which were saved by the current frame.  */
215
216   if (frame != NULL)
217     {
218       for (frame = get_next_frame (frame);
219            get_frame_type (frame) != SENTINEL_FRAME;
220            frame = get_next_frame (frame))
221         {
222           if (get_frame_type (frame) == DUMMY_FRAME)
223             {
224               if (lval)         /* found it in a CALL_DUMMY frame */
225                 *lval = not_lval;
226               if (raw_buffer)
227                 {
228                   LONGEST val;
229                   /* FIXME: cagney/2002-06-26: This should be via the
230                      gdbarch_register_read() method so that it, on the
231                      fly, constructs either a raw or pseudo register
232                      from the raw register cache.  */
233                   val = deprecated_read_register_dummy (get_frame_pc (frame),
234                                                         get_frame_base (frame),
235                                                         regnum);
236                   store_unsigned_integer (raw_buffer,
237                                           DEPRECATED_REGISTER_RAW_SIZE (regnum),
238                                           val);
239                 }
240               return;
241             }
242
243           DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
244           if (deprecated_get_frame_saved_regs (frame) != NULL
245               && deprecated_get_frame_saved_regs (frame)[regnum] != 0)
246             {
247               if (lval)         /* found it saved on the stack */
248                 *lval = lval_memory;
249               if (regnum == SP_REGNUM)
250                 {
251                   if (raw_buffer)       /* SP register treated specially */
252                     /* NOTE: cagney/2003-05-09: In-line store_address()
253                        with it's body - store_unsigned_integer().  */
254                     store_unsigned_integer (raw_buffer,
255                                             DEPRECATED_REGISTER_RAW_SIZE (regnum),
256                                             deprecated_get_frame_saved_regs (frame)[regnum]);
257                 }
258               else
259                 {
260                   if (addrp)    /* any other register */
261                     *addrp = deprecated_get_frame_saved_regs (frame)[regnum];
262                   if (raw_buffer)
263                     read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer,
264                                  DEPRECATED_REGISTER_RAW_SIZE (regnum));
265                 }
266               return;
267             }
268         }
269     }
270
271   /* If we get thru the loop to this point, it means the register was
272      not saved in any frame.  Return the actual live-register value.  */
273
274   if (lval)                     /* found it in a live register */
275     *lval = lval_register;
276   if (addrp)
277     *addrp = DEPRECATED_REGISTER_BYTE (regnum);
278   if (raw_buffer)
279     deprecated_read_register_gen (regnum, raw_buffer);
280 }
281
282 /* Function: xstormy16_type_is_scalar
283    Makes the decision if a given type is a scalar types.  Scalar
284    types are returned in the registers r2-r7 as they fit. */
285
286 static int
287 xstormy16_type_is_scalar (struct type *t)
288 {
289   return (TYPE_CODE(t) != TYPE_CODE_STRUCT
290           && TYPE_CODE(t) != TYPE_CODE_UNION
291           && TYPE_CODE(t) != TYPE_CODE_ARRAY);
292 }
293
294 /* Function: xstormy16_extract_return_value
295    Copy the function's return value into VALBUF. 
296    This function is called only in the context of "target function calls",
297    ie. when the debugger forces a function to be called in the child, and
298    when the debugger forces a function to return prematurely via the
299    "return" command. */
300
301 static void
302 xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf)
303 {
304   CORE_ADDR return_buffer;
305   int offset = 0;
306
307   if (xstormy16_type_is_scalar (type)
308       && TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
309     {
310       /* Scalar return values of <= 12 bytes are returned in 
311          E_1ST_ARG_REGNUM to E_LST_ARG_REGNUM. */
312       memcpy (valbuf,
313               &regbuf[DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset,
314               TYPE_LENGTH (type));
315     }
316   else
317     {
318       /* Aggregates and return values > 12 bytes are returned in memory,
319          pointed to by R2. */
320       return_buffer =
321         extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_PTR_RET_REGNUM),
322                                   DEPRECATED_REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
323
324       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
325     }
326 }
327
328 /* Function: xstormy16_push_arguments
329    Setup the function arguments for GDB to call a function in the inferior.
330    Called only in the context of a target function call from the debugger.
331    Returns the value of the SP register after the args are pushed.
332 */
333
334 static CORE_ADDR
335 xstormy16_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
336                           int struct_return, CORE_ADDR struct_addr)
337 {
338   CORE_ADDR stack_dest = sp;
339   int argreg = E_1ST_ARG_REGNUM;
340   int i, j;
341   int typelen, slacklen;
342   char *val;
343
344   /* If struct_return is true, then the struct return address will
345      consume one argument-passing register.  */
346   if (struct_return)
347     argreg++;
348
349   /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
350      fit in the remaining registers we're switching over to the stack.
351      No argument is put on stack partially and as soon as we switched
352      over to stack no further argument is put in a register even if it
353      would fit in the remaining unused registers. */
354   for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
355     {
356       typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
357       if (typelen > E_MAX_RETTYPE_SIZE (argreg))
358         break;
359
360       /* Put argument into registers wordwise. */
361       val = VALUE_CONTENTS (args[i]);
362       for (j = 0; j < typelen; j += xstormy16_reg_size)
363         write_register (argreg++,
364                         extract_unsigned_integer (val + j,
365                                                   typelen - j ==
366                                                   1 ? 1 :
367                                                   xstormy16_reg_size));
368     }
369
370   /* Align SP */
371   if (stack_dest & 1)
372     ++stack_dest;
373
374   /* Loop backwards through remaining arguments and push them on the stack,
375      wordaligned. */
376   for (j = nargs - 1; j >= i; j--)
377     {
378       typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[j]));
379       slacklen = typelen & 1;
380       val = alloca (typelen + slacklen);
381       memcpy (val, VALUE_CONTENTS (args[j]), typelen);
382       memset (val + typelen, 0, slacklen);
383
384       /* Now write this data to the stack. The stack grows upwards. */
385       write_memory (stack_dest, val, typelen + slacklen);
386       stack_dest += typelen + slacklen;
387     }
388
389   /* And that should do it.  Return the new stack pointer. */
390   return stack_dest;
391 }
392
393 /* Function: xstormy16_push_return_address (pc)
394    Setup the return address for GDB to call a function in the inferior.
395    Called only in the context of a target function call from the debugger.
396    Returns the value of the SP register when the operation is finished
397    (which may or may not be the same as before).
398 */
399
400 static CORE_ADDR
401 xstormy16_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
402 {
403   unsigned char buf[xstormy16_pc_size];
404
405   store_unsigned_integer (buf, xstormy16_pc_size, entry_point_address ());
406   write_memory (sp, buf, xstormy16_pc_size);
407   return sp + xstormy16_pc_size;
408 }
409
410 /* Function: xstormy16_pop_frame
411    Destroy the innermost (Top-Of-Stack) stack frame, restoring the 
412    machine state that was in effect before the frame was created. 
413    Used in the contexts of the "return" command, and of 
414    target function calls from the debugger.
415 */
416
417 static void
418 xstormy16_pop_frame (void)
419 {
420   struct frame_info *fi = get_current_frame ();
421   int i;
422
423   if (fi == NULL)
424     return;                     /* paranoia */
425
426   if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
427     {
428       deprecated_pop_dummy_frame ();
429     }
430   else
431     {
432       /* Restore the saved regs. */
433       for (i = 0; i < NUM_REGS; i++)
434         if (deprecated_get_frame_saved_regs (fi)[i])
435           {
436             if (i == SP_REGNUM)
437               write_register (i, deprecated_get_frame_saved_regs (fi)[i]);
438             else if (i == E_PC_REGNUM)
439               write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
440                                                       xstormy16_pc_size));
441             else
442               write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
443                                                       xstormy16_reg_size));
444           }
445       /* Restore the PC */
446       write_register (PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (fi));
447       flush_cached_frames ();
448     }
449   return;
450 }
451
452 /* Function: xstormy16_store_struct_return
453    Copy the (struct) function return value to its destined location. 
454    Called only in the context of a target function call from the debugger.
455 */
456
457 static void
458 xstormy16_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
459 {
460   write_register (E_PTR_RET_REGNUM, addr);
461 }
462
463 /* Function: xstormy16_store_return_value
464    Copy the function return value from VALBUF into the 
465    proper location for a function return. 
466    Called only in the context of the "return" command.
467 */
468
469 static void
470 xstormy16_store_return_value (struct type *type, char *valbuf)
471 {
472   CORE_ADDR return_buffer;
473   char buf[xstormy16_reg_size];
474
475   if (xstormy16_type_is_scalar (type) && TYPE_LENGTH (type) == 1)
476     {
477       /* Add leading zeros to the value. */
478       memset (buf, 0, xstormy16_reg_size);
479       memcpy (buf, valbuf, 1);
480       deprecated_write_register_gen (E_1ST_ARG_REGNUM, buf);
481     }
482   else if (xstormy16_type_is_scalar (type) &&
483            TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
484     deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM),
485                                      valbuf, TYPE_LENGTH (type));
486   else
487     {
488       return_buffer = read_register (E_PTR_RET_REGNUM);
489       write_memory (return_buffer, valbuf, TYPE_LENGTH (type));
490     }
491 }
492
493 /* Function: xstormy16_extract_struct_value_address
494    Returns the address in which a function should return a struct value. 
495    Used in the contexts of the "return" command, and of 
496    target function calls from the debugger.
497 */
498
499 static CORE_ADDR
500 xstormy16_extract_struct_value_address (struct regcache *regcache)
501 {
502   /* FIXME: cagney/2004-01-17: Does the ABI guarantee that the return
503      address regster is preserved across function calls?  Probably
504      not, making this function wrong.  */
505   ULONGEST val;
506   regcache_raw_read_unsigned (regcache, E_PTR_RET_REGNUM, &val);
507   return val;
508 }
509
510 /* Function: xstormy16_use_struct_convention 
511    Returns non-zero if the given struct type will be returned using
512    a special convention, rather than the normal function return method. 
513    7sed in the contexts of the "return" command, and of 
514    target function calls from the debugger.
515 */
516
517 static int
518 xstormy16_use_struct_convention (int gcc_p, struct type *type)
519 {
520   return !xstormy16_type_is_scalar (type)
521     || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
522 }
523
524 /* Function: frame_saved_register
525    Returns the value that regnum had in frame fi
526    (saved in fi or in one of its children).  
527 */
528
529 static CORE_ADDR
530 xstormy16_frame_saved_register (struct frame_info *fi, int regnum)
531 {
532   int size = xstormy16_register_raw_size (regnum);
533   char *buf = (char *) alloca (size);
534
535   xstormy16_get_saved_register (buf, NULL, NULL, fi, regnum, NULL);
536   return (CORE_ADDR) extract_unsigned_integer (buf, size);
537 }
538
539 /* Function: xstormy16_scan_prologue
540    Decode the instructions within the given address range.
541    Decide when we must have reached the end of the function prologue.
542    If a frame_info pointer is provided, fill in its saved_regs etc.
543
544    Returns the address of the first instruction after the prologue. 
545 */
546
547 static CORE_ADDR
548 xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
549                          struct frame_info *fi, int *frameless)
550 {
551   CORE_ADDR sp = 0, fp = 0;
552   CORE_ADDR next_addr;
553   ULONGEST inst, inst2;
554   LONGEST offset;
555   int regnum;
556
557   if (frameless)
558     *frameless = 1;
559   if (fi)
560     {
561       /* In a call dummy, don't touch the frame. */
562       if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
563         return start_addr;
564
565       /* Grab the frame-relative values of SP and FP, needed below. 
566          The frame_saved_register function will find them on the
567          stack or in the registers as appropriate. */
568       sp = xstormy16_frame_saved_register (fi, E_SP_REGNUM);
569       fp = xstormy16_frame_saved_register (fi, E_FP_REGNUM);
570
571       /* Initialize framesize with size of PC put on stack by CALLF inst. */
572       get_frame_extra_info (fi)->framesize = xstormy16_pc_size;
573     }
574   for (next_addr = start_addr;
575        next_addr < end_addr; next_addr += xstormy16_inst_size)
576     {
577       inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size);
578       inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
579                                             xstormy16_inst_size);
580
581       if (inst >= 0x0082 && inst <= 0x008d)     /* push r2 .. push r13 */
582         {
583           if (fi)
584             {
585               regnum = inst & 0x000f;
586               deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize;
587               get_frame_extra_info (fi)->framesize += xstormy16_reg_size;
588             }
589         }
590
591       /* optional stack allocation for args and local vars <= 4 byte */
592       else if (inst == 0x301f || inst == 0x303f)        /* inc r15, #0x1/#0x3 */
593         {
594           if (fi)               /* Record the frame size. */
595             get_frame_extra_info (fi)->framesize += ((inst & 0x0030) >> 4) + 1;
596         }
597
598       /* optional stack allocation for args and local vars > 4 && < 16 byte */
599       else if ((inst & 0xff0f) == 0x510f)       /* 51Hf   add r15, #0xH */
600         {
601           if (fi)               /* Record the frame size. */
602             get_frame_extra_info (fi)->framesize += (inst & 0x00f0) >> 4;
603         }
604
605       /* optional stack allocation for args and local vars >= 16 byte */
606       else if (inst == 0x314f && inst2 >= 0x0010)       /* 314f HHHH  add r15, #0xH */
607         {
608           if (fi)               /* Record the frame size. */
609             get_frame_extra_info (fi)->framesize += inst2;
610           next_addr += xstormy16_inst_size;
611         }
612
613       else if (inst == 0x46fd)  /* mov r13, r15 */
614         {
615           if (fi)               /* Record that the frame pointer is in use. */
616             get_frame_extra_info (fi)->frameless_p = 0;
617           if (frameless)
618             *frameless = 0;
619         }
620
621       /* optional copying of args in r2-r7 to r10-r13 */
622       /* Probably only in optimized case but legal action for prologue */
623       else if ((inst & 0xff00) == 0x4600        /* 46SD   mov rD, rS */
624                && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
625                && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
626         ;
627
628       /* optional copying of args in r2-r7 to stack */
629       /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */
630       /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
631       else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
632         {
633           if (fi)
634             {
635               regnum = inst & 0x0007;
636               /* Only 12 of 16 bits of the argument are used for the
637                  signed offset. */
638               offset = (LONGEST) (inst2 & 0x0fff);
639               if (offset & 0x0800)
640                 offset -= 0x1000;
641
642               deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset;
643             }
644           next_addr += xstormy16_inst_size;
645         }
646
647 #if 0
648       /* 2001-08-10: Not part of the prologue anymore due to change in
649          ABI. r8 and r9 are not used for argument passing anymore. */
650
651       /* optional copying of r8, r9 to stack */
652       /* 46S7; 73Df HHHH   mov.w r7,rS; mov.w (rD, 0xHHHH), r7 D=8,9; S=13,15 */
653       /* 46S7; 72df HHHH   mov.w r7,rS; mov.b (rD, 0xHHHH), r7 D=8,9; S=13,15 */
654       else if ((inst & 0xffef) == 0x4687 && (inst2 & 0xfedf) == 0x72df)
655         {
656           next_addr += xstormy16_inst_size;
657           if (fi)
658             {
659               regnum = (inst & 0x00f0) >> 4;
660               inst = inst2;
661               inst2 = read_memory_unsigned_integer (next_addr
662                                                     + xstormy16_inst_size,
663                                                     xstormy16_inst_size);
664               /* Only 12 of 16 bits of the argument are used for the
665                  signed offset. */
666               offset = (LONGEST) (inst2 & 0x0fff);
667               if (offset & 0x0800)
668                 offset -= 0x1000;
669
670               fi->saved_regs[regnum] = fi->extra_info->framesize + offset;
671             }
672           next_addr += xstormy16_inst_size;
673         }
674 #endif
675
676       else                      /* Not a prologue instruction. */
677         break;
678     }
679
680   if (fi)
681     {
682       /* Special handling for the "saved" address of the SP:
683          The SP is of course never saved on the stack at all, so
684          by convention what we put here is simply the previous 
685          _value_ of the SP (as opposed to an address where the
686          previous value would have been pushed).  */
687       if (get_frame_extra_info (fi)->frameless_p)
688         {
689           deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - get_frame_extra_info (fi)->framesize;
690           deprecated_update_frame_base_hack (fi, sp);
691         }
692       else
693         {
694           deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - get_frame_extra_info (fi)->framesize;
695           deprecated_update_frame_base_hack (fi, fp);
696         }
697
698       /* So far only offsets to the beginning of the frame are
699          saved in the saved_regs. Now we now the relation between
700          sp, fp and framesize. We know the beginning of the frame
701          so we can translate the register offsets to real addresses. */
702       for (regnum = 0; regnum < E_SP_REGNUM; ++regnum)
703         if (deprecated_get_frame_saved_regs (fi)[regnum])
704           deprecated_get_frame_saved_regs (fi)[regnum] += deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
705
706       /* Save address of PC on stack. */
707       deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM] = deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
708     }
709
710   return next_addr;
711 }
712
713 /* Function: xstormy16_skip_prologue
714    If the input address is in a function prologue, 
715    returns the address of the end of the prologue;
716    else returns the input address.
717
718    Note: the input address is likely to be the function start, 
719    since this function is mainly used for advancing a breakpoint
720    to the first line, or stepping to the first line when we have
721    stepped into a function call.  */
722
723 static CORE_ADDR
724 xstormy16_skip_prologue (CORE_ADDR pc)
725 {
726   CORE_ADDR func_addr = 0, func_end = 0;
727   char *func_name;
728
729   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
730     {
731       struct symtab_and_line sal;
732       struct symbol *sym;
733
734       /* Don't trust line number debug info in frameless functions. */
735       int frameless = 1;
736       CORE_ADDR plg_end = xstormy16_scan_prologue (func_addr, func_end,
737                                                    NULL, &frameless);
738       if (frameless)
739         return plg_end;
740
741       /* Found a function.  */
742       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
743       /* Don't use line number debug info for assembly source files. */
744       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
745         {
746           sal = find_pc_line (func_addr, 0);
747           if (sal.end && sal.end < func_end)
748             {
749               /* Found a line number, use it as end of prologue.  */
750               return sal.end;
751             }
752         }
753       /* No useable line symbol.  Use result of prologue parsing method. */
754       return plg_end;
755     }
756
757   /* No function symbol -- just return the PC. */
758
759   return (CORE_ADDR) pc;
760 }
761
762 /* The epilogue is defined here as the area at the end of a function,
763    either on the `ret' instruction itself or after an instruction which
764    destroys the function's stack frame. */
765 static int
766 xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
767 {
768   CORE_ADDR addr, func_addr = 0, func_end = 0;
769
770   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
771     {
772       ULONGEST inst, inst2;
773       CORE_ADDR addr = func_end - xstormy16_inst_size;
774
775       /* The Xstormy16 epilogue is max. 14 bytes long. */
776       if (pc < func_end - 7 * xstormy16_inst_size)
777         return 0;
778
779       /* Check if we're on a `ret' instruction.  Otherwise it's
780          too dangerous to proceed. */
781       inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
782       if (inst != 0x0003)
783         return 0;
784
785       while ((addr -= xstormy16_inst_size) >= func_addr)
786         {
787           inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
788           if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
789             continue;
790           if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
791             break;
792           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
793                                                 xstormy16_inst_size);
794           if (inst2 == 0x314f && inst >= 0x8000)        /* add r15, neg. value */
795             {
796               addr -= xstormy16_inst_size;
797               break;
798             }
799           return 0;
800         }
801       if (pc > addr)
802         return 1;
803     }
804   return 0;
805 }
806
807 /* Function: xstormy16_frame_init_saved_regs
808    Set up the 'saved_regs' array.
809    This is a data structure containing the addresses on the stack 
810    where each register has been saved, for each stack frame.  
811    Registers that have not been saved will have zero here.
812    The stack register is special: rather than the address where the 
813    stack register has been saved, saved_regs[SP_REGNUM] will have the
814    actual value of the previous frame's stack register. 
815
816    This function may be called in any context where the saved register
817    values may be needed (backtrace, frame_info, frame_register).  On
818    many targets, it is called directly by init_extra_frame_info, in
819    part because the information may be needed immediately by
820    frame_chain.  */
821
822 static void
823 xstormy16_frame_init_saved_regs (struct frame_info *fi)
824 {
825   CORE_ADDR func_addr, func_end;
826
827   if (!deprecated_get_frame_saved_regs (fi))
828     {
829       frame_saved_regs_zalloc (fi);
830
831       /* Find the beginning of this function, so we can analyze its
832          prologue. */
833       if (find_pc_partial_function (get_frame_pc (fi), NULL, &func_addr, &func_end))
834         xstormy16_scan_prologue (func_addr, get_frame_pc (fi), fi, NULL);
835       /* Else we're out of luck (can't debug completely stripped code). 
836          FIXME. */
837     }
838 }
839
840 /* Function: xstormy16_frame_saved_pc
841    Returns the return address for the selected frame. 
842    Called by frame_info, legacy_frame_chain_valid, and sometimes by
843    get_prev_frame.  */
844
845 static CORE_ADDR
846 xstormy16_frame_saved_pc (struct frame_info *fi)
847 {
848   CORE_ADDR saved_pc;
849
850   if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
851     {
852       saved_pc = deprecated_read_register_dummy (get_frame_pc (fi),
853                                                  get_frame_base (fi),
854                                                  E_PC_REGNUM);
855     }
856   else
857     {
858       saved_pc = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM],
859                                                xstormy16_pc_size);
860     }
861
862   return saved_pc;
863 }
864
865 /* Function: xstormy16_init_extra_frame_info
866    This is the constructor function for the frame_info struct, 
867    called whenever a new frame_info is created (from create_new_frame,
868    and from get_prev_frame).
869 */
870
871 static void
872 xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi)
873 {
874   if (!get_frame_extra_info (fi))
875     {
876       frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
877       get_frame_extra_info (fi)->framesize = 0;
878       get_frame_extra_info (fi)->frameless_p = 1;       /* Default frameless, detect framed */
879
880       /* By default, the fi->frame is set to the value of the FP reg by gdb.
881          This may not always be right; we may be in a frameless function,
882          or we may be in the prologue, before the FP has been set up.
883          Unfortunately, we can't make this determination without first
884          calling scan_prologue, and we can't do that unles we know the
885          get_frame_pc (fi).  */
886
887       if (!get_frame_pc (fi))
888         {
889           /* Sometimes we are called from get_prev_frame without
890              the PC being set up first.  Long history, don't ask.
891              Fortunately this will never happen from the outermost
892              frame, so we should be able to get the saved pc from
893              the next frame. */
894           if (get_next_frame (fi))
895             deprecated_update_frame_pc_hack (fi, xstormy16_frame_saved_pc (get_next_frame (fi)));
896         }
897
898       /* Take care of the saved_regs right here (non-lazy). */
899       xstormy16_frame_init_saved_regs (fi);
900     }
901 }
902
903 /* Function: xstormy16_frame_chain
904    Returns a pointer to the stack frame of the calling function.
905    Called only from get_prev_frame.  Needed for backtrace, "up", etc.
906 */
907
908 static CORE_ADDR
909 xstormy16_frame_chain (struct frame_info *fi)
910 {
911   if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
912     {
913       /* Call dummy's frame is the same as caller's.  */
914       return get_frame_base (fi);
915     }
916   else
917     {
918       /* Return computed offset from this frame's fp. */
919       return get_frame_base (fi) - get_frame_extra_info (fi)->framesize;
920     }
921 }
922
923 static int
924 xstormy16_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
925 {
926   return chain < 0x8000 && DEPRECATED_FRAME_SAVED_PC (thisframe) >= 0x8000 &&
927     (get_frame_extra_info (thisframe)->frameless_p ||
928      get_frame_base (thisframe) - get_frame_extra_info (thisframe)->framesize == chain);
929 }
930
931 /* Function: xstormy16_saved_pc_after_call Returns the previous PC
932    immediately after a function call.  This function is meant to
933    bypass the regular frame_register() mechanism, ie. it is meant to
934    work even if the frame isn't complete.  Called by
935    step_over_function, and sometimes by get_prev_frame.  */
936
937 static CORE_ADDR
938 xstormy16_saved_pc_after_call (struct frame_info *ignore)
939 {
940   CORE_ADDR sp, pc, tmp;
941
942   sp = read_register (E_SP_REGNUM) - xstormy16_pc_size;
943   pc = read_memory_integer (sp, xstormy16_pc_size);
944
945   /* Skip over jump table entry if necessary.  */
946   if ((tmp = SKIP_TRAMPOLINE_CODE (pc)))
947     pc = tmp;
948
949   return pc;
950 }
951
952 const static unsigned char *
953 xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
954 {
955   static unsigned char breakpoint[] = { 0x06, 0x0 };
956   *lenptr = sizeof (breakpoint);
957   return breakpoint;
958 }
959
960 /* Given a pointer to a jump table entry, return the address
961    of the function it jumps to.  Return 0 if not found. */
962 static CORE_ADDR
963 xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr)
964 {
965   struct obj_section *faddr_sect = find_pc_section (faddr);
966
967   if (faddr_sect)
968     {
969       LONGEST inst, inst2, addr;
970       char buf[2 * xstormy16_inst_size];
971
972       /* Return faddr if it's not pointing into the jump table. */
973       if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
974         return faddr;
975
976       if (!target_read_memory (faddr, buf, sizeof buf))
977         {
978           inst = extract_unsigned_integer (buf, xstormy16_inst_size);
979           inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
980                                             xstormy16_inst_size);
981           addr = inst2 << 8 | (inst & 0xff);
982           return addr;
983         }
984     }
985   return 0;
986 }
987
988 /* Given a function's address, attempt to find (and return) the
989    address of the corresponding jump table entry.  Return 0 if
990    not found. */
991 static CORE_ADDR
992 xstormy16_find_jmp_table_entry (CORE_ADDR faddr)
993 {
994   struct obj_section *faddr_sect = find_pc_section (faddr);
995
996   if (faddr_sect)
997     {
998       struct obj_section *osect;
999
1000       /* Return faddr if it's already a pointer to a jump table entry. */
1001       if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
1002         return faddr;
1003
1004       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
1005       {
1006         if (!strcmp (osect->the_bfd_section->name, ".plt"))
1007           break;
1008       }
1009
1010       if (osect < faddr_sect->objfile->sections_end)
1011         {
1012           CORE_ADDR addr;
1013           for (addr = osect->addr;
1014                addr < osect->endaddr; addr += 2 * xstormy16_inst_size)
1015             {
1016               int status;
1017               LONGEST inst, inst2, faddr2;
1018               char buf[2 * xstormy16_inst_size];
1019
1020               if (target_read_memory (addr, buf, sizeof buf))
1021                 return 0;
1022               inst = extract_unsigned_integer (buf, xstormy16_inst_size);
1023               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
1024                                                 xstormy16_inst_size);
1025               faddr2 = inst2 << 8 | (inst & 0xff);
1026               if (faddr == faddr2)
1027                 return addr;
1028             }
1029         }
1030     }
1031   return 0;
1032 }
1033
1034 static CORE_ADDR
1035 xstormy16_skip_trampoline_code (CORE_ADDR pc)
1036 {
1037   int tmp = xstormy16_resolve_jmp_table_entry (pc);
1038
1039   if (tmp && tmp != pc)
1040     return tmp;
1041   return 0;
1042 }
1043
1044 static int
1045 xstormy16_in_solib_call_trampoline (CORE_ADDR pc, char *name)
1046 {
1047   return xstormy16_skip_trampoline_code (pc) != 0;
1048 }
1049
1050 static CORE_ADDR
1051 xstormy16_pointer_to_address (struct type *type, const void *buf)
1052 {
1053   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
1054   CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
1055
1056   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
1057     {
1058       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr);
1059       if (addr2)
1060         addr = addr2;
1061     }
1062
1063   return addr;
1064 }
1065
1066 static void
1067 xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
1068 {
1069   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
1070
1071   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
1072     {
1073       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr);
1074       if (addr2)
1075         addr = addr2;
1076     }
1077   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
1078 }
1079
1080 static CORE_ADDR
1081 xstormy16_stack_align (CORE_ADDR addr)
1082 {
1083   if (addr & 1)
1084     ++addr;
1085   return addr;
1086 }
1087
1088 static void
1089 xstormy16_save_dummy_frame_tos (CORE_ADDR sp)
1090 {
1091   generic_save_dummy_frame_tos (sp - xstormy16_pc_size);
1092 }
1093
1094 /* Function: xstormy16_gdbarch_init
1095    Initializer function for the xstormy16 gdbarch vector.
1096    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
1097
1098 static struct gdbarch *
1099 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1100 {
1101   struct gdbarch_tdep *tdep = NULL;
1102   struct gdbarch *gdbarch;
1103
1104   /* find a candidate among the list of pre-declared architectures. */
1105   arches = gdbarch_list_lookup_by_info (arches, &info);
1106   if (arches != NULL)
1107     return (arches->gdbarch);
1108
1109 #if 0
1110   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1111 #endif
1112
1113   gdbarch = gdbarch_alloc (&info, 0);
1114
1115   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1116      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
1117   set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
1118
1119   /*
1120    * Basic register fields and methods.
1121    */
1122
1123   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1124   set_gdbarch_num_pseudo_regs (gdbarch, 0);
1125   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1126   set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
1127   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1128   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
1129   set_gdbarch_deprecated_register_size (gdbarch, xstormy16_reg_size);
1130   set_gdbarch_deprecated_register_bytes (gdbarch, E_ALL_REGS_SIZE);
1131   set_gdbarch_deprecated_register_byte (gdbarch, xstormy16_register_byte);
1132   set_gdbarch_deprecated_register_raw_size (gdbarch, xstormy16_register_raw_size);
1133   set_gdbarch_deprecated_max_register_raw_size (gdbarch, xstormy16_pc_size);
1134   set_gdbarch_deprecated_register_virtual_size (gdbarch, xstormy16_register_raw_size);
1135   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4);
1136   set_gdbarch_deprecated_register_virtual_type (gdbarch, xstormy16_reg_virtual_type);
1137
1138   /*
1139    * Frame Info
1140    */
1141   set_gdbarch_deprecated_init_extra_frame_info (gdbarch,
1142                                      xstormy16_init_extra_frame_info);
1143   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
1144                                      xstormy16_frame_init_saved_regs);
1145   set_gdbarch_deprecated_frame_chain (gdbarch, xstormy16_frame_chain);
1146   set_gdbarch_deprecated_get_saved_register (gdbarch, xstormy16_get_saved_register);
1147   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call);
1148   set_gdbarch_deprecated_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc);
1149   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
1150   set_gdbarch_deprecated_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
1151
1152   set_gdbarch_in_function_epilogue_p (gdbarch,
1153                                       xstormy16_in_function_epilogue_p);
1154
1155   /* 
1156    * Miscelany
1157    */
1158   /* Stack grows up. */
1159   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
1160
1161   /*
1162    * Call Dummies
1163    * 
1164    * These values and methods are used when gdb calls a target function.  */
1165   set_gdbarch_deprecated_push_return_address (gdbarch, xstormy16_push_return_address);
1166   set_gdbarch_deprecated_extract_return_value (gdbarch, xstormy16_extract_return_value);
1167   set_gdbarch_deprecated_push_arguments (gdbarch, xstormy16_push_arguments);
1168   set_gdbarch_deprecated_pop_frame (gdbarch, xstormy16_pop_frame);
1169   set_gdbarch_deprecated_store_struct_return (gdbarch, xstormy16_store_struct_return);
1170   set_gdbarch_deprecated_store_return_value (gdbarch, xstormy16_store_return_value);
1171   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, xstormy16_extract_struct_value_address);
1172   set_gdbarch_use_struct_convention (gdbarch,
1173                                      xstormy16_use_struct_convention);
1174   set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
1175
1176   set_gdbarch_char_signed (gdbarch, 0);
1177   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1178   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1179   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1180   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1181
1182   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
1183   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
1184
1185   set_gdbarch_deprecated_stack_align (gdbarch, xstormy16_stack_align);
1186
1187   set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos);
1188
1189   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
1190
1191   set_gdbarch_in_solib_call_trampoline (gdbarch,
1192                                         xstormy16_in_solib_call_trampoline);
1193
1194   /* Should be using push_dummy_call.  */
1195   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1196
1197   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
1198
1199   return gdbarch;
1200 }
1201
1202 /* Function: _initialize_xstormy16_tdep
1203    Initializer function for the Sanyo Xstormy16a module.
1204    Called by gdb at start-up. */
1205
1206 extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
1207
1208 void
1209 _initialize_xstormy16_tdep (void)
1210 {
1211   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
1212 }