GDB (xrefs)
Loading...
Searching...
No Matches
avr-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for Atmel AVR, for GDB.
2
3 Copyright (C) 1996-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/* Contributed by Theodore A. Roth, troth@openavr.org */
21
22/* Portions of this file were taken from the original gdb-4.18 patch developed
23 by Denis Chertykov, denisc@overta.ru */
24
25#include "defs.h"
26#include "frame.h"
27#include "frame-unwind.h"
28#include "frame-base.h"
29#include "trad-frame.h"
30#include "gdbcmd.h"
31#include "gdbcore.h"
32#include "gdbtypes.h"
33#include "inferior.h"
34#include "symfile.h"
35#include "arch-utils.h"
36#include "regcache.h"
37#include "dis-asm.h"
38#include "objfiles.h"
39#include <algorithm>
40#include "gdbarch.h"
41
42/* AVR Background:
43
44 (AVR micros are pure Harvard Architecture processors.)
45
46 The AVR family of microcontrollers have three distinctly different memory
47 spaces: flash, sram and eeprom. The flash is 16 bits wide and is used for
48 the most part to store program instructions. The sram is 8 bits wide and is
49 used for the stack and the heap. Some devices lack sram and some can have
50 an additional external sram added on as a peripheral.
51
52 The eeprom is 8 bits wide and is used to store data when the device is
53 powered down. Eeprom is not directly accessible, it can only be accessed
54 via io-registers using a special algorithm. Accessing eeprom via gdb's
55 remote serial protocol ('m' or 'M' packets) looks difficult to do and is
56 not included at this time.
57
58 [The eeprom could be read manually via ``x/b <eaddr + AVR_EMEM_START>'' or
59 written using ``set {unsigned char}<eaddr + AVR_EMEM_START>''. For this to
60 work, the remote target must be able to handle eeprom accesses and perform
61 the address translation.]
62
63 All three memory spaces have physical addresses beginning at 0x0. In
64 addition, the flash is addressed by gcc/binutils/gdb with respect to 8 bit
65 bytes instead of the 16 bit wide words used by the real device for the
66 Program Counter.
67
68 In order for remote targets to work correctly, extra bits must be added to
69 addresses before they are send to the target or received from the target
70 via the remote serial protocol. The extra bits are the MSBs and are used to
71 decode which memory space the address is referring to. */
72
73/* Constants: prefixed with AVR_ to avoid name space clashes */
74
75/* Address space flags */
76
77/* We are assigning the TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 to the flash address
78 space. */
79
80#define AVR_TYPE_ADDRESS_CLASS_FLASH TYPE_ADDRESS_CLASS_1
81#define AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH \
82 TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
83
84
85enum
86{
92
96
97 AVR_NUM_REGS = 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
98 AVR_NUM_REG_BYTES = 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
99
100 /* Pseudo registers. */
103
104 AVR_PC_REG_INDEX = 35, /* index into array of registers */
105
106 AVR_MAX_PROLOGUE_SIZE = 64, /* bytes */
107
108 /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
110
111 /* Number of the last pushed register. r17 for current avr-gcc */
113
114 AVR_ARG1_REGNUM = 24, /* Single byte argument */
115 AVR_ARGN_REGNUM = 25, /* Multi byte arguments */
116 AVR_LAST_ARG_REGNUM = 8, /* Last argument register */
117
118 AVR_RET1_REGNUM = 24, /* Single byte return value */
119 AVR_RETN_REGNUM = 25, /* Multi byte return value */
120
121 /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
122 bits? Do these have to match the bfd vma values? It sure would make
123 things easier in the future if they didn't need to match.
124
125 Note: I chose these values so as to be consistent with bfd vma
126 addresses.
127
128 TRoth/2002-04-08: There is already a conflict with very large programs
129 in the mega128. The mega128 has 128K instruction bytes (64K words),
130 thus the Most Significant Bit is 0x10000 which gets masked off my
131 AVR_MEM_MASK.
132
133 The problem manifests itself when trying to set a breakpoint in a
134 function which resides in the upper half of the instruction space and
135 thus requires a 17-bit address.
136
137 For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
138 from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
139 but could be for some remote targets by just adding the correct offset
140 to the address and letting the remote target handle the low-level
141 details of actually accessing the eeprom. */
142
143 AVR_IMEM_START = 0x00000000, /* INSN memory */
144 AVR_SMEM_START = 0x00800000, /* SRAM memory */
145#if 1
146 /* No eeprom mask defined */
147 AVR_MEM_MASK = 0x00f00000, /* mask to determine memory space */
148#else
149 AVR_EMEM_START = 0x00810000, /* EEPROM memory */
150 AVR_MEM_MASK = 0x00ff0000, /* mask to determine memory space */
151#endif
152};
153
154/* Prologue types:
155
156 NORMAL and CALL are the typical types (the -mcall-prologues gcc option
157 causes the generation of the CALL type prologues). */
158
159enum {
160 AVR_PROLOGUE_NONE, /* No prologue */
162 AVR_PROLOGUE_CALL, /* -mcall-prologues */
164 AVR_PROLOGUE_INTR, /* interrupt handler */
165 AVR_PROLOGUE_SIG, /* signal handler */
166};
167
168/* Any function with a frame looks like this
169 ....... <-SP POINTS HERE
170 LOCALS1 <-FP POINTS HERE
171 LOCALS0
172 SAVED FP
173 SAVED R3
174 SAVED R2
175 RET PC
176 FIRST ARG
177 SECOND ARG */
178
180{
181 /* The previous frame's inner most stack address. Used as this
182 frame ID's stack_addr. */
183 CORE_ADDR prev_sp;
184 /* The frame's base, optionally used by the high-level debug info. */
185 CORE_ADDR base;
186 int size;
188 /* Table indicating the location of each and every register. */
190};
191
193{
194 /* Number of bytes stored to the stack by call instructions.
195 2 bytes for avr1-5 and avrxmega1-5, 3 bytes for avr6 and avrxmega6-7. */
196 int call_length = 0;
197
198 /* Type for void. */
199 struct type *void_type = nullptr;
200 /* Type for a function returning void. */
201 struct type *func_void_type = nullptr;
202 /* Type for a pointer to a function. Used for the type of PC. */
203 struct type *pc_type = nullptr;
204};
205
206/* Lookup the name of a register given it's number. */
207
208static const char *
210{
211 static const char * const register_names[] = {
212 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
213 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
214 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
215 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
216 "SREG", "SP", "PC2",
217 "pc"
218 };
219 gdb_static_assert (ARRAY_SIZE (register_names)
221 return register_names[regnum];
222}
223
224/* Return the GDB type object for the "standard" data type
225 of data in register N. */
226
227static struct type *
228avr_register_type (struct gdbarch *gdbarch, int reg_nr)
229{
230 if (reg_nr == AVR_PC_REGNUM)
232
233 avr_gdbarch_tdep *tdep = gdbarch_tdep<avr_gdbarch_tdep> (gdbarch);
234 if (reg_nr == AVR_PSEUDO_PC_REGNUM)
235 return tdep->pc_type;
236
237 if (reg_nr == AVR_SP_REGNUM)
239
241}
242
243/* Instruction address checks and conversions. */
244
245static CORE_ADDR
246avr_make_iaddr (CORE_ADDR x)
247{
248 return ((x) | AVR_IMEM_START);
249}
250
251/* FIXME: TRoth: Really need to use a larger mask for instructions. Some
252 devices are already up to 128KBytes of flash space.
253
254 TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined. */
255
256static CORE_ADDR
258{
259 return ((x) & 0xffffffff);
260}
261
262/* SRAM address checks and conversions. */
263
264static CORE_ADDR
265avr_make_saddr (CORE_ADDR x)
266{
267 /* Return 0 for NULL. */
268 if (x == 0)
269 return 0;
270
271 return ((x) | AVR_SMEM_START);
272}
273
274static CORE_ADDR
276{
277 return ((x) & 0xffffffff);
278}
279
280/* EEPROM address checks and conversions. I don't know if these will ever
281 actually be used, but I've added them just the same. TRoth */
282
283/* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
284 programs in the mega128. */
285
286/* static CORE_ADDR */
287/* avr_make_eaddr (CORE_ADDR x) */
288/* { */
289/* return ((x) | AVR_EMEM_START); */
290/* } */
291
292/* static int */
293/* avr_eaddr_p (CORE_ADDR x) */
294/* { */
295/* return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
296/* } */
297
298/* static CORE_ADDR */
299/* avr_convert_eaddr_to_raw (CORE_ADDR x) */
300/* { */
301/* return ((x) & 0xffffffff); */
302/* } */
303
304/* Convert from address to pointer and vice-versa. */
305
306static void
308 struct type *type, gdb_byte *buf, CORE_ADDR addr)
309{
310 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
311
312 /* Is it a data address in flash? */
314 {
315 /* A data pointer in flash is byte addressed. */
316 store_unsigned_integer (buf, type->length (), byte_order,
318 }
319 /* Is it a code address? */
320 else if (type->target_type ()->code () == TYPE_CODE_FUNC
321 || type->target_type ()->code () == TYPE_CODE_METHOD)
322 {
323 /* A code pointer is word (16 bits) addressed. We shift the address down
324 by 1 bit to convert it to a pointer. */
325 store_unsigned_integer (buf, type->length (), byte_order,
326 avr_convert_iaddr_to_raw (addr >> 1));
327 }
328 else
329 {
330 /* Strip off any upper segment bits. */
331 store_unsigned_integer (buf, type->length (), byte_order,
333 }
334}
335
336static CORE_ADDR
338 struct type *type, const gdb_byte *buf)
339{
340 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
341 CORE_ADDR addr
342 = extract_unsigned_integer (buf, type->length (), byte_order);
343
344 /* Is it a data address in flash? */
346 {
347 /* A data pointer in flash is already byte addressed. */
348 return avr_make_iaddr (addr);
349 }
350 /* Is it a code address? */
351 else if (type->target_type ()->code () == TYPE_CODE_FUNC
352 || type->target_type ()->code () == TYPE_CODE_METHOD
354 {
355 /* A code pointer is word (16 bits) addressed so we shift it up
356 by 1 bit to convert it to an address. */
357 return avr_make_iaddr (addr << 1);
358 }
359 else
360 return avr_make_saddr (addr);
361}
362
363static CORE_ADDR
365 struct type *type, const gdb_byte *buf)
366{
367 ULONGEST addr = unpack_long (type, buf);
368
369 if (TYPE_DATA_SPACE (type))
370 return avr_make_saddr (addr);
371 else
372 return avr_make_iaddr (addr);
373}
374
375static CORE_ADDR
377{
378 ULONGEST pc;
379
381 return avr_make_iaddr (pc);
382}
383
384static void
390
391static enum register_status
393 int regnum, gdb_byte *buf)
394{
395 ULONGEST val;
396 enum register_status status;
397
398 switch (regnum)
399 {
402 if (status != REG_VALID)
403 return status;
404 val >>= 1;
406 return status;
407 default:
408 internal_error (_("invalid regnum"));
409 }
410}
411
412static void
414 int regnum, const gdb_byte *buf)
415{
416 ULONGEST val;
417
418 switch (regnum)
419 {
422 val <<= 1;
424 break;
425 default:
426 internal_error (_("invalid regnum"));
427 }
428}
429
430/* Function: avr_scan_prologue
431
432 This function decodes an AVR function prologue to determine:
433 1) the size of the stack frame
434 2) which registers are saved on it
435 3) the offsets of saved regs
436 This information is stored in the avr_unwind_cache structure.
437
438 Some devices lack the sbiw instruction, so on those replace this:
439 sbiw r28, XX
440 with this:
441 subi r28,lo8(XX)
442 sbci r29,hi8(XX)
443
444 A typical AVR function prologue with a frame pointer might look like this:
445 push rXX ; saved regs
446 ...
447 push r28
448 push r29
449 in r28,__SP_L__
450 in r29,__SP_H__
451 sbiw r28,<LOCALS_SIZE>
452 in __tmp_reg__,__SREG__
453 cli
454 out __SP_H__,r29
455 out __SREG__,__tmp_reg__
456 out __SP_L__,r28
457
458 A typical AVR function prologue without a frame pointer might look like
459 this:
460 push rXX ; saved regs
461 ...
462
463 A main function prologue looks like this:
464 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
465 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
466 out __SP_H__,r29
467 out __SP_L__,r28
468
469 A signal handler prologue looks like this:
470 push __zero_reg__
471 push __tmp_reg__
472 in __tmp_reg__, __SREG__
473 push __tmp_reg__
474 clr __zero_reg__
475 push rXX ; save registers r18:r27, r30:r31
476 ...
477 push r28 ; save frame pointer
478 push r29
479 in r28, __SP_L__
480 in r29, __SP_H__
481 sbiw r28, <LOCALS_SIZE>
482 out __SP_H__, r29
483 out __SP_L__, r28
484
485 A interrupt handler prologue looks like this:
486 sei
487 push __zero_reg__
488 push __tmp_reg__
489 in __tmp_reg__, __SREG__
490 push __tmp_reg__
491 clr __zero_reg__
492 push rXX ; save registers r18:r27, r30:r31
493 ...
494 push r28 ; save frame pointer
495 push r29
496 in r28, __SP_L__
497 in r29, __SP_H__
498 sbiw r28, <LOCALS_SIZE>
499 cli
500 out __SP_H__, r29
501 sei
502 out __SP_L__, r28
503
504 A `-mcall-prologues' prologue looks like this (Note that the megas use a
505 jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
506 32 bit insn and rjmp is a 16 bit insn):
507 ldi r26,lo8(<LOCALS_SIZE>)
508 ldi r27,hi8(<LOCALS_SIZE>)
509 ldi r30,pm_lo8(.L_foo_body)
510 ldi r31,pm_hi8(.L_foo_body)
511 rjmp __prologue_saves__+RRR
512 .L_foo_body: */
513
514/* Not really part of a prologue, but still need to scan for it, is when a
515 function prologue moves values passed via registers as arguments to new
516 registers. In this case, all local variables live in registers, so there
517 may be some register saves. This is what it looks like:
518 movw rMM, rNN
519 ...
520
521 There could be multiple movw's. If the target doesn't have a movw insn, it
522 will use two mov insns. This could be done after any of the above prologue
523 types. */
524
525static CORE_ADDR
526avr_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR pc_beg, CORE_ADDR pc_end,
527 struct avr_unwind_cache *info)
528{
529 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
530 int i;
531 unsigned short insn;
532 int scan_stage = 0;
533 struct bound_minimal_symbol msymbol;
534 unsigned char prologue[AVR_MAX_PROLOGUE_SIZE];
535 int vpc = 0;
536 int len;
537
538 len = pc_end - pc_beg;
539 if (len > AVR_MAX_PROLOGUE_SIZE)
541
542 /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
543 reading in the bytes of the prologue. The problem is that the figuring
544 out where the end of the prologue is is a bit difficult. The old code
545 tried to do that, but failed quite often. */
546 read_memory (pc_beg, prologue, len);
547
548 /* Scanning main()'s prologue
549 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
550 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
551 out __SP_H__,r29
552 out __SP_L__,r28 */
553
554 if (len >= 4)
555 {
556 CORE_ADDR locals;
557 static const unsigned char img[] = {
558 0xde, 0xbf, /* out __SP_H__,r29 */
559 0xcd, 0xbf /* out __SP_L__,r28 */
560 };
561
562 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
563 /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
564 if ((insn & 0xf0f0) == 0xe0c0)
565 {
566 locals = (insn & 0xf) | ((insn & 0x0f00) >> 4);
567 insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
568 /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
569 if ((insn & 0xf0f0) == 0xe0d0)
570 {
571 locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
572 if (vpc + 4 + sizeof (img) < len
573 && memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
574 {
575 info->prologue_type = AVR_PROLOGUE_MAIN;
576 info->base = locals;
577 return pc_beg + 4;
578 }
579 }
580 }
581 }
582
583 /* Scanning `-mcall-prologues' prologue
584 Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
585
586 while (1) /* Using a while to avoid many goto's */
587 {
588 int loc_size;
589 int body_addr;
590 unsigned num_pushes;
591 int pc_offset = 0;
592
593 /* At least the fifth instruction must have been executed to
594 modify frame shape. */
595 if (len < 10)
596 break;
597
598 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
599 /* ldi r26,<LOCALS_SIZE> */
600 if ((insn & 0xf0f0) != 0xe0a0)
601 break;
602 loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4);
603 pc_offset += 2;
604
605 insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
606 /* ldi r27,<LOCALS_SIZE> / 256 */
607 if ((insn & 0xf0f0) != 0xe0b0)
608 break;
609 loc_size |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
610 pc_offset += 2;
611
612 insn = extract_unsigned_integer (&prologue[vpc + 4], 2, byte_order);
613 /* ldi r30,pm_lo8(.L_foo_body) */
614 if ((insn & 0xf0f0) != 0xe0e0)
615 break;
616 body_addr = (insn & 0xf) | ((insn & 0x0f00) >> 4);
617 pc_offset += 2;
618
619 insn = extract_unsigned_integer (&prologue[vpc + 6], 2, byte_order);
620 /* ldi r31,pm_hi8(.L_foo_body) */
621 if ((insn & 0xf0f0) != 0xe0f0)
622 break;
623 body_addr |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
624 pc_offset += 2;
625
626 msymbol = lookup_minimal_symbol ("__prologue_saves__", NULL, NULL);
627 if (!msymbol.minsym)
628 break;
629
630 insn = extract_unsigned_integer (&prologue[vpc + 8], 2, byte_order);
631 /* rjmp __prologue_saves__+RRR */
632 if ((insn & 0xf000) == 0xc000)
633 {
634 /* Extract PC relative offset from RJMP */
635 i = (insn & 0xfff) | (insn & 0x800 ? (-1 ^ 0xfff) : 0);
636 /* Convert offset to byte addressable mode */
637 i *= 2;
638 /* Destination address */
639 i += pc_beg + 10;
640
641 if (body_addr != (pc_beg + 10)/2)
642 break;
643
644 pc_offset += 2;
645 }
646 else if ((insn & 0xfe0e) == 0x940c)
647 {
648 /* Extract absolute PC address from JMP */
649 i = (((insn & 0x1) | ((insn & 0x1f0) >> 3) << 16)
650 | (extract_unsigned_integer (&prologue[vpc + 10], 2, byte_order)
651 & 0xffff));
652 /* Convert address to byte addressable mode */
653 i *= 2;
654
655 if (body_addr != (pc_beg + 12)/2)
656 break;
657
658 pc_offset += 4;
659 }
660 else
661 break;
662
663 /* Resolve offset (in words) from __prologue_saves__ symbol.
664 Which is a pushes count in `-mcall-prologues' mode */
665 num_pushes = AVR_MAX_PUSHES - (i - msymbol.value_address ()) / 2;
666
667 if (num_pushes > AVR_MAX_PUSHES)
668 {
669 gdb_printf (gdb_stderr, _("Num pushes too large: %d\n"),
670 num_pushes);
671 num_pushes = 0;
672 }
673
674 if (num_pushes)
675 {
676 int from;
677
678 info->saved_regs[AVR_FP_REGNUM + 1].set_addr (num_pushes);
679 if (num_pushes >= 2)
680 info->saved_regs[AVR_FP_REGNUM].set_addr (num_pushes - 1);
681
682 i = 0;
683 for (from = AVR_LAST_PUSHED_REGNUM + 1 - (num_pushes - 2);
684 from <= AVR_LAST_PUSHED_REGNUM; ++from)
685 info->saved_regs [from].set_addr (++i);
686 }
687 info->size = loc_size + num_pushes;
688 info->prologue_type = AVR_PROLOGUE_CALL;
689
690 return pc_beg + pc_offset;
691 }
692
693 /* Scan for the beginning of the prologue for an interrupt or signal
694 function. Note that we have to set the prologue type here since the
695 third stage of the prologue may not be present (e.g. no saved registered
696 or changing of the SP register). */
697
698 if (1)
699 {
700 static const unsigned char img[] = {
701 0x78, 0x94, /* sei */
702 0x1f, 0x92, /* push r1 */
703 0x0f, 0x92, /* push r0 */
704 0x0f, 0xb6, /* in r0,0x3f SREG */
705 0x0f, 0x92, /* push r0 */
706 0x11, 0x24 /* clr r1 */
707 };
708 if (len >= sizeof (img)
709 && memcmp (prologue, img, sizeof (img)) == 0)
710 {
711 info->prologue_type = AVR_PROLOGUE_INTR;
712 vpc += sizeof (img);
713 info->saved_regs[AVR_SREG_REGNUM].set_addr (3);
714 info->saved_regs[0].set_addr (2);
715 info->saved_regs[1].set_addr (1);
716 info->size += 3;
717 }
718 else if (len >= sizeof (img) - 2
719 && memcmp (img + 2, prologue, sizeof (img) - 2) == 0)
720 {
721 info->prologue_type = AVR_PROLOGUE_SIG;
722 vpc += sizeof (img) - 2;
723 info->saved_regs[AVR_SREG_REGNUM].set_addr (3);
724 info->saved_regs[0].set_addr (2);
725 info->saved_regs[1].set_addr (1);
726 info->size += 2;
727 }
728 }
729
730 /* First stage of the prologue scanning.
731 Scan pushes (saved registers) */
732
733 for (; vpc < len; vpc += 2)
734 {
735 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
736 if ((insn & 0xfe0f) == 0x920f) /* push rXX */
737 {
738 /* Bits 4-9 contain a mask for registers R0-R32. */
739 int regno = (insn & 0x1f0) >> 4;
740 info->size++;
741 info->saved_regs[regno].set_addr (info->size);
742 scan_stage = 1;
743 }
744 else
745 break;
746 }
747
748 gdb_assert (vpc < AVR_MAX_PROLOGUE_SIZE);
749
750 /* Handle static small stack allocation using rcall or push. */
751 avr_gdbarch_tdep *tdep = gdbarch_tdep<avr_gdbarch_tdep> (gdbarch);
752 while (scan_stage == 1 && vpc < len)
753 {
754 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
755 if (insn == 0xd000) /* rcall .+0 */
756 {
757 info->size += tdep->call_length;
758 vpc += 2;
759 }
760 else if (insn == 0x920f || insn == 0x921f) /* push r0 or push r1 */
761 {
762 info->size += 1;
763 vpc += 2;
764 }
765 else
766 break;
767 }
768
769 /* Second stage of the prologue scanning.
770 Scan:
771 in r28,__SP_L__
772 in r29,__SP_H__ */
773
774 if (scan_stage == 1 && vpc < len)
775 {
776 static const unsigned char img[] = {
777 0xcd, 0xb7, /* in r28,__SP_L__ */
778 0xde, 0xb7 /* in r29,__SP_H__ */
779 };
780
781 if (vpc + sizeof (img) < len
782 && memcmp (prologue + vpc, img, sizeof (img)) == 0)
783 {
784 vpc += 4;
785 scan_stage = 2;
786 }
787 }
788
789 /* Third stage of the prologue scanning. (Really two stages).
790 Scan for:
791 sbiw r28,XX or subi r28,lo8(XX)
792 sbci r29,hi8(XX)
793 in __tmp_reg__,__SREG__
794 cli
795 out __SP_H__,r29
796 out __SREG__,__tmp_reg__
797 out __SP_L__,r28 */
798
799 if (scan_stage == 2 && vpc < len)
800 {
801 int locals_size = 0;
802 static const unsigned char img[] = {
803 0x0f, 0xb6, /* in r0,0x3f */
804 0xf8, 0x94, /* cli */
805 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
806 0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
807 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
808 };
809 static const unsigned char img_sig[] = {
810 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
811 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
812 };
813 static const unsigned char img_int[] = {
814 0xf8, 0x94, /* cli */
815 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
816 0x78, 0x94, /* sei */
817 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
818 };
819
820 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
821 if ((insn & 0xff30) == 0x9720) /* sbiw r28,XXX */
822 {
823 locals_size = (insn & 0xf) | ((insn & 0xc0) >> 2);
824 vpc += 2;
825 }
826 else if ((insn & 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
827 {
828 locals_size = (insn & 0xf) | ((insn & 0xf00) >> 4);
829 vpc += 2;
830 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
831 vpc += 2;
832 locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4)) << 8;
833 }
834 else
835 return pc_beg + vpc;
836
837 /* Scan the last part of the prologue. May not be present for interrupt
838 or signal handler functions, which is why we set the prologue type
839 when we saw the beginning of the prologue previously. */
840
841 if (vpc + sizeof (img_sig) < len
842 && memcmp (prologue + vpc, img_sig, sizeof (img_sig)) == 0)
843 {
844 vpc += sizeof (img_sig);
845 }
846 else if (vpc + sizeof (img_int) < len
847 && memcmp (prologue + vpc, img_int, sizeof (img_int)) == 0)
848 {
849 vpc += sizeof (img_int);
850 }
851 if (vpc + sizeof (img) < len
852 && memcmp (prologue + vpc, img, sizeof (img)) == 0)
853 {
854 info->prologue_type = AVR_PROLOGUE_NORMAL;
855 vpc += sizeof (img);
856 }
857
858 info->size += locals_size;
859
860 /* Fall through. */
861 }
862
863 /* If we got this far, we could not scan the prologue, so just return the pc
864 of the frame plus an adjustment for argument move insns. */
865
866 for (; vpc < len; vpc += 2)
867 {
868 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
869 if ((insn & 0xff00) == 0x0100) /* movw rXX, rYY */
870 continue;
871 else if ((insn & 0xfc00) == 0x2c00) /* mov rXX, rYY */
872 continue;
873 else
874 break;
875 }
876
877 return pc_beg + vpc;
878}
879
880static CORE_ADDR
881avr_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
882{
883 CORE_ADDR func_addr, func_end;
884 CORE_ADDR post_prologue_pc;
885
886 /* See what the symbol table says */
887
888 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
889 return pc;
890
891 post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr);
892 if (post_prologue_pc != 0)
893 return std::max (pc, post_prologue_pc);
894
895 {
896 CORE_ADDR prologue_end = pc;
897 struct avr_unwind_cache info = {0};
899
900 info.saved_regs = saved_regs;
901
902 /* Need to run the prologue scanner to figure out if the function has a
903 prologue and possibly skip over moving arguments passed via registers
904 to other registers. */
905
906 prologue_end = avr_scan_prologue (gdbarch, func_addr, func_end, &info);
907
908 if (info.prologue_type != AVR_PROLOGUE_NONE)
909 return prologue_end;
910 }
911
912 /* Either we didn't find the start of this function (nothing we can do),
913 or there's no line info, or the line after the prologue is after
914 the end of the function (there probably isn't a prologue). */
915
916 return pc;
917}
918
919/* Not all avr devices support the BREAK insn. Those that don't should treat
920 it as a NOP. Thus, it should be ok. Since the avr is currently a remote
921 only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
922
923constexpr gdb_byte avr_break_insn [] = { 0x98, 0x95 };
924
925typedef BP_MANIPULATION (avr_break_insn) avr_breakpoint;
926
927/* Determine, for architecture GDBARCH, how a return value of TYPE
928 should be returned. If it is supposed to be returned in registers,
929 and READBUF is non-zero, read the appropriate value from REGCACHE,
930 and copy it into READBUF. If WRITEBUF is non-zero, write the value
931 from WRITEBUF into REGCACHE. */
932
933static enum return_value_convention
934avr_return_value (struct gdbarch *gdbarch, struct value *function,
935 struct type *valtype, struct regcache *regcache,
936 gdb_byte *readbuf, const gdb_byte *writebuf)
937{
938 int i;
939 /* Single byte are returned in r24.
940 Otherwise, the MSB of the return value is always in r25, calculate which
941 register holds the LSB. */
942 int lsb_reg;
943
944 if ((valtype->code () == TYPE_CODE_STRUCT
945 || valtype->code () == TYPE_CODE_UNION
946 || valtype->code () == TYPE_CODE_ARRAY)
947 && valtype->length () > 8)
949
950 if (valtype->length () <= 2)
951 lsb_reg = 24;
952 else if (valtype->length () <= 4)
953 lsb_reg = 22;
954 else if (valtype->length () <= 8)
955 lsb_reg = 18;
956 else
957 gdb_assert_not_reached ("unexpected type length");
958
959 if (writebuf != NULL)
960 {
961 for (i = 0; i < valtype->length (); i++)
962 regcache->cooked_write (lsb_reg + i, writebuf + i);
963 }
964
965 if (readbuf != NULL)
966 {
967 for (i = 0; i < valtype->length (); i++)
968 regcache->cooked_read (lsb_reg + i, readbuf + i);
969 }
970
972}
973
974
975/* Put here the code to store, into fi->saved_regs, the addresses of
976 the saved registers of frame described by FRAME_INFO. This
977 includes special registers such as pc and fp saved in special ways
978 in the stack frame. sp is even more special: the address we return
979 for it IS the sp for the next frame. */
980
981static struct avr_unwind_cache *
983 void **this_prologue_cache)
984{
985 CORE_ADDR start_pc, current_pc;
986 ULONGEST prev_sp;
987 ULONGEST this_base;
988 struct avr_unwind_cache *info;
989 struct gdbarch *gdbarch;
990 int i;
991
992 if (*this_prologue_cache)
993 return (struct avr_unwind_cache *) *this_prologue_cache;
994
996 *this_prologue_cache = info;
997 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
998
999 info->size = 0;
1000 info->prologue_type = AVR_PROLOGUE_NONE;
1001
1002 start_pc = get_frame_func (this_frame);
1003 current_pc = get_frame_pc (this_frame);
1004 if ((start_pc > 0) && (start_pc <= current_pc))
1005 avr_scan_prologue (get_frame_arch (this_frame),
1006 start_pc, current_pc, info);
1007
1008 if ((info->prologue_type != AVR_PROLOGUE_NONE)
1009 && (info->prologue_type != AVR_PROLOGUE_MAIN))
1010 {
1011 ULONGEST high_base; /* High byte of FP */
1012
1013 /* The SP was moved to the FP. This indicates that a new frame
1014 was created. Get THIS frame's FP value by unwinding it from
1015 the next frame. */
1016 this_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM);
1017 high_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM + 1);
1018 this_base += (high_base << 8);
1019
1020 /* The FP points at the last saved register. Adjust the FP back
1021 to before the first saved register giving the SP. */
1022 prev_sp = this_base + info->size;
1023 }
1024 else
1025 {
1026 /* Assume that the FP is this frame's SP but with that pushed
1027 stack space added back. */
1028 this_base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM);
1029 prev_sp = this_base + info->size;
1030 }
1031
1032 /* Add 1 here to adjust for the post-decrement nature of the push
1033 instruction.*/
1034 info->prev_sp = avr_make_saddr (prev_sp + 1);
1035 info->base = avr_make_saddr (this_base);
1036
1037 gdbarch = get_frame_arch (this_frame);
1038
1039 /* Adjust all the saved registers so that they contain addresses and not
1040 offsets. */
1041 for (i = 0; i < gdbarch_num_regs (gdbarch) - 1; i++)
1042 if (info->saved_regs[i].is_addr ())
1043 info->saved_regs[i].set_addr (info->prev_sp
1044 - info->saved_regs[i].addr ());
1045
1046 /* Except for the main and startup code, the return PC is always saved on
1047 the stack and is at the base of the frame. */
1048
1049 if (info->prologue_type != AVR_PROLOGUE_MAIN)
1050 info->saved_regs[AVR_PC_REGNUM].set_addr (info->prev_sp);
1051
1052 /* The previous frame's SP needed to be computed. Save the computed
1053 value. */
1054 avr_gdbarch_tdep *tdep = gdbarch_tdep<avr_gdbarch_tdep> (gdbarch);
1055 info->saved_regs[AVR_SP_REGNUM].set_value (info->prev_sp
1056 - 1 + tdep->call_length);
1057
1058 return info;
1059}
1060
1061static CORE_ADDR
1063{
1064 ULONGEST pc;
1065
1067
1068 return avr_make_iaddr (pc);
1069}
1070
1071static CORE_ADDR
1073{
1074 ULONGEST sp;
1075
1077
1078 return avr_make_saddr (sp);
1079}
1080
1081/* Given a GDB frame, determine the address of the calling function's
1082 frame. This will be used to create a new GDB frame struct. */
1083
1084static void
1086 void **this_prologue_cache,
1087 struct frame_id *this_id)
1088{
1089 struct avr_unwind_cache *info
1090 = avr_frame_unwind_cache (this_frame, this_prologue_cache);
1091 CORE_ADDR base;
1092 CORE_ADDR func;
1093 struct frame_id id;
1094
1095 /* The FUNC is easy. */
1096 func = get_frame_func (this_frame);
1097
1098 /* Hopefully the prologue analysis either correctly determined the
1099 frame's base (which is the SP from the previous frame), or set
1100 that base to "NULL". */
1101 base = info->prev_sp;
1102 if (base == 0)
1103 return;
1104
1105 id = frame_id_build (base, func);
1106 (*this_id) = id;
1107}
1108
1109static struct value *
1111 void **this_prologue_cache, int regnum)
1112{
1113 struct avr_unwind_cache *info
1114 = avr_frame_unwind_cache (this_frame, this_prologue_cache);
1115
1117 {
1118 if (info->saved_regs[AVR_PC_REGNUM].is_addr ())
1119 {
1120 /* Reading the return PC from the PC register is slightly
1121 abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
1122 but in reality, only two bytes (3 in upcoming mega256) are
1123 stored on the stack.
1124
1125 Also, note that the value on the stack is an addr to a word
1126 not a byte, so we will need to multiply it by two at some
1127 point.
1128
1129 And to confuse matters even more, the return address stored
1130 on the stack is in big endian byte order, even though most
1131 everything else about the avr is little endian. Ick! */
1132 ULONGEST pc;
1133 int i;
1134 gdb_byte buf[3];
1135 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1136 avr_gdbarch_tdep *tdep = gdbarch_tdep<avr_gdbarch_tdep> (gdbarch);
1137
1138 read_memory (info->saved_regs[AVR_PC_REGNUM].addr (),
1139 buf, tdep->call_length);
1140
1141 /* Extract the PC read from memory as a big-endian. */
1142 pc = 0;
1143 for (i = 0; i < tdep->call_length; i++)
1144 pc = (pc << 8) | buf[i];
1145
1146 if (regnum == AVR_PC_REGNUM)
1147 pc <<= 1;
1148
1149 return frame_unwind_got_constant (this_frame, regnum, pc);
1150 }
1151
1152 return frame_unwind_got_optimized (this_frame, regnum);
1153 }
1154
1155 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1156}
1157
1158static const struct frame_unwind avr_frame_unwind = {
1159 "avr prologue",
1164 NULL,
1166};
1167
1168static CORE_ADDR
1169avr_frame_base_address (frame_info_ptr this_frame, void **this_cache)
1170{
1171 struct avr_unwind_cache *info
1172 = avr_frame_unwind_cache (this_frame, this_cache);
1173
1174 return info->base;
1175}
1176
1183
1184/* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1185 frame. The frame ID's base needs to match the TOS value saved by
1186 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1187
1188static struct frame_id
1190{
1191 ULONGEST base;
1192
1193 base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM);
1194 return frame_id_build (avr_make_saddr (base), get_frame_pc (this_frame));
1195}
1196
1197/* When arguments must be pushed onto the stack, they go on in reverse
1198 order. The below implements a FILO (stack) to do this. */
1199
1201{
1202 int len;
1204 gdb_byte *data;
1205};
1206
1207static struct avr_stack_item *
1208push_stack_item (struct avr_stack_item *prev, const bfd_byte *contents,
1209 int len)
1210{
1211 struct avr_stack_item *si;
1212 si = XNEW (struct avr_stack_item);
1213 si->data = (gdb_byte *) xmalloc (len);
1214 si->len = len;
1215 si->prev = prev;
1216 memcpy (si->data, contents, len);
1217 return si;
1218}
1219
1220static struct avr_stack_item *
1222{
1223 struct avr_stack_item *dead = si;
1224 si = si->prev;
1225 xfree (dead->data);
1226 xfree (dead);
1227 return si;
1228}
1229
1230/* Setup the function arguments for calling a function in the inferior.
1231
1232 On the AVR architecture, there are 18 registers (R25 to R8) which are
1233 dedicated for passing function arguments. Up to the first 18 arguments
1234 (depending on size) may go into these registers. The rest go on the stack.
1235
1236 All arguments are aligned to start in even-numbered registers (odd-sized
1237 arguments, including char, have one free register above them). For example,
1238 an int in arg1 and a char in arg2 would be passed as such:
1239
1240 arg1 -> r25:r24
1241 arg2 -> r22
1242
1243 Arguments that are larger than 2 bytes will be split between two or more
1244 registers as available, but will NOT be split between a register and the
1245 stack. Arguments that go onto the stack are pushed last arg first (this is
1246 similar to the d10v). */
1247
1248/* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1249 inaccurate.
1250
1251 An exceptional case exists for struct arguments (and possibly other
1252 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1253 not a multiple of WORDSIZE bytes. In this case the argument is never split
1254 between the registers and the stack, but instead is copied in its entirety
1255 onto the stack, AND also copied into as many registers as there is room
1256 for. In other words, space in registers permitting, two copies of the same
1257 argument are passed in. As far as I can tell, only the one on the stack is
1258 used, although that may be a function of the level of compiler
1259 optimization. I suspect this is a compiler bug. Arguments of these odd
1260 sizes are left-justified within the word (as opposed to arguments smaller
1261 than WORDSIZE bytes, which are right-justified).
1262
1263 If the function is to return an aggregate type such as a struct, the caller
1264 must allocate space into which the callee will copy the return value. In
1265 this case, a pointer to the return value location is passed into the callee
1266 in register R0, which displaces one of the other arguments passed in via
1267 registers R0 to R2. */
1268
1269static CORE_ADDR
1270avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1271 struct regcache *regcache, CORE_ADDR bp_addr,
1272 int nargs, struct value **args, CORE_ADDR sp,
1273 function_call_return_method return_method,
1274 CORE_ADDR struct_addr)
1275{
1276 int i;
1277 gdb_byte buf[3];
1278 avr_gdbarch_tdep *tdep = gdbarch_tdep<avr_gdbarch_tdep> (gdbarch);
1279 int call_length = tdep->call_length;
1280 CORE_ADDR return_pc = avr_convert_iaddr_to_raw (bp_addr);
1281 int regnum = AVR_ARGN_REGNUM;
1282 struct avr_stack_item *si = NULL;
1283
1284 if (return_method == return_method_struct)
1285 {
1287 (regcache, regnum--, (struct_addr >> 8) & 0xff);
1289 (regcache, regnum--, struct_addr & 0xff);
1290 /* SP being post decremented, we need to reserve one byte so that the
1291 return address won't overwrite the result (or vice-versa). */
1292 if (sp == struct_addr)
1293 sp--;
1294 }
1295
1296 for (i = 0; i < nargs; i++)
1297 {
1298 int last_regnum;
1299 int j;
1300 struct value *arg = args[i];
1301 struct type *type = check_typedef (arg->type ());
1302 const bfd_byte *contents = arg->contents ().data ();
1303 int len = type->length ();
1304
1305 /* Calculate the potential last register needed.
1306 E.g. For length 2, registers regnum and regnum-1 (say 25 and 24)
1307 shall be used. So, last needed register will be regnum-1(24). */
1308 last_regnum = regnum - (len + (len & 1)) + 1;
1309
1310 /* If there are registers available, use them. Once we start putting
1311 stuff on the stack, all subsequent args go on stack. */
1312 if ((si == NULL) && (last_regnum >= AVR_LAST_ARG_REGNUM))
1313 {
1314 /* Skip a register for odd length args. */
1315 if (len & 1)
1316 regnum--;
1317
1318 /* Write MSB of argument into register and subsequent bytes in
1319 decreasing register numbers. */
1320 for (j = 0; j < len; j++)
1322 (regcache, regnum--, contents[len - j - 1]);
1323 }
1324 /* No registers available, push the args onto the stack. */
1325 else
1326 {
1327 /* From here on, we don't care about regnum. */
1328 si = push_stack_item (si, contents, len);
1329 }
1330 }
1331
1332 /* Push args onto the stack. */
1333 while (si)
1334 {
1335 sp -= si->len;
1336 /* Add 1 to sp here to account for post decr nature of pushes. */
1337 write_memory (sp + 1, si->data, si->len);
1338 si = pop_stack_item (si);
1339 }
1340
1341 /* Set the return address. For the avr, the return address is the BP_ADDR.
1342 Need to push the return address onto the stack noting that it needs to be
1343 in big-endian order on the stack. */
1344 for (i = 1; i <= call_length; i++)
1345 {
1346 buf[call_length - i] = return_pc & 0xff;
1347 return_pc >>= 8;
1348 }
1349
1350 sp -= call_length;
1351 /* Use 'sp + 1' since pushes are post decr ops. */
1352 write_memory (sp + 1, buf, call_length);
1353
1354 /* Finally, update the SP register. */
1357
1358 /* Return SP value for the dummy frame, where the return address hasn't been
1359 pushed. */
1360 return sp + call_length;
1361}
1362
1363/* Unfortunately dwarf2 register for SP is 32. */
1364
1365static int
1367{
1368 if (reg >= 0 && reg < 32)
1369 return reg;
1370 if (reg == 32)
1371 return AVR_SP_REGNUM;
1372 return -1;
1373}
1374
1375/* Implementation of `address_class_type_flags' gdbarch method.
1376
1377 This method maps DW_AT_address_class attributes to a
1378 type_instance_flag_value. */
1379
1380static type_instance_flags
1381avr_address_class_type_flags (int byte_size, int dwarf2_addr_class)
1382{
1383 /* The value 1 of the DW_AT_address_class attribute corresponds to the
1384 __flash qualifier. Note that this attribute is only valid with
1385 pointer types and therefore the flag is set to the pointer type and
1386 not its target type. */
1387 if (dwarf2_addr_class == 1 && byte_size == 2)
1389 return 0;
1390}
1391
1392/* Implementation of `address_class_type_flags_to_name' gdbarch method.
1393
1394 Convert a type_instance_flag_value to an address space qualifier. */
1395
1396static const char*
1398 type_instance_flags type_flags)
1399{
1401 return "flash";
1402 else
1403 return NULL;
1404}
1405
1406/* Implementation of `address_class_name_to_type_flags' gdbarch method.
1407
1408 Convert an address space qualifier to a type_instance_flag_value. */
1409
1410static bool
1412 const char* name,
1413 type_instance_flags *type_flags_ptr)
1414{
1415 if (strcmp (name, "flash") == 0)
1416 {
1418 return true;
1419 }
1420 else
1421 return false;
1422}
1423
1424/* Initialize the gdbarch structure for the AVR's. */
1425
1426static struct gdbarch *
1428{
1429 struct gdbarch_list *best_arch;
1430 int call_length;
1431
1432 /* Avr-6 call instructions save 3 bytes. */
1433 switch (info.bfd_arch_info->mach)
1434 {
1435 case bfd_mach_avr1:
1436 case bfd_mach_avrxmega1:
1437 case bfd_mach_avr2:
1438 case bfd_mach_avrxmega2:
1439 case bfd_mach_avr3:
1440 case bfd_mach_avrxmega3:
1441 case bfd_mach_avr4:
1442 case bfd_mach_avrxmega4:
1443 case bfd_mach_avr5:
1444 case bfd_mach_avrxmega5:
1445 default:
1446 call_length = 2;
1447 break;
1448 case bfd_mach_avr6:
1449 case bfd_mach_avrxmega6:
1450 case bfd_mach_avrxmega7:
1451 call_length = 3;
1452 break;
1453 }
1454
1455 /* If there is already a candidate, use it. */
1456 for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1457 best_arch != NULL;
1458 best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1459 {
1460 avr_gdbarch_tdep *tdep
1461 = gdbarch_tdep<avr_gdbarch_tdep> (best_arch->gdbarch);
1462
1463 if (tdep->call_length == call_length)
1464 return best_arch->gdbarch;
1465 }
1466
1467 /* None found, create a new architecture from the information provided. */
1470 avr_gdbarch_tdep *tdep = gdbarch_tdep<avr_gdbarch_tdep> (gdbarch);
1471
1472 tdep->call_length = call_length;
1473
1474 /* Create a type for PC. We can't use builtin types here, as they may not
1475 be defined. */
1476 type_allocator alloc (gdbarch);
1477 tdep->void_type = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
1478 tdep->func_void_type = make_function_type (tdep->void_type, NULL);
1479 tdep->pc_type = init_pointer_type (alloc, 4 * TARGET_CHAR_BIT, NULL,
1480 tdep->func_void_type);
1481
1482 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1483 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1484 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1485 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1486 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1488
1489 set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1491
1492 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1493 set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1494 set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1495
1499
1502
1504
1507
1510
1514
1515 set_gdbarch_return_value (gdbarch, avr_return_value);
1516
1518
1520
1524
1527
1528 set_gdbarch_breakpoint_kind_from_pc (gdbarch, avr_breakpoint::kind_from_pc);
1529 set_gdbarch_sw_breakpoint_from_kind (gdbarch, avr_breakpoint::bp_from_kind);
1530
1533
1535
1538
1544
1545 return gdbarch;
1546}
1547
1548/* Send a query request to the avr remote target asking for values of the io
1549 registers. If args parameter is not NULL, then the user has requested info
1550 on a specific io register [This still needs implemented and is ignored for
1551 now]. The query string should be one of these forms:
1552
1553 "Ravr.io_reg" -> reply is "NN" number of io registers
1554
1555 "Ravr.io_reg:addr,len" where addr is first register and len is number of
1556 registers to be read. The reply should be "<NAME>,VV;" for each io register
1557 where, <NAME> is a string, and VV is the hex value of the register.
1558
1559 All io registers are 8-bit. */
1560
1561static void
1562avr_io_reg_read_command (const char *args, int from_tty)
1563{
1564 char query[400];
1565 unsigned int nreg = 0;
1566 unsigned int val;
1567
1568 /* Find out how many io registers the target has. */
1569 gdb::optional<gdb::byte_vector> buf
1570 = target_read_alloc (current_inferior ()->top_target (),
1571 TARGET_OBJECT_AVR, "avr.io_reg");
1572
1573 if (!buf)
1574 {
1576 _("ERR: info io_registers NOT supported "
1577 "by current target\n"));
1578 return;
1579 }
1580
1581 const char *bufstr = (const char *) buf->data ();
1582
1583 if (sscanf (bufstr, "%x", &nreg) != 1)
1584 {
1586 _("Error fetching number of io registers\n"));
1587 return;
1588 }
1589
1590 gdb_printf (_("Target has %u io registers:\n\n"), nreg);
1591
1592 /* only fetch up to 8 registers at a time to keep the buffer small */
1593 int step = 8;
1594
1595 for (int i = 0; i < nreg; i += step)
1596 {
1597 /* how many registers this round? */
1598 int j = step;
1599 if ((i+j) >= nreg)
1600 j = nreg - i; /* last block is less than 8 registers */
1601
1602 snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j);
1603 buf = target_read_alloc (current_inferior ()->top_target (),
1605
1606 if (!buf)
1607 {
1609 _("ERR: error reading avr.io_reg:%x,%x\n"),
1610 i, j);
1611 return;
1612 }
1613
1614 const char *p = (const char *) buf->data ();
1615 for (int k = i; k < (i + j); k++)
1616 {
1617 if (sscanf (p, "%[^,],%x;", query, &val) == 2)
1618 {
1619 gdb_printf ("[%02x] %-15s : %02x\n", k, query, val);
1620 while ((*p != ';') && (*p != '\0'))
1621 p++;
1622 p++; /* skip over ';' */
1623 if (*p == '\0')
1624 break;
1625 }
1626 }
1627 }
1628}
1629
1630void _initialize_avr_tdep ();
1631void
1633{
1634 gdbarch_register (bfd_arch_avr, avr_gdbarch_init);
1635
1636 /* Add a new command to allow the user to query the avr remote target for
1637 the values of the io space registers in a saner way than just using
1638 `x/NNNb ADDR`. */
1639
1640 /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1641 io_registers' to signify it is not available on other platforms. */
1642
1643 add_info ("io_registers", avr_io_reg_read_command,
1644 _("Query remote AVR target for I/O space register values."));
1645}
int regnum
const char *const name
void * xmalloc(YYSIZE_T)
void xfree(void *)
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_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:177
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
static CORE_ADDR avr_make_iaddr(CORE_ADDR x)
Definition avr-tdep.c:246
static void avr_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition avr-tdep.c:1085
static struct gdbarch * avr_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition avr-tdep.c:1427
#define AVR_TYPE_ADDRESS_CLASS_FLASH
Definition avr-tdep.c:80
constexpr gdb_byte avr_break_insn[]
Definition avr-tdep.c:923
static CORE_ADDR avr_integer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition avr-tdep.c:364
static struct value * avr_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
Definition avr-tdep.c:1110
static const struct frame_unwind avr_frame_unwind
Definition avr-tdep.c:1158
static CORE_ADDR avr_unwind_pc(struct gdbarch *gdbarch, frame_info_ptr next_frame)
Definition avr-tdep.c:1062
static void avr_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition avr-tdep.c:413
static const struct frame_base avr_frame_base
Definition avr-tdep.c:1177
static type_instance_flags avr_address_class_type_flags(int byte_size, int dwarf2_addr_class)
Definition avr-tdep.c:1381
static CORE_ADDR avr_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition avr-tdep.c:337
static void avr_io_reg_read_command(const char *args, int from_tty)
Definition avr-tdep.c:1562
@ AVR_PROLOGUE_SIG
Definition avr-tdep.c:165
@ AVR_PROLOGUE_CALL
Definition avr-tdep.c:162
@ AVR_PROLOGUE_NORMAL
Definition avr-tdep.c:161
@ AVR_PROLOGUE_MAIN
Definition avr-tdep.c:163
@ AVR_PROLOGUE_NONE
Definition avr-tdep.c:160
@ AVR_PROLOGUE_INTR
Definition avr-tdep.c:164
static CORE_ADDR avr_make_saddr(CORE_ADDR x)
Definition avr-tdep.c:265
@ AVR_SREG_REGNUM
Definition avr-tdep.c:93
@ AVR_LAST_PUSHED_REGNUM
Definition avr-tdep.c:112
@ AVR_ARGN_REGNUM
Definition avr-tdep.c:115
@ AVR_NUM_REG_BYTES
Definition avr-tdep.c:98
@ AVR_PC_REG_INDEX
Definition avr-tdep.c:104
@ AVR_REG_Y
Definition avr-tdep.c:89
@ AVR_REG_W
Definition avr-tdep.c:87
@ AVR_NUM_REGS
Definition avr-tdep.c:97
@ AVR_MEM_MASK
Definition avr-tdep.c:147
@ AVR_PC_REGNUM
Definition avr-tdep.c:95
@ AVR_LAST_ARG_REGNUM
Definition avr-tdep.c:116
@ AVR_FP_REGNUM
Definition avr-tdep.c:90
@ AVR_RETN_REGNUM
Definition avr-tdep.c:119
@ AVR_RET1_REGNUM
Definition avr-tdep.c:118
@ AVR_ARG1_REGNUM
Definition avr-tdep.c:114
@ AVR_SMEM_START
Definition avr-tdep.c:144
@ AVR_PSEUDO_PC_REGNUM
Definition avr-tdep.c:101
@ AVR_MAX_PROLOGUE_SIZE
Definition avr-tdep.c:106
@ AVR_REG_X
Definition avr-tdep.c:88
@ AVR_SP_REGNUM
Definition avr-tdep.c:94
@ AVR_MAX_PUSHES
Definition avr-tdep.c:109
@ AVR_REG_Z
Definition avr-tdep.c:91
@ AVR_IMEM_START
Definition avr-tdep.c:143
@ AVR_NUM_PSEUDO_REGS
Definition avr-tdep.c:102
static const char * avr_address_class_type_flags_to_name(struct gdbarch *gdbarch, type_instance_flags type_flags)
Definition avr-tdep.c:1397
static CORE_ADDR avr_scan_prologue(struct gdbarch *gdbarch, CORE_ADDR pc_beg, CORE_ADDR pc_end, struct avr_unwind_cache *info)
Definition avr-tdep.c:526
void _initialize_avr_tdep()
Definition avr-tdep.c:1632
static CORE_ADDR avr_read_pc(readable_regcache *regcache)
Definition avr-tdep.c:376
static bool avr_address_class_name_to_type_flags(struct gdbarch *gdbarch, const char *name, type_instance_flags *type_flags_ptr)
Definition avr-tdep.c:1411
static CORE_ADDR avr_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)
Definition avr-tdep.c:1270
static int avr_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
Definition avr-tdep.c:1366
static struct avr_unwind_cache * avr_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
Definition avr-tdep.c:982
static const char * avr_register_name(struct gdbarch *gdbarch, int regnum)
Definition avr-tdep.c:209
static void avr_write_pc(struct regcache *regcache, CORE_ADDR val)
Definition avr-tdep.c:385
static CORE_ADDR avr_unwind_sp(struct gdbarch *gdbarch, frame_info_ptr next_frame)
Definition avr-tdep.c:1072
static CORE_ADDR avr_convert_iaddr_to_raw(CORE_ADDR x)
Definition avr-tdep.c:257
static struct avr_stack_item * push_stack_item(struct avr_stack_item *prev, const bfd_byte *contents, int len)
Definition avr-tdep.c:1208
#define AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH
Definition avr-tdep.c:81
static enum register_status avr_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf)
Definition avr-tdep.c:392
static struct avr_stack_item * pop_stack_item(struct avr_stack_item *si)
Definition avr-tdep.c:1221
static CORE_ADDR avr_frame_base_address(frame_info_ptr this_frame, void **this_cache)
Definition avr-tdep.c:1169
static void avr_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition avr-tdep.c:307
static CORE_ADDR avr_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition avr-tdep.c:881
static struct frame_id avr_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
Definition avr-tdep.c:1189
static CORE_ADDR avr_convert_saddr_to_raw(CORE_ADDR x)
Definition avr-tdep.c:275
static struct type * avr_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition avr-tdep.c:228
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
enum register_status cooked_read(int regnum, gdb_byte *buf)
Definition regcache.c:698
void cooked_write(int regnum, const gdb_byte *buf)
Definition regcache.c:870
type * new_type()
Definition gdbtypes.c:208
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:347
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition corefile.c:238
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
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 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_optimized(frame_info_ptr frame, int 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
ULONGEST frame_unwind_register_unsigned(frame_info_ptr next_frame, int regnum)
Definition frame.c:1371
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_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc)
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_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc)
void set_gdbarch_integer_to_address(struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype *integer_to_address)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_address_class_type_flags_to_name(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name)
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_address_class_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition gdbarch.c:1459
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
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1930
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_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition gdbarch.c:1663
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition gdbarch.c:2064
void set_gdbarch_address_class_name_to_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags)
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_short_bit(struct gdbarch *gdbarch, int short_bit)
Definition gdbarch.c:1442
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition gdbarch.c:1958
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum)
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_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read)
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_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_read_pc(struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc)
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp)
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
Definition gdbarch.c:1629
void set_gdbarch_pointer_to_address(struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype *pointer_to_address)
void set_gdbarch_float_format(struct gdbarch *gdbarch, const struct floatformat **float_format)
Definition gdbarch.c:1595
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
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
Definition gdbarch.h:73
function_call_return_method
Definition gdbarch.h:114
@ return_method_struct
Definition gdbarch.h:126
struct type * init_pointer_type(type_allocator &alloc, int bit, const char *name, struct type *target_type)
Definition gdbtypes.c:3485
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:85
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
struct type * make_function_type(struct type *type, struct type **typeptr)
Definition gdbtypes.c:537
#define TYPE_DATA_SPACE(t)
Definition gdbtypes.h:176
#define TYPE_CODE_SPACE(t)
Definition gdbtypes.h:173
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
struct inferior * current_inferior(void)
Definition inferior.c:55
@ locals
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
info(Component c)
Definition gdbarch.py:41
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:677
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
void(* func)(remote_target *remote, char *)
struct type * void_type
Definition avr-tdep.c:199
struct type * func_void_type
Definition avr-tdep.c:201
struct type * pc_type
Definition avr-tdep.c:203
gdb_byte * data
Definition avr-tdep.c:1204
struct avr_stack_item * prev
Definition avr-tdep.c:1203
trad_frame_saved_reg * saved_regs
Definition avr-tdep.c:189
CORE_ADDR base
Definition avr-tdep.c:185
CORE_ADDR prev_sp
Definition avr-tdep.c:183
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
struct type * builtin_uint32
Definition gdbtypes.h:2120
struct type * builtin_uint8
Definition gdbtypes.h:2114
struct gdbarch * gdbarch
Definition gdbarch.h:243
struct gdbarch_list * next
Definition gdbarch.h:244
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
gdb::array_view< const gdb_byte > contents()
Definition value.c:1262
struct type * type() const
Definition value.h:180
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition symtab.c:3963
gdb::optional< gdb::byte_vector > target_read_alloc(struct target_ops *ops, enum target_object object, const char *annex)
Definition target.c:2312
@ TARGET_OBJECT_AVR
Definition target.h:145
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition trad-frame.c:62
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
Definition trad-frame.c:187
int query(const char *ctlstr,...)
Definition utils.c:943
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stderr
Definition utils.h:187
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition value.c:2753