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 memset (&cache
, 0, sizeof cache
);
419 /* Don't trust line number debug info in frameless functions. */
420 CORE_ADDR plg_end
= xstormy16_analyze_prologue (func_addr
, func_end
,
425 /* Found a function. */
426 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
, NULL
);
427 /* Don't use line number debug info for assembly source files. */
428 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
430 sal
= find_pc_line (func_addr
, 0);
431 if (sal
.end
&& sal
.end
< func_end
)
433 /* Found a line number, use it as end of prologue. */
437 /* No useable line symbol. Use result of prologue parsing method. */
441 /* No function symbol -- just return the PC. */
443 return (CORE_ADDR
) pc
;
446 /* The epilogue is defined here as the area at the end of a function,
447 either on the `ret' instruction itself or after an instruction which
448 destroys the function's stack frame. */
450 xstormy16_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
452 CORE_ADDR func_addr
= 0, func_end
= 0;
454 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
456 ULONGEST inst
, inst2
;
457 CORE_ADDR addr
= func_end
- xstormy16_inst_size
;
459 /* The Xstormy16 epilogue is max. 14 bytes long. */
460 if (pc
< func_end
- 7 * xstormy16_inst_size
)
463 /* Check if we're on a `ret' instruction. Otherwise it's
464 too dangerous to proceed. */
465 inst
= read_memory_unsigned_integer (addr
, xstormy16_inst_size
);
469 while ((addr
-= xstormy16_inst_size
) >= func_addr
)
471 inst
= read_memory_unsigned_integer (addr
, xstormy16_inst_size
);
472 if (inst
>= 0x009a && inst
<= 0x009d) /* pop r10...r13 */
474 if (inst
== 0x305f || inst
== 0x307f) /* dec r15, #0x1/#0x3 */
476 inst2
= read_memory_unsigned_integer (addr
- xstormy16_inst_size
,
477 xstormy16_inst_size
);
478 if (inst2
== 0x314f && inst
>= 0x8000) /* add r15, neg. value */
480 addr
-= xstormy16_inst_size
;
491 const static unsigned char *
492 xstormy16_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
494 static unsigned char breakpoint
[] = { 0x06, 0x0 };
495 *lenptr
= sizeof (breakpoint
);
499 /* Given a pointer to a jump table entry, return the address
500 of the function it jumps to. Return 0 if not found. */
502 xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr
)
504 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
508 LONGEST inst
, inst2
, addr
;
509 char buf
[2 * xstormy16_inst_size
];
511 /* Return faddr if it's not pointing into the jump table. */
512 if (strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
515 if (!target_read_memory (faddr
, buf
, sizeof buf
))
517 inst
= extract_unsigned_integer (buf
, xstormy16_inst_size
);
518 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
519 xstormy16_inst_size
);
520 addr
= inst2
<< 8 | (inst
& 0xff);
527 /* Given a function's address, attempt to find (and return) the
528 address of the corresponding jump table entry. Return 0 if
531 xstormy16_find_jmp_table_entry (CORE_ADDR faddr
)
533 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
537 struct obj_section
*osect
;
539 /* Return faddr if it's already a pointer to a jump table entry. */
540 if (!strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
543 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
545 if (!strcmp (osect
->the_bfd_section
->name
, ".plt"))
549 if (osect
< faddr_sect
->objfile
->sections_end
)
552 for (addr
= osect
->addr
;
553 addr
< osect
->endaddr
; addr
+= 2 * xstormy16_inst_size
)
555 LONGEST inst
, inst2
, faddr2
;
556 char buf
[2 * xstormy16_inst_size
];
558 if (target_read_memory (addr
, buf
, sizeof buf
))
560 inst
= extract_unsigned_integer (buf
, xstormy16_inst_size
);
561 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
562 xstormy16_inst_size
);
563 faddr2
= inst2
<< 8 | (inst
& 0xff);
573 xstormy16_skip_trampoline_code (CORE_ADDR pc
)
575 CORE_ADDR tmp
= xstormy16_resolve_jmp_table_entry (pc
);
577 if (tmp
&& tmp
!= pc
)
582 /* Function pointers are 16 bit. The address space is 24 bit, using
583 32 bit addresses. Pointers to functions on the XStormy16 are implemented
584 by using 16 bit pointers, which are either direct pointers in case the
585 function begins below 0x10000, or indirect pointers into a jump table.
586 The next two functions convert 16 bit pointers into 24 (32) bit addresses
590 xstormy16_pointer_to_address (struct type
*type
, const void *buf
)
592 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
593 CORE_ADDR addr
= extract_unsigned_integer (buf
, TYPE_LENGTH (type
));
595 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
597 CORE_ADDR addr2
= xstormy16_resolve_jmp_table_entry (addr
);
606 xstormy16_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
608 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
610 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
612 CORE_ADDR addr2
= xstormy16_find_jmp_table_entry (addr
);
616 store_unsigned_integer (buf
, TYPE_LENGTH (type
), addr
);
619 static struct xstormy16_frame_cache
*
620 xstormy16_alloc_frame_cache (void)
622 struct xstormy16_frame_cache
*cache
;
625 cache
= FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache
);
631 cache
->framesize
= 0;
632 for (i
= 0; i
< E_NUM_REGS
; ++i
)
633 cache
->saved_regs
[i
] = REG_UNAVAIL
;
638 static struct xstormy16_frame_cache
*
639 xstormy16_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
641 struct xstormy16_frame_cache
*cache
;
642 CORE_ADDR current_pc
;
648 cache
= xstormy16_alloc_frame_cache ();
651 cache
->base
= frame_unwind_register_unsigned (next_frame
, E_FP_REGNUM
);
652 if (cache
->base
== 0)
655 cache
->pc
= frame_func_unwind (next_frame
);
656 current_pc
= frame_pc_unwind (next_frame
);
658 xstormy16_analyze_prologue (cache
->pc
, current_pc
, cache
, next_frame
);
661 cache
->base
= frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
663 cache
->saved_sp
= cache
->base
- cache
->framesize
;
665 for (i
= 0; i
< E_NUM_REGS
; ++i
)
666 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
667 cache
->saved_regs
[i
] += cache
->saved_sp
;
673 xstormy16_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
674 int regnum
, int *optimizedp
,
675 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
676 int *realnump
, void *valuep
)
678 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (next_frame
,
680 gdb_assert (regnum
>= 0);
682 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
690 /* Store the value. */
691 store_unsigned_integer (valuep
, xstormy16_reg_size
, cache
->saved_sp
);
696 if (regnum
< E_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
699 *lvalp
= lval_memory
;
700 *addrp
= cache
->saved_regs
[regnum
];
704 /* Read the value in from memory. */
705 read_memory (*addrp
, valuep
,
706 register_size (current_gdbarch
, regnum
));
712 *lvalp
= lval_register
;
716 frame_unwind_register (next_frame
, (*realnump
), valuep
);
720 xstormy16_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
721 struct frame_id
*this_id
)
723 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (next_frame
,
726 /* This marks the outermost frame. */
727 if (cache
->base
== 0)
730 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
734 xstormy16_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
736 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (next_frame
,
741 static const struct frame_unwind xstormy16_frame_unwind
= {
743 xstormy16_frame_this_id
,
744 xstormy16_frame_prev_register
747 static const struct frame_base xstormy16_frame_base
= {
748 &xstormy16_frame_unwind
,
749 xstormy16_frame_base_address
,
750 xstormy16_frame_base_address
,
751 xstormy16_frame_base_address
754 static const struct frame_unwind
*
755 xstormy16_frame_sniffer (struct frame_info
*next_frame
)
757 return &xstormy16_frame_unwind
;
761 xstormy16_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
763 return frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
767 xstormy16_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
769 return frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
772 static struct frame_id
773 xstormy16_unwind_dummy_id (struct gdbarch
*gdbarch
,
774 struct frame_info
*next_frame
)
776 return frame_id_build (xstormy16_unwind_sp (gdbarch
, next_frame
),
777 frame_pc_unwind (next_frame
));
781 /* Function: xstormy16_gdbarch_init
782 Initializer function for the xstormy16 gdbarch vector.
783 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
785 static struct gdbarch
*
786 xstormy16_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
788 struct gdbarch
*gdbarch
;
790 /* find a candidate among the list of pre-declared architectures. */
791 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
793 return (arches
->gdbarch
);
795 gdbarch
= gdbarch_alloc (&info
, NULL
);
798 * Basic register fields and methods, datatype sizes and stuff.
801 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
802 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
803 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
804 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
805 set_gdbarch_register_name (gdbarch
, xstormy16_register_name
);
806 set_gdbarch_register_type (gdbarch
, xstormy16_register_type
);
808 set_gdbarch_char_signed (gdbarch
, 0);
809 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
810 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
811 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
812 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
814 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
815 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
816 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
818 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
819 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
821 set_gdbarch_address_to_pointer (gdbarch
, xstormy16_address_to_pointer
);
822 set_gdbarch_pointer_to_address (gdbarch
, xstormy16_pointer_to_address
);
824 set_gdbarch_write_pc (gdbarch
, generic_target_write_pc
);
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_unwind_dummy_id (gdbarch
, xstormy16_unwind_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 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
854 frame_unwind_append_sniffer (gdbarch
, xstormy16_frame_sniffer
);
859 /* Function: _initialize_xstormy16_tdep
860 Initializer function for the Sanyo Xstormy16a module.
861 Called by gdb at start-up. */
863 extern initialize_file_ftype _initialize_xstormy16_tdep
; /* -Wmissing-prototypes */
866 _initialize_xstormy16_tdep (void)
868 register_gdbarch_init (bfd_arch_xstormy16
, xstormy16_gdbarch_init
);