Update
[gdb.git] / gdb / xstormy16-tdep.c
blob78173cf913dd21bee1b9e0a73aa9b8a6465a99a1
1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "defs.h"
22 #include "frame.h"
23 #include "frame-base.h"
24 #include "frame-unwind.h"
25 #include "dwarf2-frame.h"
26 #include "symtab.h"
27 #include "gdbtypes.h"
28 #include "gdbcmd.h"
29 #include "gdbcore.h"
30 #include "value.h"
31 #include "dis-asm.h"
32 #include "inferior.h"
33 #include "gdb_string.h"
34 #include "gdb_assert.h"
35 #include "arch-utils.h"
36 #include "floatformat.h"
37 #include "regcache.h"
38 #include "doublest.h"
39 #include "osabi.h"
40 #include "objfiles.h"
42 enum gdb_regnum
44 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
45 Functions will return their values in register R2-R7 as they fit.
46 Otherwise a hidden pointer to an big enough area is given as argument
47 to the function in r2. Further arguments are beginning in r3 then.
48 R13 is used as frame pointer when GCC compiles w/o optimization
49 R14 is used as "PSW", displaying the CPU status.
50 R15 is used implicitely as stack pointer. */
51 E_R0_REGNUM,
52 E_R1_REGNUM,
53 E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
54 E_R3_REGNUM,
55 E_R4_REGNUM,
56 E_R5_REGNUM,
57 E_R6_REGNUM,
58 E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
59 E_R8_REGNUM,
60 E_R9_REGNUM,
61 E_R10_REGNUM,
62 E_R11_REGNUM,
63 E_R12_REGNUM,
64 E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
65 E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
66 E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
67 E_PC_REGNUM,
68 E_NUM_REGS
71 /* Use an invalid address value as 'not available' marker. */
72 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
74 struct xstormy16_frame_cache
76 /* Base address. */
77 CORE_ADDR base;
78 CORE_ADDR pc;
79 LONGEST framesize;
80 int uses_fp;
81 CORE_ADDR saved_regs[E_NUM_REGS];
82 CORE_ADDR saved_sp;
85 /* Size of instructions, registers, etc. */
86 enum
88 xstormy16_inst_size = 2,
89 xstormy16_reg_size = 2,
90 xstormy16_pc_size = 4
93 /* Size of return datatype which fits into the remaining return registers. */
94 #define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
95 * xstormy16_reg_size)
97 /* Size of return datatype which fits into all return registers. */
98 enum
100 E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
103 /* Function: xstormy16_register_name
104 Returns the name of the standard Xstormy16 register N. */
106 static const char *
107 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
109 static char *register_names[] = {
110 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
111 "r8", "r9", "r10", "r11", "r12", "r13",
112 "psw", "sp", "pc"
115 if (regnum < 0 || regnum >= E_NUM_REGS)
116 internal_error (__FILE__, __LINE__,
117 _("xstormy16_register_name: illegal register number %d"),
118 regnum);
119 else
120 return register_names[regnum];
124 static struct type *
125 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
127 if (regnum == E_PC_REGNUM)
128 return builtin_type_uint32;
129 else
130 return builtin_type_uint16;
133 /* Function: xstormy16_type_is_scalar
134 Makes the decision if a given type is a scalar types. Scalar
135 types are returned in the registers r2-r7 as they fit. */
137 static int
138 xstormy16_type_is_scalar (struct type *t)
140 return (TYPE_CODE(t) != TYPE_CODE_STRUCT
141 && TYPE_CODE(t) != TYPE_CODE_UNION
142 && TYPE_CODE(t) != TYPE_CODE_ARRAY);
145 /* Function: xstormy16_use_struct_convention
146 Returns non-zero if the given struct type will be returned using
147 a special convention, rather than the normal function return method.
148 7sed in the contexts of the "return" command, and of
149 target function calls from the debugger. */
151 static int
152 xstormy16_use_struct_convention (struct type *type)
154 return !xstormy16_type_is_scalar (type)
155 || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
158 /* Function: xstormy16_extract_return_value
159 Find a function's return value in the appropriate registers (in
160 regbuf), and copy it into valbuf. */
162 static void
163 xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
164 void *valbuf)
166 int len = TYPE_LENGTH (type);
167 int i, regnum = E_1ST_ARG_REGNUM;
169 for (i = 0; i < len; i += xstormy16_reg_size)
170 regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
173 /* Function: xstormy16_store_return_value
174 Copy the function return value from VALBUF into the
175 proper location for a function return.
176 Called only in the context of the "return" command. */
178 static void
179 xstormy16_store_return_value (struct type *type, struct regcache *regcache,
180 const void *valbuf)
182 if (TYPE_LENGTH (type) == 1)
184 /* Add leading zeros to the value. */
185 char buf[xstormy16_reg_size];
186 memset (buf, 0, xstormy16_reg_size);
187 memcpy (buf, valbuf, 1);
188 regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
190 else
192 int len = TYPE_LENGTH (type);
193 int i, regnum = E_1ST_ARG_REGNUM;
195 for (i = 0; i < len; i += xstormy16_reg_size)
196 regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
200 static enum return_value_convention
201 xstormy16_return_value (struct gdbarch *gdbarch, struct type *type,
202 struct regcache *regcache,
203 gdb_byte *readbuf, const gdb_byte *writebuf)
205 if (xstormy16_use_struct_convention (type))
206 return RETURN_VALUE_STRUCT_CONVENTION;
207 if (writebuf)
208 xstormy16_store_return_value (type, regcache, writebuf);
209 else if (readbuf)
210 xstormy16_extract_return_value (type, regcache, readbuf);
211 return RETURN_VALUE_REGISTER_CONVENTION;
214 static CORE_ADDR
215 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
217 if (addr & 1)
218 ++addr;
219 return addr;
222 /* Function: xstormy16_push_dummy_call
223 Setup the function arguments for GDB to call a function in the inferior.
224 Called only in the context of a target function call from the debugger.
225 Returns the value of the SP register after the args are pushed. */
227 static CORE_ADDR
228 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
229 struct value *function,
230 struct regcache *regcache,
231 CORE_ADDR bp_addr, int nargs,
232 struct value **args,
233 CORE_ADDR sp, int struct_return,
234 CORE_ADDR struct_addr)
236 CORE_ADDR stack_dest = sp;
237 int argreg = E_1ST_ARG_REGNUM;
238 int i, j;
239 int typelen, slacklen;
240 const gdb_byte *val;
241 char buf[xstormy16_pc_size];
243 /* If struct_return is true, then the struct return address will
244 consume one argument-passing register. */
245 if (struct_return)
247 regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
248 argreg++;
251 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
252 fit in the remaining registers we're switching over to the stack.
253 No argument is put on stack partially and as soon as we switched
254 over to stack no further argument is put in a register even if it
255 would fit in the remaining unused registers. */
256 for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
258 typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
259 if (typelen > E_MAX_RETTYPE_SIZE (argreg))
260 break;
262 /* Put argument into registers wordwise. */
263 val = value_contents (args[i]);
264 for (j = 0; j < typelen; j += xstormy16_reg_size)
265 regcache_cooked_write_unsigned (regcache, argreg++,
266 extract_unsigned_integer (val + j,
267 typelen - j ==
268 1 ? 1 :
269 xstormy16_reg_size));
272 /* Align SP */
273 stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
275 /* Loop backwards through remaining arguments and push them on the stack,
276 wordaligned. */
277 for (j = nargs - 1; j >= i; j--)
279 char *val;
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);
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;
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;
296 /* Update stack pointer. */
297 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
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;
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.
309 Returns the address of the first instruction after the prologue. */
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)
316 CORE_ADDR next_addr;
317 ULONGEST inst, inst2;
318 LONGEST offset;
319 int regnum;
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;
325 if (start_addr >= end_addr)
326 return end_addr;
328 for (next_addr = start_addr;
329 next_addr < end_addr; next_addr += xstormy16_inst_size)
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);
335 if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
337 regnum = inst & 0x000f;
338 cache->saved_regs[regnum] = cache->framesize;
339 cache->framesize += xstormy16_reg_size;
342 /* optional stack allocation for args and local vars <= 4 byte */
343 else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
345 cache->framesize += ((inst & 0x0030) >> 4) + 1;
348 /* optional stack allocation for args and local vars > 4 && < 16 byte */
349 else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
351 cache->framesize += (inst & 0x00f0) >> 4;
354 /* optional stack allocation for args and local vars >= 16 byte */
355 else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
357 cache->framesize += inst2;
358 next_addr += xstormy16_inst_size;
361 else if (inst == 0x46fd) /* mov r13, r15 */
363 cache->uses_fp = 1;
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)
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)
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;
385 cache->saved_regs[regnum] = cache->framesize + offset;
386 next_addr += xstormy16_inst_size;
389 else /* Not a prologue instruction. */
390 break;
393 return next_addr;
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.
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. */
406 static CORE_ADDR
407 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
409 CORE_ADDR func_addr = 0, func_end = 0;
410 char *func_name;
412 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
414 struct symtab_and_line sal;
415 struct symbol *sym;
416 struct xstormy16_frame_cache cache;
417 CORE_ADDR plg_end;
419 memset (&cache, 0, sizeof cache);
421 /* Don't trust line number debug info in frameless functions. */
422 plg_end = xstormy16_analyze_prologue (func_addr, func_end, &cache, NULL);
423 if (!cache.uses_fp)
424 return plg_end;
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)
431 sal = find_pc_line (func_addr, 0);
432 if (sal.end && sal.end < func_end)
434 /* Found a line number, use it as end of prologue. */
435 return sal.end;
438 /* No useable line symbol. Use result of prologue parsing method. */
439 return plg_end;
442 /* No function symbol -- just return the PC. */
444 return (CORE_ADDR) pc;
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)
453 CORE_ADDR func_addr = 0, func_end = 0;
455 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
457 ULONGEST inst, inst2;
458 CORE_ADDR addr = func_end - xstormy16_inst_size;
460 /* The Xstormy16 epilogue is max. 14 bytes long. */
461 if (pc < func_end - 7 * xstormy16_inst_size)
462 return 0;
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;
470 while ((addr -= xstormy16_inst_size) >= func_addr)
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 */
481 addr -= xstormy16_inst_size;
482 break;
484 return 0;
486 if (pc > addr)
487 return 1;
489 return 0;
492 const static unsigned char *
493 xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
494 int *lenptr)
496 static unsigned char breakpoint[] = { 0x06, 0x0 };
497 *lenptr = sizeof (breakpoint);
498 return breakpoint;
501 /* Given a pointer to a jump table entry, return the address
502 of the function it jumps to. Return 0 if not found. */
503 static CORE_ADDR
504 xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr)
506 struct obj_section *faddr_sect = find_pc_section (faddr);
508 if (faddr_sect)
510 LONGEST inst, inst2, addr;
511 char buf[2 * xstormy16_inst_size];
513 /* Return faddr if it's not pointing into the jump table. */
514 if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
515 return faddr;
517 if (!target_read_memory (faddr, buf, sizeof buf))
519 inst = extract_unsigned_integer (buf, xstormy16_inst_size);
520 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
521 xstormy16_inst_size);
522 addr = inst2 << 8 | (inst & 0xff);
523 return addr;
526 return 0;
529 /* Given a function's address, attempt to find (and return) the
530 address of the corresponding jump table entry. Return 0 if
531 not found. */
532 static CORE_ADDR
533 xstormy16_find_jmp_table_entry (CORE_ADDR faddr)
535 struct obj_section *faddr_sect = find_pc_section (faddr);
537 if (faddr_sect)
539 struct obj_section *osect;
541 /* Return faddr if it's already a pointer to a jump table entry. */
542 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
543 return faddr;
545 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
547 if (!strcmp (osect->the_bfd_section->name, ".plt"))
548 break;
551 if (osect < faddr_sect->objfile->sections_end)
553 CORE_ADDR addr;
554 for (addr = osect->addr;
555 addr < osect->endaddr; addr += 2 * xstormy16_inst_size)
557 LONGEST inst, inst2, faddr2;
558 char buf[2 * xstormy16_inst_size];
560 if (target_read_memory (addr, buf, sizeof buf))
561 return 0;
562 inst = extract_unsigned_integer (buf, xstormy16_inst_size);
563 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
564 xstormy16_inst_size);
565 faddr2 = inst2 << 8 | (inst & 0xff);
566 if (faddr == faddr2)
567 return addr;
571 return 0;
574 static CORE_ADDR
575 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
577 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (pc);
579 if (tmp && tmp != pc)
580 return tmp;
581 return 0;
584 /* Function pointers are 16 bit. The address space is 24 bit, using
585 32 bit addresses. Pointers to functions on the XStormy16 are implemented
586 by using 16 bit pointers, which are either direct pointers in case the
587 function begins below 0x10000, or indirect pointers into a jump table.
588 The next two functions convert 16 bit pointers into 24 (32) bit addresses
589 and vice versa. */
591 static CORE_ADDR
592 xstormy16_pointer_to_address (struct type *type, const gdb_byte *buf)
594 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
595 CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
597 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
599 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr);
600 if (addr2)
601 addr = addr2;
604 return addr;
607 static void
608 xstormy16_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
610 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
612 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
614 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr);
615 if (addr2)
616 addr = addr2;
618 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
621 static struct xstormy16_frame_cache *
622 xstormy16_alloc_frame_cache (void)
624 struct xstormy16_frame_cache *cache;
625 int i;
627 cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
629 cache->base = 0;
630 cache->saved_sp = 0;
631 cache->pc = 0;
632 cache->uses_fp = 0;
633 cache->framesize = 0;
634 for (i = 0; i < E_NUM_REGS; ++i)
635 cache->saved_regs[i] = REG_UNAVAIL;
637 return cache;
640 static struct xstormy16_frame_cache *
641 xstormy16_frame_cache (struct frame_info *next_frame, void **this_cache)
643 struct xstormy16_frame_cache *cache;
644 CORE_ADDR current_pc;
645 int i;
647 if (*this_cache)
648 return *this_cache;
650 cache = xstormy16_alloc_frame_cache ();
651 *this_cache = cache;
653 cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
654 if (cache->base == 0)
655 return cache;
657 cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
658 current_pc = frame_pc_unwind (next_frame);
659 if (cache->pc)
660 xstormy16_analyze_prologue (cache->pc, current_pc, cache, next_frame);
662 if (!cache->uses_fp)
663 cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
665 cache->saved_sp = cache->base - cache->framesize;
667 for (i = 0; i < E_NUM_REGS; ++i)
668 if (cache->saved_regs[i] != REG_UNAVAIL)
669 cache->saved_regs[i] += cache->saved_sp;
671 return cache;
674 static void
675 xstormy16_frame_prev_register (struct frame_info *next_frame,
676 void **this_cache,
677 int regnum, int *optimizedp,
678 enum lval_type *lvalp, CORE_ADDR *addrp,
679 int *realnump, gdb_byte *valuep)
681 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
682 this_cache);
683 gdb_assert (regnum >= 0);
685 if (regnum == E_SP_REGNUM && cache->saved_sp)
687 *optimizedp = 0;
688 *lvalp = not_lval;
689 *addrp = 0;
690 *realnump = -1;
691 if (valuep)
693 /* Store the value. */
694 store_unsigned_integer (valuep, xstormy16_reg_size, cache->saved_sp);
696 return;
699 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
701 *optimizedp = 0;
702 *lvalp = lval_memory;
703 *addrp = cache->saved_regs[regnum];
704 *realnump = -1;
705 if (valuep)
707 /* Read the value in from memory. */
708 read_memory (*addrp, valuep,
709 register_size (get_frame_arch (next_frame), regnum));
711 return;
714 *optimizedp = 0;
715 *lvalp = lval_register;
716 *addrp = 0;
717 *realnump = regnum;
718 if (valuep)
719 frame_unwind_register (next_frame, (*realnump), valuep);
722 static void
723 xstormy16_frame_this_id (struct frame_info *next_frame, void **this_cache,
724 struct frame_id *this_id)
726 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
727 this_cache);
729 /* This marks the outermost frame. */
730 if (cache->base == 0)
731 return;
733 *this_id = frame_id_build (cache->saved_sp, cache->pc);
736 static CORE_ADDR
737 xstormy16_frame_base_address (struct frame_info *next_frame, void **this_cache)
739 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (next_frame,
740 this_cache);
741 return cache->base;
744 static const struct frame_unwind xstormy16_frame_unwind = {
745 NORMAL_FRAME,
746 xstormy16_frame_this_id,
747 xstormy16_frame_prev_register
750 static const struct frame_base xstormy16_frame_base = {
751 &xstormy16_frame_unwind,
752 xstormy16_frame_base_address,
753 xstormy16_frame_base_address,
754 xstormy16_frame_base_address
757 static const struct frame_unwind *
758 xstormy16_frame_sniffer (struct frame_info *next_frame)
760 return &xstormy16_frame_unwind;
763 static CORE_ADDR
764 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
766 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
769 static CORE_ADDR
770 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
772 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
775 static struct frame_id
776 xstormy16_unwind_dummy_id (struct gdbarch *gdbarch,
777 struct frame_info *next_frame)
779 return frame_id_build (xstormy16_unwind_sp (gdbarch, next_frame),
780 frame_pc_unwind (next_frame));
784 /* Function: xstormy16_gdbarch_init
785 Initializer function for the xstormy16 gdbarch vector.
786 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
788 static struct gdbarch *
789 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
791 struct gdbarch *gdbarch;
793 /* find a candidate among the list of pre-declared architectures. */
794 arches = gdbarch_list_lookup_by_info (arches, &info);
795 if (arches != NULL)
796 return (arches->gdbarch);
798 gdbarch = gdbarch_alloc (&info, NULL);
801 * Basic register fields and methods, datatype sizes and stuff.
804 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
805 set_gdbarch_num_pseudo_regs (gdbarch, 0);
806 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
807 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
808 set_gdbarch_register_name (gdbarch, xstormy16_register_name);
809 set_gdbarch_register_type (gdbarch, xstormy16_register_type);
811 set_gdbarch_char_signed (gdbarch, 0);
812 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
813 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
814 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
815 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
817 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
818 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
819 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
821 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
822 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
824 set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
825 set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
827 /* Stack grows up. */
828 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
831 * Frame Info
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);
839 set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
840 set_gdbarch_in_function_epilogue_p (gdbarch,
841 xstormy16_in_function_epilogue_p);
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);
848 set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
850 set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
852 gdbarch_init_osabi (info, gdbarch);
854 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
855 frame_unwind_append_sniffer (gdbarch, xstormy16_frame_sniffer);
857 return gdbarch;
860 /* Function: _initialize_xstormy16_tdep
861 Initializer function for the Sanyo Xstormy16a module.
862 Called by gdb at start-up. */
864 extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
866 void
867 _initialize_xstormy16_tdep (void)
869 register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);