1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
3 Copyright (C) 2001-2018 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 "common/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 implicitely 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 (TYPE_CODE(t
) != TYPE_CODE_STRUCT
137 && TYPE_CODE(t
) != TYPE_CODE_UNION
138 && TYPE_CODE(t
) != 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
,
199 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
201 if (xstormy16_use_struct_convention (type
))
202 return RETURN_VALUE_STRUCT_CONVENTION
;
204 xstormy16_store_return_value (type
, regcache
, writebuf
);
206 xstormy16_extract_return_value (type
, regcache
, readbuf
);
207 return RETURN_VALUE_REGISTER_CONVENTION
;
211 xstormy16_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
218 /* Function: xstormy16_push_dummy_call
219 Setup the function arguments for GDB to call a function in the inferior.
220 Called only in the context of a target function call from the debugger.
221 Returns the value of the SP register after the args are pushed. */
224 xstormy16_push_dummy_call (struct gdbarch
*gdbarch
,
225 struct value
*function
,
226 struct regcache
*regcache
,
227 CORE_ADDR bp_addr
, int nargs
,
229 CORE_ADDR sp
, int struct_return
,
230 CORE_ADDR struct_addr
)
232 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
233 CORE_ADDR stack_dest
= sp
;
234 int argreg
= E_1ST_ARG_REGNUM
;
236 int typelen
, slacklen
;
237 gdb_byte buf
[xstormy16_pc_size
];
239 /* If struct_return is true, then the struct return address will
240 consume one argument-passing register. */
243 regcache_cooked_write_unsigned (regcache
, E_PTR_RET_REGNUM
, struct_addr
);
247 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
248 fit in the remaining registers we're switching over to the stack.
249 No argument is put on stack partially and as soon as we switched
250 over to stack no further argument is put in a register even if it
251 would fit in the remaining unused registers. */
252 for (i
= 0; i
< nargs
&& argreg
<= E_LST_ARG_REGNUM
; i
++)
254 typelen
= TYPE_LENGTH (value_enclosing_type (args
[i
]));
255 if (typelen
> E_MAX_RETTYPE_SIZE (argreg
))
258 /* Put argument into registers wordwise. */
259 const gdb_byte
*val
= value_contents (args
[i
]);
260 for (j
= 0; j
< typelen
; j
+= xstormy16_reg_size
)
263 int size
= (typelen
- j
== 1) ? 1 : xstormy16_reg_size
;
265 regval
= extract_unsigned_integer (val
+ j
, size
, byte_order
);
266 regcache_cooked_write_unsigned (regcache
, argreg
++, regval
);
271 stack_dest
= xstormy16_frame_align (gdbarch
, stack_dest
);
273 /* Loop backwards through remaining arguments and push them on the stack,
275 for (j
= nargs
- 1; j
>= i
; j
--)
277 const gdb_byte
*bytes
= value_contents (args
[j
]);
279 typelen
= TYPE_LENGTH (value_enclosing_type (args
[j
]));
280 slacklen
= typelen
& 1;
281 gdb::byte_vector
val (typelen
+ slacklen
);
282 memcpy (val
.data (), bytes
, typelen
);
283 memset (val
.data () + typelen
, 0, slacklen
);
285 /* Now write this data to the stack. The stack grows upwards. */
286 write_memory (stack_dest
, val
.data (), typelen
+ slacklen
);
287 stack_dest
+= typelen
+ slacklen
;
290 store_unsigned_integer (buf
, xstormy16_pc_size
, byte_order
, bp_addr
);
291 write_memory (stack_dest
, buf
, xstormy16_pc_size
);
292 stack_dest
+= xstormy16_pc_size
;
294 /* Update stack pointer. */
295 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, stack_dest
);
297 /* Return the new stack pointer minus the return address slot since
298 that's what DWARF2/GCC uses as the frame's CFA. */
299 return stack_dest
- xstormy16_pc_size
;
302 /* Function: xstormy16_scan_prologue
303 Decode the instructions within the given address range.
304 Decide when we must have reached the end of the function prologue.
305 If a frame_info pointer is provided, fill in its saved_regs etc.
307 Returns the address of the first instruction after the prologue. */
310 xstormy16_analyze_prologue (struct gdbarch
*gdbarch
,
311 CORE_ADDR start_addr
, CORE_ADDR end_addr
,
312 struct xstormy16_frame_cache
*cache
,
313 struct frame_info
*this_frame
)
315 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
317 ULONGEST inst
, inst2
;
321 /* Initialize framesize with size of PC put on stack by CALLF inst. */
322 cache
->saved_regs
[E_PC_REGNUM
] = 0;
323 cache
->framesize
= xstormy16_pc_size
;
325 if (start_addr
>= end_addr
)
328 for (next_addr
= start_addr
;
329 next_addr
< end_addr
; next_addr
+= xstormy16_inst_size
)
331 inst
= read_memory_unsigned_integer (next_addr
,
332 xstormy16_inst_size
, byte_order
);
333 inst2
= read_memory_unsigned_integer (next_addr
+ xstormy16_inst_size
,
334 xstormy16_inst_size
, byte_order
);
336 if (inst
>= 0x0082 && inst
<= 0x008d) /* push r2 .. push r13 */
338 regnum
= inst
& 0x000f;
339 cache
->saved_regs
[regnum
] = cache
->framesize
;
340 cache
->framesize
+= xstormy16_reg_size
;
343 /* Optional stack allocation for args and local vars <= 4 byte. */
344 else if (inst
== 0x301f || inst
== 0x303f) /* inc r15, #0x1/#0x3 */
346 cache
->framesize
+= ((inst
& 0x0030) >> 4) + 1;
349 /* optional stack allocation for args and local vars > 4 && < 16 byte */
350 else if ((inst
& 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
352 cache
->framesize
+= (inst
& 0x00f0) >> 4;
355 /* Optional stack allocation for args and local vars >= 16 byte. */
356 else if (inst
== 0x314f && inst2
>= 0x0010) /* 314f HHHH add r15, #0xH */
358 cache
->framesize
+= inst2
;
359 next_addr
+= xstormy16_inst_size
;
362 else if (inst
== 0x46fd) /* mov r13, r15 */
367 /* optional copying of args in r2-r7 to r10-r13. */
368 /* Probably only in optimized case but legal action for prologue. */
369 else if ((inst
& 0xff00) == 0x4600 /* 46SD mov rD, rS */
370 && (inst
& 0x00f0) >= 0x0020 && (inst
& 0x00f0) <= 0x0070
371 && (inst
& 0x000f) >= 0x000a && (inst
& 0x000f) <= 0x000d)
374 /* Optional copying of args in r2-r7 to stack. */
375 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8)
376 (bit3 always 1, bit2-0 = reg) */
377 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
378 else if ((inst
& 0xfed8) == 0x72d8 && (inst
& 0x0007) >= 2)
380 regnum
= inst
& 0x0007;
381 /* Only 12 of 16 bits of the argument are used for the
383 offset
= (LONGEST
) (inst2
& 0x0fff);
387 cache
->saved_regs
[regnum
] = cache
->framesize
+ offset
;
388 next_addr
+= xstormy16_inst_size
;
391 else /* Not a prologue instruction. */
398 /* Function: xstormy16_skip_prologue
399 If the input address is in a function prologue,
400 returns the address of the end of the prologue;
401 else returns the input address.
403 Note: the input address is likely to be the function start,
404 since this function is mainly used for advancing a breakpoint
405 to the first line, or stepping to the first line when we have
406 stepped into a function call. */
409 xstormy16_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
411 CORE_ADDR func_addr
= 0, func_end
= 0;
412 const char *func_name
;
414 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
416 struct symtab_and_line sal
;
418 struct xstormy16_frame_cache cache
;
421 memset (&cache
, 0, sizeof cache
);
423 /* Don't trust line number debug info in frameless functions. */
424 plg_end
= xstormy16_analyze_prologue (gdbarch
, func_addr
, func_end
,
429 /* Found a function. */
430 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
431 /* Don't use line number debug info for assembly source files. */
432 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
434 sal
= find_pc_line (func_addr
, 0);
435 if (sal
.end
&& sal
.end
< func_end
)
437 /* Found a line number, use it as end of prologue. */
441 /* No useable line symbol. Use result of prologue parsing method. */
445 /* No function symbol -- just return the PC. */
447 return (CORE_ADDR
) pc
;
450 /* Implement the stack_frame_destroyed_p gdbarch method.
452 The epilogue is defined here as the area at the end of a function,
453 either on the `ret' instruction itself or after an instruction which
454 destroys the function's stack frame. */
457 xstormy16_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
459 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
460 CORE_ADDR func_addr
= 0, func_end
= 0;
462 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
464 ULONGEST inst
, inst2
;
465 CORE_ADDR addr
= func_end
- xstormy16_inst_size
;
467 /* The Xstormy16 epilogue is max. 14 bytes long. */
468 if (pc
< func_end
- 7 * xstormy16_inst_size
)
471 /* Check if we're on a `ret' instruction. Otherwise it's
472 too dangerous to proceed. */
473 inst
= read_memory_unsigned_integer (addr
,
474 xstormy16_inst_size
, byte_order
);
478 while ((addr
-= xstormy16_inst_size
) >= func_addr
)
480 inst
= read_memory_unsigned_integer (addr
,
483 if (inst
>= 0x009a && inst
<= 0x009d) /* pop r10...r13 */
485 if (inst
== 0x305f || inst
== 0x307f) /* dec r15, #0x1/#0x3 */
487 inst2
= read_memory_unsigned_integer (addr
- xstormy16_inst_size
,
490 if (inst2
== 0x314f && inst
>= 0x8000) /* add r15, neg. value */
492 addr
-= xstormy16_inst_size
;
503 constexpr gdb_byte xstormy16_break_insn
[] = { 0x06, 0x0 };
505 typedef BP_MANIPULATION (xstormy16_break_insn
) xstormy16_breakpoint
;
507 /* Given a pointer to a jump table entry, return the address
508 of the function it jumps to. Return 0 if not found. */
510 xstormy16_resolve_jmp_table_entry (struct gdbarch
*gdbarch
, CORE_ADDR faddr
)
512 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
513 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
517 LONGEST inst
, inst2
, addr
;
518 gdb_byte buf
[2 * xstormy16_inst_size
];
520 /* Return faddr if it's not pointing into the jump table. */
521 if (strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
524 if (!target_read_memory (faddr
, buf
, sizeof buf
))
526 inst
= extract_unsigned_integer (buf
,
527 xstormy16_inst_size
, byte_order
);
528 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
529 xstormy16_inst_size
, byte_order
);
530 addr
= inst2
<< 8 | (inst
& 0xff);
537 /* Given a function's address, attempt to find (and return) the
538 address of the corresponding jump table entry. Return 0 if
541 xstormy16_find_jmp_table_entry (struct gdbarch
*gdbarch
, CORE_ADDR faddr
)
543 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
544 struct obj_section
*faddr_sect
= find_pc_section (faddr
);
548 struct obj_section
*osect
;
550 /* Return faddr if it's already a pointer to a jump table entry. */
551 if (!strcmp (faddr_sect
->the_bfd_section
->name
, ".plt"))
554 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
556 if (!strcmp (osect
->the_bfd_section
->name
, ".plt"))
560 if (osect
< faddr_sect
->objfile
->sections_end
)
562 CORE_ADDR addr
, endaddr
;
564 addr
= obj_section_addr (osect
);
565 endaddr
= obj_section_endaddr (osect
);
567 for (; addr
< endaddr
; addr
+= 2 * xstormy16_inst_size
)
569 LONGEST inst
, inst2
, faddr2
;
570 gdb_byte buf
[2 * xstormy16_inst_size
];
572 if (target_read_memory (addr
, buf
, sizeof buf
))
574 inst
= extract_unsigned_integer (buf
,
577 inst2
= extract_unsigned_integer (buf
+ xstormy16_inst_size
,
580 faddr2
= inst2
<< 8 | (inst
& 0xff);
590 xstormy16_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
592 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
593 CORE_ADDR tmp
= xstormy16_resolve_jmp_table_entry (gdbarch
, pc
);
595 if (tmp
&& tmp
!= pc
)
600 /* Function pointers are 16 bit. The address space is 24 bit, using
601 32 bit addresses. Pointers to functions on the XStormy16 are implemented
602 by using 16 bit pointers, which are either direct pointers in case the
603 function begins below 0x10000, or indirect pointers into a jump table.
604 The next two functions convert 16 bit pointers into 24 (32) bit addresses
608 xstormy16_pointer_to_address (struct gdbarch
*gdbarch
,
609 struct type
*type
, const gdb_byte
*buf
)
611 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
612 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
614 = extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
616 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
618 CORE_ADDR addr2
= xstormy16_resolve_jmp_table_entry (gdbarch
, addr
);
627 xstormy16_address_to_pointer (struct gdbarch
*gdbarch
,
628 struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
630 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
631 enum type_code target
= TYPE_CODE (TYPE_TARGET_TYPE (type
));
633 if (target
== TYPE_CODE_FUNC
|| target
== TYPE_CODE_METHOD
)
635 CORE_ADDR addr2
= xstormy16_find_jmp_table_entry (gdbarch
, addr
);
639 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
642 static struct xstormy16_frame_cache
*
643 xstormy16_alloc_frame_cache (void)
645 struct xstormy16_frame_cache
*cache
;
648 cache
= FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache
);
654 cache
->framesize
= 0;
655 for (i
= 0; i
< E_NUM_REGS
; ++i
)
656 cache
->saved_regs
[i
] = REG_UNAVAIL
;
661 static struct xstormy16_frame_cache
*
662 xstormy16_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
664 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
665 struct xstormy16_frame_cache
*cache
;
666 CORE_ADDR current_pc
;
670 return (struct xstormy16_frame_cache
*) *this_cache
;
672 cache
= xstormy16_alloc_frame_cache ();
675 cache
->base
= get_frame_register_unsigned (this_frame
, E_FP_REGNUM
);
676 if (cache
->base
== 0)
679 cache
->pc
= get_frame_func (this_frame
);
680 current_pc
= get_frame_pc (this_frame
);
682 xstormy16_analyze_prologue (gdbarch
, cache
->pc
, current_pc
,
686 cache
->base
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
688 cache
->saved_sp
= cache
->base
- cache
->framesize
;
690 for (i
= 0; i
< E_NUM_REGS
; ++i
)
691 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
692 cache
->saved_regs
[i
] += cache
->saved_sp
;
697 static struct value
*
698 xstormy16_frame_prev_register (struct frame_info
*this_frame
,
699 void **this_cache
, int regnum
)
701 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (this_frame
,
703 gdb_assert (regnum
>= 0);
705 if (regnum
== E_SP_REGNUM
&& cache
->saved_sp
)
706 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
708 if (regnum
< E_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
709 return frame_unwind_got_memory (this_frame
, regnum
,
710 cache
->saved_regs
[regnum
]);
712 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
716 xstormy16_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
717 struct frame_id
*this_id
)
719 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (this_frame
,
722 /* This marks the outermost frame. */
723 if (cache
->base
== 0)
726 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
730 xstormy16_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
732 struct xstormy16_frame_cache
*cache
= xstormy16_frame_cache (this_frame
,
737 static const struct frame_unwind xstormy16_frame_unwind
= {
739 default_frame_unwind_stop_reason
,
740 xstormy16_frame_this_id
,
741 xstormy16_frame_prev_register
,
743 default_frame_sniffer
746 static const struct frame_base xstormy16_frame_base
= {
747 &xstormy16_frame_unwind
,
748 xstormy16_frame_base_address
,
749 xstormy16_frame_base_address
,
750 xstormy16_frame_base_address
754 xstormy16_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
756 return frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
760 xstormy16_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
762 return frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
765 static struct frame_id
766 xstormy16_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
768 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, E_SP_REGNUM
);
769 return frame_id_build (sp
, get_frame_pc (this_frame
));
773 /* Function: xstormy16_gdbarch_init
774 Initializer function for the xstormy16 gdbarch vector.
775 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
777 static struct gdbarch
*
778 xstormy16_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
780 struct gdbarch
*gdbarch
;
782 /* find a candidate among the list of pre-declared architectures. */
783 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
785 return (arches
->gdbarch
);
787 gdbarch
= gdbarch_alloc (&info
, NULL
);
790 * Basic register fields and methods, datatype sizes and stuff.
793 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
794 set_gdbarch_num_pseudo_regs (gdbarch
, 0);
795 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
796 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
797 set_gdbarch_register_name (gdbarch
, xstormy16_register_name
);
798 set_gdbarch_register_type (gdbarch
, xstormy16_register_type
);
800 set_gdbarch_char_signed (gdbarch
, 0);
801 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
802 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
803 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
804 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
806 set_gdbarch_wchar_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
807 set_gdbarch_wchar_signed (gdbarch
, 1);
809 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
810 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
811 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
813 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
814 set_gdbarch_addr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
815 set_gdbarch_dwarf2_addr_size (gdbarch
, 4);
817 set_gdbarch_address_to_pointer (gdbarch
, xstormy16_address_to_pointer
);
818 set_gdbarch_pointer_to_address (gdbarch
, xstormy16_pointer_to_address
);
820 /* Stack grows up. */
821 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
826 set_gdbarch_unwind_sp (gdbarch
, xstormy16_unwind_sp
);
827 set_gdbarch_unwind_pc (gdbarch
, xstormy16_unwind_pc
);
828 set_gdbarch_dummy_id (gdbarch
, xstormy16_dummy_id
);
829 set_gdbarch_frame_align (gdbarch
, xstormy16_frame_align
);
830 frame_base_set_default (gdbarch
, &xstormy16_frame_base
);
832 set_gdbarch_skip_prologue (gdbarch
, xstormy16_skip_prologue
);
833 set_gdbarch_stack_frame_destroyed_p (gdbarch
,
834 xstormy16_stack_frame_destroyed_p
);
836 /* These values and methods are used when gdb calls a target function. */
837 set_gdbarch_push_dummy_call (gdbarch
, xstormy16_push_dummy_call
);
838 set_gdbarch_breakpoint_kind_from_pc (gdbarch
,
839 xstormy16_breakpoint::kind_from_pc
);
840 set_gdbarch_sw_breakpoint_from_kind (gdbarch
,
841 xstormy16_breakpoint::bp_from_kind
);
842 set_gdbarch_return_value (gdbarch
, xstormy16_return_value
);
844 set_gdbarch_skip_trampoline_code (gdbarch
, xstormy16_skip_trampoline_code
);
846 gdbarch_init_osabi (info
, gdbarch
);
848 dwarf2_append_unwinders (gdbarch
);
849 frame_unwind_append_unwinder (gdbarch
, &xstormy16_frame_unwind
);
854 /* Function: _initialize_xstormy16_tdep
855 Initializer function for the Sanyo Xstormy16a module.
856 Called by gdb at start-up. */
859 _initialize_xstormy16_tdep (void)
861 register_gdbarch_init (bfd_arch_xstormy16
, xstormy16_gdbarch_init
);