GDB (xrefs)
Loading...
Searching...
No Matches
xstormy16-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
2
3 Copyright (C) 2001-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "frame.h"
22#include "frame-base.h"
23#include "frame-unwind.h"
24#include "dwarf2/frame.h"
25#include "symtab.h"
26#include "gdbtypes.h"
27#include "gdbcmd.h"
28#include "gdbcore.h"
29#include "value.h"
30#include "dis-asm.h"
31#include "inferior.h"
32#include "arch-utils.h"
33#include "regcache.h"
34#include "osabi.h"
35#include "objfiles.h"
36#include "gdbsupport/byte-vector.h"
37
39{
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. */
65};
66
67/* Use an invalid address value as 'not available' marker. */
68enum { REG_UNAVAIL = (CORE_ADDR) -1 };
69
71{
72 /* Base address. */
73 CORE_ADDR base;
74 CORE_ADDR pc;
75 LONGEST framesize;
78 CORE_ADDR saved_sp;
79};
80
81/* Size of instructions, registers, etc. */
82enum
83{
87};
88
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) \
91 * xstormy16_reg_size)
92
93/* Size of return datatype which fits into all return registers. */
94enum
95{
97};
98
99/* Function: xstormy16_register_name
100 Returns the name of the standard Xstormy16 register N. */
101
102static const char *
104{
105 static const char *register_names[] = {
106 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
107 "r8", "r9", "r10", "r11", "r12", "r13",
108 "psw", "sp", "pc"
109 };
110
111 gdb_static_assert (ARRAY_SIZE (register_names) == E_NUM_REGS);
112 return register_names[regnum];
113}
114
115static struct type *
117{
118 if (regnum == E_PC_REGNUM)
120 else
122}
123
124/* Function: xstormy16_type_is_scalar
125 Makes the decision if a given type is a scalar types. Scalar
126 types are returned in the registers r2-r7 as they fit. */
127
128static int
130{
131 return (t->code () != TYPE_CODE_STRUCT
132 && t->code () != TYPE_CODE_UNION
133 && t->code () != TYPE_CODE_ARRAY);
134}
135
136/* Function: xstormy16_use_struct_convention
137 Returns non-zero if the given struct type will be returned using
138 a special convention, rather than the normal function return method.
139 7sed in the contexts of the "return" command, and of
140 target function calls from the debugger. */
141
142static int
144{
147}
148
149/* Function: xstormy16_extract_return_value
150 Find a function's return value in the appropriate registers (in
151 regbuf), and copy it into valbuf. */
152
153static void
155 gdb_byte *valbuf)
156{
157 int len = type->length ();
158 int i, regnum = E_1ST_ARG_REGNUM;
159
160 for (i = 0; i < len; i += xstormy16_reg_size)
161 regcache->raw_read (regnum++, valbuf + i);
162}
163
164/* Function: xstormy16_store_return_value
165 Copy the function return value from VALBUF into the
166 proper location for a function return.
167 Called only in the context of the "return" command. */
168
169static void
171 const gdb_byte *valbuf)
172{
173 if (type->length () == 1)
174 {
175 /* Add leading zeros to the value. */
176 gdb_byte buf[xstormy16_reg_size];
177 memset (buf, 0, xstormy16_reg_size);
178 memcpy (buf, valbuf, 1);
180 }
181 else
182 {
183 int len = type->length ();
184 int i, regnum = E_1ST_ARG_REGNUM;
185
186 for (i = 0; i < len; i += xstormy16_reg_size)
187 regcache->raw_write (regnum++, valbuf + i);
188 }
189}
190
191static enum return_value_convention
192xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
193 struct type *type, struct regcache *regcache,
194 gdb_byte *readbuf, const gdb_byte *writebuf)
195{
198 if (writebuf)
200 else if (readbuf)
203}
204
205static CORE_ADDR
206xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
207{
208 if (addr & 1)
209 ++addr;
210 return addr;
211}
212
213/* Function: xstormy16_push_dummy_call
214 Setup the function arguments for GDB to call a function in the inferior.
215 Called only in the context of a target function call from the debugger.
216 Returns the value of the SP register after the args are pushed. */
217
218static CORE_ADDR
220 struct value *function,
221 struct regcache *regcache,
222 CORE_ADDR bp_addr, int nargs,
223 struct value **args,
224 CORE_ADDR sp,
225 function_call_return_method return_method,
226 CORE_ADDR struct_addr)
227{
228 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
229 CORE_ADDR stack_dest = sp;
230 int argreg = E_1ST_ARG_REGNUM;
231 int i, j;
232 int typelen, slacklen;
233 gdb_byte buf[xstormy16_pc_size];
234
235 /* If returning a struct using target ABI method, then the struct return
236 address will consume one argument-passing register. */
237 if (return_method == return_method_struct)
238 {
240 argreg++;
241 }
242
243 /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
244 fit in the remaining registers we're switching over to the stack.
245 No argument is put on stack partially and as soon as we switched
246 over to stack no further argument is put in a register even if it
247 would fit in the remaining unused registers. */
248 for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
249 {
250 typelen = value_enclosing_type (args[i])->length ();
251 if (typelen > E_MAX_RETTYPE_SIZE (argreg))
252 break;
253
254 /* Put argument into registers wordwise. */
255 const gdb_byte *val = value_contents (args[i]).data ();
256 for (j = 0; j < typelen; j += xstormy16_reg_size)
257 {
258 ULONGEST regval;
259 int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
260
261 regval = extract_unsigned_integer (val + j, size, byte_order);
262 regcache_cooked_write_unsigned (regcache, argreg++, regval);
263 }
264 }
265
266 /* Align SP */
267 stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
268
269 /* Loop backwards through remaining arguments and push them on the stack,
270 wordaligned. */
271 for (j = nargs - 1; j >= i; j--)
272 {
273 const gdb_byte *bytes = value_contents (args[j]).data ();
274
275 typelen = value_enclosing_type (args[j])->length ();
276 slacklen = typelen & 1;
277 gdb::byte_vector val (typelen + slacklen);
278 memcpy (val.data (), bytes, typelen);
279 memset (val.data () + typelen, 0, slacklen);
280
281 /* Now write this data to the stack. The stack grows upwards. */
282 write_memory (stack_dest, val.data (), typelen + slacklen);
283 stack_dest += typelen + slacklen;
284 }
285
286 store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
287 write_memory (stack_dest, buf, xstormy16_pc_size);
288 stack_dest += xstormy16_pc_size;
289
290 /* Update stack pointer. */
292
293 /* Return the new stack pointer minus the return address slot since
294 that's what DWARF2/GCC uses as the frame's CFA. */
295 return stack_dest - xstormy16_pc_size;
296}
297
298/* Function: xstormy16_scan_prologue
299 Decode the instructions within the given address range.
300 Decide when we must have reached the end of the function prologue.
301 If a frame_info pointer is provided, fill in its saved_regs etc.
302
303 Returns the address of the first instruction after the prologue. */
304
305static CORE_ADDR
307 CORE_ADDR start_addr, CORE_ADDR end_addr,
308 struct xstormy16_frame_cache *cache,
309 frame_info_ptr this_frame)
310{
311 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
312 CORE_ADDR next_addr;
313 ULONGEST inst, inst2;
314 LONGEST offset;
315 int regnum;
316
317 /* Initialize framesize with size of PC put on stack by CALLF inst. */
318 cache->saved_regs[E_PC_REGNUM] = 0;
320
321 if (start_addr >= end_addr)
322 return end_addr;
323
324 for (next_addr = start_addr;
325 next_addr < end_addr; next_addr += xstormy16_inst_size)
326 {
327 inst = read_memory_unsigned_integer (next_addr,
328 xstormy16_inst_size, byte_order);
330 xstormy16_inst_size, byte_order);
331
332 if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
333 {
334 regnum = inst & 0x000f;
335 cache->saved_regs[regnum] = cache->framesize;
337 }
338
339 /* Optional stack allocation for args and local vars <= 4 byte. */
340 else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
341 {
342 cache->framesize += ((inst & 0x0030) >> 4) + 1;
343 }
344
345 /* optional stack allocation for args and local vars > 4 && < 16 byte */
346 else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
347 {
348 cache->framesize += (inst & 0x00f0) >> 4;
349 }
350
351 /* Optional stack allocation for args and local vars >= 16 byte. */
352 else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
353 {
354 cache->framesize += inst2;
355 next_addr += xstormy16_inst_size;
356 }
357
358 else if (inst == 0x46fd) /* mov r13, r15 */
359 {
360 cache->uses_fp = 1;
361 }
362
363 /* optional copying of args in r2-r7 to r10-r13. */
364 /* Probably only in optimized case but legal action for prologue. */
365 else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */
366 && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
367 && (inst & 0x000f) >= 0x000a && (inst & 0x000f) <= 0x000d)
368 ;
369
370 /* Optional copying of args in r2-r7 to stack. */
371 /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8)
372 (bit3 always 1, bit2-0 = reg) */
373 /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
374 else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
375 {
376 regnum = inst & 0x0007;
377 /* Only 12 of 16 bits of the argument are used for the
378 signed offset. */
379 offset = (LONGEST) (inst2 & 0x0fff);
380 if (offset & 0x0800)
381 offset -= 0x1000;
382
383 cache->saved_regs[regnum] = cache->framesize + offset;
384 next_addr += xstormy16_inst_size;
385 }
386
387 else /* Not a prologue instruction. */
388 break;
389 }
390
391 return next_addr;
392}
393
394/* Function: xstormy16_skip_prologue
395 If the input address is in a function prologue,
396 returns the address of the end of the prologue;
397 else returns the input address.
398
399 Note: the input address is likely to be the function start,
400 since this function is mainly used for advancing a breakpoint
401 to the first line, or stepping to the first line when we have
402 stepped into a function call. */
403
404static CORE_ADDR
406{
407 CORE_ADDR func_addr = 0, func_end = 0;
408 const char *func_name;
409
410 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
411 {
412 struct symtab_and_line sal;
413 struct symbol *sym;
414 struct xstormy16_frame_cache cache;
415 CORE_ADDR plg_end;
416
417 memset (&cache, 0, sizeof cache);
418
419 /* Don't trust line number debug info in frameless functions. */
420 plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
421 &cache, NULL);
422 if (!cache.uses_fp)
423 return plg_end;
424
425 /* Found a function. */
426 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
427 /* Don't use line number debug info for assembly source files. */
428 if (sym && sym->language () != language_asm)
429 {
430 sal = find_pc_line (func_addr, 0);
431 if (sal.end && sal.end < func_end)
432 {
433 /* Found a line number, use it as end of prologue. */
434 return sal.end;
435 }
436 }
437 /* No useable line symbol. Use result of prologue parsing method. */
438 return plg_end;
439 }
440
441 /* No function symbol -- just return the PC. */
442
443 return (CORE_ADDR) pc;
444}
445
446/* Implement the stack_frame_destroyed_p gdbarch method.
447
448 The epilogue is defined here as the area at the end of a function,
449 either on the `ret' instruction itself or after an instruction which
450 destroys the function's stack frame. */
451
452static int
454{
455 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
456 CORE_ADDR func_addr = 0, func_end = 0;
457
458 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
459 {
460 ULONGEST inst, inst2;
461 CORE_ADDR addr = func_end - xstormy16_inst_size;
462
463 /* The Xstormy16 epilogue is max. 14 bytes long. */
464 if (pc < func_end - 7 * xstormy16_inst_size)
465 return 0;
466
467 /* Check if we're on a `ret' instruction. Otherwise it's
468 too dangerous to proceed. */
469 inst = read_memory_unsigned_integer (addr,
470 xstormy16_inst_size, byte_order);
471 if (inst != 0x0003)
472 return 0;
473
474 while ((addr -= xstormy16_inst_size) >= func_addr)
475 {
476 inst = read_memory_unsigned_integer (addr,
478 byte_order);
479 if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
480 continue;
481 if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
482 break;
485 byte_order);
486 if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
487 {
488 addr -= xstormy16_inst_size;
489 break;
490 }
491 return 0;
492 }
493 if (pc > addr)
494 return 1;
495 }
496 return 0;
497}
498
499constexpr gdb_byte xstormy16_break_insn[] = { 0x06, 0x0 };
500
501typedef BP_MANIPULATION (xstormy16_break_insn) xstormy16_breakpoint;
502
503/* Given a pointer to a jump table entry, return the address
504 of the function it jumps to. Return 0 if not found. */
505static CORE_ADDR
506xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
507{
508 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
509 struct obj_section *faddr_sect = find_pc_section (faddr);
510
511 if (faddr_sect)
512 {
513 LONGEST inst, inst2, addr;
514 gdb_byte buf[2 * xstormy16_inst_size];
515
516 /* Return faddr if it's not pointing into the jump table. */
517 if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
518 return faddr;
519
520 if (!target_read_memory (faddr, buf, sizeof buf))
521 {
522 inst = extract_unsigned_integer (buf,
523 xstormy16_inst_size, byte_order);
525 xstormy16_inst_size, byte_order);
526 addr = inst2 << 8 | (inst & 0xff);
527 return addr;
528 }
529 }
530 return 0;
531}
532
533/* Given a function's address, attempt to find (and return) the
534 address of the corresponding jump table entry. Return 0 if
535 not found. */
536static CORE_ADDR
538{
539 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
540 struct obj_section *faddr_sect = find_pc_section (faddr);
541
542 if (faddr_sect)
543 {
544 struct obj_section *osect;
545
546 /* Return faddr if it's already a pointer to a jump table entry. */
547 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
548 return faddr;
549
550 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
551 {
552 if (!strcmp (osect->the_bfd_section->name, ".plt"))
553 break;
554 }
555
556 if (osect < faddr_sect->objfile->sections_end)
557 {
558 CORE_ADDR addr, endaddr;
559
560 addr = osect->addr ();
561 endaddr = osect->endaddr ();
562
563 for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
564 {
565 LONGEST inst, inst2, faddr2;
566 gdb_byte buf[2 * xstormy16_inst_size];
567
568 if (target_read_memory (addr, buf, sizeof buf))
569 return 0;
570 inst = extract_unsigned_integer (buf,
572 byte_order);
575 byte_order);
576 faddr2 = inst2 << 8 | (inst & 0xff);
577 if (faddr == faddr2)
578 return addr;
579 }
580 }
581 }
582 return 0;
583}
584
585static CORE_ADDR
587{
588 struct gdbarch *gdbarch = get_frame_arch (frame);
589 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
590
591 if (tmp && tmp != pc)
592 return tmp;
593 return 0;
594}
595
596/* Function pointers are 16 bit. The address space is 24 bit, using
597 32 bit addresses. Pointers to functions on the XStormy16 are implemented
598 by using 16 bit pointers, which are either direct pointers in case the
599 function begins below 0x10000, or indirect pointers into a jump table.
600 The next two functions convert 16 bit pointers into 24 (32) bit addresses
601 and vice versa. */
602
603static CORE_ADDR
605 struct type *type, const gdb_byte *buf)
606{
607 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
608 enum type_code target = type->target_type ()->code ();
609 CORE_ADDR addr
610 = extract_unsigned_integer (buf, type->length (), byte_order);
611
612 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
613 {
614 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
615 if (addr2)
616 addr = addr2;
617 }
618
619 return addr;
620}
621
622static void
624 struct type *type, gdb_byte *buf, CORE_ADDR addr)
625{
626 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
627 enum type_code target = type->target_type ()->code ();
628
629 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
630 {
631 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
632 if (addr2)
633 addr = addr2;
634 }
635 store_unsigned_integer (buf, type->length (), byte_order, addr);
636}
637
638static struct xstormy16_frame_cache *
640{
641 struct xstormy16_frame_cache *cache;
642 int i;
643
645
646 cache->base = 0;
647 cache->saved_sp = 0;
648 cache->pc = 0;
649 cache->uses_fp = 0;
650 cache->framesize = 0;
651 for (i = 0; i < E_NUM_REGS; ++i)
652 cache->saved_regs[i] = REG_UNAVAIL;
653
654 return cache;
655}
656
657static struct xstormy16_frame_cache *
658xstormy16_frame_cache (frame_info_ptr this_frame, void **this_cache)
659{
660 struct gdbarch *gdbarch = get_frame_arch (this_frame);
661 struct xstormy16_frame_cache *cache;
662 CORE_ADDR current_pc;
663 int i;
664
665 if (*this_cache)
666 return (struct xstormy16_frame_cache *) *this_cache;
667
669 *this_cache = cache;
670
671 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
672 if (cache->base == 0)
673 return cache;
674
675 cache->pc = get_frame_func (this_frame);
676 current_pc = get_frame_pc (this_frame);
677 if (cache->pc)
678 xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
679 cache, this_frame);
680
681 if (!cache->uses_fp)
682 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
683
684 cache->saved_sp = cache->base - cache->framesize;
685
686 for (i = 0; i < E_NUM_REGS; ++i)
687 if (cache->saved_regs[i] != REG_UNAVAIL)
688 cache->saved_regs[i] += cache->saved_sp;
689
690 return cache;
691}
692
693static struct value *
695 void **this_cache, int regnum)
696{
697 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
698 this_cache);
699 gdb_assert (regnum >= 0);
700
701 if (regnum == E_SP_REGNUM && cache->saved_sp)
702 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
703
704 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
705 return frame_unwind_got_memory (this_frame, regnum,
706 cache->saved_regs[regnum]);
707
708 return frame_unwind_got_register (this_frame, regnum, regnum);
709}
710
711static void
712xstormy16_frame_this_id (frame_info_ptr this_frame, void **this_cache,
713 struct frame_id *this_id)
714{
715 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
716 this_cache);
717
718 /* This marks the outermost frame. */
719 if (cache->base == 0)
720 return;
721
722 *this_id = frame_id_build (cache->saved_sp, cache->pc);
723}
724
725static CORE_ADDR
726xstormy16_frame_base_address (frame_info_ptr this_frame, void **this_cache)
727{
728 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
729 this_cache);
730 return cache->base;
731}
732
734 "xstormy16 prologue",
739 NULL,
741};
742
743static const struct frame_base xstormy16_frame_base = {
748};
749
750/* Function: xstormy16_gdbarch_init
751 Initializer function for the xstormy16 gdbarch vector.
752 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
753
754static struct gdbarch *
756{
757 struct gdbarch *gdbarch;
758
759 /* find a candidate among the list of pre-declared architectures. */
761 if (arches != NULL)
762 return (arches->gdbarch);
763
764 gdbarch = gdbarch_alloc (&info, NULL);
765
766 /*
767 * Basic register fields and methods, datatype sizes and stuff.
768 */
769
776
778 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
779 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
780 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
781 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
782
783 set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
785
786 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
787 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
788 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
789
790 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
791 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
793
796
797 /* Stack grows up. */
799
800 /*
801 * Frame Info
802 */
805
809
810 /* These values and methods are used when gdb calls a target function. */
813 xstormy16_breakpoint::kind_from_pc);
815 xstormy16_breakpoint::bp_from_kind);
817
819
821
824
825 return gdbarch;
826}
827
828/* Function: _initialize_xstormy16_tdep
829 Initializer function for the Sanyo Xstormy16a module.
830 Called by gdb at start-up. */
831
833void
835{
836 gdbarch_register (bfd_arch_xstormy16, xstormy16_gdbarch_init);
837}
int regnum
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
static std::vector< const char * > arches
Definition arch-utils.c:685
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
int core_addr_greaterthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:183
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
Definition arch-utils.h:70
gdb_regnum
Definition arm.h:39
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition blockframe.c:373
enum register_status raw_read(int regnum, gdb_byte *buf)
Definition regcache.c:605
void raw_write(int regnum, const gdb_byte *buf)
Definition regcache.c:827
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:346
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:305
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:561
@ language_asm
Definition defs.h:221
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:526
return_value_convention
Definition defs.h:258
@ RETURN_VALUE_REGISTER_CONVENTION
Definition defs.h:261
@ RETURN_VALUE_STRUCT_CONVENTION
Definition defs.h:268
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
Definition frame.c:1361
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition frame-base.c:93
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
struct value * frame_unwind_got_constant(frame_info_ptr frame, int regnum, ULONGEST val)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1351
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2592
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:713
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:2907
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1050
@ NORMAL_FRAME
Definition frame.h:179
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:608
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition gdbarch.c:1467
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
Definition gdbarch.c:1719
void set_gdbarch_address_to_pointer(struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype *address_to_pointer)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
Definition gdbarch.c:1755
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1370
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_wchar_bit(struct gdbarch *gdbarch, int wchar_bit)
Definition gdbarch.c:1649
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition gdbarch.c:1433
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_wchar_signed(struct gdbarch *gdbarch, int wchar_signed)
Definition gdbarch.c:1667
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
Definition gdbarch.c:1583
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition gdbarch.c:2016
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition gdbarch.c:2033
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
Definition gdbarch.c:1550
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
Definition gdbarch.c:1416
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition gdbarch.c:1927
void set_gdbarch_dwarf2_addr_size(struct gdbarch *gdbarch, int dwarf2_addr_size)
Definition gdbarch.c:1737
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition gdbarch.c:1450
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition gdbarch.c:1701
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1910
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition gdbarch.c:1616
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_pointer_to_address(struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep_base *tdep)
Definition gdbarch.c:264
function_call_return_method
Definition gdbarch.h:112
@ return_method_struct
Definition gdbarch.h:124
type_code
Definition gdbtypes.h:99
size_t size
Definition go32-nat.c:241
info(c)
Definition gdbarch.py:184
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition objfiles.c:1170
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition objfiles.h:130
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition osabi.c:382
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:819
struct symbol * symbol
Definition symtab.h:1494
struct type * builtin_uint16
Definition gdbtypes.h:2284
struct type * builtin_uint32
Definition gdbtypes.h:2288
enum language language() const
Definition symtab.h:501
CORE_ADDR addr() const
Definition objfiles.h:822
CORE_ADDR endaddr() const
Definition objfiles.h:829
struct objfile * objfile
Definition objfiles.h:838
struct bfd_section * the_bfd_section
Definition objfiles.h:835
struct obj_section * sections_end
Definition objfiles.h:726
CORE_ADDR end
Definition symtab.h:2273
struct type * target_type() const
Definition gdbtypes.h:1000
type_code code() const
Definition gdbtypes.h:927
ULONGEST length() const
Definition gdbtypes.h:954
Definition value.c:181
CORE_ADDR saved_regs[E_NUM_REGS]
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition symtab.c:1967
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition symtab.c:3297
@ VAR_DOMAIN
Definition symtab.h:881
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1771
gdb::array_view< const gdb_byte > value_contents(struct value *value)
Definition value.c:1464
struct type * value_enclosing_type(const struct value *value)
Definition value.c:1189
@ REG_UNAVAIL
static const struct frame_unwind xstormy16_frame_unwind
static CORE_ADDR xstormy16_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start_addr, CORE_ADDR end_addr, struct xstormy16_frame_cache *cache, frame_info_ptr this_frame)
@ E_MAX_RETTYPE_SIZE_IN_REGS
static CORE_ADDR xstormy16_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
static const char * xstormy16_register_name(struct gdbarch *gdbarch, int regnum)
static int xstormy16_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
static struct xstormy16_frame_cache * xstormy16_alloc_frame_cache(void)
constexpr gdb_byte xstormy16_break_insn[]
static void xstormy16_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
void _initialize_xstormy16_tdep()
static int xstormy16_use_struct_convention(struct type *type)
static void xstormy16_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static CORE_ADDR xstormy16_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
static CORE_ADDR xstormy16_skip_trampoline_code(frame_info_ptr frame, CORE_ADDR pc)
static CORE_ADDR xstormy16_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static void xstormy16_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
static CORE_ADDR xstormy16_frame_base_address(frame_info_ptr this_frame, void **this_cache)
static CORE_ADDR xstormy16_find_jmp_table_entry(struct gdbarch *gdbarch, CORE_ADDR faddr)
static struct type * xstormy16_register_type(struct gdbarch *gdbarch, int regnum)
static int xstormy16_type_is_scalar(struct type *t)
static enum return_value_convention xstormy16_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static struct value * xstormy16_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static CORE_ADDR xstormy16_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
@ E_R7_REGNUM
@ E_1ST_ARG_REGNUM
@ E_R9_REGNUM
@ E_R5_REGNUM
@ E_LST_ARG_REGNUM
@ E_R10_REGNUM
@ E_PSW_REGNUM
@ E_R13_REGNUM
@ E_R11_REGNUM
@ E_NUM_REGS
@ E_R2_REGNUM
@ E_R15_REGNUM
@ E_R6_REGNUM
@ E_R8_REGNUM
@ E_SP_REGNUM
@ E_R0_REGNUM
@ E_R12_REGNUM
@ E_PTR_RET_REGNUM
@ E_R1_REGNUM
@ E_R4_REGNUM
@ E_PC_REGNUM
@ E_R14_REGNUM
@ E_FP_REGNUM
@ E_R3_REGNUM
@ xstormy16_reg_size
@ xstormy16_inst_size
@ xstormy16_pc_size
static struct gdbarch * xstormy16_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static const struct frame_base xstormy16_frame_base
static void xstormy16_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
#define E_MAX_RETTYPE_SIZE(regnum)