1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
3 Copyright 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "frame-base.h"
25 #include "frame-unwind.h"
26 #include "dwarf2-frame.h"
34 #include "gdb_string.h"
35 #include "gdb_assert.h"
36 #include "arch-utils.h"
37 #include "floatformat.h"
45 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
46 Functions will return their values in register R2-R7 as they fit.
47 Otherwise a hidden pointer to an big enough area is given as argument
48 to the function in r2. Further arguments are beginning in r3 then.
49 R13 is used as frame pointer when GCC compiles w/o optimization
50 R14 is used as "PSW", displaying the CPU status.
51 R15 is used implicitely as stack pointer. */
54 E_R2_REGNUM
, E_1ST_ARG_REGNUM
= E_R2_REGNUM
, E_PTR_RET_REGNUM
= E_R2_REGNUM
,
59 E_R7_REGNUM
, E_LST_ARG_REGNUM
= E_R7_REGNUM
,
65 E_R13_REGNUM
, E_FP_REGNUM
= E_R13_REGNUM
,
66 E_R14_REGNUM
, E_PSW_REGNUM
= E_R14_REGNUM
,
67 E_R15_REGNUM
, E_SP_REGNUM
= E_R15_REGNUM
,
72 /* Use an invalid address value as 'not available' marker. */
73 enum { REG_UNAVAIL
= (CORE_ADDR
) -1 };
75 struct xstormy16_frame_cache
82 CORE_ADDR saved_regs
[E_NUM_REGS
];
86 /* Size of instructions, registers, etc. */
89 xstormy16_inst_size
= 2,
90 xstormy16_reg_size
= 2,
94 /* Size of return datatype which fits into the remaining return registers. */
95 #define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
98 /* Size of return datatype which fits into all return registers. */
101 E_MAX_RETTYPE_SIZE_IN_REGS
= E_MAX_RETTYPE_SIZE (E_R2_REGNUM
)
104 /* Function: xstormy16_register_name
105 Returns the name of the standard Xstormy16 register N. */
108 xstormy16_register_name (int regnum
)
110 static char *register_names
[] = {
111 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
112 "r8", "r9", "r10", "r11", "r12", "r13",
116 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
117 internal_error (__FILE__
, __LINE__
,
118 "xstormy16_register_name: illegal register number %d",
121 return register_names
[regnum
];
126 xstormy16_register_type (struct gdbarch
*gdbarch
, int regnum
)
128 if (regnum
== E_PC_REGNUM
)
129 return builtin_type_uint32
;
131 return builtin_type_uint16
;
134 /* Function: xstormy16_type_is_scalar
135 Makes the decision if a given type is a scalar types. Scalar
136 types are returned in the registers r2-r7 as they fit. */
139 xstormy16_type_is_scalar (struct type
*t
)
141 return (TYPE_CODE(t
) != TYPE_CODE_STRUCT
142 && TYPE_CODE(t
) != TYPE_CODE_UNION
143 && TYPE_CODE(t
) != TYPE_CODE_ARRAY
);
146 /* Function: xstormy16_use_struct_convention
147 Returns non-zero if the given struct type will be returned using
148 a special convention, rather than the normal function return method.
149 7sed in the contexts of the "return" command, and of
150 target function calls from the debugger. */
153 xstormy16_use_struct_convention (struct type
*type
)
155 return !xstormy16_type_is_scalar (type
)
156 || TYPE_LENGTH (type
) > E_MAX_RETTYPE_SIZE_IN_REGS
;
159 /* Function: xstormy16_extract_return_value
160 Find a function's return value in the appropriate registers (in
161 regbuf), and copy it into valbuf. */
164 xstormy16_extract_return_value (struct type
*type
, struct regcache
*regcache
,
167 int len
= TYPE_LENGTH (type
);
168 int i
, regnum
= E_1ST_ARG_REGNUM
;
170 for (i
= 0; i
< len
; i
+= xstormy16_reg_size
)
171 regcache_raw_read (regcache
, regnum
++, (char *) valbuf
+ i
);
174 /* Function: xstormy16_store_return_value
175 Copy the function return value from VALBUF into the
176 proper location for a function return.
177 Called only in the context of the "return" command. */
180 xstormy16_store_return_value (struct type
*type
, struct regcache
*regcache
,
183 if (TYPE_LENGTH (type
) == 1)
185 /* Add leading zeros to the value. */
186 char buf
[xstormy16_reg_size
];
187 memset (buf
, 0, xstormy16_reg_size
);
188 memcpy (buf
, valbuf
, 1);
189 regcache_raw_write (regcache
, E_1ST_ARG_REGNUM
, buf
);
193 int len
= TYPE_LENGTH (type
);
194 int i
, regnum
= E_1ST_ARG_REGNUM
;
196 for (i
= 0; i
< len
; i
+= xstormy16_reg_size
)
197 regcache_raw_write (regcache
, regnum
++, (char *) valbuf
+ i
);
201 static enum return_value_convention
202 xstormy16_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
203 struct regcache
*regcache
,
204 void *readbuf
, const void *writebuf
)
206 if (xstormy16_use_struct_convention (type
))
207 return RETURN_VALUE_STRUCT_CONVENTION
;
209 xstormy16_store_return_value (type
, regcache
, writebuf
);
211 xstormy16_extract_return_value (type
, regcache
, readbuf
);
212 return RETURN_VALUE_REGISTER_CONVENTION
;
216 xstormy16_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
223 /* Function: xstormy16_push_dummy_call
224 Setup the function arguments for GDB to call a function in the inferior.
225 Called only in the context of a target function call from the debugger.
226 Returns the value of the SP register after the args are pushed. */
229 xstormy16_push_dummy_call (struct gdbarch
*gdbarch
,
230 struct value
*function
,
231 struct regcache
*regcache
,
232 CORE_ADDR bp_addr
, int nargs
,
234 CORE_ADDR sp
, int struct_return
,
235 CORE_ADDR struct_addr
)
237 CORE_ADDR stack_dest
= sp
;
238 int argreg
= E_1ST_ARG_REGNUM
;
240 int typelen
, slacklen
;
242 char buf
[xstormy16_pc_size
];
244 /* If struct_return is true, then the struct return address will
245 consume one argument-passing register. */
248 regcache_cooked_write_unsigned (regcache
, E_PTR_RET_REGNUM
, struct_addr
);
252 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
253 fit in the remaining registers we're switching over to the stack.
254 No argument is put on stack partially and as soon as we switched
255 over to stack no further argument is put in a register even if it
256 would fit in the remaining unused registers. */
257 for (i
= 0; i
< nargs
&& argreg
<= E_LST_ARG_REGNUM
; i
++)
259 typelen
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args
[i
]));
260 if (typelen
> E_MAX_RETTYPE_SIZE (argreg
))
263 /* Put argument into registers wordwise. */
264 val
= VALUE_CONTENTS (args
[i
]);
265 for (j
= 0; j
< typelen
; j
+= xstormy16_reg_size
)
266 regcache_cooked_write_unsigned (regcache
, argreg
++,
267 extract_unsigned_integer (val
+ j
,
270 xstormy16_reg_size
));
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
--)
280 typelen
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args
[j
]));
281 slacklen
= typelen
& 1;
282 val
= alloca (typelen
+ slacklen
);
283 memcpy (val
, VALUE_CONTENTS (args
[j
]), typelen
);
284 memset (val
+ typelen
, 0, slacklen
);
286 /* Now write this data to the stack. The stack grows upwards. */
287 write_memory (stack_dest
, val
, typelen
+ slacklen
);
288 stack_dest
+= typelen
+ slacklen
;
291 store_unsigned_integer (buf
, xstormy16_pc_size
, 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. */
311 xstormy16_analyze_prologue (CORE_ADDR start_addr
, CORE_ADDR end_addr
,
312 struct xstormy16_frame_cache
*cache
,
313 struct frame_info
*next_frame
)
316 ULONGEST inst
, inst2
;
320 /* Initialize framesize with size of PC put on stack by CALLF inst. */
321 cache
->saved_regs
[E_PC_REGNUM
] = 0;
322 cache
->framesize
= xstormy16_pc_size
;
324 if (start_addr
>= end_addr
)
327 for (next_addr
= start_addr
;
328 next_addr
< end_addr
; next_addr
+= xstormy16_inst_size
)
330 inst
= read_memory_unsigned_integer (next_addr
, xstormy16_inst_size
);
331 inst2
= read_memory_unsigned_integer (next_addr
+ xstormy16_inst_size
,
332 xstormy16_inst_size
);
334 if (inst
>= 0x0082 && inst
<= 0x008d) /* push r2 .. push r13 */
336 regnum
= inst
& 0x000f;
337 cache
->saved_regs
[regnum
] = cache
->framesize
;
338 cache
->framesize
+= xstormy16_reg_size
;
341 /* optional stack allocation for args and local vars <= 4 byte */
342 else if (inst
== 0x301f || inst
== 0x303f) /* inc r15, #0x1/#0x3 */
344 cache
->framesize
+= ((inst
& 0x0030) >> 4) + 1;
347 /* optional stack allocation for args and local vars > 4 && < 16 byte */
348 else if ((inst
& 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
350 cache
->framesize
+= (inst
& 0x00f0) >> 4;
353 /* optional stack allocation for args and local vars >= 16 byte */
354 else if (inst
== 0x314f && inst2
>= 0x0010) /* 314f HHHH add r15, #0xH */
356 cache
->framesize
+= inst2
;
357 next_addr
+= xstormy16_inst_size
;
360 else if (inst
== 0x46fd) /* mov r13, r15 */
365 /* optional copying of args in r2-r7 to r10-r13 */
366 /* Probably only in optimized case but legal action for prologue */
367 else if ((inst
& 0xff00) == 0x4600 /* 46SD mov rD, rS */
368 && (inst
& 0x00f0) >= 0x0020 && (inst
& 0x00f0) <= 0x0070
369 && (inst
& 0x000f) >= 0x00a0 && (inst
& 0x000f) <= 0x000d)
372 /* optional copying of args in r2-r7 to stack */
373 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */
374 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
375 else if ((inst
& 0xfed8) == 0x72d8 && (inst
& 0x0007) >= 2)
377 regnum
= inst
& 0x0007;
378 /* Only 12 of 16 bits of the argument are used for the
380 offset
= (LONGEST
) (inst2
& 0x0fff);
384 cache
->saved_regs
[regnum
] = cache
->framesize
+ offset
;
385 next_addr
+= xstormy16_inst_size
;
388 else /* Not a prologue instruction. */
395 /* Function: xstormy16_skip_prologue
396 If the input address is in a function prologue,
397 returns the address of the end of the prologue;
398 else returns the input address.
400 Note: the input address is likely to be the function start,
401 since this function is mainly used for advancing a breakpoint
402 to the first line, or stepping to the first line when we have
403 stepped into a function call. */
406 xstormy16_skip_prologue (CORE_ADDR pc
)
408 CORE_ADDR func_addr
= 0, func_end
= 0;
411 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
413 struct symtab_and_line sal
;
415 struct xstormy16_frame_cache cache
;
417 /* Don't trust line number debug info in frameless functions. */
418 CORE_ADDR plg_end
= xstormy16_analyze_prologue (func_addr
, func_end
,
423 /* Found a function. */
424 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
, NULL
);
425 /* Don't use line number debug info for assembly source files. */
426 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
428 sal
= find_pc_line (func_addr
, 0);
429 if (sal
.end
&& sal
.end
< func_end
)
431 /* Found a line number, use it as end of prologue. */
435 /* No useable line symbol. Use result of prologue parsing method. */
439 /* No function symbol -- just return the PC. */
441 return (CORE_ADDR
) pc
;
444 /* The epilogue is defined here as the area at the end of a function,
445 either on the `ret' instruction itself or after an instruction which
446 destroys the function's stack frame. */
448 xstormy16_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
450 CORE_ADDR func_addr
= 0, func_end
= 0;
452 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
454 ULONGEST inst
, inst2
;
455 CORE_ADDR addr
= func_end
- xstormy16_inst_size
;
457 /* The Xstormy16 epilogue is max. 14 bytes long. */
458 if (pc
< func_end
- 7 * xstormy16_inst_size
)
461 /* Check if we're on a `ret' instruction. Otherwise it's
462 too dangerous to proceed. */
463 inst
= read_memory_unsigned_integer (addr
, xstormy16_inst_size
);
467 while ((addr
-= xstormy16_inst_size
) >= func_addr
)
469 inst
= read_memory_unsigned_integer (addr
, xstormy16_inst_size
);
470 if (inst
>= 0x009a && inst
<= 0x009d) /* pop r10...r13 */
472 if (inst
== 0x305f || inst
== 0x307f) /* dec r15, #0x1/#0x3 */
474 inst2
= read_memory_unsigned_integer (addr
- xstormy16_inst_size
,
475 xstormy16_inst_size
);
476 if (inst2
== 0x314f && inst
>= 0x8000) /* add r15, neg. value */
478 addr
-= xstormy16_inst_size
;
489 const static unsigned char *
490 xstormy16_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
492 static unsigned char breakpoint
[] = { 0x06, 0x0 };
493 *lenptr
= sizeof (breakpoint
);
497 /* Given a pointer to a jump table entry, return the address
498 of the function it jumps to. Return 0 if not found. */
500 xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr
)
502 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
506 LONGEST inst
, inst2
, addr
;
507 char buf
[2 * xstormy16_inst_size
];
509 /* Return faddr if it's not pointing into the jump table. */
510 if (strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
513 if (!target_read_memory (faddr
, buf
, sizeof buf
))
515 inst
= extract_unsigned_integer (buf
, xstormy16_inst_size
);
516 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
517 xstormy16_inst_size
);
518 addr
= inst2
<< 8 | (inst
& 0xff);
525 /* Given a function's address, attempt to find (and return) the
526 address of the corresponding jump table entry. Return 0 if
529 xstormy16_find_jmp_table_entry (CORE_ADDR faddr
)
531 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
535 struct obj_section
*osect
;
537 /* Return faddr if it's already a pointer to a jump table entry. */
538 if (!strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
541 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
543 if (!strcmp (osect
->the_bfd_section
->name
, ".plt"))
547 if (osect
< faddr_sect
->objfile
->sections_end
)
550 for (addr
= osect
->addr
;
551 addr
< osect
->endaddr
; addr
+= 2 * xstormy16_inst_size
)
553 LONGEST inst
, inst2
, faddr2
;
554 char buf
[2 * xstormy16_inst_size
];
556 if (target_read_memory (addr
, buf
, sizeof buf
))
558 inst
= extract_unsigned_integer (buf
, xstormy16_inst_size
);
559 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
560 xstormy16_inst_size
);
561 faddr2
= inst2
<< 8 | (inst
& 0xff);
571 xstormy16_skip_trampoline_code (CORE_ADDR pc
)
573 CORE_ADDR tmp
= xstormy16_resolve_jmp_table_entry (pc
);
575 if (tmp
&& tmp
!= pc
)
580 /* Function pointers are 16 bit. The address space is 24 bit, using
581 32 bit addresses. Pointers to functions on the XStormy16 are implemented
582 by using 16 bit pointers, which are either direct pointers in case the
583 function begins below 0x10000, or indirect pointers into a jump table.
584 The next two functions convert 16 bit pointers into 24 (32) bit addresses
588 xstormy16_pointer_to_address (struct type
*type
, const void *buf
)
590 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
591 CORE_ADDR addr
= extract_unsigned_integer (buf
, TYPE_LENGTH (type
));
593 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
595 CORE_ADDR addr2
= xstormy16_resolve_jmp_table_entry (addr
);
604 xstormy16_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
606 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
608 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
610 CORE_ADDR addr2
= xstormy16_find_jmp_table_entry (addr
);
614 store_unsigned_integer (buf
, TYPE_LENGTH (type
), addr
);
617 static struct xstormy16_frame_cache
*
618 xstormy16_alloc_frame_cache (void)
620 struct xstormy16_frame_cache
*cache
;
623 cache
= FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache
);
629 cache
->framesize
= 0;
630 for (i
= 0; i
< E_NUM_REGS
; ++i
)
631 cache
->saved_regs
[i
] = REG_UNAVAIL
;
636 static struct xstormy16_frame_cache
*
637 xstormy16_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
639 struct xstormy16_frame_cache
*cache
;
640 CORE_ADDR current_pc
;
646 cache
= xstormy16_alloc_frame_cache ();
649 cache
->base
= frame_unwind_register_unsigned (next_frame
, E_FP_REGNUM
);
650 if (cache
->base
== 0)
653 cache
->pc
= frame_func_unwind (next_frame
);
654 current_pc
= frame_pc_unwind (next_frame
);
656 xstormy16_analyze_prologue (cache
->pc
, current_pc
, cache
, next_frame
);
659 cache
->base
= frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
661 cache
->saved_sp
= cache
->base
- cache
->framesize
;
663 for (i
= 0; i
< E_NUM_REGS
; ++i
)
664 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
665 cache
->saved_regs
[i
] += cache
->saved_sp
;
671 xstormy16_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
672 int regnum
, int *optimizedp
,
673 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
674 int *realnump
, void *valuep
)
676 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (next_frame
,
678 gdb_assert (regnum
>= 0);
680 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
688 /* Store the value. */
689 store_unsigned_integer (valuep
, xstormy16_reg_size
, cache
->saved_sp
);
694 if (regnum
< E_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
697 *lvalp
= lval_memory
;
698 *addrp
= cache
->saved_regs
[regnum
];
702 /* Read the value in from memory. */
703 read_memory (*addrp
, valuep
,
704 register_size (current_gdbarch
, regnum
));
710 *lvalp
= lval_register
;
714 frame_unwind_register (next_frame
, (*realnump
), valuep
);
718 xstormy16_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
719 struct frame_id
*this_id
)
721 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (next_frame
,
724 /* This marks the outermost frame. */
725 if (cache
->base
== 0)
728 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
732 xstormy16_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
734 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (next_frame
,
739 static const struct frame_unwind xstormy16_frame_unwind
= {
741 xstormy16_frame_this_id
,
742 xstormy16_frame_prev_register
745 static const struct frame_base xstormy16_frame_base
= {
746 &xstormy16_frame_unwind
,
747 xstormy16_frame_base_address
,
748 xstormy16_frame_base_address
,
749 xstormy16_frame_base_address
752 static const struct frame_unwind
*
753 xstormy16_frame_sniffer (struct frame_info
*next_frame
)
755 return &xstormy16_frame_unwind
;
759 xstormy16_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
761 return frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
765 xstormy16_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
767 return frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
770 static struct frame_id
771 xstormy16_unwind_dummy_id (struct gdbarch
*gdbarch
,
772 struct frame_info
*next_frame
)
774 return frame_id_build (xstormy16_unwind_sp (gdbarch
, next_frame
),
775 frame_pc_unwind (next_frame
));
779 /* Function: xstormy16_gdbarch_init
780 Initializer function for the xstormy16 gdbarch vector.
781 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
783 static struct gdbarch
*
784 xstormy16_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
786 struct gdbarch
*gdbarch
;
788 /* find a candidate among the list of pre-declared architectures. */
789 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
791 return (arches
->gdbarch
);
793 gdbarch
= gdbarch_alloc (&info
, NULL
);
796 * Basic register fields and methods, datatype sizes and stuff.
799 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
800 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
801 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
802 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
803 set_gdbarch_register_name (gdbarch
, xstormy16_register_name
);
804 set_gdbarch_register_type (gdbarch
, xstormy16_register_type
);
806 set_gdbarch_char_signed (gdbarch
, 0);
807 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
808 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
809 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
810 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
812 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
813 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
814 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
816 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
817 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
819 set_gdbarch_address_to_pointer (gdbarch
, xstormy16_address_to_pointer
);
820 set_gdbarch_pointer_to_address (gdbarch
, xstormy16_pointer_to_address
);
822 set_gdbarch_write_pc (gdbarch
, generic_target_write_pc
);
824 /* Stack grows up. */
825 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
830 set_gdbarch_unwind_sp (gdbarch
, xstormy16_unwind_sp
);
831 set_gdbarch_unwind_pc (gdbarch
, xstormy16_unwind_pc
);
832 set_gdbarch_unwind_dummy_id (gdbarch
, xstormy16_unwind_dummy_id
);
833 set_gdbarch_frame_align (gdbarch
, xstormy16_frame_align
);
834 frame_base_set_default (gdbarch
, &xstormy16_frame_base
);
836 set_gdbarch_skip_prologue (gdbarch
, xstormy16_skip_prologue
);
837 set_gdbarch_in_function_epilogue_p (gdbarch
,
838 xstormy16_in_function_epilogue_p
);
840 /* These values and methods are used when gdb calls a target function. */
841 set_gdbarch_push_dummy_call (gdbarch
, xstormy16_push_dummy_call
);
842 set_gdbarch_breakpoint_from_pc (gdbarch
, xstormy16_breakpoint_from_pc
);
843 set_gdbarch_return_value (gdbarch
, xstormy16_return_value
);
845 set_gdbarch_skip_trampoline_code (gdbarch
, xstormy16_skip_trampoline_code
);
847 set_gdbarch_print_insn (gdbarch
, print_insn_xstormy16
);
849 gdbarch_init_osabi (info
, gdbarch
);
851 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
852 frame_unwind_append_sniffer (gdbarch
, xstormy16_frame_sniffer
);
857 /* Function: _initialize_xstormy16_tdep
858 Initializer function for the Sanyo Xstormy16a module.
859 Called by gdb at start-up. */
861 extern initialize_file_ftype _initialize_xstormy16_tdep
; /* -Wmissing-prototypes */
864 _initialize_xstormy16_tdep (void)
866 register_gdbarch_init (bfd_arch_xstormy16
, xstormy16_gdbarch_init
);