1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
3 Copyright (C) 2001-2013 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 "gdb_assert.h"
34 #include "arch-utils.h"
35 #include "floatformat.h"
43 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
44 Functions will return their values in register R2-R7 as they fit.
45 Otherwise a hidden pointer to an big enough area is given as argument
46 to the function in r2. Further arguments are beginning in r3 then.
47 R13 is used as frame pointer when GCC compiles w/o optimization
48 R14 is used as "PSW", displaying the CPU status.
49 R15 is used implicitely as stack pointer. */
52 E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
57 E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
63 E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
64 E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
65 E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
70 /* Use an invalid address value as 'not available' marker. */
71 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
73 struct xstormy16_frame_cache
80 CORE_ADDR saved_regs[E_NUM_REGS];
84 /* Size of instructions, registers, etc. */
87 xstormy16_inst_size = 2,
88 xstormy16_reg_size = 2,
92 /* Size of return datatype which fits into the remaining return registers. */
93 #define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
96 /* Size of return datatype which fits into all return registers. */
99 E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
102 /* Function: xstormy16_register_name
103 Returns the name of the standard Xstormy16 register N. */
106 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
108 static char *register_names[] = {
109 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
110 "r8", "r9", "r10", "r11", "r12", "r13",
114 if (regnum < 0 || regnum >= E_NUM_REGS)
115 internal_error (__FILE__, __LINE__,
116 _("xstormy16_register_name: illegal register number %d"),
119 return register_names[regnum];
124 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
126 if (regnum == E_PC_REGNUM)
127 return builtin_type (gdbarch)->builtin_uint32;
129 return builtin_type (gdbarch)->builtin_uint16;
132 /* Function: xstormy16_type_is_scalar
133 Makes the decision if a given type is a scalar types. Scalar
134 types are returned in the registers r2-r7 as they fit. */
137 xstormy16_type_is_scalar (struct type *t)
139 return (TYPE_CODE(t) != TYPE_CODE_STRUCT
140 && TYPE_CODE(t) != TYPE_CODE_UNION
141 && TYPE_CODE(t) != TYPE_CODE_ARRAY);
144 /* Function: xstormy16_use_struct_convention
145 Returns non-zero if the given struct type will be returned using
146 a special convention, rather than the normal function return method.
147 7sed in the contexts of the "return" command, and of
148 target function calls from the debugger. */
151 xstormy16_use_struct_convention (struct type *type)
153 return !xstormy16_type_is_scalar (type)
154 || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
157 /* Function: xstormy16_extract_return_value
158 Find a function's return value in the appropriate registers (in
159 regbuf), and copy it into valbuf. */
162 xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
165 int len = TYPE_LENGTH (type);
166 int i, regnum = E_1ST_ARG_REGNUM;
168 for (i = 0; i < len; i += xstormy16_reg_size)
169 regcache_raw_read (regcache, regnum++, valbuf + i);
172 /* Function: xstormy16_store_return_value
173 Copy the function return value from VALBUF into the
174 proper location for a function return.
175 Called only in the context of the "return" command. */
178 xstormy16_store_return_value (struct type *type, struct regcache *regcache,
179 const gdb_byte *valbuf)
181 if (TYPE_LENGTH (type) == 1)
183 /* Add leading zeros to the value. */
184 gdb_byte buf[xstormy16_reg_size];
185 memset (buf, 0, xstormy16_reg_size);
186 memcpy (buf, valbuf, 1);
187 regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
191 int len = TYPE_LENGTH (type);
192 int i, regnum = E_1ST_ARG_REGNUM;
194 for (i = 0; i < len; i += xstormy16_reg_size)
195 regcache_raw_write (regcache, regnum++, valbuf + i);
199 static enum return_value_convention
200 xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
201 struct type *type, struct regcache *regcache,
202 gdb_byte *readbuf, const gdb_byte *writebuf)
204 if (xstormy16_use_struct_convention (type))
205 return RETURN_VALUE_STRUCT_CONVENTION;
207 xstormy16_store_return_value (type, regcache, writebuf);
209 xstormy16_extract_return_value (type, regcache, readbuf);
210 return RETURN_VALUE_REGISTER_CONVENTION;
214 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
221 /* Function: xstormy16_push_dummy_call
222 Setup the function arguments for GDB to call a function in the inferior.
223 Called only in the context of a target function call from the debugger.
224 Returns the value of the SP register after the args are pushed. */
227 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
228 struct value *function,
229 struct regcache *regcache,
230 CORE_ADDR bp_addr, int nargs,
232 CORE_ADDR sp, int struct_return,
233 CORE_ADDR struct_addr)
235 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
236 CORE_ADDR stack_dest = sp;
237 int argreg = E_1ST_ARG_REGNUM;
239 int typelen, slacklen;
241 gdb_byte buf[xstormy16_pc_size];
243 /* If struct_return is true, then the struct return address will
244 consume one argument-passing register. */
247 regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
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))
262 /* Put argument into registers wordwise. */
263 val = value_contents (args[i]);
264 for (j = 0; j < typelen; j += xstormy16_reg_size)
267 int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
269 regval = extract_unsigned_integer (val + j, size, byte_order);
270 regcache_cooked_write_unsigned (regcache, argreg++, regval);
275 stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
277 /* Loop backwards through remaining arguments and push them on the stack,
279 for (j = nargs - 1; j >= i; j--)
282 struct cleanup *back_to;
283 const gdb_byte *bytes = value_contents (args[j]);
285 typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
286 slacklen = typelen & 1;
287 val = xmalloc (typelen + slacklen);
288 back_to = make_cleanup (xfree, val);
289 memcpy (val, bytes, typelen);
290 memset (val + typelen, 0, slacklen);
292 /* Now write this data to the stack. The stack grows upwards. */
293 write_memory (stack_dest, val, typelen + slacklen);
294 stack_dest += typelen + slacklen;
295 do_cleanups (back_to);
298 store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
299 write_memory (stack_dest, buf, xstormy16_pc_size);
300 stack_dest += xstormy16_pc_size;
302 /* Update stack pointer. */
303 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
305 /* Return the new stack pointer minus the return address slot since
306 that's what DWARF2/GCC uses as the frame's CFA. */
307 return stack_dest - xstormy16_pc_size;
310 /* Function: xstormy16_scan_prologue
311 Decode the instructions within the given address range.
312 Decide when we must have reached the end of the function prologue.
313 If a frame_info pointer is provided, fill in its saved_regs etc.
315 Returns the address of the first instruction after the prologue. */
318 xstormy16_analyze_prologue (struct gdbarch *gdbarch,
319 CORE_ADDR start_addr, CORE_ADDR end_addr,
320 struct xstormy16_frame_cache *cache,
321 struct frame_info *this_frame)
323 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
325 ULONGEST inst, inst2;
329 /* Initialize framesize with size of PC put on stack by CALLF inst. */
330 cache->saved_regs[E_PC_REGNUM] = 0;
331 cache->framesize = xstormy16_pc_size;
333 if (start_addr >= end_addr)
336 for (next_addr = start_addr;
337 next_addr < end_addr; next_addr += xstormy16_inst_size)
339 inst = read_memory_unsigned_integer (next_addr,
340 xstormy16_inst_size, byte_order);
341 inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
342 xstormy16_inst_size, byte_order);
344 if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
346 regnum = inst & 0x000f;
347 cache->saved_regs[regnum] = cache->framesize;
348 cache->framesize += xstormy16_reg_size;
351 /* Optional stack allocation for args and local vars <= 4 byte. */
352 else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
354 cache->framesize += ((inst & 0x0030) >> 4) + 1;
357 /* optional stack allocation for args and local vars > 4 && < 16 byte */
358 else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
360 cache->framesize += (inst & 0x00f0) >> 4;
363 /* Optional stack allocation for args and local vars >= 16 byte. */
364 else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
366 cache->framesize += inst2;
367 next_addr += xstormy16_inst_size;
370 else if (inst == 0x46fd) /* mov r13, r15 */
375 /* optional copying of args in r2-r7 to r10-r13. */
376 /* Probably only in optimized case but legal action for prologue. */
377 else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */
378 && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
379 && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
382 /* Optional copying of args in r2-r7 to stack. */
383 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8)
384 (bit3 always 1, bit2-0 = reg) */
385 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
386 else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
388 regnum = inst & 0x0007;
389 /* Only 12 of 16 bits of the argument are used for the
391 offset = (LONGEST) (inst2 & 0x0fff);
395 cache->saved_regs[regnum] = cache->framesize + offset;
396 next_addr += xstormy16_inst_size;
399 else /* Not a prologue instruction. */
406 /* Function: xstormy16_skip_prologue
407 If the input address is in a function prologue,
408 returns the address of the end of the prologue;
409 else returns the input address.
411 Note: the input address is likely to be the function start,
412 since this function is mainly used for advancing a breakpoint
413 to the first line, or stepping to the first line when we have
414 stepped into a function call. */
417 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
419 CORE_ADDR func_addr = 0, func_end = 0;
420 const char *func_name;
422 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
424 struct symtab_and_line sal;
426 struct xstormy16_frame_cache cache;
429 memset (&cache, 0, sizeof cache);
431 /* Don't trust line number debug info in frameless functions. */
432 plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
437 /* Found a function. */
438 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
439 /* Don't use line number debug info for assembly source files. */
440 if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
442 sal = find_pc_line (func_addr, 0);
443 if (sal.end && sal.end < func_end)
445 /* Found a line number, use it as end of prologue. */
449 /* No useable line symbol. Use result of prologue parsing method. */
453 /* No function symbol -- just return the PC. */
455 return (CORE_ADDR) pc;
458 /* The epilogue is defined here as the area at the end of a function,
459 either on the `ret' instruction itself or after an instruction which
460 destroys the function's stack frame. */
462 xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
464 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
465 CORE_ADDR func_addr = 0, func_end = 0;
467 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
469 ULONGEST inst, inst2;
470 CORE_ADDR addr = func_end - xstormy16_inst_size;
472 /* The Xstormy16 epilogue is max. 14 bytes long. */
473 if (pc < func_end - 7 * xstormy16_inst_size)
476 /* Check if we're on a `ret' instruction. Otherwise it's
477 too dangerous to proceed. */
478 inst = read_memory_unsigned_integer (addr,
479 xstormy16_inst_size, byte_order);
483 while ((addr -= xstormy16_inst_size) >= func_addr)
485 inst = read_memory_unsigned_integer (addr,
488 if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
490 if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
492 inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
495 if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
497 addr -= xstormy16_inst_size;
508 static const unsigned char *
509 xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
512 static unsigned char breakpoint[] = { 0x06, 0x0 };
513 *lenptr = sizeof (breakpoint);
517 /* Given a pointer to a jump table entry, return the address
518 of the function it jumps to. Return 0 if not found. */
520 xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
522 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
523 struct obj_section *faddr_sect = find_pc_section (faddr);
527 LONGEST inst, inst2, addr;
528 gdb_byte buf[2 * xstormy16_inst_size];
530 /* Return faddr if it's not pointing into the jump table. */
531 if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
534 if (!target_read_memory (faddr, buf, sizeof buf))
536 inst = extract_unsigned_integer (buf,
537 xstormy16_inst_size, byte_order);
538 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
539 xstormy16_inst_size, byte_order);
540 addr = inst2 << 8 | (inst & 0xff);
547 /* Given a function's address, attempt to find (and return) the
548 address of the corresponding jump table entry. Return 0 if
551 xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
553 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
554 struct obj_section *faddr_sect = find_pc_section (faddr);
558 struct obj_section *osect;
560 /* Return faddr if it's already a pointer to a jump table entry. */
561 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
564 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
566 if (!strcmp (osect->the_bfd_section->name, ".plt"))
570 if (osect < faddr_sect->objfile->sections_end)
572 CORE_ADDR addr, endaddr;
574 addr = obj_section_addr (osect);
575 endaddr = obj_section_endaddr (osect);
577 for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
579 LONGEST inst, inst2, faddr2;
580 gdb_byte buf[2 * xstormy16_inst_size];
582 if (target_read_memory (addr, buf, sizeof buf))
584 inst = extract_unsigned_integer (buf,
587 inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
590 faddr2 = inst2 << 8 | (inst & 0xff);
600 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
602 struct gdbarch *gdbarch = get_frame_arch (frame);
603 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
605 if (tmp && tmp != pc)
610 /* Function pointers are 16 bit. The address space is 24 bit, using
611 32 bit addresses. Pointers to functions on the XStormy16 are implemented
612 by using 16 bit pointers, which are either direct pointers in case the
613 function begins below 0x10000, or indirect pointers into a jump table.
614 The next two functions convert 16 bit pointers into 24 (32) bit addresses
618 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
619 struct type *type, const gdb_byte *buf)
621 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
622 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
624 = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
626 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
628 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
637 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
638 struct type *type, gdb_byte *buf, CORE_ADDR addr)
640 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
641 enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
643 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
645 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
649 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
652 static struct xstormy16_frame_cache *
653 xstormy16_alloc_frame_cache (void)
655 struct xstormy16_frame_cache *cache;
658 cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
664 cache->framesize = 0;
665 for (i = 0; i < E_NUM_REGS; ++i)
666 cache->saved_regs[i] = REG_UNAVAIL;
671 static struct xstormy16_frame_cache *
672 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
674 struct gdbarch *gdbarch = get_frame_arch (this_frame);
675 struct xstormy16_frame_cache *cache;
676 CORE_ADDR current_pc;
682 cache = xstormy16_alloc_frame_cache ();
685 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
686 if (cache->base == 0)
689 cache->pc = get_frame_func (this_frame);
690 current_pc = get_frame_pc (this_frame);
692 xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
696 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
698 cache->saved_sp = cache->base - cache->framesize;
700 for (i = 0; i < E_NUM_REGS; ++i)
701 if (cache->saved_regs[i] != REG_UNAVAIL)
702 cache->saved_regs[i] += cache->saved_sp;
707 static struct value *
708 xstormy16_frame_prev_register (struct frame_info *this_frame,
709 void **this_cache, int regnum)
711 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
713 gdb_assert (regnum >= 0);
715 if (regnum == E_SP_REGNUM && cache->saved_sp)
716 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
718 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
719 return frame_unwind_got_memory (this_frame, regnum,
720 cache->saved_regs[regnum]);
722 return frame_unwind_got_register (this_frame, regnum, regnum);
726 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
727 struct frame_id *this_id)
729 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
732 /* This marks the outermost frame. */
733 if (cache->base == 0)
736 *this_id = frame_id_build (cache->saved_sp, cache->pc);
740 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
742 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
747 static const struct frame_unwind xstormy16_frame_unwind = {
749 default_frame_unwind_stop_reason,
750 xstormy16_frame_this_id,
751 xstormy16_frame_prev_register,
753 default_frame_sniffer
756 static const struct frame_base xstormy16_frame_base = {
757 &xstormy16_frame_unwind,
758 xstormy16_frame_base_address,
759 xstormy16_frame_base_address,
760 xstormy16_frame_base_address
764 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
766 return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
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_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
778 CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
779 return frame_id_build (sp, get_frame_pc (this_frame));
783 /* Function: xstormy16_gdbarch_init
784 Initializer function for the xstormy16 gdbarch vector.
785 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
787 static struct gdbarch *
788 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
790 struct gdbarch *gdbarch;
792 /* find a candidate among the list of pre-declared architectures. */
793 arches = gdbarch_list_lookup_by_info (arches, &info);
795 return (arches->gdbarch);
797 gdbarch = gdbarch_alloc (&info, NULL);
800 * Basic register fields and methods, datatype sizes and stuff.
803 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
804 set_gdbarch_num_pseudo_regs (gdbarch, 0);
805 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
806 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
807 set_gdbarch_register_name (gdbarch, xstormy16_register_name);
808 set_gdbarch_register_type (gdbarch, xstormy16_register_type);
810 set_gdbarch_char_signed (gdbarch, 0);
811 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
812 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
813 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
814 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
816 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
817 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
818 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
820 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
821 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
822 set_gdbarch_dwarf2_addr_size (gdbarch, 4);
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);
833 set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
834 set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
835 set_gdbarch_dummy_id (gdbarch, xstormy16_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 dwarf2_append_unwinders (gdbarch);
855 frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
860 /* Function: _initialize_xstormy16_tdep
861 Initializer function for the Sanyo Xstormy16a module.
862 Called by gdb at start-up. */
864 /* -Wmissing-prototypes */
865 extern initialize_file_ftype _initialize_xstormy16_tdep;
868 _initialize_xstormy16_tdep (void)
870 register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);