1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
3 Copyright (C) 2001-2020 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"
32 #include "arch-utils.h"
36 #include "gdbsupport/byte-vector.h"
40 /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
41 Functions will return their values in register R2-R7 as they fit.
42 Otherwise a hidden pointer to an big enough area is given as argument
43 to the function in r2. Further arguments are beginning in r3 then.
44 R13 is used as frame pointer when GCC compiles w/o optimization
45 R14 is used as "PSW", displaying the CPU status.
46 R15 is used implicitly as stack pointer. */
49 E_R2_REGNUM
, E_1ST_ARG_REGNUM
= E_R2_REGNUM
, E_PTR_RET_REGNUM
= E_R2_REGNUM
,
54 E_R7_REGNUM
, E_LST_ARG_REGNUM
= E_R7_REGNUM
,
60 E_R13_REGNUM
, E_FP_REGNUM
= E_R13_REGNUM
,
61 E_R14_REGNUM
, E_PSW_REGNUM
= E_R14_REGNUM
,
62 E_R15_REGNUM
, E_SP_REGNUM
= E_R15_REGNUM
,
67 /* Use an invalid address value as 'not available' marker. */
68 enum { REG_UNAVAIL
= (CORE_ADDR
) -1 };
70 struct xstormy16_frame_cache
77 CORE_ADDR saved_regs
[E_NUM_REGS
];
81 /* Size of instructions, registers, etc. */
84 xstormy16_inst_size
= 2,
85 xstormy16_reg_size
= 2,
89 /* Size of return datatype which fits into the remaining return registers. */
90 #define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
93 /* Size of return datatype which fits into all return registers. */
96 E_MAX_RETTYPE_SIZE_IN_REGS
= E_MAX_RETTYPE_SIZE (E_R2_REGNUM
)
99 /* Function: xstormy16_register_name
100 Returns the name of the standard Xstormy16 register N. */
103 xstormy16_register_name (struct gdbarch
*gdbarch
, int regnum
)
105 static const char *register_names
[] = {
106 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
107 "r8", "r9", "r10", "r11", "r12", "r13",
111 if (regnum
< 0 || regnum
>= E_NUM_REGS
)
112 internal_error (__FILE__
, __LINE__
,
113 _("xstormy16_register_name: illegal register number %d"),
116 return register_names
[regnum
];
121 xstormy16_register_type (struct gdbarch
*gdbarch
, int regnum
)
123 if (regnum
== E_PC_REGNUM
)
124 return builtin_type (gdbarch
)->builtin_uint32
;
126 return builtin_type (gdbarch
)->builtin_uint16
;
129 /* Function: xstormy16_type_is_scalar
130 Makes the decision if a given type is a scalar types. Scalar
131 types are returned in the registers r2-r7 as they fit. */
134 xstormy16_type_is_scalar (struct type
*t
)
136 return (t
->code () != TYPE_CODE_STRUCT
137 && t
->code () != TYPE_CODE_UNION
138 && t
->code () != TYPE_CODE_ARRAY
);
141 /* Function: xstormy16_use_struct_convention
142 Returns non-zero if the given struct type will be returned using
143 a special convention, rather than the normal function return method.
144 7sed in the contexts of the "return" command, and of
145 target function calls from the debugger. */
148 xstormy16_use_struct_convention (struct type
*type
)
150 return !xstormy16_type_is_scalar (type
)
151 || TYPE_LENGTH (type
) > E_MAX_RETTYPE_SIZE_IN_REGS
;
154 /* Function: xstormy16_extract_return_value
155 Find a function's return value in the appropriate registers (in
156 regbuf), and copy it into valbuf. */
159 xstormy16_extract_return_value (struct type
*type
, struct regcache
*regcache
,
162 int len
= TYPE_LENGTH (type
);
163 int i
, regnum
= E_1ST_ARG_REGNUM
;
165 for (i
= 0; i
< len
; i
+= xstormy16_reg_size
)
166 regcache
->raw_read (regnum
++, valbuf
+ i
);
169 /* Function: xstormy16_store_return_value
170 Copy the function return value from VALBUF into the
171 proper location for a function return.
172 Called only in the context of the "return" command. */
175 xstormy16_store_return_value (struct type
*type
, struct regcache
*regcache
,
176 const gdb_byte
*valbuf
)
178 if (TYPE_LENGTH (type
) == 1)
180 /* Add leading zeros to the value. */
181 gdb_byte buf
[xstormy16_reg_size
];
182 memset (buf
, 0, xstormy16_reg_size
);
183 memcpy (buf
, valbuf
, 1);
184 regcache
->raw_write (E_1ST_ARG_REGNUM
, buf
);
188 int len
= TYPE_LENGTH (type
);
189 int i
, regnum
= E_1ST_ARG_REGNUM
;
191 for (i
= 0; i
< len
; i
+= xstormy16_reg_size
)
192 regcache
->raw_write (regnum
++, valbuf
+ i
);
196 static enum return_value_convention
197 xstormy16_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
198 struct type
*type
, struct regcache
*regcache
,
200 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
202 if (xstormy16_use_struct_convention (type
))
203 return RETURN_VALUE_STRUCT_CONVENTION
;
205 xstormy16_store_return_value (type
, regcache
, writebuf
);
207 xstormy16_extract_return_value (type
, regcache
, readbuf
);
208 return RETURN_VALUE_REGISTER_CONVENTION
;
212 xstormy16_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
219 /* Function: xstormy16_push_dummy_call
220 Setup the function arguments for GDB to call a function in the inferior.
221 Called only in the context of a target function call from the debugger.
222 Returns the value of the SP register after the args are pushed. */
225 xstormy16_push_dummy_call (struct gdbarch
*gdbarch
,
226 struct value
*function
,
227 struct regcache
*regcache
,
228 CORE_ADDR bp_addr
, int nargs
,
231 function_call_return_method return_method
,
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
;
239 gdb_byte buf
[xstormy16_pc_size
];
241 /* If returning a struct using target ABI method, then the struct return
242 address will consume one argument-passing register. */
243 if (return_method
== return_method_struct
)
245 regcache_cooked_write_unsigned (regcache
, E_PTR_RET_REGNUM
, struct_addr
);
249 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
250 fit in the remaining registers we're switching over to the stack.
251 No argument is put on stack partially and as soon as we switched
252 over to stack no further argument is put in a register even if it
253 would fit in the remaining unused registers. */
254 for (i
= 0; i
< nargs
&& argreg
<= E_LST_ARG_REGNUM
; i
++)
256 typelen
= TYPE_LENGTH (value_enclosing_type (args
[i
]));
257 if (typelen
> E_MAX_RETTYPE_SIZE (argreg
))
260 /* Put argument into registers wordwise. */
261 const gdb_byte
*val
= value_contents (args
[i
]);
262 for (j
= 0; j
< typelen
; j
+= xstormy16_reg_size
)
265 int size
= (typelen
- j
== 1) ? 1 : xstormy16_reg_size
;
267 regval
= extract_unsigned_integer (val
+ j
, size
, byte_order
);
268 regcache_cooked_write_unsigned (regcache
, argreg
++, regval
);
273 stack_dest
= xstormy16_frame_align (gdbarch
, stack_dest
);
275 /* Loop backwards through remaining arguments and push them on the stack,
277 for (j
= nargs
- 1; j
>= i
; j
--)
279 const gdb_byte
*bytes
= value_contents (args
[j
]);
281 typelen
= TYPE_LENGTH (value_enclosing_type (args
[j
]));
282 slacklen
= typelen
& 1;
283 gdb::byte_vector
val (typelen
+ slacklen
);
284 memcpy (val
.data (), bytes
, typelen
);
285 memset (val
.data () + typelen
, 0, slacklen
);
287 /* Now write this data to the stack. The stack grows upwards. */
288 write_memory (stack_dest
, val
.data (), typelen
+ slacklen
);
289 stack_dest
+= typelen
+ slacklen
;
292 store_unsigned_integer (buf
, xstormy16_pc_size
, byte_order
, bp_addr
);
293 write_memory (stack_dest
, buf
, xstormy16_pc_size
);
294 stack_dest
+= xstormy16_pc_size
;
296 /* Update stack pointer. */
297 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, stack_dest
);
299 /* Return the new stack pointer minus the return address slot since
300 that's what DWARF2/GCC uses as the frame's CFA. */
301 return stack_dest
- xstormy16_pc_size
;
304 /* Function: xstormy16_scan_prologue
305 Decode the instructions within the given address range.
306 Decide when we must have reached the end of the function prologue.
307 If a frame_info pointer is provided, fill in its saved_regs etc.
309 Returns the address of the first instruction after the prologue. */
312 xstormy16_analyze_prologue (struct gdbarch
*gdbarch
,
313 CORE_ADDR start_addr
, CORE_ADDR end_addr
,
314 struct xstormy16_frame_cache
*cache
,
315 struct frame_info
*this_frame
)
317 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
319 ULONGEST inst
, inst2
;
323 /* Initialize framesize with size of PC put on stack by CALLF inst. */
324 cache
->saved_regs
[E_PC_REGNUM
] = 0;
325 cache
->framesize
= xstormy16_pc_size
;
327 if (start_addr
>= end_addr
)
330 for (next_addr
= start_addr
;
331 next_addr
< end_addr
; next_addr
+= xstormy16_inst_size
)
333 inst
= read_memory_unsigned_integer (next_addr
,
334 xstormy16_inst_size
, byte_order
);
335 inst2
= read_memory_unsigned_integer (next_addr
+ xstormy16_inst_size
,
336 xstormy16_inst_size
, byte_order
);
338 if (inst
>= 0x0082 && inst
<= 0x008d) /* push r2 .. push r13 */
340 regnum
= inst
& 0x000f;
341 cache
->saved_regs
[regnum
] = cache
->framesize
;
342 cache
->framesize
+= xstormy16_reg_size
;
345 /* Optional stack allocation for args and local vars <= 4 byte. */
346 else if (inst
== 0x301f || inst
== 0x303f) /* inc r15, #0x1/#0x3 */
348 cache
->framesize
+= ((inst
& 0x0030) >> 4) + 1;
351 /* optional stack allocation for args and local vars > 4 && < 16 byte */
352 else if ((inst
& 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
354 cache
->framesize
+= (inst
& 0x00f0) >> 4;
357 /* Optional stack allocation for args and local vars >= 16 byte. */
358 else if (inst
== 0x314f && inst2
>= 0x0010) /* 314f HHHH add r15, #0xH */
360 cache
->framesize
+= inst2
;
361 next_addr
+= xstormy16_inst_size
;
364 else if (inst
== 0x46fd) /* mov r13, r15 */
369 /* optional copying of args in r2-r7 to r10-r13. */
370 /* Probably only in optimized case but legal action for prologue. */
371 else if ((inst
& 0xff00) == 0x4600 /* 46SD mov rD, rS */
372 && (inst
& 0x00f0) >= 0x0020 && (inst
& 0x00f0) <= 0x0070
373 && (inst
& 0x000f) >= 0x000a && (inst
& 0x000f) <= 0x000d)
376 /* Optional copying of args in r2-r7 to stack. */
377 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8)
378 (bit3 always 1, bit2-0 = reg) */
379 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
380 else if ((inst
& 0xfed8) == 0x72d8 && (inst
& 0x0007) >= 2)
382 regnum
= inst
& 0x0007;
383 /* Only 12 of 16 bits of the argument are used for the
385 offset
= (LONGEST
) (inst2
& 0x0fff);
389 cache
->saved_regs
[regnum
] = cache
->framesize
+ offset
;
390 next_addr
+= xstormy16_inst_size
;
393 else /* Not a prologue instruction. */
400 /* Function: xstormy16_skip_prologue
401 If the input address is in a function prologue,
402 returns the address of the end of the prologue;
403 else returns the input address.
405 Note: the input address is likely to be the function start,
406 since this function is mainly used for advancing a breakpoint
407 to the first line, or stepping to the first line when we have
408 stepped into a function call. */
411 xstormy16_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
413 CORE_ADDR func_addr
= 0, func_end
= 0;
414 const char *func_name
;
416 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
418 struct symtab_and_line sal
;
420 struct xstormy16_frame_cache cache
;
423 memset (&cache
, 0, sizeof cache
);
425 /* Don't trust line number debug info in frameless functions. */
426 plg_end
= xstormy16_analyze_prologue (gdbarch
, func_addr
, func_end
,
431 /* Found a function. */
432 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
433 /* Don't use line number debug info for assembly source files. */
434 if (sym
&& sym
->language () != language_asm
)
436 sal
= find_pc_line (func_addr
, 0);
437 if (sal
.end
&& sal
.end
< func_end
)
439 /* Found a line number, use it as end of prologue. */
443 /* No useable line symbol. Use result of prologue parsing method. */
447 /* No function symbol -- just return the PC. */
449 return (CORE_ADDR
) pc
;
452 /* Implement the stack_frame_destroyed_p gdbarch method.
454 The epilogue is defined here as the area at the end of a function,
455 either on the `ret' instruction itself or after an instruction which
456 destroys the function's stack frame. */
459 xstormy16_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
461 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
462 CORE_ADDR func_addr
= 0, func_end
= 0;
464 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
466 ULONGEST inst
, inst2
;
467 CORE_ADDR addr
= func_end
- xstormy16_inst_size
;
469 /* The Xstormy16 epilogue is max. 14 bytes long. */
470 if (pc
< func_end
- 7 * xstormy16_inst_size
)
473 /* Check if we're on a `ret' instruction. Otherwise it's
474 too dangerous to proceed. */
475 inst
= read_memory_unsigned_integer (addr
,
476 xstormy16_inst_size
, byte_order
);
480 while ((addr
-= xstormy16_inst_size
) >= func_addr
)
482 inst
= read_memory_unsigned_integer (addr
,
485 if (inst
>= 0x009a && inst
<= 0x009d) /* pop r10...r13 */
487 if (inst
== 0x305f || inst
== 0x307f) /* dec r15, #0x1/#0x3 */
489 inst2
= read_memory_unsigned_integer (addr
- xstormy16_inst_size
,
492 if (inst2
== 0x314f && inst
>= 0x8000) /* add r15, neg. value */
494 addr
-= xstormy16_inst_size
;
505 constexpr gdb_byte xstormy16_break_insn
[] = { 0x06, 0x0 };
507 typedef BP_MANIPULATION (xstormy16_break_insn
) xstormy16_breakpoint
;
509 /* Given a pointer to a jump table entry, return the address
510 of the function it jumps to. Return 0 if not found. */
512 xstormy16_resolve_jmp_table_entry (struct gdbarch
*gdbarch
, CORE_ADDR faddr
)
514 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
515 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
519 LONGEST inst
, inst2
, addr
;
520 gdb_byte buf
[2 * xstormy16_inst_size
];
522 /* Return faddr if it's not pointing into the jump table. */
523 if (strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
526 if (!target_read_memory (faddr
, buf
, sizeof buf
))
528 inst
= extract_unsigned_integer (buf
,
529 xstormy16_inst_size
, byte_order
);
530 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
531 xstormy16_inst_size
, byte_order
);
532 addr
= inst2
<< 8 | (inst
& 0xff);
539 /* Given a function's address, attempt to find (and return) the
540 address of the corresponding jump table entry. Return 0 if
543 xstormy16_find_jmp_table_entry (struct gdbarch
*gdbarch
, CORE_ADDR faddr
)
545 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
546 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
550 struct obj_section
*osect
;
552 /* Return faddr if it's already a pointer to a jump table entry. */
553 if (!strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
556 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
558 if (!strcmp (osect
->the_bfd_section
->name
, ".plt"))
562 if (osect
< faddr_sect
->objfile
->sections_end
)
564 CORE_ADDR addr
, endaddr
;
566 addr
= obj_section_addr (osect
);
567 endaddr
= obj_section_endaddr (osect
);
569 for (; addr
< endaddr
; addr
+= 2 * xstormy16_inst_size
)
571 LONGEST inst
, inst2
, faddr2
;
572 gdb_byte buf
[2 * xstormy16_inst_size
];
574 if (target_read_memory (addr
, buf
, sizeof buf
))
576 inst
= extract_unsigned_integer (buf
,
579 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
582 faddr2
= inst2
<< 8 | (inst
& 0xff);
592 xstormy16_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
594 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
595 CORE_ADDR tmp
= xstormy16_resolve_jmp_table_entry (gdbarch
, pc
);
597 if (tmp
&& tmp
!= pc
)
602 /* Function pointers are 16 bit. The address space is 24 bit, using
603 32 bit addresses. Pointers to functions on the XStormy16 are implemented
604 by using 16 bit pointers, which are either direct pointers in case the
605 function begins below 0x10000, or indirect pointers into a jump table.
606 The next two functions convert 16 bit pointers into 24 (32) bit addresses
610 xstormy16_pointer_to_address (struct gdbarch
*gdbarch
,
611 struct type
*type
, const gdb_byte
*buf
)
613 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
614 enum type_code target
= TYPE_TARGET_TYPE (type
)->code ();
616 = extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
618 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
620 CORE_ADDR addr2
= xstormy16_resolve_jmp_table_entry (gdbarch
, addr
);
629 xstormy16_address_to_pointer (struct gdbarch
*gdbarch
,
630 struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
632 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
633 enum type_code target
= TYPE_TARGET_TYPE (type
)->code ();
635 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
637 CORE_ADDR addr2
= xstormy16_find_jmp_table_entry (gdbarch
, addr
);
641 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
644 static struct xstormy16_frame_cache
*
645 xstormy16_alloc_frame_cache (void)
647 struct xstormy16_frame_cache
*cache
;
650 cache
= FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache
);
656 cache
->framesize
= 0;
657 for (i
= 0; i
< E_NUM_REGS
; ++i
)
658 cache
->saved_regs
[i
] = REG_UNAVAIL
;
663 static struct xstormy16_frame_cache
*
664 xstormy16_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
666 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
667 struct xstormy16_frame_cache
*cache
;
668 CORE_ADDR current_pc
;
672 return (struct xstormy16_frame_cache
*) *this_cache
;
674 cache
= xstormy16_alloc_frame_cache ();
677 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
678 if (cache
->base
== 0)
681 cache
->pc
= get_frame_func (this_frame
);
682 current_pc
= get_frame_pc (this_frame
);
684 xstormy16_analyze_prologue (gdbarch
, cache
->pc
, current_pc
,
688 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
690 cache
->saved_sp
= cache
->base
- cache
->framesize
;
692 for (i
= 0; i
< E_NUM_REGS
; ++i
)
693 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
694 cache
->saved_regs
[i
] += cache
->saved_sp
;
699 static struct value
*
700 xstormy16_frame_prev_register (struct frame_info
*this_frame
,
701 void **this_cache
, int regnum
)
703 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (this_frame
,
705 gdb_assert (regnum
>= 0);
707 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
708 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
710 if (regnum
< E_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
711 return frame_unwind_got_memory (this_frame
, regnum
,
712 cache
->saved_regs
[regnum
]);
714 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
718 xstormy16_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
719 struct frame_id
*this_id
)
721 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (this_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
*this_frame
, void **this_cache
)
734 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (this_frame
,
739 static const struct frame_unwind xstormy16_frame_unwind
= {
741 default_frame_unwind_stop_reason
,
742 xstormy16_frame_this_id
,
743 xstormy16_frame_prev_register
,
745 default_frame_sniffer
748 static const struct frame_base xstormy16_frame_base
= {
749 &xstormy16_frame_unwind
,
750 xstormy16_frame_base_address
,
751 xstormy16_frame_base_address
,
752 xstormy16_frame_base_address
755 /* Function: xstormy16_gdbarch_init
756 Initializer function for the xstormy16 gdbarch vector.
757 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
759 static struct gdbarch
*
760 xstormy16_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
762 struct gdbarch
*gdbarch
;
764 /* find a candidate among the list of pre-declared architectures. */
765 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
767 return (arches
->gdbarch
);
769 gdbarch
= gdbarch_alloc (&info
, NULL
);
772 * Basic register fields and methods, datatype sizes and stuff.
775 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
776 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
777 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
778 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
779 set_gdbarch_register_name (gdbarch
, xstormy16_register_name
);
780 set_gdbarch_register_type (gdbarch
, xstormy16_register_type
);
782 set_gdbarch_char_signed (gdbarch
, 0);
783 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
784 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
785 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
786 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
788 set_gdbarch_wchar_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
789 set_gdbarch_wchar_signed (gdbarch
, 1);
791 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
792 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
793 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
795 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
796 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
797 set_gdbarch_dwarf2_addr_size (gdbarch
, 4);
799 set_gdbarch_address_to_pointer (gdbarch
, xstormy16_address_to_pointer
);
800 set_gdbarch_pointer_to_address (gdbarch
, xstormy16_pointer_to_address
);
802 /* Stack grows up. */
803 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
808 set_gdbarch_frame_align (gdbarch
, xstormy16_frame_align
);
809 frame_base_set_default (gdbarch
, &xstormy16_frame_base
);
811 set_gdbarch_skip_prologue (gdbarch
, xstormy16_skip_prologue
);
812 set_gdbarch_stack_frame_destroyed_p (gdbarch
,
813 xstormy16_stack_frame_destroyed_p
);
815 /* These values and methods are used when gdb calls a target function. */
816 set_gdbarch_push_dummy_call (gdbarch
, xstormy16_push_dummy_call
);
817 set_gdbarch_breakpoint_kind_from_pc (gdbarch
,
818 xstormy16_breakpoint::kind_from_pc
);
819 set_gdbarch_sw_breakpoint_from_kind (gdbarch
,
820 xstormy16_breakpoint::bp_from_kind
);
821 set_gdbarch_return_value (gdbarch
, xstormy16_return_value
);
823 set_gdbarch_skip_trampoline_code (gdbarch
, xstormy16_skip_trampoline_code
);
825 gdbarch_init_osabi (info
, gdbarch
);
827 dwarf2_append_unwinders (gdbarch
);
828 frame_unwind_append_unwinder (gdbarch
, &xstormy16_frame_unwind
);
833 /* Function: _initialize_xstormy16_tdep
834 Initializer function for the Sanyo Xstormy16a module.
835 Called by gdb at start-up. */
837 void _initialize_xstormy16_tdep ();
839 _initialize_xstormy16_tdep ()
841 register_gdbarch_init (bfd_arch_xstormy16
, xstormy16_gdbarch_init
);