1 /* Target-dependent code for Atmel AVR, for GDB.
3 Copyright (C) 1996-2024 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* Contributed by Theodore A. Roth, troth@openavr.org */
22 /* Portions of this file were taken from the original gdb-4.18 patch developed
23 by Denis Chertykov, denisc@overta.ru */
26 #include "frame-unwind.h"
27 #include "frame-base.h"
28 #include "trad-frame.h"
34 #include "arch-utils.h"
43 (AVR micros are pure Harvard Architecture processors.)
45 The AVR family of microcontrollers have three distinctly different memory
46 spaces: flash, sram and eeprom. The flash is 16 bits wide and is used for
47 the most part to store program instructions. The sram is 8 bits wide and is
48 used for the stack and the heap. Some devices lack sram and some can have
49 an additional external sram added on as a peripheral.
51 The eeprom is 8 bits wide and is used to store data when the device is
52 powered down. Eeprom is not directly accessible, it can only be accessed
53 via io-registers using a special algorithm. Accessing eeprom via gdb's
54 remote serial protocol ('m' or 'M' packets) looks difficult to do and is
55 not included at this time.
57 [The eeprom could be read manually via ``x/b <eaddr + AVR_EMEM_START>'' or
58 written using ``set {unsigned char}<eaddr + AVR_EMEM_START>''. For this to
59 work, the remote target must be able to handle eeprom accesses and perform
60 the address translation.]
62 All three memory spaces have physical addresses beginning at 0x0. In
63 addition, the flash is addressed by gcc/binutils/gdb with respect to 8 bit
64 bytes instead of the 16 bit wide words used by the real device for the
67 In order for remote targets to work correctly, extra bits must be added to
68 addresses before they are send to the target or received from the target
69 via the remote serial protocol. The extra bits are the MSBs and are used to
70 decode which memory space the address is referring to. */
72 /* Constants: prefixed with AVR_ to avoid name space clashes */
74 /* Address space flags */
76 /* We are assigning the TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 to the flash address
79 #define AVR_TYPE_ADDRESS_CLASS_FLASH TYPE_ADDRESS_CLASS_1
80 #define AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH \
81 TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
96 AVR_NUM_REGS
= 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
97 AVR_NUM_REG_BYTES
= 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
99 /* Pseudo registers. */
100 AVR_PSEUDO_PC_REGNUM
= 35,
101 AVR_NUM_PSEUDO_REGS
= 1,
103 AVR_PC_REG_INDEX
= 35, /* index into array of registers */
105 AVR_MAX_PROLOGUE_SIZE
= 64, /* bytes */
107 /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
110 /* Number of the last pushed register. r17 for current avr-gcc */
111 AVR_LAST_PUSHED_REGNUM
= 17,
113 AVR_ARG1_REGNUM
= 24, /* Single byte argument */
114 AVR_ARGN_REGNUM
= 25, /* Multi byte arguments */
115 AVR_LAST_ARG_REGNUM
= 8, /* Last argument register */
117 AVR_RET1_REGNUM
= 24, /* Single byte return value */
118 AVR_RETN_REGNUM
= 25, /* Multi byte return value */
120 /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
121 bits? Do these have to match the bfd vma values? It sure would make
122 things easier in the future if they didn't need to match.
124 Note: I chose these values so as to be consistent with bfd vma
127 TRoth/2002-04-08: There is already a conflict with very large programs
128 in the mega128. The mega128 has 128K instruction bytes (64K words),
129 thus the Most Significant Bit is 0x10000 which gets masked off my
132 The problem manifests itself when trying to set a breakpoint in a
133 function which resides in the upper half of the instruction space and
134 thus requires a 17-bit address.
136 For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
137 from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
138 but could be for some remote targets by just adding the correct offset
139 to the address and letting the remote target handle the low-level
140 details of actually accessing the eeprom. */
142 AVR_IMEM_START
= 0x00000000, /* INSN memory */
143 AVR_SMEM_START
= 0x00800000, /* SRAM memory */
145 /* No eeprom mask defined */
146 AVR_MEM_MASK
= 0x00f00000, /* mask to determine memory space */
148 AVR_EMEM_START
= 0x00810000, /* EEPROM memory */
149 AVR_MEM_MASK
= 0x00ff0000, /* mask to determine memory space */
155 NORMAL and CALL are the typical types (the -mcall-prologues gcc option
156 causes the generation of the CALL type prologues). */
159 AVR_PROLOGUE_NONE
, /* No prologue */
161 AVR_PROLOGUE_CALL
, /* -mcall-prologues */
163 AVR_PROLOGUE_INTR
, /* interrupt handler */
164 AVR_PROLOGUE_SIG
, /* signal handler */
167 /* Any function with a frame looks like this
168 ....... <-SP POINTS HERE
169 LOCALS1 <-FP POINTS HERE
178 struct avr_unwind_cache
180 /* The previous frame's inner most stack address. Used as this
181 frame ID's stack_addr. */
183 /* The frame's base, optionally used by the high-level debug info. */
187 /* Table indicating the location of each and every register. */
188 trad_frame_saved_reg
*saved_regs
;
191 struct avr_gdbarch_tdep
: gdbarch_tdep_base
193 /* Number of bytes stored to the stack by call instructions.
194 2 bytes for avr1-5 and avrxmega1-5, 3 bytes for avr6 and avrxmega6-7. */
198 struct type
*void_type
= nullptr;
199 /* Type for a function returning void. */
200 struct type
*func_void_type
= nullptr;
201 /* Type for a pointer to a function. Used for the type of PC. */
202 struct type
*pc_type
= nullptr;
205 /* Lookup the name of a register given it's number. */
208 avr_register_name (struct gdbarch
*gdbarch
, int regnum
)
210 static const char * const register_names
[] = {
211 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
212 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
213 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
214 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
218 static_assert (ARRAY_SIZE (register_names
)
219 == (AVR_NUM_REGS
+ AVR_NUM_PSEUDO_REGS
));
220 return register_names
[regnum
];
223 /* Return the GDB type object for the "standard" data type
224 of data in register N. */
227 avr_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
229 if (reg_nr
== AVR_PC_REGNUM
)
230 return builtin_type (gdbarch
)->builtin_uint32
;
232 avr_gdbarch_tdep
*tdep
= gdbarch_tdep
<avr_gdbarch_tdep
> (gdbarch
);
233 if (reg_nr
== AVR_PSEUDO_PC_REGNUM
)
234 return tdep
->pc_type
;
236 if (reg_nr
== AVR_SP_REGNUM
)
237 return builtin_type (gdbarch
)->builtin_data_ptr
;
239 return builtin_type (gdbarch
)->builtin_uint8
;
242 /* Instruction address checks and conversions. */
245 avr_make_iaddr (CORE_ADDR x
)
247 return ((x
) | AVR_IMEM_START
);
250 /* FIXME: TRoth: Really need to use a larger mask for instructions. Some
251 devices are already up to 128KBytes of flash space.
253 TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined. */
256 avr_convert_iaddr_to_raw (CORE_ADDR x
)
258 return ((x
) & 0xffffffff);
261 /* SRAM address checks and conversions. */
264 avr_make_saddr (CORE_ADDR x
)
266 /* Return 0 for NULL. */
270 return ((x
) | AVR_SMEM_START
);
274 avr_convert_saddr_to_raw (CORE_ADDR x
)
276 return ((x
) & 0xffffffff);
279 /* EEPROM address checks and conversions. I don't know if these will ever
280 actually be used, but I've added them just the same. TRoth */
282 /* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
283 programs in the mega128. */
285 /* static CORE_ADDR */
286 /* avr_make_eaddr (CORE_ADDR x) */
288 /* return ((x) | AVR_EMEM_START); */
292 /* avr_eaddr_p (CORE_ADDR x) */
294 /* return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
297 /* static CORE_ADDR */
298 /* avr_convert_eaddr_to_raw (CORE_ADDR x) */
300 /* return ((x) & 0xffffffff); */
303 /* Convert from address to pointer and vice-versa. */
306 avr_address_to_pointer (struct gdbarch
*gdbarch
,
307 struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
309 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
311 /* Is it a data address in flash? */
312 if (AVR_TYPE_ADDRESS_CLASS_FLASH (type
))
314 /* A data pointer in flash is byte addressed. */
315 store_unsigned_integer (buf
, type
->length (), byte_order
,
316 avr_convert_iaddr_to_raw (addr
));
318 /* Is it a code address? */
319 else if (type
->target_type ()->code () == TYPE_CODE_FUNC
320 || type
->target_type ()->code () == TYPE_CODE_METHOD
)
322 /* A code pointer is word (16 bits) addressed. We shift the address down
323 by 1 bit to convert it to a pointer. */
324 store_unsigned_integer (buf
, type
->length (), byte_order
,
325 avr_convert_iaddr_to_raw (addr
>> 1));
329 /* Strip off any upper segment bits. */
330 store_unsigned_integer (buf
, type
->length (), byte_order
,
331 avr_convert_saddr_to_raw (addr
));
336 avr_pointer_to_address (struct gdbarch
*gdbarch
,
337 struct type
*type
, const gdb_byte
*buf
)
339 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
341 = extract_unsigned_integer (buf
, type
->length (), byte_order
);
343 /* Is it a data address in flash? */
344 if (AVR_TYPE_ADDRESS_CLASS_FLASH (type
))
346 /* A data pointer in flash is already byte addressed. */
347 return avr_make_iaddr (addr
);
349 /* Is it a code address? */
350 else if (type
->target_type ()->code () == TYPE_CODE_FUNC
351 || type
->target_type ()->code () == TYPE_CODE_METHOD
352 || TYPE_CODE_SPACE (type
->target_type ()))
354 /* A code pointer is word (16 bits) addressed so we shift it up
355 by 1 bit to convert it to an address. */
356 return avr_make_iaddr (addr
<< 1);
359 return avr_make_saddr (addr
);
363 avr_integer_to_address (struct gdbarch
*gdbarch
,
364 struct type
*type
, const gdb_byte
*buf
)
366 ULONGEST addr
= unpack_long (type
, buf
);
368 if (TYPE_DATA_SPACE (type
))
369 return avr_make_saddr (addr
);
371 return avr_make_iaddr (addr
);
375 avr_read_pc (readable_regcache
*regcache
)
379 regcache
->cooked_read (AVR_PC_REGNUM
, &pc
);
380 return avr_make_iaddr (pc
);
384 avr_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
386 regcache_cooked_write_unsigned (regcache
, AVR_PC_REGNUM
,
387 avr_convert_iaddr_to_raw (val
));
390 static enum register_status
391 avr_pseudo_register_read (struct gdbarch
*gdbarch
, readable_regcache
*regcache
,
392 int regnum
, gdb_byte
*buf
)
395 enum register_status status
;
399 case AVR_PSEUDO_PC_REGNUM
:
400 status
= regcache
->raw_read (AVR_PC_REGNUM
, &val
);
401 if (status
!= REG_VALID
)
404 store_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
), val
);
407 internal_error (_("invalid regnum"));
412 avr_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
413 int regnum
, const gdb_byte
*buf
)
419 case AVR_PSEUDO_PC_REGNUM
:
420 val
= extract_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
));
422 regcache_raw_write_unsigned (regcache
, AVR_PC_REGNUM
, val
);
425 internal_error (_("invalid regnum"));
429 /* Function: avr_scan_prologue
431 This function decodes an AVR function prologue to determine:
432 1) the size of the stack frame
433 2) which registers are saved on it
434 3) the offsets of saved regs
435 This information is stored in the avr_unwind_cache structure.
437 Some devices lack the sbiw instruction, so on those replace this:
443 A typical AVR function prologue with a frame pointer might look like this:
444 push rXX ; saved regs
450 sbiw r28,<LOCALS_SIZE>
451 in __tmp_reg__,__SREG__
454 out __SREG__,__tmp_reg__
457 A typical AVR function prologue without a frame pointer might look like
459 push rXX ; saved regs
462 A main function prologue looks like this:
463 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
464 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
468 A signal handler prologue looks like this:
471 in __tmp_reg__, __SREG__
474 push rXX ; save registers r18:r27, r30:r31
476 push r28 ; save frame pointer
480 sbiw r28, <LOCALS_SIZE>
484 A interrupt handler prologue looks like this:
488 in __tmp_reg__, __SREG__
491 push rXX ; save registers r18:r27, r30:r31
493 push r28 ; save frame pointer
497 sbiw r28, <LOCALS_SIZE>
503 A `-mcall-prologues' prologue looks like this (Note that the megas use a
504 jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
505 32 bit insn and rjmp is a 16 bit insn):
506 ldi r26,lo8(<LOCALS_SIZE>)
507 ldi r27,hi8(<LOCALS_SIZE>)
508 ldi r30,pm_lo8(.L_foo_body)
509 ldi r31,pm_hi8(.L_foo_body)
510 rjmp __prologue_saves__+RRR
513 /* Not really part of a prologue, but still need to scan for it, is when a
514 function prologue moves values passed via registers as arguments to new
515 registers. In this case, all local variables live in registers, so there
516 may be some register saves. This is what it looks like:
520 There could be multiple movw's. If the target doesn't have a movw insn, it
521 will use two mov insns. This could be done after any of the above prologue
525 avr_scan_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc_beg
, CORE_ADDR pc_end
,
526 struct avr_unwind_cache
*info
)
528 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
532 struct bound_minimal_symbol msymbol
;
533 unsigned char prologue
[AVR_MAX_PROLOGUE_SIZE
];
537 len
= pc_end
- pc_beg
;
538 if (len
> AVR_MAX_PROLOGUE_SIZE
)
539 len
= AVR_MAX_PROLOGUE_SIZE
;
541 /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
542 reading in the bytes of the prologue. The problem is that the figuring
543 out where the end of the prologue is is a bit difficult. The old code
544 tried to do that, but failed quite often. */
545 read_memory (pc_beg
, prologue
, len
);
547 /* Scanning main()'s prologue
548 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
549 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
556 static const unsigned char img
[] = {
557 0xde, 0xbf, /* out __SP_H__,r29 */
558 0xcd, 0xbf /* out __SP_L__,r28 */
561 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
562 /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
563 if ((insn
& 0xf0f0) == 0xe0c0)
565 locals
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
566 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
567 /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
568 if ((insn
& 0xf0f0) == 0xe0d0)
570 locals
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
571 if (vpc
+ 4 + sizeof (img
) < len
572 && memcmp (prologue
+ vpc
+ 4, img
, sizeof (img
)) == 0)
574 info
->prologue_type
= AVR_PROLOGUE_MAIN
;
582 /* Scanning `-mcall-prologues' prologue
583 Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
585 while (1) /* Using a while to avoid many goto's */
592 /* At least the fifth instruction must have been executed to
593 modify frame shape. */
597 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
598 /* ldi r26,<LOCALS_SIZE> */
599 if ((insn
& 0xf0f0) != 0xe0a0)
601 loc_size
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
604 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
605 /* ldi r27,<LOCALS_SIZE> / 256 */
606 if ((insn
& 0xf0f0) != 0xe0b0)
608 loc_size
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
611 insn
= extract_unsigned_integer (&prologue
[vpc
+ 4], 2, byte_order
);
612 /* ldi r30,pm_lo8(.L_foo_body) */
613 if ((insn
& 0xf0f0) != 0xe0e0)
615 body_addr
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
618 insn
= extract_unsigned_integer (&prologue
[vpc
+ 6], 2, byte_order
);
619 /* ldi r31,pm_hi8(.L_foo_body) */
620 if ((insn
& 0xf0f0) != 0xe0f0)
622 body_addr
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
625 msymbol
= lookup_minimal_symbol ("__prologue_saves__", NULL
, NULL
);
629 insn
= extract_unsigned_integer (&prologue
[vpc
+ 8], 2, byte_order
);
630 /* rjmp __prologue_saves__+RRR */
631 if ((insn
& 0xf000) == 0xc000)
633 /* Extract PC relative offset from RJMP */
634 i
= (insn
& 0xfff) | (insn
& 0x800 ? (-1 ^ 0xfff) : 0);
635 /* Convert offset to byte addressable mode */
637 /* Destination address */
640 if (body_addr
!= (pc_beg
+ 10)/2)
645 else if ((insn
& 0xfe0e) == 0x940c)
647 /* Extract absolute PC address from JMP */
648 i
= (((insn
& 0x1) | ((insn
& 0x1f0) >> 3) << 16)
649 | (extract_unsigned_integer (&prologue
[vpc
+ 10], 2, byte_order
)
651 /* Convert address to byte addressable mode */
654 if (body_addr
!= (pc_beg
+ 12)/2)
662 /* Resolve offset (in words) from __prologue_saves__ symbol.
663 Which is a pushes count in `-mcall-prologues' mode */
664 num_pushes
= AVR_MAX_PUSHES
- (i
- msymbol
.value_address ()) / 2;
666 if (num_pushes
> AVR_MAX_PUSHES
)
668 gdb_printf (gdb_stderr
, _("Num pushes too large: %d\n"),
677 info
->saved_regs
[AVR_FP_REGNUM
+ 1].set_addr (num_pushes
);
679 info
->saved_regs
[AVR_FP_REGNUM
].set_addr (num_pushes
- 1);
682 for (from
= AVR_LAST_PUSHED_REGNUM
+ 1 - (num_pushes
- 2);
683 from
<= AVR_LAST_PUSHED_REGNUM
; ++from
)
684 info
->saved_regs
[from
].set_addr (++i
);
686 info
->size
= loc_size
+ num_pushes
;
687 info
->prologue_type
= AVR_PROLOGUE_CALL
;
689 return pc_beg
+ pc_offset
;
692 /* Scan for the beginning of the prologue for an interrupt or signal
693 function. Note that we have to set the prologue type here since the
694 third stage of the prologue may not be present (e.g. no saved registered
695 or changing of the SP register). */
699 static const unsigned char img
[] = {
700 0x78, 0x94, /* sei */
701 0x1f, 0x92, /* push r1 */
702 0x0f, 0x92, /* push r0 */
703 0x0f, 0xb6, /* in r0,0x3f SREG */
704 0x0f, 0x92, /* push r0 */
705 0x11, 0x24 /* clr r1 */
707 if (len
>= sizeof (img
)
708 && memcmp (prologue
, img
, sizeof (img
)) == 0)
710 info
->prologue_type
= AVR_PROLOGUE_INTR
;
712 info
->saved_regs
[AVR_SREG_REGNUM
].set_addr (3);
713 info
->saved_regs
[0].set_addr (2);
714 info
->saved_regs
[1].set_addr (1);
717 else if (len
>= sizeof (img
) - 2
718 && memcmp (img
+ 2, prologue
, sizeof (img
) - 2) == 0)
720 info
->prologue_type
= AVR_PROLOGUE_SIG
;
721 vpc
+= sizeof (img
) - 2;
722 info
->saved_regs
[AVR_SREG_REGNUM
].set_addr (3);
723 info
->saved_regs
[0].set_addr (2);
724 info
->saved_regs
[1].set_addr (1);
729 /* First stage of the prologue scanning.
730 Scan pushes (saved registers) */
732 for (; vpc
< len
; vpc
+= 2)
734 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
735 if ((insn
& 0xfe0f) == 0x920f) /* push rXX */
737 /* Bits 4-9 contain a mask for registers R0-R32. */
738 int regno
= (insn
& 0x1f0) >> 4;
740 info
->saved_regs
[regno
].set_addr (info
->size
);
747 gdb_assert (vpc
< AVR_MAX_PROLOGUE_SIZE
);
749 /* Handle static small stack allocation using rcall or push. */
750 avr_gdbarch_tdep
*tdep
= gdbarch_tdep
<avr_gdbarch_tdep
> (gdbarch
);
751 while (scan_stage
== 1 && vpc
< len
)
753 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
754 if (insn
== 0xd000) /* rcall .+0 */
756 info
->size
+= tdep
->call_length
;
759 else if (insn
== 0x920f || insn
== 0x921f) /* push r0 or push r1 */
768 /* Second stage of the prologue scanning.
773 if (scan_stage
== 1 && vpc
< len
)
775 static const unsigned char img
[] = {
776 0xcd, 0xb7, /* in r28,__SP_L__ */
777 0xde, 0xb7 /* in r29,__SP_H__ */
780 if (vpc
+ sizeof (img
) < len
781 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
788 /* Third stage of the prologue scanning. (Really two stages).
790 sbiw r28,XX or subi r28,lo8(XX)
792 in __tmp_reg__,__SREG__
795 out __SREG__,__tmp_reg__
798 if (scan_stage
== 2 && vpc
< len
)
801 static const unsigned char img
[] = {
802 0x0f, 0xb6, /* in r0,0x3f */
803 0xf8, 0x94, /* cli */
804 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
805 0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
806 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
808 static const unsigned char img_sig
[] = {
809 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
810 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
812 static const unsigned char img_int
[] = {
813 0xf8, 0x94, /* cli */
814 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
815 0x78, 0x94, /* sei */
816 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
819 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
820 if ((insn
& 0xff30) == 0x9720) /* sbiw r28,XXX */
822 locals_size
= (insn
& 0xf) | ((insn
& 0xc0) >> 2);
825 else if ((insn
& 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
827 locals_size
= (insn
& 0xf) | ((insn
& 0xf00) >> 4);
829 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
831 locals_size
+= ((insn
& 0xf) | ((insn
& 0xf00) >> 4)) << 8;
836 /* Scan the last part of the prologue. May not be present for interrupt
837 or signal handler functions, which is why we set the prologue type
838 when we saw the beginning of the prologue previously. */
840 if (vpc
+ sizeof (img_sig
) < len
841 && memcmp (prologue
+ vpc
, img_sig
, sizeof (img_sig
)) == 0)
843 vpc
+= sizeof (img_sig
);
845 else if (vpc
+ sizeof (img_int
) < len
846 && memcmp (prologue
+ vpc
, img_int
, sizeof (img_int
)) == 0)
848 vpc
+= sizeof (img_int
);
850 if (vpc
+ sizeof (img
) < len
851 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
853 info
->prologue_type
= AVR_PROLOGUE_NORMAL
;
857 info
->size
+= locals_size
;
862 /* If we got this far, we could not scan the prologue, so just return the pc
863 of the frame plus an adjustment for argument move insns. */
865 for (; vpc
< len
; vpc
+= 2)
867 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
868 if ((insn
& 0xff00) == 0x0100) /* movw rXX, rYY */
870 else if ((insn
& 0xfc00) == 0x2c00) /* mov rXX, rYY */
880 avr_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
882 CORE_ADDR func_addr
, func_end
;
883 CORE_ADDR post_prologue_pc
;
885 /* See what the symbol table says */
887 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
890 post_prologue_pc
= skip_prologue_using_sal (gdbarch
, func_addr
);
891 if (post_prologue_pc
!= 0)
892 return std::max (pc
, post_prologue_pc
);
895 CORE_ADDR prologue_end
= pc
;
896 struct avr_unwind_cache info
= {0};
897 trad_frame_saved_reg saved_regs
[AVR_NUM_REGS
];
899 info
.saved_regs
= saved_regs
;
901 /* Need to run the prologue scanner to figure out if the function has a
902 prologue and possibly skip over moving arguments passed via registers
903 to other registers. */
905 prologue_end
= avr_scan_prologue (gdbarch
, func_addr
, func_end
, &info
);
907 if (info
.prologue_type
!= AVR_PROLOGUE_NONE
)
911 /* Either we didn't find the start of this function (nothing we can do),
912 or there's no line info, or the line after the prologue is after
913 the end of the function (there probably isn't a prologue). */
918 /* Not all avr devices support the BREAK insn. Those that don't should treat
919 it as a NOP. Thus, it should be ok. Since the avr is currently a remote
920 only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
922 constexpr gdb_byte avr_break_insn
[] = { 0x98, 0x95 };
924 typedef BP_MANIPULATION (avr_break_insn
) avr_breakpoint
;
926 /* Determine, for architecture GDBARCH, how a return value of TYPE
927 should be returned. If it is supposed to be returned in registers,
928 and READBUF is non-zero, read the appropriate value from REGCACHE,
929 and copy it into READBUF. If WRITEBUF is non-zero, write the value
930 from WRITEBUF into REGCACHE. */
932 static enum return_value_convention
933 avr_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
934 struct type
*valtype
, struct regcache
*regcache
,
935 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
938 /* Single byte are returned in r24.
939 Otherwise, the MSB of the return value is always in r25, calculate which
940 register holds the LSB. */
943 if ((valtype
->code () == TYPE_CODE_STRUCT
944 || valtype
->code () == TYPE_CODE_UNION
945 || valtype
->code () == TYPE_CODE_ARRAY
)
946 && valtype
->length () > 8)
947 return RETURN_VALUE_STRUCT_CONVENTION
;
949 if (valtype
->length () <= 2)
951 else if (valtype
->length () <= 4)
953 else if (valtype
->length () <= 8)
956 gdb_assert_not_reached ("unexpected type length");
958 if (writebuf
!= NULL
)
960 for (i
= 0; i
< valtype
->length (); i
++)
961 regcache
->cooked_write (lsb_reg
+ i
, writebuf
+ i
);
966 for (i
= 0; i
< valtype
->length (); i
++)
967 regcache
->cooked_read (lsb_reg
+ i
, readbuf
+ i
);
970 return RETURN_VALUE_REGISTER_CONVENTION
;
974 /* Put here the code to store, into fi->saved_regs, the addresses of
975 the saved registers of frame described by FRAME_INFO. This
976 includes special registers such as pc and fp saved in special ways
977 in the stack frame. sp is even more special: the address we return
978 for it IS the sp for the next frame. */
980 static struct avr_unwind_cache
*
981 avr_frame_unwind_cache (const frame_info_ptr
&this_frame
,
982 void **this_prologue_cache
)
984 CORE_ADDR start_pc
, current_pc
;
987 struct avr_unwind_cache
*info
;
988 struct gdbarch
*gdbarch
;
991 if (*this_prologue_cache
)
992 return (struct avr_unwind_cache
*) *this_prologue_cache
;
994 info
= FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache
);
995 *this_prologue_cache
= info
;
996 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
999 info
->prologue_type
= AVR_PROLOGUE_NONE
;
1001 start_pc
= get_frame_func (this_frame
);
1002 current_pc
= get_frame_pc (this_frame
);
1003 if ((start_pc
> 0) && (start_pc
<= current_pc
))
1004 avr_scan_prologue (get_frame_arch (this_frame
),
1005 start_pc
, current_pc
, info
);
1007 if ((info
->prologue_type
!= AVR_PROLOGUE_NONE
)
1008 && (info
->prologue_type
!= AVR_PROLOGUE_MAIN
))
1010 ULONGEST high_base
; /* High byte of FP */
1012 /* The SP was moved to the FP. This indicates that a new frame
1013 was created. Get THIS frame's FP value by unwinding it from
1015 this_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
);
1016 high_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
+ 1);
1017 this_base
+= (high_base
<< 8);
1019 /* The FP points at the last saved register. Adjust the FP back
1020 to before the first saved register giving the SP. */
1021 prev_sp
= this_base
+ info
->size
;
1025 /* Assume that the FP is this frame's SP but with that pushed
1026 stack space added back. */
1027 this_base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1028 prev_sp
= this_base
+ info
->size
;
1031 /* Add 1 here to adjust for the post-decrement nature of the push
1033 info
->prev_sp
= avr_make_saddr (prev_sp
+ 1);
1034 info
->base
= avr_make_saddr (this_base
);
1036 gdbarch
= get_frame_arch (this_frame
);
1038 /* Adjust all the saved registers so that they contain addresses and not
1040 for (i
= 0; i
< gdbarch_num_regs (gdbarch
) - 1; i
++)
1041 if (info
->saved_regs
[i
].is_addr ())
1042 info
->saved_regs
[i
].set_addr (info
->prev_sp
1043 - info
->saved_regs
[i
].addr ());
1045 /* Except for the main and startup code, the return PC is always saved on
1046 the stack and is at the base of the frame. */
1048 if (info
->prologue_type
!= AVR_PROLOGUE_MAIN
)
1049 info
->saved_regs
[AVR_PC_REGNUM
].set_addr (info
->prev_sp
);
1051 /* The previous frame's SP needed to be computed. Save the computed
1053 avr_gdbarch_tdep
*tdep
= gdbarch_tdep
<avr_gdbarch_tdep
> (gdbarch
);
1054 info
->saved_regs
[AVR_SP_REGNUM
].set_value (info
->prev_sp
1055 - 1 + tdep
->call_length
);
1061 avr_unwind_pc (struct gdbarch
*gdbarch
, const frame_info_ptr
&next_frame
)
1065 pc
= frame_unwind_register_unsigned (next_frame
, AVR_PC_REGNUM
);
1067 return avr_make_iaddr (pc
);
1071 avr_unwind_sp (struct gdbarch
*gdbarch
, const frame_info_ptr
&next_frame
)
1075 sp
= frame_unwind_register_unsigned (next_frame
, AVR_SP_REGNUM
);
1077 return avr_make_saddr (sp
);
1080 /* Given a GDB frame, determine the address of the calling function's
1081 frame. This will be used to create a new GDB frame struct. */
1084 avr_frame_this_id (const frame_info_ptr
&this_frame
,
1085 void **this_prologue_cache
,
1086 struct frame_id
*this_id
)
1088 struct avr_unwind_cache
*info
1089 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1094 /* The FUNC is easy. */
1095 func
= get_frame_func (this_frame
);
1097 /* Hopefully the prologue analysis either correctly determined the
1098 frame's base (which is the SP from the previous frame), or set
1099 that base to "NULL". */
1100 base
= info
->prev_sp
;
1104 id
= frame_id_build (base
, func
);
1108 static struct value
*
1109 avr_frame_prev_register (const frame_info_ptr
&this_frame
,
1110 void **this_prologue_cache
, int regnum
)
1112 struct avr_unwind_cache
*info
1113 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1115 if (regnum
== AVR_PC_REGNUM
|| regnum
== AVR_PSEUDO_PC_REGNUM
)
1117 if (info
->saved_regs
[AVR_PC_REGNUM
].is_addr ())
1119 /* Reading the return PC from the PC register is slightly
1120 abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
1121 but in reality, only two bytes (3 in upcoming mega256) are
1122 stored on the stack.
1124 Also, note that the value on the stack is an addr to a word
1125 not a byte, so we will need to multiply it by two at some
1128 And to confuse matters even more, the return address stored
1129 on the stack is in big endian byte order, even though most
1130 everything else about the avr is little endian. Ick! */
1134 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1135 avr_gdbarch_tdep
*tdep
= gdbarch_tdep
<avr_gdbarch_tdep
> (gdbarch
);
1137 read_memory (info
->saved_regs
[AVR_PC_REGNUM
].addr (),
1138 buf
, tdep
->call_length
);
1140 /* Extract the PC read from memory as a big-endian. */
1142 for (i
= 0; i
< tdep
->call_length
; i
++)
1143 pc
= (pc
<< 8) | buf
[i
];
1145 if (regnum
== AVR_PC_REGNUM
)
1148 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
1151 return frame_unwind_got_optimized (this_frame
, regnum
);
1154 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1157 static const struct frame_unwind avr_frame_unwind
= {
1160 default_frame_unwind_stop_reason
,
1162 avr_frame_prev_register
,
1164 default_frame_sniffer
1168 avr_frame_base_address (const frame_info_ptr
&this_frame
, void **this_cache
)
1170 struct avr_unwind_cache
*info
1171 = avr_frame_unwind_cache (this_frame
, this_cache
);
1176 static const struct frame_base avr_frame_base
= {
1178 avr_frame_base_address
,
1179 avr_frame_base_address
,
1180 avr_frame_base_address
1183 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1184 frame. The frame ID's base needs to match the TOS value saved by
1185 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1187 static struct frame_id
1188 avr_dummy_id (struct gdbarch
*gdbarch
, const frame_info_ptr
&this_frame
)
1192 base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1193 return frame_id_build (avr_make_saddr (base
), get_frame_pc (this_frame
));
1196 /* When arguments must be pushed onto the stack, they go on in reverse
1197 order. The below implements a FILO (stack) to do this. */
1199 struct avr_stack_item
1202 struct avr_stack_item
*prev
;
1206 static struct avr_stack_item
*
1207 push_stack_item (struct avr_stack_item
*prev
, const bfd_byte
*contents
,
1210 struct avr_stack_item
*si
;
1211 si
= XNEW (struct avr_stack_item
);
1212 si
->data
= (gdb_byte
*) xmalloc (len
);
1215 memcpy (si
->data
, contents
, len
);
1219 static struct avr_stack_item
*
1220 pop_stack_item (struct avr_stack_item
*si
)
1222 struct avr_stack_item
*dead
= si
;
1229 /* Setup the function arguments for calling a function in the inferior.
1231 On the AVR architecture, there are 18 registers (R25 to R8) which are
1232 dedicated for passing function arguments. Up to the first 18 arguments
1233 (depending on size) may go into these registers. The rest go on the stack.
1235 All arguments are aligned to start in even-numbered registers (odd-sized
1236 arguments, including char, have one free register above them). For example,
1237 an int in arg1 and a char in arg2 would be passed as such:
1242 Arguments that are larger than 2 bytes will be split between two or more
1243 registers as available, but will NOT be split between a register and the
1244 stack. Arguments that go onto the stack are pushed last arg first (this is
1245 similar to the d10v). */
1247 /* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1250 An exceptional case exists for struct arguments (and possibly other
1251 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1252 not a multiple of WORDSIZE bytes. In this case the argument is never split
1253 between the registers and the stack, but instead is copied in its entirety
1254 onto the stack, AND also copied into as many registers as there is room
1255 for. In other words, space in registers permitting, two copies of the same
1256 argument are passed in. As far as I can tell, only the one on the stack is
1257 used, although that may be a function of the level of compiler
1258 optimization. I suspect this is a compiler bug. Arguments of these odd
1259 sizes are left-justified within the word (as opposed to arguments smaller
1260 than WORDSIZE bytes, which are right-justified).
1262 If the function is to return an aggregate type such as a struct, the caller
1263 must allocate space into which the callee will copy the return value. In
1264 this case, a pointer to the return value location is passed into the callee
1265 in register R0, which displaces one of the other arguments passed in via
1266 registers R0 to R2. */
1269 avr_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1270 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1271 int nargs
, struct value
**args
, CORE_ADDR sp
,
1272 function_call_return_method return_method
,
1273 CORE_ADDR struct_addr
)
1277 avr_gdbarch_tdep
*tdep
= gdbarch_tdep
<avr_gdbarch_tdep
> (gdbarch
);
1278 int call_length
= tdep
->call_length
;
1279 CORE_ADDR return_pc
= avr_convert_iaddr_to_raw (bp_addr
);
1280 int regnum
= AVR_ARGN_REGNUM
;
1281 struct avr_stack_item
*si
= NULL
;
1283 if (return_method
== return_method_struct
)
1285 regcache_cooked_write_unsigned
1286 (regcache
, regnum
--, (struct_addr
>> 8) & 0xff);
1287 regcache_cooked_write_unsigned
1288 (regcache
, regnum
--, struct_addr
& 0xff);
1289 /* SP being post decremented, we need to reserve one byte so that the
1290 return address won't overwrite the result (or vice-versa). */
1291 if (sp
== struct_addr
)
1295 for (i
= 0; i
< nargs
; i
++)
1299 struct value
*arg
= args
[i
];
1300 struct type
*type
= check_typedef (arg
->type ());
1301 const bfd_byte
*contents
= arg
->contents ().data ();
1302 int len
= type
->length ();
1304 /* Calculate the potential last register needed.
1305 E.g. For length 2, registers regnum and regnum-1 (say 25 and 24)
1306 shall be used. So, last needed register will be regnum-1(24). */
1307 last_regnum
= regnum
- (len
+ (len
& 1)) + 1;
1309 /* If there are registers available, use them. Once we start putting
1310 stuff on the stack, all subsequent args go on stack. */
1311 if ((si
== NULL
) && (last_regnum
>= AVR_LAST_ARG_REGNUM
))
1313 /* Skip a register for odd length args. */
1317 /* Write MSB of argument into register and subsequent bytes in
1318 decreasing register numbers. */
1319 for (j
= 0; j
< len
; j
++)
1320 regcache_cooked_write_unsigned
1321 (regcache
, regnum
--, contents
[len
- j
- 1]);
1323 /* No registers available, push the args onto the stack. */
1326 /* From here on, we don't care about regnum. */
1327 si
= push_stack_item (si
, contents
, len
);
1331 /* Push args onto the stack. */
1335 /* Add 1 to sp here to account for post decr nature of pushes. */
1336 write_memory (sp
+ 1, si
->data
, si
->len
);
1337 si
= pop_stack_item (si
);
1340 /* Set the return address. For the avr, the return address is the BP_ADDR.
1341 Need to push the return address onto the stack noting that it needs to be
1342 in big-endian order on the stack. */
1343 for (i
= 1; i
<= call_length
; i
++)
1345 buf
[call_length
- i
] = return_pc
& 0xff;
1350 /* Use 'sp + 1' since pushes are post decr ops. */
1351 write_memory (sp
+ 1, buf
, call_length
);
1353 /* Finally, update the SP register. */
1354 regcache_cooked_write_unsigned (regcache
, AVR_SP_REGNUM
,
1355 avr_convert_saddr_to_raw (sp
));
1357 /* Return SP value for the dummy frame, where the return address hasn't been
1359 return sp
+ call_length
;
1362 /* Unfortunately dwarf2 register for SP is 32. */
1365 avr_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1367 if (reg
>= 0 && reg
< 32)
1370 return AVR_SP_REGNUM
;
1374 /* Implementation of `address_class_type_flags' gdbarch method.
1376 This method maps DW_AT_address_class attributes to a
1377 type_instance_flag_value. */
1379 static type_instance_flags
1380 avr_address_class_type_flags (int byte_size
, int dwarf2_addr_class
)
1382 /* The value 1 of the DW_AT_address_class attribute corresponds to the
1383 __flash qualifier. Note that this attribute is only valid with
1384 pointer types and therefore the flag is set to the pointer type and
1385 not its target type. */
1386 if (dwarf2_addr_class
== 1 && byte_size
== 2)
1387 return AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH
;
1391 /* Implementation of `address_class_type_flags_to_name' gdbarch method.
1393 Convert a type_instance_flag_value to an address space qualifier. */
1396 avr_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
1397 type_instance_flags type_flags
)
1399 if (type_flags
& AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH
)
1405 /* Implementation of `address_class_name_to_type_flags' gdbarch method.
1407 Convert an address space qualifier to a type_instance_flag_value. */
1410 avr_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
1412 type_instance_flags
*type_flags_ptr
)
1414 if (strcmp (name
, "flash") == 0)
1416 *type_flags_ptr
= AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH
;
1423 /* Initialize the gdbarch structure for the AVR's. */
1425 static struct gdbarch
*
1426 avr_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1428 struct gdbarch_list
*best_arch
;
1431 /* Avr-6 call instructions save 3 bytes. */
1432 switch (info
.bfd_arch_info
->mach
)
1435 case bfd_mach_avrxmega1
:
1437 case bfd_mach_avrxmega2
:
1439 case bfd_mach_avrxmega3
:
1441 case bfd_mach_avrxmega4
:
1443 case bfd_mach_avrxmega5
:
1448 case bfd_mach_avrxmega6
:
1449 case bfd_mach_avrxmega7
:
1454 /* If there is already a candidate, use it. */
1455 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1457 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1459 avr_gdbarch_tdep
*tdep
1460 = gdbarch_tdep
<avr_gdbarch_tdep
> (best_arch
->gdbarch
);
1462 if (tdep
->call_length
== call_length
)
1463 return best_arch
->gdbarch
;
1466 /* None found, create a new architecture from the information provided. */
1468 = gdbarch_alloc (&info
, gdbarch_tdep_up (new avr_gdbarch_tdep
));
1469 avr_gdbarch_tdep
*tdep
= gdbarch_tdep
<avr_gdbarch_tdep
> (gdbarch
);
1471 tdep
->call_length
= call_length
;
1473 /* Create a type for PC. We can't use builtin types here, as they may not
1475 type_allocator
alloc (gdbarch
);
1476 tdep
->void_type
= alloc
.new_type (TYPE_CODE_VOID
, TARGET_CHAR_BIT
, "void");
1477 tdep
->func_void_type
= make_function_type (tdep
->void_type
, NULL
);
1478 tdep
->pc_type
= init_pointer_type (alloc
, 4 * TARGET_CHAR_BIT
, NULL
,
1479 tdep
->func_void_type
);
1481 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1482 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1483 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1484 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1485 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1486 set_gdbarch_addr_bit (gdbarch
, 32);
1488 set_gdbarch_wchar_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1489 set_gdbarch_wchar_signed (gdbarch
, 1);
1491 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1492 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1493 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1495 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1496 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1497 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1499 set_gdbarch_read_pc (gdbarch
, avr_read_pc
);
1500 set_gdbarch_write_pc (gdbarch
, avr_write_pc
);
1502 set_gdbarch_num_regs (gdbarch
, AVR_NUM_REGS
);
1504 set_gdbarch_sp_regnum (gdbarch
, AVR_SP_REGNUM
);
1505 set_gdbarch_pc_regnum (gdbarch
, AVR_PC_REGNUM
);
1507 set_gdbarch_register_name (gdbarch
, avr_register_name
);
1508 set_gdbarch_register_type (gdbarch
, avr_register_type
);
1510 set_gdbarch_num_pseudo_regs (gdbarch
, AVR_NUM_PSEUDO_REGS
);
1511 set_gdbarch_pseudo_register_read (gdbarch
, avr_pseudo_register_read
);
1512 set_gdbarch_deprecated_pseudo_register_write (gdbarch
,
1513 avr_pseudo_register_write
);
1515 set_gdbarch_return_value (gdbarch
, avr_return_value
);
1517 set_gdbarch_push_dummy_call (gdbarch
, avr_push_dummy_call
);
1519 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, avr_dwarf_reg_to_regnum
);
1521 set_gdbarch_address_to_pointer (gdbarch
, avr_address_to_pointer
);
1522 set_gdbarch_pointer_to_address (gdbarch
, avr_pointer_to_address
);
1523 set_gdbarch_integer_to_address (gdbarch
, avr_integer_to_address
);
1525 set_gdbarch_skip_prologue (gdbarch
, avr_skip_prologue
);
1526 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
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
);
1531 frame_unwind_append_unwinder (gdbarch
, &avr_frame_unwind
);
1532 frame_base_set_default (gdbarch
, &avr_frame_base
);
1534 set_gdbarch_dummy_id (gdbarch
, avr_dummy_id
);
1536 set_gdbarch_unwind_pc (gdbarch
, avr_unwind_pc
);
1537 set_gdbarch_unwind_sp (gdbarch
, avr_unwind_sp
);
1539 set_gdbarch_address_class_type_flags (gdbarch
, avr_address_class_type_flags
);
1540 set_gdbarch_address_class_name_to_type_flags
1541 (gdbarch
, avr_address_class_name_to_type_flags
);
1542 set_gdbarch_address_class_type_flags_to_name
1543 (gdbarch
, avr_address_class_type_flags_to_name
);
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:
1553 "Ravr.io_reg" -> reply is "NN" number of io registers
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.
1559 All io registers are 8-bit. */
1562 avr_io_reg_read_command (const char *args
, int from_tty
)
1565 unsigned int nreg
= 0;
1568 /* Find out how many io registers the target has. */
1569 std::optional
<gdb::byte_vector
> buf
1570 = target_read_alloc (current_inferior ()->top_target (),
1571 TARGET_OBJECT_AVR
, "avr.io_reg");
1575 gdb_printf (gdb_stderr
,
1576 _("ERR: info io_registers NOT supported "
1577 "by current target\n"));
1581 const char *bufstr
= (const char *) buf
->data ();
1583 if (sscanf (bufstr
, "%x", &nreg
) != 1)
1585 gdb_printf (gdb_stderr
,
1586 _("Error fetching number of io registers\n"));
1590 gdb_printf (_("Target has %u io registers:\n\n"), nreg
);
1592 /* only fetch up to 8 registers at a time to keep the buffer small */
1595 for (int i
= 0; i
< nreg
; i
+= step
)
1597 /* how many registers this round? */
1600 j
= nreg
- i
; /* last block is less than 8 registers */
1602 snprintf (query
, sizeof (query
) - 1, "avr.io_reg:%x,%x", i
, j
);
1603 buf
= target_read_alloc (current_inferior ()->top_target (),
1604 TARGET_OBJECT_AVR
, query
);
1608 gdb_printf (gdb_stderr
,
1609 _("ERR: error reading avr.io_reg:%x,%x\n"),
1614 const char *p
= (const char *) buf
->data ();
1615 for (int k
= i
; k
< (i
+ j
); k
++)
1617 if (sscanf (p
, "%[^,],%x;", query
, &val
) == 2)
1619 gdb_printf ("[%02x] %-15s : %02x\n", k
, query
, val
);
1620 while ((*p
!= ';') && (*p
!= '\0'))
1622 p
++; /* skip over ';' */
1630 void _initialize_avr_tdep ();
1632 _initialize_avr_tdep ()
1634 gdbarch_register (bfd_arch_avr
, avr_gdbarch_init
);
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
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. */
1643 add_info ("io_registers", avr_io_reg_read_command
,
1644 _("Query remote AVR target for I/O space register values."));