1 /* Target-dependent code for Atmel AVR, for GDB.
3 Copyright (C) 1996-2012 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 */
27 #include "frame-unwind.h"
28 #include "frame-base.h"
29 #include "trad-frame.h"
35 #include "arch-utils.h"
37 #include "gdb_string.h"
42 (AVR micros are pure Harvard Architecture processors.)
44 The AVR family of microcontrollers have three distinctly different memory
45 spaces: flash, sram and eeprom. The flash is 16 bits wide and is used for
46 the most part to store program instructions. The sram is 8 bits wide and is
47 used for the stack and the heap. Some devices lack sram and some can have
48 an additional external sram added on as a peripheral.
50 The eeprom is 8 bits wide and is used to store data when the device is
51 powered down. Eeprom is not directly accessible, it can only be accessed
52 via io-registers using a special algorithm. Accessing eeprom via gdb's
53 remote serial protocol ('m' or 'M' packets) looks difficult to do and is
54 not included at this time.
56 [The eeprom could be read manually via ``x/b <eaddr + AVR_EMEM_START>'' or
57 written using ``set {unsigned char}<eaddr + AVR_EMEM_START>''. For this to
58 work, the remote target must be able to handle eeprom accesses and perform
59 the address translation.]
61 All three memory spaces have physical addresses beginning at 0x0. In
62 addition, the flash is addressed by gcc/binutils/gdb with respect to 8 bit
63 bytes instead of the 16 bit wide words used by the real device for the
66 In order for remote targets to work correctly, extra bits must be added to
67 addresses before they are send to the target or received from the target
68 via the remote serial protocol. The extra bits are the MSBs and are used to
69 decode which memory space the address is referring to. */
72 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
74 /* Constants: prefixed with AVR_ to avoid name space clashes */
88 AVR_NUM_REGS
= 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
89 AVR_NUM_REG_BYTES
= 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
91 /* Pseudo registers. */
92 AVR_PSEUDO_PC_REGNUM
= 35,
93 AVR_NUM_PSEUDO_REGS
= 1,
95 AVR_PC_REG_INDEX
= 35, /* index into array of registers */
97 AVR_MAX_PROLOGUE_SIZE
= 64, /* bytes */
99 /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
102 /* Number of the last pushed register. r17 for current avr-gcc */
103 AVR_LAST_PUSHED_REGNUM
= 17,
105 AVR_ARG1_REGNUM
= 24, /* Single byte argument */
106 AVR_ARGN_REGNUM
= 25, /* Multi byte argments */
108 AVR_RET1_REGNUM
= 24, /* Single byte return value */
109 AVR_RETN_REGNUM
= 25, /* Multi byte return value */
111 /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
112 bits? Do these have to match the bfd vma values? It sure would make
113 things easier in the future if they didn't need to match.
115 Note: I chose these values so as to be consistent with bfd vma
118 TRoth/2002-04-08: There is already a conflict with very large programs
119 in the mega128. The mega128 has 128K instruction bytes (64K words),
120 thus the Most Significant Bit is 0x10000 which gets masked off my
123 The problem manifests itself when trying to set a breakpoint in a
124 function which resides in the upper half of the instruction space and
125 thus requires a 17-bit address.
127 For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
128 from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
129 but could be for some remote targets by just adding the correct offset
130 to the address and letting the remote target handle the low-level
131 details of actually accessing the eeprom. */
133 AVR_IMEM_START
= 0x00000000, /* INSN memory */
134 AVR_SMEM_START
= 0x00800000, /* SRAM memory */
136 /* No eeprom mask defined */
137 AVR_MEM_MASK
= 0x00f00000, /* mask to determine memory space */
139 AVR_EMEM_START
= 0x00810000, /* EEPROM memory */
140 AVR_MEM_MASK
= 0x00ff0000, /* mask to determine memory space */
146 NORMAL and CALL are the typical types (the -mcall-prologues gcc option
147 causes the generation of the CALL type prologues). */
150 AVR_PROLOGUE_NONE
, /* No prologue */
152 AVR_PROLOGUE_CALL
, /* -mcall-prologues */
154 AVR_PROLOGUE_INTR
, /* interrupt handler */
155 AVR_PROLOGUE_SIG
, /* signal handler */
158 /* Any function with a frame looks like this
159 ....... <-SP POINTS HERE
160 LOCALS1 <-FP POINTS HERE
169 struct avr_unwind_cache
171 /* The previous frame's inner most stack address. Used as this
172 frame ID's stack_addr. */
174 /* The frame's base, optionally used by the high-level debug info. */
178 /* Table indicating the location of each and every register. */
179 struct trad_frame_saved_reg
*saved_regs
;
184 /* Number of bytes stored to the stack by call instructions.
185 2 bytes for avr1-5, 3 bytes for avr6. */
189 struct type
*void_type
;
190 /* Type for a function returning void. */
191 struct type
*func_void_type
;
192 /* Type for a pointer to a function. Used for the type of PC. */
193 struct type
*pc_type
;
196 /* Lookup the name of a register given it's number. */
199 avr_register_name (struct gdbarch
*gdbarch
, int regnum
)
201 static const char * const register_names
[] = {
202 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
203 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
204 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
205 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
211 if (regnum
>= (sizeof (register_names
) / sizeof (*register_names
)))
213 return register_names
[regnum
];
216 /* Return the GDB type object for the "standard" data type
217 of data in register N. */
220 avr_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
222 if (reg_nr
== AVR_PC_REGNUM
)
223 return builtin_type (gdbarch
)->builtin_uint32
;
224 if (reg_nr
== AVR_PSEUDO_PC_REGNUM
)
225 return gdbarch_tdep (gdbarch
)->pc_type
;
226 if (reg_nr
== AVR_SP_REGNUM
)
227 return builtin_type (gdbarch
)->builtin_data_ptr
;
228 return builtin_type (gdbarch
)->builtin_uint8
;
231 /* Instruction address checks and convertions. */
234 avr_make_iaddr (CORE_ADDR x
)
236 return ((x
) | AVR_IMEM_START
);
239 /* FIXME: TRoth: Really need to use a larger mask for instructions. Some
240 devices are already up to 128KBytes of flash space.
242 TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined. */
245 avr_convert_iaddr_to_raw (CORE_ADDR x
)
247 return ((x
) & 0xffffffff);
250 /* SRAM address checks and convertions. */
253 avr_make_saddr (CORE_ADDR x
)
255 /* Return 0 for NULL. */
259 return ((x
) | AVR_SMEM_START
);
263 avr_convert_saddr_to_raw (CORE_ADDR x
)
265 return ((x
) & 0xffffffff);
268 /* EEPROM address checks and convertions. I don't know if these will ever
269 actually be used, but I've added them just the same. TRoth */
271 /* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
272 programs in the mega128. */
274 /* static CORE_ADDR */
275 /* avr_make_eaddr (CORE_ADDR x) */
277 /* return ((x) | AVR_EMEM_START); */
281 /* avr_eaddr_p (CORE_ADDR x) */
283 /* return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
286 /* static CORE_ADDR */
287 /* avr_convert_eaddr_to_raw (CORE_ADDR x) */
289 /* return ((x) & 0xffffffff); */
292 /* Convert from address to pointer and vice-versa. */
295 avr_address_to_pointer (struct gdbarch
*gdbarch
,
296 struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
298 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
300 /* Is it a code address? */
301 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
302 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
)
304 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
,
305 avr_convert_iaddr_to_raw (addr
>> 1));
309 /* Strip off any upper segment bits. */
310 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
,
311 avr_convert_saddr_to_raw (addr
));
316 avr_pointer_to_address (struct gdbarch
*gdbarch
,
317 struct type
*type
, const gdb_byte
*buf
)
319 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
321 = extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
323 /* Is it a code address? */
324 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
325 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
326 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type
)))
327 return avr_make_iaddr (addr
<< 1);
329 return avr_make_saddr (addr
);
333 avr_integer_to_address (struct gdbarch
*gdbarch
,
334 struct type
*type
, const gdb_byte
*buf
)
336 ULONGEST addr
= unpack_long (type
, buf
);
338 return avr_make_saddr (addr
);
342 avr_read_pc (struct regcache
*regcache
)
345 regcache_cooked_read_unsigned (regcache
, AVR_PC_REGNUM
, &pc
);
346 return avr_make_iaddr (pc
);
350 avr_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
352 regcache_cooked_write_unsigned (regcache
, AVR_PC_REGNUM
,
353 avr_convert_iaddr_to_raw (val
));
356 static enum register_status
357 avr_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
358 int regnum
, gdb_byte
*buf
)
361 enum register_status status
;
365 case AVR_PSEUDO_PC_REGNUM
:
366 status
= regcache_raw_read_unsigned (regcache
, AVR_PC_REGNUM
, &val
);
367 if (status
!= REG_VALID
)
370 store_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
), val
);
373 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
378 avr_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
379 int regnum
, const gdb_byte
*buf
)
385 case AVR_PSEUDO_PC_REGNUM
:
386 val
= extract_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
));
388 regcache_raw_write_unsigned (regcache
, AVR_PC_REGNUM
, val
);
391 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
395 /* Function: avr_scan_prologue
397 This function decodes an AVR function prologue to determine:
398 1) the size of the stack frame
399 2) which registers are saved on it
400 3) the offsets of saved regs
401 This information is stored in the avr_unwind_cache structure.
403 Some devices lack the sbiw instruction, so on those replace this:
409 A typical AVR function prologue with a frame pointer might look like this:
410 push rXX ; saved regs
416 sbiw r28,<LOCALS_SIZE>
417 in __tmp_reg__,__SREG__
420 out __SREG__,__tmp_reg__
423 A typical AVR function prologue without a frame pointer might look like
425 push rXX ; saved regs
428 A main function prologue looks like this:
429 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
430 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
434 A signal handler prologue looks like this:
437 in __tmp_reg__, __SREG__
440 push rXX ; save registers r18:r27, r30:r31
442 push r28 ; save frame pointer
446 sbiw r28, <LOCALS_SIZE>
450 A interrupt handler prologue looks like this:
454 in __tmp_reg__, __SREG__
457 push rXX ; save registers r18:r27, r30:r31
459 push r28 ; save frame pointer
463 sbiw r28, <LOCALS_SIZE>
469 A `-mcall-prologues' prologue looks like this (Note that the megas use a
470 jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
471 32 bit insn and rjmp is a 16 bit insn):
472 ldi r26,lo8(<LOCALS_SIZE>)
473 ldi r27,hi8(<LOCALS_SIZE>)
474 ldi r30,pm_lo8(.L_foo_body)
475 ldi r31,pm_hi8(.L_foo_body)
476 rjmp __prologue_saves__+RRR
479 /* Not really part of a prologue, but still need to scan for it, is when a
480 function prologue moves values passed via registers as arguments to new
481 registers. In this case, all local variables live in registers, so there
482 may be some register saves. This is what it looks like:
486 There could be multiple movw's. If the target doesn't have a movw insn, it
487 will use two mov insns. This could be done after any of the above prologue
491 avr_scan_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc_beg
, CORE_ADDR pc_end
,
492 struct avr_unwind_cache
*info
)
494 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
498 struct minimal_symbol
*msymbol
;
499 unsigned char prologue
[AVR_MAX_PROLOGUE_SIZE
];
503 len
= pc_end
- pc_beg
;
504 if (len
> AVR_MAX_PROLOGUE_SIZE
)
505 len
= AVR_MAX_PROLOGUE_SIZE
;
507 /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
508 reading in the bytes of the prologue. The problem is that the figuring
509 out where the end of the prologue is is a bit difficult. The old code
510 tried to do that, but failed quite often. */
511 read_memory (pc_beg
, prologue
, len
);
513 /* Scanning main()'s prologue
514 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
515 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
522 static const unsigned char img
[] = {
523 0xde, 0xbf, /* out __SP_H__,r29 */
524 0xcd, 0xbf /* out __SP_L__,r28 */
527 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
528 /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
529 if ((insn
& 0xf0f0) == 0xe0c0)
531 locals
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
532 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
533 /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
534 if ((insn
& 0xf0f0) == 0xe0d0)
536 locals
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
537 if (vpc
+ 4 + sizeof (img
) < len
538 && memcmp (prologue
+ vpc
+ 4, img
, sizeof (img
)) == 0)
540 info
->prologue_type
= AVR_PROLOGUE_MAIN
;
548 /* Scanning `-mcall-prologues' prologue
549 Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
551 while (1) /* Using a while to avoid many goto's */
558 /* At least the fifth instruction must have been executed to
559 modify frame shape. */
563 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
564 /* ldi r26,<LOCALS_SIZE> */
565 if ((insn
& 0xf0f0) != 0xe0a0)
567 loc_size
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
570 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
571 /* ldi r27,<LOCALS_SIZE> / 256 */
572 if ((insn
& 0xf0f0) != 0xe0b0)
574 loc_size
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
577 insn
= extract_unsigned_integer (&prologue
[vpc
+ 4], 2, byte_order
);
578 /* ldi r30,pm_lo8(.L_foo_body) */
579 if ((insn
& 0xf0f0) != 0xe0e0)
581 body_addr
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
584 insn
= extract_unsigned_integer (&prologue
[vpc
+ 6], 2, byte_order
);
585 /* ldi r31,pm_hi8(.L_foo_body) */
586 if ((insn
& 0xf0f0) != 0xe0f0)
588 body_addr
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
591 msymbol
= lookup_minimal_symbol ("__prologue_saves__", NULL
, NULL
);
595 insn
= extract_unsigned_integer (&prologue
[vpc
+ 8], 2, byte_order
);
596 /* rjmp __prologue_saves__+RRR */
597 if ((insn
& 0xf000) == 0xc000)
599 /* Extract PC relative offset from RJMP */
600 i
= (insn
& 0xfff) | (insn
& 0x800 ? (-1 ^ 0xfff) : 0);
601 /* Convert offset to byte addressable mode */
603 /* Destination address */
606 if (body_addr
!= (pc_beg
+ 10)/2)
611 else if ((insn
& 0xfe0e) == 0x940c)
613 /* Extract absolute PC address from JMP */
614 i
= (((insn
& 0x1) | ((insn
& 0x1f0) >> 3) << 16)
615 | (extract_unsigned_integer (&prologue
[vpc
+ 10], 2, byte_order
)
617 /* Convert address to byte addressable mode */
620 if (body_addr
!= (pc_beg
+ 12)/2)
628 /* Resolve offset (in words) from __prologue_saves__ symbol.
629 Which is a pushes count in `-mcall-prologues' mode */
630 num_pushes
= AVR_MAX_PUSHES
- (i
- SYMBOL_VALUE_ADDRESS (msymbol
)) / 2;
632 if (num_pushes
> AVR_MAX_PUSHES
)
634 fprintf_unfiltered (gdb_stderr
, _("Num pushes too large: %d\n"),
643 info
->saved_regs
[AVR_FP_REGNUM
+ 1].addr
= num_pushes
;
645 info
->saved_regs
[AVR_FP_REGNUM
].addr
= num_pushes
- 1;
648 for (from
= AVR_LAST_PUSHED_REGNUM
+ 1 - (num_pushes
- 2);
649 from
<= AVR_LAST_PUSHED_REGNUM
; ++from
)
650 info
->saved_regs
[from
].addr
= ++i
;
652 info
->size
= loc_size
+ num_pushes
;
653 info
->prologue_type
= AVR_PROLOGUE_CALL
;
655 return pc_beg
+ pc_offset
;
658 /* Scan for the beginning of the prologue for an interrupt or signal
659 function. Note that we have to set the prologue type here since the
660 third stage of the prologue may not be present (e.g. no saved registered
661 or changing of the SP register). */
665 static const unsigned char img
[] = {
666 0x78, 0x94, /* sei */
667 0x1f, 0x92, /* push r1 */
668 0x0f, 0x92, /* push r0 */
669 0x0f, 0xb6, /* in r0,0x3f SREG */
670 0x0f, 0x92, /* push r0 */
671 0x11, 0x24 /* clr r1 */
673 if (len
>= sizeof (img
)
674 && memcmp (prologue
, img
, sizeof (img
)) == 0)
676 info
->prologue_type
= AVR_PROLOGUE_INTR
;
678 info
->saved_regs
[AVR_SREG_REGNUM
].addr
= 3;
679 info
->saved_regs
[0].addr
= 2;
680 info
->saved_regs
[1].addr
= 1;
683 else if (len
>= sizeof (img
) - 2
684 && memcmp (img
+ 2, prologue
, sizeof (img
) - 2) == 0)
686 info
->prologue_type
= AVR_PROLOGUE_SIG
;
687 vpc
+= sizeof (img
) - 2;
688 info
->saved_regs
[AVR_SREG_REGNUM
].addr
= 3;
689 info
->saved_regs
[0].addr
= 2;
690 info
->saved_regs
[1].addr
= 1;
695 /* First stage of the prologue scanning.
696 Scan pushes (saved registers) */
698 for (; vpc
< len
; vpc
+= 2)
700 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
701 if ((insn
& 0xfe0f) == 0x920f) /* push rXX */
703 /* Bits 4-9 contain a mask for registers R0-R32. */
704 int regno
= (insn
& 0x1f0) >> 4;
706 info
->saved_regs
[regno
].addr
= info
->size
;
713 gdb_assert (vpc
< AVR_MAX_PROLOGUE_SIZE
);
715 /* Handle static small stack allocation using rcall or push. */
717 while (scan_stage
== 1 && vpc
< len
)
719 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
720 if (insn
== 0xd000) /* rcall .+0 */
722 info
->size
+= gdbarch_tdep (gdbarch
)->call_length
;
725 else if (insn
== 0x920f) /* push r0 */
734 /* Second stage of the prologue scanning.
739 if (scan_stage
== 1 && vpc
< len
)
741 static const unsigned char img
[] = {
742 0xcd, 0xb7, /* in r28,__SP_L__ */
743 0xde, 0xb7 /* in r29,__SP_H__ */
745 unsigned short insn1
;
747 if (vpc
+ sizeof (img
) < len
748 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
755 /* Third stage of the prologue scanning. (Really two stages).
757 sbiw r28,XX or subi r28,lo8(XX)
759 in __tmp_reg__,__SREG__
762 out __SREG__,__tmp_reg__
765 if (scan_stage
== 2 && vpc
< len
)
768 static const unsigned char img
[] = {
769 0x0f, 0xb6, /* in r0,0x3f */
770 0xf8, 0x94, /* cli */
771 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
772 0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
773 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
775 static const unsigned char img_sig
[] = {
776 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
777 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
779 static const unsigned char img_int
[] = {
780 0xf8, 0x94, /* cli */
781 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
782 0x78, 0x94, /* sei */
783 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
786 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
787 if ((insn
& 0xff30) == 0x9720) /* sbiw r28,XXX */
789 locals_size
= (insn
& 0xf) | ((insn
& 0xc0) >> 2);
792 else if ((insn
& 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
794 locals_size
= (insn
& 0xf) | ((insn
& 0xf00) >> 4);
796 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
798 locals_size
+= ((insn
& 0xf) | ((insn
& 0xf00) >> 4)) << 8;
803 /* Scan the last part of the prologue. May not be present for interrupt
804 or signal handler functions, which is why we set the prologue type
805 when we saw the beginning of the prologue previously. */
807 if (vpc
+ sizeof (img_sig
) < len
808 && memcmp (prologue
+ vpc
, img_sig
, sizeof (img_sig
)) == 0)
810 vpc
+= sizeof (img_sig
);
812 else if (vpc
+ sizeof (img_int
) < len
813 && memcmp (prologue
+ vpc
, img_int
, sizeof (img_int
)) == 0)
815 vpc
+= sizeof (img_int
);
817 if (vpc
+ sizeof (img
) < len
818 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
820 info
->prologue_type
= AVR_PROLOGUE_NORMAL
;
824 info
->size
+= locals_size
;
829 /* If we got this far, we could not scan the prologue, so just return the pc
830 of the frame plus an adjustment for argument move insns. */
832 for (; vpc
< len
; vpc
+= 2)
834 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
835 if ((insn
& 0xff00) == 0x0100) /* movw rXX, rYY */
837 else if ((insn
& 0xfc00) == 0x2c00) /* mov rXX, rYY */
847 avr_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
849 CORE_ADDR func_addr
, func_end
;
850 CORE_ADDR post_prologue_pc
;
852 /* See what the symbol table says */
854 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
857 post_prologue_pc
= skip_prologue_using_sal (gdbarch
, func_addr
);
858 if (post_prologue_pc
!= 0)
859 return max (pc
, post_prologue_pc
);
862 CORE_ADDR prologue_end
= pc
;
863 struct avr_unwind_cache info
= {0};
864 struct trad_frame_saved_reg saved_regs
[AVR_NUM_REGS
];
866 info
.saved_regs
= saved_regs
;
868 /* Need to run the prologue scanner to figure out if the function has a
869 prologue and possibly skip over moving arguments passed via registers
870 to other registers. */
872 prologue_end
= avr_scan_prologue (gdbarch
, func_addr
, func_end
, &info
);
874 if (info
.prologue_type
!= AVR_PROLOGUE_NONE
)
878 /* Either we didn't find the start of this function (nothing we can do),
879 or there's no line info, or the line after the prologue is after
880 the end of the function (there probably isn't a prologue). */
885 /* Not all avr devices support the BREAK insn. Those that don't should treat
886 it as a NOP. Thus, it should be ok. Since the avr is currently a remote
887 only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
889 static const unsigned char *
890 avr_breakpoint_from_pc (struct gdbarch
*gdbarch
,
891 CORE_ADDR
*pcptr
, int *lenptr
)
893 static const unsigned char avr_break_insn
[] = { 0x98, 0x95 };
894 *lenptr
= sizeof (avr_break_insn
);
895 return avr_break_insn
;
898 /* Determine, for architecture GDBARCH, how a return value of TYPE
899 should be returned. If it is supposed to be returned in registers,
900 and READBUF is non-zero, read the appropriate value from REGCACHE,
901 and copy it into READBUF. If WRITEBUF is non-zero, write the value
902 from WRITEBUF into REGCACHE. */
904 static enum return_value_convention
905 avr_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
906 struct type
*valtype
, struct regcache
*regcache
,
907 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
910 /* Single byte are returned in r24.
911 Otherwise, the MSB of the return value is always in r25, calculate which
912 register holds the LSB. */
915 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
916 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
917 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
918 && TYPE_LENGTH (valtype
) > 8)
919 return RETURN_VALUE_STRUCT_CONVENTION
;
921 if (TYPE_LENGTH (valtype
) <= 2)
923 else if (TYPE_LENGTH (valtype
) <= 4)
925 else if (TYPE_LENGTH (valtype
) <= 8)
928 gdb_assert_not_reached ("unexpected type length");
930 if (writebuf
!= NULL
)
932 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
933 regcache_cooked_write (regcache
, lsb_reg
+ i
, writebuf
+ i
);
938 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
939 regcache_cooked_read (regcache
, lsb_reg
+ i
, readbuf
+ i
);
942 return RETURN_VALUE_REGISTER_CONVENTION
;
946 /* Put here the code to store, into fi->saved_regs, the addresses of
947 the saved registers of frame described by FRAME_INFO. This
948 includes special registers such as pc and fp saved in special ways
949 in the stack frame. sp is even more special: the address we return
950 for it IS the sp for the next frame. */
952 static struct avr_unwind_cache
*
953 avr_frame_unwind_cache (struct frame_info
*this_frame
,
954 void **this_prologue_cache
)
956 CORE_ADDR start_pc
, current_pc
;
959 struct avr_unwind_cache
*info
;
960 struct gdbarch
*gdbarch
;
961 struct gdbarch_tdep
*tdep
;
964 if (*this_prologue_cache
)
965 return *this_prologue_cache
;
967 info
= FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache
);
968 *this_prologue_cache
= info
;
969 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
972 info
->prologue_type
= AVR_PROLOGUE_NONE
;
974 start_pc
= get_frame_func (this_frame
);
975 current_pc
= get_frame_pc (this_frame
);
976 if ((start_pc
> 0) && (start_pc
<= current_pc
))
977 avr_scan_prologue (get_frame_arch (this_frame
),
978 start_pc
, current_pc
, info
);
980 if ((info
->prologue_type
!= AVR_PROLOGUE_NONE
)
981 && (info
->prologue_type
!= AVR_PROLOGUE_MAIN
))
983 ULONGEST high_base
; /* High byte of FP */
985 /* The SP was moved to the FP. This indicates that a new frame
986 was created. Get THIS frame's FP value by unwinding it from
988 this_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
);
989 high_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
+ 1);
990 this_base
+= (high_base
<< 8);
992 /* The FP points at the last saved register. Adjust the FP back
993 to before the first saved register giving the SP. */
994 prev_sp
= this_base
+ info
->size
;
998 /* Assume that the FP is this frame's SP but with that pushed
999 stack space added back. */
1000 this_base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1001 prev_sp
= this_base
+ info
->size
;
1004 /* Add 1 here to adjust for the post-decrement nature of the push
1006 info
->prev_sp
= avr_make_saddr (prev_sp
+ 1);
1007 info
->base
= avr_make_saddr (this_base
);
1009 gdbarch
= get_frame_arch (this_frame
);
1011 /* Adjust all the saved registers so that they contain addresses and not
1013 for (i
= 0; i
< gdbarch_num_regs (gdbarch
) - 1; i
++)
1014 if (info
->saved_regs
[i
].addr
> 0)
1015 info
->saved_regs
[i
].addr
= info
->prev_sp
- info
->saved_regs
[i
].addr
;
1017 /* Except for the main and startup code, the return PC is always saved on
1018 the stack and is at the base of the frame. */
1020 if (info
->prologue_type
!= AVR_PROLOGUE_MAIN
)
1021 info
->saved_regs
[AVR_PC_REGNUM
].addr
= info
->prev_sp
;
1023 /* The previous frame's SP needed to be computed. Save the computed
1025 tdep
= gdbarch_tdep (gdbarch
);
1026 trad_frame_set_value (info
->saved_regs
, AVR_SP_REGNUM
,
1027 info
->prev_sp
- 1 + tdep
->call_length
);
1033 avr_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1037 pc
= frame_unwind_register_unsigned (next_frame
, AVR_PC_REGNUM
);
1039 return avr_make_iaddr (pc
);
1043 avr_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1047 sp
= frame_unwind_register_unsigned (next_frame
, AVR_SP_REGNUM
);
1049 return avr_make_saddr (sp
);
1052 /* Given a GDB frame, determine the address of the calling function's
1053 frame. This will be used to create a new GDB frame struct. */
1056 avr_frame_this_id (struct frame_info
*this_frame
,
1057 void **this_prologue_cache
,
1058 struct frame_id
*this_id
)
1060 struct avr_unwind_cache
*info
1061 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1066 /* The FUNC is easy. */
1067 func
= get_frame_func (this_frame
);
1069 /* Hopefully the prologue analysis either correctly determined the
1070 frame's base (which is the SP from the previous frame), or set
1071 that base to "NULL". */
1072 base
= info
->prev_sp
;
1076 id
= frame_id_build (base
, func
);
1080 static struct value
*
1081 avr_frame_prev_register (struct frame_info
*this_frame
,
1082 void **this_prologue_cache
, int regnum
)
1084 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1085 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1086 struct avr_unwind_cache
*info
1087 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1089 if (regnum
== AVR_PC_REGNUM
|| regnum
== AVR_PSEUDO_PC_REGNUM
)
1091 if (trad_frame_addr_p (info
->saved_regs
, AVR_PC_REGNUM
))
1093 /* Reading the return PC from the PC register is slightly
1094 abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
1095 but in reality, only two bytes (3 in upcoming mega256) are
1096 stored on the stack.
1098 Also, note that the value on the stack is an addr to a word
1099 not a byte, so we will need to multiply it by two at some
1102 And to confuse matters even more, the return address stored
1103 on the stack is in big endian byte order, even though most
1104 everything else about the avr is little endian. Ick! */
1107 unsigned char buf
[3];
1108 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1109 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1111 read_memory (info
->saved_regs
[AVR_PC_REGNUM
].addr
,
1112 buf
, tdep
->call_length
);
1114 /* Extract the PC read from memory as a big-endian. */
1116 for (i
= 0; i
< tdep
->call_length
; i
++)
1117 pc
= (pc
<< 8) | buf
[i
];
1119 if (regnum
== AVR_PC_REGNUM
)
1122 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
1125 return frame_unwind_got_optimized (this_frame
, regnum
);
1128 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1131 static const struct frame_unwind avr_frame_unwind
= {
1133 default_frame_unwind_stop_reason
,
1135 avr_frame_prev_register
,
1137 default_frame_sniffer
1141 avr_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1143 struct avr_unwind_cache
*info
1144 = avr_frame_unwind_cache (this_frame
, this_cache
);
1149 static const struct frame_base avr_frame_base
= {
1151 avr_frame_base_address
,
1152 avr_frame_base_address
,
1153 avr_frame_base_address
1156 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1157 frame. The frame ID's base needs to match the TOS value saved by
1158 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1160 static struct frame_id
1161 avr_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1165 base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1166 return frame_id_build (avr_make_saddr (base
), get_frame_pc (this_frame
));
1169 /* When arguments must be pushed onto the stack, they go on in reverse
1170 order. The below implements a FILO (stack) to do this. */
1175 struct stack_item
*prev
;
1179 static struct stack_item
*
1180 push_stack_item (struct stack_item
*prev
, const bfd_byte
*contents
, int len
)
1182 struct stack_item
*si
;
1183 si
= xmalloc (sizeof (struct stack_item
));
1184 si
->data
= xmalloc (len
);
1187 memcpy (si
->data
, contents
, len
);
1191 static struct stack_item
*pop_stack_item (struct stack_item
*si
);
1192 static struct stack_item
*
1193 pop_stack_item (struct stack_item
*si
)
1195 struct stack_item
*dead
= si
;
1202 /* Setup the function arguments for calling a function in the inferior.
1204 On the AVR architecture, there are 18 registers (R25 to R8) which are
1205 dedicated for passing function arguments. Up to the first 18 arguments
1206 (depending on size) may go into these registers. The rest go on the stack.
1208 All arguments are aligned to start in even-numbered registers (odd-sized
1209 arguments, including char, have one free register above them). For example,
1210 an int in arg1 and a char in arg2 would be passed as such:
1215 Arguments that are larger than 2 bytes will be split between two or more
1216 registers as available, but will NOT be split between a register and the
1217 stack. Arguments that go onto the stack are pushed last arg first (this is
1218 similar to the d10v). */
1220 /* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1223 An exceptional case exists for struct arguments (and possibly other
1224 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1225 not a multiple of WORDSIZE bytes. In this case the argument is never split
1226 between the registers and the stack, but instead is copied in its entirety
1227 onto the stack, AND also copied into as many registers as there is room
1228 for. In other words, space in registers permitting, two copies of the same
1229 argument are passed in. As far as I can tell, only the one on the stack is
1230 used, although that may be a function of the level of compiler
1231 optimization. I suspect this is a compiler bug. Arguments of these odd
1232 sizes are left-justified within the word (as opposed to arguments smaller
1233 than WORDSIZE bytes, which are right-justified).
1235 If the function is to return an aggregate type such as a struct, the caller
1236 must allocate space into which the callee will copy the return value. In
1237 this case, a pointer to the return value location is passed into the callee
1238 in register R0, which displaces one of the other arguments passed in via
1239 registers R0 to R2. */
1242 avr_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1243 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1244 int nargs
, struct value
**args
, CORE_ADDR sp
,
1245 int struct_return
, CORE_ADDR struct_addr
)
1247 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1249 unsigned char buf
[3];
1250 int call_length
= gdbarch_tdep (gdbarch
)->call_length
;
1251 CORE_ADDR return_pc
= avr_convert_iaddr_to_raw (bp_addr
);
1252 int regnum
= AVR_ARGN_REGNUM
;
1253 struct stack_item
*si
= NULL
;
1257 regcache_cooked_write_unsigned
1258 (regcache
, regnum
--, (struct_addr
>> 8) & 0xff);
1259 regcache_cooked_write_unsigned
1260 (regcache
, regnum
--, struct_addr
& 0xff);
1261 /* SP being post decremented, we need to reserve one byte so that the
1262 return address won't overwrite the result (or vice-versa). */
1263 if (sp
== struct_addr
)
1267 for (i
= 0; i
< nargs
; i
++)
1271 struct value
*arg
= args
[i
];
1272 struct type
*type
= check_typedef (value_type (arg
));
1273 const bfd_byte
*contents
= value_contents (arg
);
1274 int len
= TYPE_LENGTH (type
);
1276 /* Calculate the potential last register needed. */
1277 last_regnum
= regnum
- (len
+ (len
& 1));
1279 /* If there are registers available, use them. Once we start putting
1280 stuff on the stack, all subsequent args go on stack. */
1281 if ((si
== NULL
) && (last_regnum
>= 8))
1285 /* Skip a register for odd length args. */
1289 val
= extract_unsigned_integer (contents
, len
, byte_order
);
1290 for (j
= 0; j
< len
; j
++)
1291 regcache_cooked_write_unsigned
1292 (regcache
, regnum
--, val
>> (8 * (len
- j
- 1)));
1294 /* No registers available, push the args onto the stack. */
1297 /* From here on, we don't care about regnum. */
1298 si
= push_stack_item (si
, contents
, len
);
1302 /* Push args onto the stack. */
1306 /* Add 1 to sp here to account for post decr nature of pushes. */
1307 write_memory (sp
+ 1, si
->data
, si
->len
);
1308 si
= pop_stack_item (si
);
1311 /* Set the return address. For the avr, the return address is the BP_ADDR.
1312 Need to push the return address onto the stack noting that it needs to be
1313 in big-endian order on the stack. */
1314 for (i
= 1; i
<= call_length
; i
++)
1316 buf
[call_length
- i
] = return_pc
& 0xff;
1321 /* Use 'sp + 1' since pushes are post decr ops. */
1322 write_memory (sp
+ 1, buf
, call_length
);
1324 /* Finally, update the SP register. */
1325 regcache_cooked_write_unsigned (regcache
, AVR_SP_REGNUM
,
1326 avr_convert_saddr_to_raw (sp
));
1328 /* Return SP value for the dummy frame, where the return address hasn't been
1330 return sp
+ call_length
;
1333 /* Unfortunately dwarf2 register for SP is 32. */
1336 avr_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1338 if (reg
>= 0 && reg
< 32)
1341 return AVR_SP_REGNUM
;
1343 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
1348 /* Initialize the gdbarch structure for the AVR's. */
1350 static struct gdbarch
*
1351 avr_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1353 struct gdbarch
*gdbarch
;
1354 struct gdbarch_tdep
*tdep
;
1355 struct gdbarch_list
*best_arch
;
1358 /* Avr-6 call instructions save 3 bytes. */
1359 switch (info
.bfd_arch_info
->mach
)
1374 /* If there is already a candidate, use it. */
1375 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1377 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1379 if (gdbarch_tdep (best_arch
->gdbarch
)->call_length
== call_length
)
1380 return best_arch
->gdbarch
;
1383 /* None found, create a new architecture from the information provided. */
1384 tdep
= XMALLOC (struct gdbarch_tdep
);
1385 gdbarch
= gdbarch_alloc (&info
, tdep
);
1387 tdep
->call_length
= call_length
;
1389 /* Create a type for PC. We can't use builtin types here, as they may not
1391 tdep
->void_type
= arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
1392 tdep
->func_void_type
= make_function_type (tdep
->void_type
, NULL
);
1393 tdep
->pc_type
= arch_type (gdbarch
, TYPE_CODE_PTR
, 4, NULL
);
1394 TYPE_TARGET_TYPE (tdep
->pc_type
) = tdep
->func_void_type
;
1395 TYPE_UNSIGNED (tdep
->pc_type
) = 1;
1397 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1398 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1399 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1400 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1401 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1402 set_gdbarch_addr_bit (gdbarch
, 32);
1404 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1405 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1406 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1408 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1409 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1410 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1412 set_gdbarch_read_pc (gdbarch
, avr_read_pc
);
1413 set_gdbarch_write_pc (gdbarch
, avr_write_pc
);
1415 set_gdbarch_num_regs (gdbarch
, AVR_NUM_REGS
);
1417 set_gdbarch_sp_regnum (gdbarch
, AVR_SP_REGNUM
);
1418 set_gdbarch_pc_regnum (gdbarch
, AVR_PC_REGNUM
);
1420 set_gdbarch_register_name (gdbarch
, avr_register_name
);
1421 set_gdbarch_register_type (gdbarch
, avr_register_type
);
1423 set_gdbarch_num_pseudo_regs (gdbarch
, AVR_NUM_PSEUDO_REGS
);
1424 set_gdbarch_pseudo_register_read (gdbarch
, avr_pseudo_register_read
);
1425 set_gdbarch_pseudo_register_write (gdbarch
, avr_pseudo_register_write
);
1427 set_gdbarch_return_value (gdbarch
, avr_return_value
);
1428 set_gdbarch_print_insn (gdbarch
, print_insn_avr
);
1430 set_gdbarch_push_dummy_call (gdbarch
, avr_push_dummy_call
);
1432 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, avr_dwarf_reg_to_regnum
);
1434 set_gdbarch_address_to_pointer (gdbarch
, avr_address_to_pointer
);
1435 set_gdbarch_pointer_to_address (gdbarch
, avr_pointer_to_address
);
1436 set_gdbarch_integer_to_address (gdbarch
, avr_integer_to_address
);
1438 set_gdbarch_skip_prologue (gdbarch
, avr_skip_prologue
);
1439 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1441 set_gdbarch_breakpoint_from_pc (gdbarch
, avr_breakpoint_from_pc
);
1443 frame_unwind_append_unwinder (gdbarch
, &avr_frame_unwind
);
1444 frame_base_set_default (gdbarch
, &avr_frame_base
);
1446 set_gdbarch_dummy_id (gdbarch
, avr_dummy_id
);
1448 set_gdbarch_unwind_pc (gdbarch
, avr_unwind_pc
);
1449 set_gdbarch_unwind_sp (gdbarch
, avr_unwind_sp
);
1454 /* Send a query request to the avr remote target asking for values of the io
1455 registers. If args parameter is not NULL, then the user has requested info
1456 on a specific io register [This still needs implemented and is ignored for
1457 now]. The query string should be one of these forms:
1459 "Ravr.io_reg" -> reply is "NN" number of io registers
1461 "Ravr.io_reg:addr,len" where addr is first register and len is number of
1462 registers to be read. The reply should be "<NAME>,VV;" for each io register
1463 where, <NAME> is a string, and VV is the hex value of the register.
1465 All io registers are 8-bit. */
1468 avr_io_reg_read_command (char *args
, int from_tty
)
1474 unsigned int nreg
= 0;
1478 /* Find out how many io registers the target has. */
1479 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1480 "avr.io_reg", &buf
);
1484 fprintf_unfiltered (gdb_stderr
,
1485 _("ERR: info io_registers NOT supported "
1486 "by current target\n"));
1490 if (sscanf (buf
, "%x", &nreg
) != 1)
1492 fprintf_unfiltered (gdb_stderr
,
1493 _("Error fetching number of io registers\n"));
1500 reinitialize_more_filter ();
1502 printf_unfiltered (_("Target has %u io registers:\n\n"), nreg
);
1504 /* only fetch up to 8 registers at a time to keep the buffer small */
1507 for (i
= 0; i
< nreg
; i
+= step
)
1509 /* how many registers this round? */
1512 j
= nreg
- i
; /* last block is less than 8 registers */
1514 snprintf (query
, sizeof (query
) - 1, "avr.io_reg:%x,%x", i
, j
);
1515 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1519 for (k
= i
; k
< (i
+ j
); k
++)
1521 if (sscanf (p
, "%[^,],%x;", query
, &val
) == 2)
1523 printf_filtered ("[%02x] %-15s : %02x\n", k
, query
, val
);
1524 while ((*p
!= ';') && (*p
!= '\0'))
1526 p
++; /* skip over ';' */
1536 extern initialize_file_ftype _initialize_avr_tdep
; /* -Wmissing-prototypes */
1539 _initialize_avr_tdep (void)
1541 register_gdbarch_init (bfd_arch_avr
, avr_gdbarch_init
);
1543 /* Add a new command to allow the user to query the avr remote target for
1544 the values of the io space registers in a saner way than just using
1547 /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1548 io_registers' to signify it is not available on other platforms. */
1550 add_cmd ("io_registers", class_info
, avr_io_reg_read_command
,
1551 _("query remote avr target for io space register values"),