1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
3 Copyright (C) 2001-2014 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/>. */
22 #include "frame-base.h"
23 #include "frame-unwind.h"
24 #include "dwarf2-frame.h"
33 #include "arch-utils.h"
34 #include "floatformat.h"
42 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
43 Functions will return their values in register R2-R7 as they fit.
44 Otherwise a hidden pointer to an big enough area is given as argument
45 to the function in r2. Further arguments are beginning in r3 then.
46 R13 is used as frame pointer when GCC compiles w/o optimization
47 R14 is used as "PSW", displaying the CPU status.
48 R15 is used implicitely as stack pointer. */
51 E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
56 E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
62 E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
63 E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
64 E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
69 /* Use an invalid address value as 'not available' marker. */
70 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
72 struct xstormy16_frame_cache
79 CORE_ADDR saved_regs[E_NUM_REGS];
83 /* Size of instructions, registers, etc. */
86 xstormy16_inst_size = 2,
87 xstormy16_reg_size = 2,
91 /* Size of return datatype which fits into the remaining return registers. */
92 #define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
95 /* Size of return datatype which fits into all return registers. */
98 E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
101 /* Function: xstormy16_register_name
102 Returns the name of the standard Xstormy16 register N. */
105 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
107 static char *register_names[] = {
108 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
109 "r8", "r9", "r10", "r11", "r12", "r13",
113 if (regnum < 0 || regnum >= E_NUM_REGS)
114 internal_error (__FILE__, __LINE__,
115 _("xstormy16_register_name: illegal register number %d"),
118 return register_names[regnum];
123 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
125 if (regnum == E_PC_REGNUM)
126 return builtin_type (gdbarch)->builtin_uint32;
128 return builtin_type (gdbarch)->builtin_uint16;
131 /* Function: xstormy16_type_is_scalar
132 Makes the decision if a given type is a scalar types. Scalar
133 types are returned in the registers r2-r7 as they fit. */
136 xstormy16_type_is_scalar (struct type *t)
138 return (TYPE_CODE(t) != TYPE_CODE_STRUCT
139 && TYPE_CODE(t) != TYPE_CODE_UNION
140 && TYPE_CODE(t) != TYPE_CODE_ARRAY);
143 /* Function: xstormy16_use_struct_convention
144 Returns non-zero if the given struct type will be returned using
145 a special convention, rather than the normal function return method.
146 7sed in the contexts of the "return" command, and of
147 target function calls from the debugger. */
150 xstormy16_use_struct_convention (struct type *type)
152 return !xstormy16_type_is_scalar (type)
153 || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
156 /* Function: xstormy16_extract_return_value
157 Find a function's return value in the appropriate registers (in
158 regbuf), and copy it into valbuf. */
161 xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
164 int len = TYPE_LENGTH (type);
165 int i, regnum = E_1ST_ARG_REGNUM;
167 for (i = 0; i < len; i += xstormy16_reg_size)
168 regcache_raw_read (regcache, regnum++, valbuf + i);
171 /* Function: xstormy16_store_return_value
172 Copy the function return value from VALBUF into the
173 proper location for a function return.
174 Called only in the context of the "return" command. */
177 xstormy16_store_return_value (struct type *type, struct regcache *regcache,
178 const gdb_byte *valbuf)
180 if (TYPE_LENGTH (type) == 1)
182 /* Add leading zeros to the value. */
183 gdb_byte buf[xstormy16_reg_size];
184 memset (buf, 0, xstormy16_reg_size);
185 memcpy (buf, valbuf, 1);
186 regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
190 int len = TYPE_LENGTH (type);
191 int i, regnum = E_1ST_ARG_REGNUM;
193 for (i = 0; i < len; i += xstormy16_reg_size)
194 regcache_raw_write (regcache, regnum++, valbuf + i);
198 static enum return_value_convention
199 xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
200 struct type *type, struct regcache *regcache,
201 gdb_byte *readbuf, const gdb_byte *writebuf)
203 if (xstormy16_use_struct_convention (type))
204 return RETURN_VALUE_STRUCT_CONVENTION;
206 xstormy16_store_return_value (type, regcache, writebuf);
208 xstormy16_extract_return_value (type, regcache, readbuf);
209 return RETURN_VALUE_REGISTER_CONVENTION;
213 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
220 /* Function: xstormy16_push_dummy_call
221 Setup the function arguments for GDB to call a function in the inferior.
222 Called only in the context of a target function call from the debugger.
223 Returns the value of the SP register after the args are pushed. */
226 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
227 struct value *function,
228 struct regcache *regcache,
229 CORE_ADDR bp_addr, int nargs,
231 CORE_ADDR sp, int struct_return,
232 CORE_ADDR struct_addr)
234 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
235 CORE_ADDR stack_dest = sp;
236 int argreg = E_1ST_ARG_REGNUM;
238 int typelen, slacklen;
240 gdb_byte buf[xstormy16_pc_size];
242 /* If struct_return is true, then the struct return address will
243 consume one argument-passing register. */
246 regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
250 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
251 fit in the remaining registers we're switching over to the stack.
252 No argument is put on stack partially and as soon as we switched
253 over to stack no further argument is put in a register even if it
254 would fit in the remaining unused registers. */
255 for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
257 typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
258 if (typelen > E_MAX_RETTYPE_SIZE (argreg))
261 /* Put argument into registers wordwise. */
262 val = value_contents (args[i]);
263 for (j = 0; j < typelen; j += xstormy16_reg_size)
266 int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
268 regval = extract_unsigned_integer (val + j, size, byte_order);
269 regcache_cooked_write_unsigned (regcache, argreg++, regval);
274 stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
276 /* Loop backwards through remaining arguments and push them on the stack,
278 for (j = nargs - 1; j >= i; j--)
281 struct cleanup *back_to;
282 const gdb_byte *bytes = value_contents (args[j]);
284 typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
285 slacklen = typelen & 1;
286 val = xmalloc (typelen + slacklen);
287 back_to = make_cleanup (xfree, val);
288 memcpy (val, bytes, typelen);
289 memset (val + typelen, 0, slacklen);
291 /* Now write this data to the stack. The stack grows upwards. */
292 write_memory (stack_dest, val, typelen + slacklen);
293 stack_dest += typelen + slacklen;
294 do_cleanups (back_to);
297 store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
298 write_memory (stack_dest, buf, xstormy16_pc_size);
299 stack_dest += xstormy16_pc_size;
301 /* Update stack pointer. */
302 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
304 /* Return the new stack pointer minus the return address slot since
305 that's what DWARF2/GCC uses as the frame's CFA. */
306 return stack_dest - xstormy16_pc_size;
309 /* Function: xstormy16_scan_prologue
310 Decode the instructions within the given address range.
311 Decide when we must have reached the end of the function prologue.
312 If a frame_info pointer is provided, fill in its saved_regs etc.
314 Returns the address of the first instruction after the prologue. */
317 xstormy16_analyze_prologue (struct gdbarch *gdbarch,
318 CORE_ADDR start_addr, CORE_ADDR end_addr,
319 struct xstormy16_frame_cache *cache,
320 struct frame_info *this_frame)
322 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
324 ULONGEST inst, inst2;
328 /* Initialize framesize with size of PC put on stack by CALLF inst. */
329 cache->saved_regs[E_PC_REGNUM] = 0;
330 cache->framesize = xstormy16_pc_size;
332 if (start_addr >= end_addr)
335 for (next_addr = start_addr;
336 next_addr < end_addr; next_addr += xstormy16_inst_size)
338 inst = read_memory_unsigned_integer (next_addr,
339 xstormy16_inst_size, byte_order);
340 inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
341 xstormy16_inst_size, byte_order);
343 if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
345 regnum = inst & 0x000f;
346 cache->saved_regs[regnum] = cache->framesize;
347 cache->framesize += xstormy16_reg_size;
350 /* Optional stack allocation for args and local vars <= 4 byte. */
351 else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
353 cache->framesize += ((inst & 0x0030) >> 4) + 1;
356 /* optional stack allocation for args and local vars > 4 && < 16 byte */
357 else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
359 cache->framesize += (inst & 0x00f0) >> 4;
362 /* Optional stack allocation for args and local vars >= 16 byte. */
363 else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
365 cache->framesize += inst2;
366 next_addr += xstormy16_inst_size;
369 else if (inst == 0x46fd) /* mov r13, r15 */
374 /* optional copying of args in r2-r7 to r10-r13. */
375 /* Probably only in optimized case but legal action for prologue. */
376 else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */
377 && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
378 && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
381 /* Optional copying of args in r2-r7 to stack. */
382 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8)
383 (bit3 always 1, bit2-0 = reg) */
384 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
385 else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
387 regnum = inst & 0x0007;
388 /* Only 12 of 16 bits of the argument are used for the
390 offset = (LONGEST) (inst2 & 0x0fff);
394 cache->saved_regs[regnum] = cache->framesize + offset;
395 next_addr += xstormy16_inst_size;
398 else /* Not a prologue instruction. */
405 /* Function: xstormy16_skip_prologue
406 If the input address is in a function prologue,
407 returns the address of the end of the prologue;
408 else returns the input address.
410 Note: the input address is likely to be the function start,
411 since this function is mainly used for advancing a breakpoint
412 to the first line, or stepping to the first line when we have
413 stepped into a function call. */
416 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
418 CORE_ADDR func_addr = 0, func_end = 0;
419 const char *func_name;
421 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
423 struct symtab_and_line sal;
425 struct xstormy16_frame_cache cache;
428 memset (&cache, 0, sizeof cache);
430 /* Don't trust line number debug info in frameless functions. */
431 plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
436 /* Found a function. */
437 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
438 /* Don't use line number debug info for assembly source files. */
439 if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
441 sal = find_pc_line (func_addr, 0);
442 if (sal.end && sal.end < func_end)
444 /* Found a line number, use it as end of prologue. */
448 /* No useable line symbol. Use result of prologue parsing method. */
452 /* No function symbol -- just return the PC. */
454 return (CORE_ADDR) pc;
457 /* The epilogue is defined here as the area at the end of a function,
458 either on the `ret' instruction itself or after an instruction which
459 destroys the function's stack frame. */
461 xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
463 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
464 CORE_ADDR func_addr = 0, func_end = 0;
466 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
468 ULONGEST inst, inst2;
469 CORE_ADDR addr = func_end - xstormy16_inst_size;
471 /* The Xstormy16 epilogue is max. 14 bytes long. */
472 if (pc < func_end - 7 * xstormy16_inst_size)
475 /* Check if we're on a `ret' instruction. Otherwise it's
476 too dangerous to proceed. */
477 inst = read_memory_unsigned_integer (addr,
478 xstormy16_inst_size, byte_order);
482 while ((addr -= xstormy16_inst_size) >= func_addr)
484 inst = read_memory_unsigned_integer (addr,
487 if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
489 if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
491 inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
494 if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
496 addr -= xstormy16_inst_size;
507 static const unsigned char *
508 xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
511 static unsigned char breakpoint[] = { 0x06, 0x0 };
512 *lenptr = sizeof (breakpoint);
516 /* Given a pointer to a jump table entry, return the address
517 of the function it jumps to. Return 0 if not found. */
519 xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
521 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
522 struct obj_section *faddr_sect = find_pc_section (faddr);
526 LONGEST inst, inst2, addr;
527 gdb_byte buf[2 * xstormy16_inst_size];
529 /* Return faddr if it's not pointing into the jump table. */
530 if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
533 if (!target_read_memory (faddr, buf, sizeof buf))
535 inst = extract_unsigned_integer (buf,
536 xstormy16_inst_size, byte_order);
537 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
538 xstormy16_inst_size, byte_order);
539 addr = inst2 << 8 | (inst & 0xff);
546 /* Given a function's address, attempt to find (and return) the
547 address of the corresponding jump table entry. Return 0 if
550 xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
552 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
553 struct obj_section *faddr_sect = find_pc_section (faddr);
557 struct obj_section *osect;
559 /* Return faddr if it's already a pointer to a jump table entry. */
560 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
563 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
565 if (!strcmp (osect->the_bfd_section->name, ".plt"))
569 if (osect < faddr_sect->objfile->sections_end)
571 CORE_ADDR addr, endaddr;
573 addr = obj_section_addr (osect);
574 endaddr = obj_section_endaddr (osect);
576 for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
578 LONGEST inst, inst2, faddr2;
579 gdb_byte buf[2 * xstormy16_inst_size];
581 if (target_read_memory (addr, buf, sizeof buf))
583 inst = extract_unsigned_integer (buf,
586 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
589 faddr2 = inst2 << 8 | (inst & 0xff);
599 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
601 struct gdbarch *gdbarch = get_frame_arch (frame);
602 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
604 if (tmp && tmp != pc)
609 /* Function pointers are 16 bit. The address space is 24 bit, using
610 32 bit addresses. Pointers to functions on the XStormy16 are implemented
611 by using 16 bit pointers, which are either direct pointers in case the
612 function begins below 0x10000, or indirect pointers into a jump table.
613 The next two functions convert 16 bit pointers into 24 (32) bit addresses
617 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
618 struct type *type, const gdb_byte *buf)
620 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
621 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
623 = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
625 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
627 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
636 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
637 struct type *type, gdb_byte *buf, CORE_ADDR addr)
639 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
640 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
642 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
644 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
648 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
651 static struct xstormy16_frame_cache *
652 xstormy16_alloc_frame_cache (void)
654 struct xstormy16_frame_cache *cache;
657 cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
663 cache->framesize = 0;
664 for (i = 0; i < E_NUM_REGS; ++i)
665 cache->saved_regs[i] = REG_UNAVAIL;
670 static struct xstormy16_frame_cache *
671 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
673 struct gdbarch *gdbarch = get_frame_arch (this_frame);
674 struct xstormy16_frame_cache *cache;
675 CORE_ADDR current_pc;
681 cache = xstormy16_alloc_frame_cache ();
684 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
685 if (cache->base == 0)
688 cache->pc = get_frame_func (this_frame);
689 current_pc = get_frame_pc (this_frame);
691 xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
695 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
697 cache->saved_sp = cache->base - cache->framesize;
699 for (i = 0; i < E_NUM_REGS; ++i)
700 if (cache->saved_regs[i] != REG_UNAVAIL)
701 cache->saved_regs[i] += cache->saved_sp;
706 static struct value *
707 xstormy16_frame_prev_register (struct frame_info *this_frame,
708 void **this_cache, int regnum)
710 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
712 gdb_assert (regnum >= 0);
714 if (regnum == E_SP_REGNUM && cache->saved_sp)
715 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
717 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
718 return frame_unwind_got_memory (this_frame, regnum,
719 cache->saved_regs[regnum]);
721 return frame_unwind_got_register (this_frame, regnum, regnum);
725 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
726 struct frame_id *this_id)
728 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
731 /* This marks the outermost frame. */
732 if (cache->base == 0)
735 *this_id = frame_id_build (cache->saved_sp, cache->pc);
739 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
741 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
746 static const struct frame_unwind xstormy16_frame_unwind = {
748 default_frame_unwind_stop_reason,
749 xstormy16_frame_this_id,
750 xstormy16_frame_prev_register,
752 default_frame_sniffer
755 static const struct frame_base xstormy16_frame_base = {
756 &xstormy16_frame_unwind,
757 xstormy16_frame_base_address,
758 xstormy16_frame_base_address,
759 xstormy16_frame_base_address
763 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
765 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
769 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
771 return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
774 static struct frame_id
775 xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
777 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
778 return frame_id_build (sp, get_frame_pc (this_frame));
782 /* Function: xstormy16_gdbarch_init
783 Initializer function for the xstormy16 gdbarch vector.
784 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
786 static struct gdbarch *
787 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
789 struct gdbarch *gdbarch;
791 /* find a candidate among the list of pre-declared architectures. */
792 arches = gdbarch_list_lookup_by_info (arches, &info);
794 return (arches->gdbarch);
796 gdbarch = gdbarch_alloc (&info, NULL);
799 * Basic register fields and methods, datatype sizes and stuff.
802 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
803 set_gdbarch_num_pseudo_regs (gdbarch, 0);
804 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
805 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
806 set_gdbarch_register_name (gdbarch, xstormy16_register_name);
807 set_gdbarch_register_type (gdbarch, xstormy16_register_type);
809 set_gdbarch_char_signed (gdbarch, 0);
810 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
811 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
812 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
813 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
815 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
816 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
817 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
819 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
820 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
821 set_gdbarch_dwarf2_addr_size (gdbarch, 4);
823 set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
824 set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
826 /* Stack grows up. */
827 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
832 set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
833 set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
834 set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
835 set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
836 frame_base_set_default (gdbarch, &xstormy16_frame_base);
838 set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
839 set_gdbarch_in_function_epilogue_p (gdbarch,
840 xstormy16_in_function_epilogue_p);
842 /* These values and methods are used when gdb calls a target function. */
843 set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
844 set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
845 set_gdbarch_return_value (gdbarch, xstormy16_return_value);
847 set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
849 set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
851 gdbarch_init_osabi (info, gdbarch);
853 dwarf2_append_unwinders (gdbarch);
854 frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
859 /* Function: _initialize_xstormy16_tdep
860 Initializer function for the Sanyo Xstormy16a module.
861 Called by gdb at start-up. */
863 /* -Wmissing-prototypes */
864 extern initialize_file_ftype _initialize_xstormy16_tdep;
867 _initialize_xstormy16_tdep (void)
869 register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);