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
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 = args[i]->enclosing_type ()->length ();
251 if (typelen > E_MAX_RETTYPE_SIZE (argreg))
252 break;
253
254 /* Put argument into registers wordwise. */
255 const gdb_byte *val = args[i]->contents ().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 = args[j]->contents ().data ();
274
275 typelen = args[j]->enclosing_type ()->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 /* Return faddr if it's already a pointer to a jump table entry. */
545 if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
546 return faddr;
547
548 for (obj_section *osect : faddr_sect->objfile->sections ())
549 {
550 if (!strcmp (osect->the_bfd_section->name, ".plt"))
551 {
552 CORE_ADDR addr, endaddr;
553
554 addr = osect->addr ();
555 endaddr = osect->endaddr ();
556
557 for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
558 {
559 LONGEST inst, inst2, faddr2;
560 gdb_byte buf[2 * xstormy16_inst_size];
561
562 if (target_read_memory (addr, buf, sizeof buf))
563 return 0;
564 inst = extract_unsigned_integer (buf,
566 byte_order);
569 byte_order);
570 faddr2 = inst2 << 8 | (inst & 0xff);
571 if (faddr == faddr2)
572 return addr;
573 }
574
575 break;
576 }
577 }
578 }
579 return 0;
580}
581
582static CORE_ADDR
584{
585 struct gdbarch *gdbarch = get_frame_arch (frame);
586 CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
587
588 if (tmp && tmp != pc)
589 return tmp;
590 return 0;
591}
592
593/* Function pointers are 16 bit. The address space is 24 bit, using
594 32 bit addresses. Pointers to functions on the XStormy16 are implemented
595 by using 16 bit pointers, which are either direct pointers in case the
596 function begins below 0x10000, or indirect pointers into a jump table.
597 The next two functions convert 16 bit pointers into 24 (32) bit addresses
598 and vice versa. */
599
600static CORE_ADDR
602 struct type *type, const gdb_byte *buf)
603{
604 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
605 enum type_code target = type->target_type ()->code ();
606 CORE_ADDR addr
607 = extract_unsigned_integer (buf, type->length (), byte_order);
608
609 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
610 {
611 CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
612 if (addr2)
613 addr = addr2;
614 }
615
616 return addr;
617}
618
619static void
621 struct type *type, gdb_byte *buf, CORE_ADDR addr)
622{
623 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
624 enum type_code target = type->target_type ()->code ();
625
626 if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
627 {
628 CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
629 if (addr2)
630 addr = addr2;
631 }
632 store_unsigned_integer (buf, type->length (), byte_order, addr);
633}
634
635static struct xstormy16_frame_cache *
637{
638 struct xstormy16_frame_cache *cache;
639 int i;
640
642
643 cache->base = 0;
644 cache->saved_sp = 0;
645 cache->pc = 0;
646 cache->uses_fp = 0;
647 cache->framesize = 0;
648 for (i = 0; i < E_NUM_REGS; ++i)
649 cache->saved_regs[i] = REG_UNAVAIL;
650
651 return cache;
652}
653
654static struct xstormy16_frame_cache *
655xstormy16_frame_cache (frame_info_ptr this_frame, void **this_cache)
656{
657 struct gdbarch *gdbarch = get_frame_arch (this_frame);
658 struct xstormy16_frame_cache *cache;
659 CORE_ADDR current_pc;
660 int i;
661
662 if (*this_cache)
663 return (struct xstormy16_frame_cache *) *this_cache;
664
666 *this_cache = cache;
667
668 cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
669 if (cache->base == 0)
670 return cache;
671
672 cache->pc = get_frame_func (this_frame);
673 current_pc = get_frame_pc (this_frame);
674 if (cache->pc)
675 xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
676 cache, this_frame);
677
678 if (!cache->uses_fp)
679 cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
680
681 cache->saved_sp = cache->base - cache->framesize;
682
683 for (i = 0; i < E_NUM_REGS; ++i)
684 if (cache->saved_regs[i] != REG_UNAVAIL)
685 cache->saved_regs[i] += cache->saved_sp;
686
687 return cache;
688}
689
690static struct value *
692 void **this_cache, int regnum)
693{
694 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
695 this_cache);
696 gdb_assert (regnum >= 0);
697
698 if (regnum == E_SP_REGNUM && cache->saved_sp)
699 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
700
701 if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
702 return frame_unwind_got_memory (this_frame, regnum,
703 cache->saved_regs[regnum]);
704
705 return frame_unwind_got_register (this_frame, regnum, regnum);
706}
707
708static void
709xstormy16_frame_this_id (frame_info_ptr this_frame, void **this_cache,
710 struct frame_id *this_id)
711{
712 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
713 this_cache);
714
715 /* This marks the outermost frame. */
716 if (cache->base == 0)
717 return;
718
719 *this_id = frame_id_build (cache->saved_sp, cache->pc);
720}
721
722static CORE_ADDR
723xstormy16_frame_base_address (frame_info_ptr this_frame, void **this_cache)
724{
725 struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
726 this_cache);
727 return cache->base;
728}
729
739
746
747/* Function: xstormy16_gdbarch_init
748 Initializer function for the xstormy16 gdbarch vector.
749 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
750
751static struct gdbarch *
753{
754 struct gdbarch *gdbarch;
755
756 /* find a candidate among the list of pre-declared architectures. */
758 if (arches != NULL)
759 return (arches->gdbarch);
760
761 gdbarch = gdbarch_alloc (&info, NULL);
762
763 /*
764 * Basic register fields and methods, datatype sizes and stuff.
765 */
766
773
775 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
776 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
777 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
778 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
779
780 set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
782
783 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
784 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
785 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
786
787 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
788 set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
790
793
794 /* Stack grows up. */
796
797 /*
798 * Frame Info
799 */
802
806
807 /* These values and methods are used when gdb calls a target function. */
810 xstormy16_breakpoint::kind_from_pc);
812 xstormy16_breakpoint::bp_from_kind);
814
816
818
821
822 return gdbarch;
823}
824
825/* Function: _initialize_xstormy16_tdep
826 Initializer function for the Sanyo Xstormy16a module.
827 Called by gdb at start-up. */
828
830void
int regnum
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
Definition arch-utils.c:685
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:611
void raw_write(int regnum, const gdb_byte *buf)
Definition regcache.c:833
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:347
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:306
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
@ 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:480
return_value_convention
Definition defs.h:257
@ RETURN_VALUE_REGISTER_CONVENTION
Definition defs.h:260
@ RETURN_VALUE_STRUCT_CONVENTION
Definition defs.h:267
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
Definition frame.c:1369
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:1399
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
@ NORMAL_FRAME
Definition frame.h:187
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition gdbarch.c:1493
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
Definition gdbarch.c:1750
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:1786
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
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:1680
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:1459
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:1698
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
Definition gdbarch.c:1612
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:2047
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition gdbarch.c:2064
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:1578
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:1442
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition gdbarch.c:1958
void set_gdbarch_dwarf2_addr_size(struct gdbarch *gdbarch, int dwarf2_addr_size)
Definition gdbarch.c:1768
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition gdbarch.c:1476
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition gdbarch.c:1732
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition gdbarch.c:1646
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, gdbarch_tdep_up tdep)
Definition gdbarch.c:266
function_call_return_method
Definition gdbarch.h:114
@ return_method_struct
Definition gdbarch.h:126
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
type_code
Definition gdbtypes.h:82
size_t size
Definition go32-nat.c:239
info(Component c)
Definition gdbarch.py:41
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition objfiles.c:1128
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:825
struct symbol * symbol
Definition symtab.h:1533
struct type * builtin_uint16
Definition gdbtypes.h:2116
struct type * builtin_uint32
Definition gdbtypes.h:2120
enum language language() const
Definition symtab.h:502
CORE_ADDR addr() const
Definition objfiles.h:385
CORE_ADDR endaddr() const
Definition objfiles.h:392
struct objfile * objfile
Definition objfiles.h:401
struct bfd_section * the_bfd_section
Definition objfiles.h:398
iterator_range< section_iterator > sections()
Definition objfiles.h:685
CORE_ADDR end
Definition symtab.h:2338
struct type * target_type() const
Definition gdbtypes.h:1037
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
Definition value.h:130
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:1964
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition symtab.c:3295
@ VAR_DOMAIN
Definition symtab.h:910
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
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)
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)
@ xstormy16_reg_size
@ xstormy16_inst_size
@ xstormy16_pc_size
void _initialize_xstormy16_tdep()
static int xstormy16_use_struct_convention(struct type *type)
@ E_MAX_RETTYPE_SIZE_IN_REGS
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
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)
static struct xstormy16_frame_cache * xstormy16_frame_cache(frame_info_ptr this_frame, void **this_cache)
#define E_MAX_RETTYPE_SIZE(regnum)
@ REG_UNAVAIL