Automatic date update in version.in
[binutils-gdb.git] / gdb / xstormy16-tdep.c
blobc0fe5dab1cbf77937dc10ca0e8eef0c0483a022c
1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
3 Copyright (C) 2001-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "defs.h"
21 #include "frame.h"
22 #include "frame-base.h"
23 #include "frame-unwind.h"
24 #include "dwarf2/frame.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "gdbcmd.h"
28 #include "gdbcore.h"
29 #include "value.h"
30 #include "dis-asm.h"
31 #include "inferior.h"
32 #include "arch-utils.h"
33 #include "regcache.h"
34 #include "osabi.h"
35 #include "objfiles.h"
36 #include "gdbsupport/byte-vector.h"
38 enum gdb_regnum
40 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
41 Functions will return their values in register R2-R7 as they fit.
42 Otherwise a hidden pointer to an big enough area is given as argument
43 to the function in r2. Further arguments are beginning in r3 then.
44 R13 is used as frame pointer when GCC compiles w/o optimization
45 R14 is used as "PSW", displaying the CPU status.
46 R15 is used implicitly as stack pointer. */
47 E_R0_REGNUM,
48 E_R1_REGNUM,
49 E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
50 E_R3_REGNUM,
51 E_R4_REGNUM,
52 E_R5_REGNUM,
53 E_R6_REGNUM,
54 E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
55 E_R8_REGNUM,
56 E_R9_REGNUM,
57 E_R10_REGNUM,
58 E_R11_REGNUM,
59 E_R12_REGNUM,
60 E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
61 E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
62 E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
63 E_PC_REGNUM,
64 E_NUM_REGS
67 /* Use an invalid address value as 'not available' marker. */
68 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
70 struct xstormy16_frame_cache
72 /* Base address. */
73 CORE_ADDR base;
74 CORE_ADDR pc;
75 LONGEST framesize;
76 int uses_fp;
77 CORE_ADDR saved_regs[E_NUM_REGS];
78 CORE_ADDR saved_sp;
81 /* Size of instructions, registers, etc. */
82 enum
84 xstormy16_inst_size = 2,
85 xstormy16_reg_size = 2,
86 xstormy16_pc_size = 4
89 /* Size of return datatype which fits into the remaining return registers. */
90 #define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
91 * xstormy16_reg_size)
93 /* Size of return datatype which fits into all return registers. */
94 enum
96 E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
99 /* Function: xstormy16_register_name
100 Returns the name of the standard Xstormy16 register N. */
102 static const char *
103 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
105 static const char *register_names[] = {
106 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
107 "r8", "r9", "r10", "r11", "r12", "r13",
108 "psw", "sp", "pc"
111 if (regnum < 0 || regnum >= E_NUM_REGS)
112 internal_error (__FILE__, __LINE__,
113 _("xstormy16_register_name: illegal register number %d"),
114 regnum);
115 else
116 return register_names[regnum];
120 static struct type *
121 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
123 if (regnum == E_PC_REGNUM)
124 return builtin_type (gdbarch)->builtin_uint32;
125 else
126 return builtin_type (gdbarch)->builtin_uint16;
129 /* Function: xstormy16_type_is_scalar
130 Makes the decision if a given type is a scalar types. Scalar
131 types are returned in the registers r2-r7 as they fit. */
133 static int
134 xstormy16_type_is_scalar (struct type *t)
136 return (t->code () != TYPE_CODE_STRUCT
137 && t->code () != TYPE_CODE_UNION
138 && t->code () != TYPE_CODE_ARRAY);
141 /* Function: xstormy16_use_struct_convention
142 Returns non-zero if the given struct type will be returned using
143 a special convention, rather than the normal function return method.
144 7sed in the contexts of the "return" command, and of
145 target function calls from the debugger. */
147 static int
148 xstormy16_use_struct_convention (struct type *type)
150 return !xstormy16_type_is_scalar (type)
151 || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
154 /* Function: xstormy16_extract_return_value
155 Find a function's return value in the appropriate registers (in
156 regbuf), and copy it into valbuf. */
158 static void
159 xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
160 gdb_byte *valbuf)
162 int len = TYPE_LENGTH (type);
163 int i, regnum = E_1ST_ARG_REGNUM;
165 for (i = 0; i < len; i += xstormy16_reg_size)
166 regcache->raw_read (regnum++, valbuf + i);
169 /* Function: xstormy16_store_return_value
170 Copy the function return value from VALBUF into the
171 proper location for a function return.
172 Called only in the context of the "return" command. */
174 static void
175 xstormy16_store_return_value (struct type *type, struct regcache *regcache,
176 const gdb_byte *valbuf)
178 if (TYPE_LENGTH (type) == 1)
180 /* Add leading zeros to the value. */
181 gdb_byte buf[xstormy16_reg_size];
182 memset (buf, 0, xstormy16_reg_size);
183 memcpy (buf, valbuf, 1);
184 regcache->raw_write (E_1ST_ARG_REGNUM, buf);
186 else
188 int len = TYPE_LENGTH (type);
189 int i, regnum = E_1ST_ARG_REGNUM;
191 for (i = 0; i < len; i += xstormy16_reg_size)
192 regcache->raw_write (regnum++, valbuf + i);
196 static enum return_value_convention
197 xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
198 struct type *type, struct regcache *regcache,
199 gdb_byte *readbuf, const gdb_byte *writebuf)
201 if (xstormy16_use_struct_convention (type))
202 return RETURN_VALUE_STRUCT_CONVENTION;
203 if (writebuf)
204 xstormy16_store_return_value (type, regcache, writebuf);
205 else if (readbuf)
206 xstormy16_extract_return_value (type, regcache, readbuf);
207 return RETURN_VALUE_REGISTER_CONVENTION;
210 static CORE_ADDR
211 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
213 if (addr & 1)
214 ++addr;
215 return addr;
218 /* Function: xstormy16_push_dummy_call
219 Setup the function arguments for GDB to call a function in the inferior.
220 Called only in the context of a target function call from the debugger.
221 Returns the value of the SP register after the args are pushed. */
223 static CORE_ADDR
224 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
225 struct value *function,
226 struct regcache *regcache,
227 CORE_ADDR bp_addr, int nargs,
228 struct value **args,
229 CORE_ADDR sp,
230 function_call_return_method return_method,
231 CORE_ADDR struct_addr)
233 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
234 CORE_ADDR stack_dest = sp;
235 int argreg = E_1ST_ARG_REGNUM;
236 int i, j;
237 int typelen, slacklen;
238 gdb_byte buf[xstormy16_pc_size];
240 /* If returning a struct using target ABI method, then the struct return
241 address will consume one argument-passing register. */
242 if (return_method == return_method_struct)
244 regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
245 argreg++;
248 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
249 fit in the remaining registers we're switching over to the stack.
250 No argument is put on stack partially and as soon as we switched
251 over to stack no further argument is put in a register even if it
252 would fit in the remaining unused registers. */
253 for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
255 typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
256 if (typelen > E_MAX_RETTYPE_SIZE (argreg))
257 break;
259 /* Put argument into registers wordwise. */
260 const gdb_byte *val = value_contents (args[i]).data ();
261 for (j = 0; j < typelen; j += xstormy16_reg_size)
263 ULONGEST regval;
264 int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
266 regval = extract_unsigned_integer (val + j, size, byte_order);
267 regcache_cooked_write_unsigned (regcache, argreg++, regval);
271 /* Align SP */
272 stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
274 /* Loop backwards through remaining arguments and push them on the stack,
275 wordaligned. */
276 for (j = nargs - 1; j >= i; j--)
278 const gdb_byte *bytes = value_contents (args[j]).data ();
280 typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
281 slacklen = typelen & 1;
282 gdb::byte_vector val (typelen + slacklen);
283 memcpy (val.data (), bytes, typelen);
284 memset (val.data () + typelen, 0, slacklen);
286 /* Now write this data to the stack. The stack grows upwards. */
287 write_memory (stack_dest, val.data (), typelen + slacklen);
288 stack_dest += typelen + slacklen;
291 store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
292 write_memory (stack_dest, buf, xstormy16_pc_size);
293 stack_dest += xstormy16_pc_size;
295 /* Update stack pointer. */
296 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
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;
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.
308 Returns the address of the first instruction after the prologue. */
310 static CORE_ADDR
311 xstormy16_analyze_prologue (struct gdbarch *gdbarch,
312 CORE_ADDR start_addr, CORE_ADDR end_addr,
313 struct xstormy16_frame_cache *cache,
314 struct frame_info *this_frame)
316 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
317 CORE_ADDR next_addr;
318 ULONGEST inst, inst2;
319 LONGEST offset;
320 int regnum;
322 /* Initialize framesize with size of PC put on stack by CALLF inst. */
323 cache->saved_regs[E_PC_REGNUM] = 0;
324 cache->framesize = xstormy16_pc_size;
326 if (start_addr >= end_addr)
327 return end_addr;
329 for (next_addr = start_addr;
330 next_addr < end_addr; next_addr += xstormy16_inst_size)
332 inst = read_memory_unsigned_integer (next_addr,
333 xstormy16_inst_size, byte_order);
334 inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
335 xstormy16_inst_size, byte_order);
337 if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
339 regnum = inst & 0x000f;
340 cache->saved_regs[regnum] = cache->framesize;
341 cache->framesize += xstormy16_reg_size;
344 /* Optional stack allocation for args and local vars <= 4 byte. */
345 else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
347 cache->framesize += ((inst & 0x0030) >> 4) + 1;
350 /* optional stack allocation for args and local vars > 4 && < 16 byte */
351 else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
353 cache->framesize += (inst & 0x00f0) >> 4;
356 /* Optional stack allocation for args and local vars >= 16 byte. */
357 else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
359 cache->framesize += inst2;
360 next_addr += xstormy16_inst_size;
363 else if (inst == 0x46fd) /* mov r13, r15 */
365 cache->uses_fp = 1;
368 /* optional copying of args in r2-r7 to r10-r13. */
369 /* Probably only in optimized case but legal action for prologue. */
370 else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */
371 && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
372 && (inst & 0x000f) >= 0x000a && (inst & 0x000f) <= 0x000d)
375 /* Optional copying of args in r2-r7 to stack. */
376 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8)
377 (bit3 always 1, bit2-0 = reg) */
378 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
379 else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
381 regnum = inst & 0x0007;
382 /* Only 12 of 16 bits of the argument are used for the
383 signed offset. */
384 offset = (LONGEST) (inst2 & 0x0fff);
385 if (offset & 0x0800)
386 offset -= 0x1000;
388 cache->saved_regs[regnum] = cache->framesize + offset;
389 next_addr += xstormy16_inst_size;
392 else /* Not a prologue instruction. */
393 break;
396 return next_addr;
399 /* Function: xstormy16_skip_prologue
400 If the input address is in a function prologue,
401 returns the address of the end of the prologue;
402 else returns the input address.
404 Note: the input address is likely to be the function start,
405 since this function is mainly used for advancing a breakpoint
406 to the first line, or stepping to the first line when we have
407 stepped into a function call. */
409 static CORE_ADDR
410 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
412 CORE_ADDR func_addr = 0, func_end = 0;
413 const char *func_name;
415 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
417 struct symtab_and_line sal;
418 struct symbol *sym;
419 struct xstormy16_frame_cache cache;
420 CORE_ADDR plg_end;
422 memset (&cache, 0, sizeof cache);
424 /* Don't trust line number debug info in frameless functions. */
425 plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
426 &cache, NULL);
427 if (!cache.uses_fp)
428 return plg_end;
430 /* Found a function. */
431 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
432 /* Don't use line number debug info for assembly source files. */
433 if (sym && sym->language () != language_asm)
435 sal = find_pc_line (func_addr, 0);
436 if (sal.end && sal.end < func_end)
438 /* Found a line number, use it as end of prologue. */
439 return sal.end;
442 /* No useable line symbol. Use result of prologue parsing method. */
443 return plg_end;
446 /* No function symbol -- just return the PC. */
448 return (CORE_ADDR) pc;
451 /* Implement the stack_frame_destroyed_p gdbarch method.
453 The epilogue is defined here as the area at the end of a function,
454 either on the `ret' instruction itself or after an instruction which
455 destroys the function's stack frame. */
457 static int
458 xstormy16_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
460 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
461 CORE_ADDR func_addr = 0, func_end = 0;
463 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
465 ULONGEST inst, inst2;
466 CORE_ADDR addr = func_end - xstormy16_inst_size;
468 /* The Xstormy16 epilogue is max. 14 bytes long. */
469 if (pc < func_end - 7 * xstormy16_inst_size)
470 return 0;
472 /* Check if we're on a `ret' instruction. Otherwise it's
473 too dangerous to proceed. */
474 inst = read_memory_unsigned_integer (addr,
475 xstormy16_inst_size, byte_order);
476 if (inst != 0x0003)
477 return 0;
479 while ((addr -= xstormy16_inst_size) >= func_addr)
481 inst = read_memory_unsigned_integer (addr,
482 xstormy16_inst_size,
483 byte_order);
484 if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
485 continue;
486 if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
487 break;
488 inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
489 xstormy16_inst_size,
490 byte_order);
491 if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
493 addr -= xstormy16_inst_size;
494 break;
496 return 0;
498 if (pc > addr)
499 return 1;
501 return 0;
504 constexpr gdb_byte xstormy16_break_insn[] = { 0x06, 0x0 };
506 typedef BP_MANIPULATION (xstormy16_break_insn) xstormy16_breakpoint;
508 /* Given a pointer to a jump table entry, return the address
509 of the function it jumps to. Return 0 if not found. */
510 static CORE_ADDR
511 xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
513 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
514 struct obj_section *faddr_sect = find_pc_section (faddr);
516 if (faddr_sect)
518 LONGEST inst, inst2, addr;
519 gdb_byte buf[2 * xstormy16_inst_size];
521 /* Return faddr if it's not pointing into the jump table. */
522 if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
523 return faddr;
525 if (!target_read_memory (faddr, buf, sizeof buf))
527 inst = extract_unsigned_integer (buf,
528 xstormy16_inst_size, byte_order);
529 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
530 xstormy16_inst_size, byte_order);
531 addr = inst2 << 8 | (inst & 0xff);
532 return addr;
535 return 0;
538 /* Given a function's address, attempt to find (and return) the
539 address of the corresponding jump table entry. Return 0 if
540 not found. */
541 static CORE_ADDR
542 xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
544 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
545 struct obj_section *faddr_sect = find_pc_section (faddr);
547 if (faddr_sect)
549 struct obj_section *osect;
551 /* Return faddr if it's already a pointer to a jump table entry. */
552 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
553 return faddr;
555 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
557 if (!strcmp (osect->the_bfd_section->name, ".plt"))
558 break;
561 if (osect < faddr_sect->objfile->sections_end)
563 CORE_ADDR addr, endaddr;
565 addr = osect->addr ();
566 endaddr = osect->endaddr ();
568 for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
570 LONGEST inst, inst2, faddr2;
571 gdb_byte buf[2 * xstormy16_inst_size];
573 if (target_read_memory (addr, buf, sizeof buf))
574 return 0;
575 inst = extract_unsigned_integer (buf,
576 xstormy16_inst_size,
577 byte_order);
578 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
579 xstormy16_inst_size,
580 byte_order);
581 faddr2 = inst2 << 8 | (inst & 0xff);
582 if (faddr == faddr2)
583 return addr;
587 return 0;
590 static CORE_ADDR
591 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
593 struct gdbarch *gdbarch = get_frame_arch (frame);
594 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
596 if (tmp && tmp != pc)
597 return tmp;
598 return 0;
601 /* Function pointers are 16 bit. The address space is 24 bit, using
602 32 bit addresses. Pointers to functions on the XStormy16 are implemented
603 by using 16 bit pointers, which are either direct pointers in case the
604 function begins below 0x10000, or indirect pointers into a jump table.
605 The next two functions convert 16 bit pointers into 24 (32) bit addresses
606 and vice versa. */
608 static CORE_ADDR
609 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
610 struct type *type, const gdb_byte *buf)
612 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
613 enum type_code target = TYPE_TARGET_TYPE (type)->code ();
614 CORE_ADDR addr
615 = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
617 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
619 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
620 if (addr2)
621 addr = addr2;
624 return addr;
627 static void
628 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
629 struct type *type, gdb_byte *buf, CORE_ADDR addr)
631 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
632 enum type_code target = TYPE_TARGET_TYPE (type)->code ();
634 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
636 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
637 if (addr2)
638 addr = addr2;
640 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
643 static struct xstormy16_frame_cache *
644 xstormy16_alloc_frame_cache (void)
646 struct xstormy16_frame_cache *cache;
647 int i;
649 cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
651 cache->base = 0;
652 cache->saved_sp = 0;
653 cache->pc = 0;
654 cache->uses_fp = 0;
655 cache->framesize = 0;
656 for (i = 0; i < E_NUM_REGS; ++i)
657 cache->saved_regs[i] = REG_UNAVAIL;
659 return cache;
662 static struct xstormy16_frame_cache *
663 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
665 struct gdbarch *gdbarch = get_frame_arch (this_frame);
666 struct xstormy16_frame_cache *cache;
667 CORE_ADDR current_pc;
668 int i;
670 if (*this_cache)
671 return (struct xstormy16_frame_cache *) *this_cache;
673 cache = xstormy16_alloc_frame_cache ();
674 *this_cache = cache;
676 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
677 if (cache->base == 0)
678 return cache;
680 cache->pc = get_frame_func (this_frame);
681 current_pc = get_frame_pc (this_frame);
682 if (cache->pc)
683 xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
684 cache, this_frame);
686 if (!cache->uses_fp)
687 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
689 cache->saved_sp = cache->base - cache->framesize;
691 for (i = 0; i < E_NUM_REGS; ++i)
692 if (cache->saved_regs[i] != REG_UNAVAIL)
693 cache->saved_regs[i] += cache->saved_sp;
695 return cache;
698 static struct value *
699 xstormy16_frame_prev_register (struct frame_info *this_frame,
700 void **this_cache, int regnum)
702 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
703 this_cache);
704 gdb_assert (regnum >= 0);
706 if (regnum == E_SP_REGNUM && cache->saved_sp)
707 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
709 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
710 return frame_unwind_got_memory (this_frame, regnum,
711 cache->saved_regs[regnum]);
713 return frame_unwind_got_register (this_frame, regnum, regnum);
716 static void
717 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
718 struct frame_id *this_id)
720 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
721 this_cache);
723 /* This marks the outermost frame. */
724 if (cache->base == 0)
725 return;
727 *this_id = frame_id_build (cache->saved_sp, cache->pc);
730 static CORE_ADDR
731 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
733 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
734 this_cache);
735 return cache->base;
738 static const struct frame_unwind xstormy16_frame_unwind = {
739 "xstormy16 prologue",
740 NORMAL_FRAME,
741 default_frame_unwind_stop_reason,
742 xstormy16_frame_this_id,
743 xstormy16_frame_prev_register,
744 NULL,
745 default_frame_sniffer
748 static const struct frame_base xstormy16_frame_base = {
749 &xstormy16_frame_unwind,
750 xstormy16_frame_base_address,
751 xstormy16_frame_base_address,
752 xstormy16_frame_base_address
755 /* Function: xstormy16_gdbarch_init
756 Initializer function for the xstormy16 gdbarch vector.
757 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
759 static struct gdbarch *
760 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
762 struct gdbarch *gdbarch;
764 /* find a candidate among the list of pre-declared architectures. */
765 arches = gdbarch_list_lookup_by_info (arches, &info);
766 if (arches != NULL)
767 return (arches->gdbarch);
769 gdbarch = gdbarch_alloc (&info, NULL);
772 * Basic register fields and methods, datatype sizes and stuff.
775 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
776 set_gdbarch_num_pseudo_regs (gdbarch, 0);
777 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
778 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
779 set_gdbarch_register_name (gdbarch, xstormy16_register_name);
780 set_gdbarch_register_type (gdbarch, xstormy16_register_type);
782 set_gdbarch_char_signed (gdbarch, 0);
783 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
784 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
785 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
786 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
788 set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
789 set_gdbarch_wchar_signed (gdbarch, 1);
791 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
792 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
793 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
795 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
796 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
797 set_gdbarch_dwarf2_addr_size (gdbarch, 4);
799 set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
800 set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
802 /* Stack grows up. */
803 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
806 * Frame Info
808 set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
809 frame_base_set_default (gdbarch, &xstormy16_frame_base);
811 set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
812 set_gdbarch_stack_frame_destroyed_p (gdbarch,
813 xstormy16_stack_frame_destroyed_p);
815 /* These values and methods are used when gdb calls a target function. */
816 set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
817 set_gdbarch_breakpoint_kind_from_pc (gdbarch,
818 xstormy16_breakpoint::kind_from_pc);
819 set_gdbarch_sw_breakpoint_from_kind (gdbarch,
820 xstormy16_breakpoint::bp_from_kind);
821 set_gdbarch_return_value (gdbarch, xstormy16_return_value);
823 set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
825 gdbarch_init_osabi (info, gdbarch);
827 dwarf2_append_unwinders (gdbarch);
828 frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
830 return gdbarch;
833 /* Function: _initialize_xstormy16_tdep
834 Initializer function for the Sanyo Xstormy16a module.
835 Called by gdb at start-up. */
837 void _initialize_xstormy16_tdep ();
838 void
839 _initialize_xstormy16_tdep ()
841 register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);