1 /* Target-dependent code for Atmel AVR, for GDB.
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Contributed by Theodore A. Roth, troth@openavr.org */
23 /* Portions of this file were taken from the original gdb-4.18 patch developed
24 by Denis Chertykov, denisc@overta.ru */
28 #include "frame-unwind.h"
29 #include "frame-base.h"
30 #include "trad-frame.h"
36 #include "arch-utils.h"
38 #include "gdb_string.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. */
73 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
75 /* Constants: prefixed with AVR_ to avoid name space clashes */
89 AVR_NUM_REGS
= 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
90 AVR_NUM_REG_BYTES
= 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
92 /* Pseudo registers. */
93 AVR_PSEUDO_PC_REGNUM
= 35,
94 AVR_NUM_PSEUDO_REGS
= 1,
96 AVR_PC_REG_INDEX
= 35, /* index into array of registers */
98 AVR_MAX_PROLOGUE_SIZE
= 64, /* bytes */
100 /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
103 /* Number of the last pushed register. r17 for current avr-gcc */
104 AVR_LAST_PUSHED_REGNUM
= 17,
106 AVR_ARG1_REGNUM
= 24, /* Single byte argument */
107 AVR_ARGN_REGNUM
= 25, /* Multi byte argments */
109 AVR_RET1_REGNUM
= 24, /* Single byte return value */
110 AVR_RETN_REGNUM
= 25, /* Multi byte return value */
112 /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
113 bits? Do these have to match the bfd vma values?. It sure would make
114 things easier in the future if they didn't need to match.
116 Note: I chose these values so as to be consistent with bfd vma
119 TRoth/2002-04-08: There is already a conflict with very large programs
120 in the mega128. The mega128 has 128K instruction bytes (64K words),
121 thus the Most Significant Bit is 0x10000 which gets masked off my
124 The problem manifests itself when trying to set a breakpoint in a
125 function which resides in the upper half of the instruction space and
126 thus requires a 17-bit address.
128 For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
129 from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
130 but could be for some remote targets by just adding the correct offset
131 to the address and letting the remote target handle the low-level
132 details of actually accessing the eeprom. */
134 AVR_IMEM_START
= 0x00000000, /* INSN memory */
135 AVR_SMEM_START
= 0x00800000, /* SRAM memory */
137 /* No eeprom mask defined */
138 AVR_MEM_MASK
= 0x00f00000, /* mask to determine memory space */
140 AVR_EMEM_START
= 0x00810000, /* EEPROM memory */
141 AVR_MEM_MASK
= 0x00ff0000, /* mask to determine memory space */
147 NORMAL and CALL are the typical types (the -mcall-prologues gcc option
148 causes the generation of the CALL type prologues). */
151 AVR_PROLOGUE_NONE
, /* No prologue */
153 AVR_PROLOGUE_CALL
, /* -mcall-prologues */
155 AVR_PROLOGUE_INTR
, /* interrupt handler */
156 AVR_PROLOGUE_SIG
, /* signal handler */
159 /* Any function with a frame looks like this
160 ....... <-SP POINTS HERE
161 LOCALS1 <-FP POINTS HERE
170 struct avr_unwind_cache
172 /* The previous frame's inner most stack address. Used as this
173 frame ID's stack_addr. */
175 /* The frame's base, optionally used by the high-level debug info. */
179 /* Table indicating the location of each and every register. */
180 struct trad_frame_saved_reg
*saved_regs
;
185 /* Number of bytes stored to the stack by call instructions.
186 2 bytes for avr1-5, 3 bytes for avr6. */
190 struct type
*void_type
;
191 /* Type for a function returning void. */
192 struct type
*func_void_type
;
193 /* Type for a pointer to a function. Used for the type of PC. */
194 struct type
*pc_type
;
197 /* Lookup the name of a register given it's number. */
200 avr_register_name (struct gdbarch
*gdbarch
, int regnum
)
202 static const char * const register_names
[] = {
203 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
204 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
205 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
206 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
212 if (regnum
>= (sizeof (register_names
) / sizeof (*register_names
)))
214 return register_names
[regnum
];
217 /* Return the GDB type object for the "standard" data type
218 of data in register N. */
221 avr_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
223 if (reg_nr
== AVR_PC_REGNUM
)
224 return builtin_type (gdbarch
)->builtin_uint32
;
225 if (reg_nr
== AVR_PSEUDO_PC_REGNUM
)
226 return gdbarch_tdep (gdbarch
)->pc_type
;
227 if (reg_nr
== AVR_SP_REGNUM
)
228 return builtin_type (gdbarch
)->builtin_data_ptr
;
229 return builtin_type (gdbarch
)->builtin_uint8
;
232 /* Instruction address checks and convertions. */
235 avr_make_iaddr (CORE_ADDR x
)
237 return ((x
) | AVR_IMEM_START
);
240 /* FIXME: TRoth: Really need to use a larger mask for instructions. Some
241 devices are already up to 128KBytes of flash space.
243 TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined. */
246 avr_convert_iaddr_to_raw (CORE_ADDR x
)
248 return ((x
) & 0xffffffff);
251 /* SRAM address checks and convertions. */
254 avr_make_saddr (CORE_ADDR x
)
256 /* Return 0 for NULL. */
260 return ((x
) | AVR_SMEM_START
);
264 avr_convert_saddr_to_raw (CORE_ADDR x
)
266 return ((x
) & 0xffffffff);
269 /* EEPROM address checks and convertions. I don't know if these will ever
270 actually be used, but I've added them just the same. TRoth */
272 /* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
273 programs in the mega128. */
275 /* static CORE_ADDR */
276 /* avr_make_eaddr (CORE_ADDR x) */
278 /* return ((x) | AVR_EMEM_START); */
282 /* avr_eaddr_p (CORE_ADDR x) */
284 /* return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
287 /* static CORE_ADDR */
288 /* avr_convert_eaddr_to_raw (CORE_ADDR x) */
290 /* return ((x) & 0xffffffff); */
293 /* Convert from address to pointer and vice-versa. */
296 avr_address_to_pointer (struct gdbarch
*gdbarch
,
297 struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
299 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
301 /* Is it a code address? */
302 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
303 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
)
305 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
,
306 avr_convert_iaddr_to_raw (addr
>> 1));
310 /* Strip off any upper segment bits. */
311 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
,
312 avr_convert_saddr_to_raw (addr
));
317 avr_pointer_to_address (struct gdbarch
*gdbarch
,
318 struct type
*type
, const gdb_byte
*buf
)
320 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
322 = extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
324 /* Is it a code address? */
325 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
326 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
327 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type
)))
328 return avr_make_iaddr (addr
<< 1);
330 return avr_make_saddr (addr
);
334 avr_integer_to_address (struct gdbarch
*gdbarch
,
335 struct type
*type
, const gdb_byte
*buf
)
337 ULONGEST addr
= unpack_long (type
, buf
);
339 return avr_make_saddr (addr
);
343 avr_read_pc (struct regcache
*regcache
)
346 regcache_cooked_read_unsigned (regcache
, AVR_PC_REGNUM
, &pc
);
347 return avr_make_iaddr (pc
);
351 avr_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
353 regcache_cooked_write_unsigned (regcache
, AVR_PC_REGNUM
,
354 avr_convert_iaddr_to_raw (val
));
358 avr_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
359 int regnum
, gdb_byte
*buf
)
365 case AVR_PSEUDO_PC_REGNUM
:
366 regcache_raw_read_unsigned (regcache
, AVR_PC_REGNUM
, &val
);
368 store_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
), val
);
371 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
376 avr_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
377 int regnum
, const gdb_byte
*buf
)
383 case AVR_PSEUDO_PC_REGNUM
:
384 val
= extract_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
));
386 regcache_raw_write_unsigned (regcache
, AVR_PC_REGNUM
, val
);
389 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
393 /* Function: avr_scan_prologue
395 This function decodes an AVR function prologue to determine:
396 1) the size of the stack frame
397 2) which registers are saved on it
398 3) the offsets of saved regs
399 This information is stored in the avr_unwind_cache structure.
401 Some devices lack the sbiw instruction, so on those replace this:
407 A typical AVR function prologue with a frame pointer might look like this:
408 push rXX ; saved regs
414 sbiw r28,<LOCALS_SIZE>
415 in __tmp_reg__,__SREG__
418 out __SREG__,__tmp_reg__
421 A typical AVR function prologue without a frame pointer might look like
423 push rXX ; saved regs
426 A main function prologue looks like this:
427 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
428 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
432 A signal handler prologue looks like this:
435 in __tmp_reg__, __SREG__
438 push rXX ; save registers r18:r27, r30:r31
440 push r28 ; save frame pointer
444 sbiw r28, <LOCALS_SIZE>
448 A interrupt handler prologue looks like this:
452 in __tmp_reg__, __SREG__
455 push rXX ; save registers r18:r27, r30:r31
457 push r28 ; save frame pointer
461 sbiw r28, <LOCALS_SIZE>
467 A `-mcall-prologues' prologue looks like this (Note that the megas use a
468 jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
469 32 bit insn and rjmp is a 16 bit insn):
470 ldi r26,lo8(<LOCALS_SIZE>)
471 ldi r27,hi8(<LOCALS_SIZE>)
472 ldi r30,pm_lo8(.L_foo_body)
473 ldi r31,pm_hi8(.L_foo_body)
474 rjmp __prologue_saves__+RRR
477 /* Not really part of a prologue, but still need to scan for it, is when a
478 function prologue moves values passed via registers as arguments to new
479 registers. In this case, all local variables live in registers, so there
480 may be some register saves. This is what it looks like:
484 There could be multiple movw's. If the target doesn't have a movw insn, it
485 will use two mov insns. This could be done after any of the above prologue
489 avr_scan_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc_beg
, CORE_ADDR pc_end
,
490 struct avr_unwind_cache
*info
)
492 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
496 struct minimal_symbol
*msymbol
;
497 unsigned char prologue
[AVR_MAX_PROLOGUE_SIZE
];
501 len
= pc_end
- pc_beg
;
502 if (len
> AVR_MAX_PROLOGUE_SIZE
)
503 len
= AVR_MAX_PROLOGUE_SIZE
;
505 /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
506 reading in the bytes of the prologue. The problem is that the figuring
507 out where the end of the prologue is is a bit difficult. The old code
508 tried to do that, but failed quite often. */
509 read_memory (pc_beg
, prologue
, len
);
511 /* Scanning main()'s prologue
512 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
513 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
520 static const unsigned char img
[] = {
521 0xde, 0xbf, /* out __SP_H__,r29 */
522 0xcd, 0xbf /* out __SP_L__,r28 */
525 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
526 /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
527 if ((insn
& 0xf0f0) == 0xe0c0)
529 locals
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
530 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
531 /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
532 if ((insn
& 0xf0f0) == 0xe0d0)
534 locals
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
535 if (vpc
+ 4 + sizeof (img
) < len
536 && memcmp (prologue
+ vpc
+ 4, img
, sizeof (img
)) == 0)
538 info
->prologue_type
= AVR_PROLOGUE_MAIN
;
546 /* Scanning `-mcall-prologues' prologue
547 Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
549 while (1) /* Using a while to avoid many goto's */
556 /* At least the fifth instruction must have been executed to
557 modify frame shape. */
561 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
562 /* ldi r26,<LOCALS_SIZE> */
563 if ((insn
& 0xf0f0) != 0xe0a0)
565 loc_size
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
568 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
569 /* ldi r27,<LOCALS_SIZE> / 256 */
570 if ((insn
& 0xf0f0) != 0xe0b0)
572 loc_size
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
575 insn
= extract_unsigned_integer (&prologue
[vpc
+ 4], 2, byte_order
);
576 /* ldi r30,pm_lo8(.L_foo_body) */
577 if ((insn
& 0xf0f0) != 0xe0e0)
579 body_addr
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
582 insn
= extract_unsigned_integer (&prologue
[vpc
+ 6], 2, byte_order
);
583 /* ldi r31,pm_hi8(.L_foo_body) */
584 if ((insn
& 0xf0f0) != 0xe0f0)
586 body_addr
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
589 msymbol
= lookup_minimal_symbol ("__prologue_saves__", NULL
, NULL
);
593 insn
= extract_unsigned_integer (&prologue
[vpc
+ 8], 2, byte_order
);
594 /* rjmp __prologue_saves__+RRR */
595 if ((insn
& 0xf000) == 0xc000)
597 /* Extract PC relative offset from RJMP */
598 i
= (insn
& 0xfff) | (insn
& 0x800 ? (-1 ^ 0xfff) : 0);
599 /* Convert offset to byte addressable mode */
601 /* Destination address */
604 if (body_addr
!= (pc_beg
+ 10)/2)
609 else if ((insn
& 0xfe0e) == 0x940c)
611 /* Extract absolute PC address from JMP */
612 i
= (((insn
& 0x1) | ((insn
& 0x1f0) >> 3) << 16)
613 | (extract_unsigned_integer (&prologue
[vpc
+ 10], 2, byte_order
)
615 /* Convert address to byte addressable mode */
618 if (body_addr
!= (pc_beg
+ 12)/2)
626 /* Resolve offset (in words) from __prologue_saves__ symbol.
627 Which is a pushes count in `-mcall-prologues' mode */
628 num_pushes
= AVR_MAX_PUSHES
- (i
- SYMBOL_VALUE_ADDRESS (msymbol
)) / 2;
630 if (num_pushes
> AVR_MAX_PUSHES
)
632 fprintf_unfiltered (gdb_stderr
, _("Num pushes too large: %d\n"),
641 info
->saved_regs
[AVR_FP_REGNUM
+ 1].addr
= num_pushes
;
643 info
->saved_regs
[AVR_FP_REGNUM
].addr
= num_pushes
- 1;
646 for (from
= AVR_LAST_PUSHED_REGNUM
+ 1 - (num_pushes
- 2);
647 from
<= AVR_LAST_PUSHED_REGNUM
; ++from
)
648 info
->saved_regs
[from
].addr
= ++i
;
650 info
->size
= loc_size
+ num_pushes
;
651 info
->prologue_type
= AVR_PROLOGUE_CALL
;
653 return pc_beg
+ pc_offset
;
656 /* Scan for the beginning of the prologue for an interrupt or signal
657 function. Note that we have to set the prologue type here since the
658 third stage of the prologue may not be present (e.g. no saved registered
659 or changing of the SP register). */
663 static const unsigned char img
[] = {
664 0x78, 0x94, /* sei */
665 0x1f, 0x92, /* push r1 */
666 0x0f, 0x92, /* push r0 */
667 0x0f, 0xb6, /* in r0,0x3f SREG */
668 0x0f, 0x92, /* push r0 */
669 0x11, 0x24 /* clr r1 */
671 if (len
>= sizeof (img
)
672 && memcmp (prologue
, img
, sizeof (img
)) == 0)
674 info
->prologue_type
= AVR_PROLOGUE_INTR
;
676 info
->saved_regs
[AVR_SREG_REGNUM
].addr
= 3;
677 info
->saved_regs
[0].addr
= 2;
678 info
->saved_regs
[1].addr
= 1;
681 else if (len
>= sizeof (img
) - 2
682 && memcmp (img
+ 2, prologue
, sizeof (img
) - 2) == 0)
684 info
->prologue_type
= AVR_PROLOGUE_SIG
;
685 vpc
+= sizeof (img
) - 2;
686 info
->saved_regs
[AVR_SREG_REGNUM
].addr
= 3;
687 info
->saved_regs
[0].addr
= 2;
688 info
->saved_regs
[1].addr
= 1;
693 /* First stage of the prologue scanning.
694 Scan pushes (saved registers) */
696 for (; vpc
< len
; vpc
+= 2)
698 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
699 if ((insn
& 0xfe0f) == 0x920f) /* push rXX */
701 /* Bits 4-9 contain a mask for registers R0-R32. */
702 int regno
= (insn
& 0x1f0) >> 4;
704 info
->saved_regs
[regno
].addr
= info
->size
;
711 if (vpc
>= AVR_MAX_PROLOGUE_SIZE
)
712 fprintf_unfiltered (gdb_stderr
,
713 _("Hit end of prologue while scanning pushes\n"));
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
, CORE_ADDR
* pcptr
, int *lenptr
)
892 static const unsigned char avr_break_insn
[] = { 0x98, 0x95 };
893 *lenptr
= sizeof (avr_break_insn
);
894 return avr_break_insn
;
897 /* Determine, for architecture GDBARCH, how a return value of TYPE
898 should be returned. If it is supposed to be returned in registers,
899 and READBUF is non-zero, read the appropriate value from REGCACHE,
900 and copy it into READBUF. If WRITEBUF is non-zero, write the value
901 from WRITEBUF into REGCACHE. */
903 static enum return_value_convention
904 avr_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
905 struct type
*valtype
, struct regcache
*regcache
,
906 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
909 /* Single byte are returned in r24.
910 Otherwise, the MSB of the return value is always in r25, calculate which
911 register holds the LSB. */
914 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
915 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
916 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
917 && TYPE_LENGTH (valtype
) > 8)
918 return RETURN_VALUE_STRUCT_CONVENTION
;
920 if (TYPE_LENGTH (valtype
) <= 2)
922 else if (TYPE_LENGTH (valtype
) <= 4)
924 else if (TYPE_LENGTH (valtype
) <= 8)
929 if (writebuf
!= NULL
)
931 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
932 regcache_cooked_write (regcache
, lsb_reg
+ i
, writebuf
+ i
);
937 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
938 regcache_cooked_read (regcache
, lsb_reg
+ i
, readbuf
+ i
);
941 return RETURN_VALUE_REGISTER_CONVENTION
;
945 /* Put here the code to store, into fi->saved_regs, the addresses of
946 the saved registers of frame described by FRAME_INFO. This
947 includes special registers such as pc and fp saved in special ways
948 in the stack frame. sp is even more special: the address we return
949 for it IS the sp for the next frame. */
951 static struct avr_unwind_cache
*
952 avr_frame_unwind_cache (struct frame_info
*this_frame
,
953 void **this_prologue_cache
)
955 CORE_ADDR start_pc
, current_pc
;
958 struct avr_unwind_cache
*info
;
959 struct gdbarch
*gdbarch
;
960 struct gdbarch_tdep
*tdep
;
963 if (*this_prologue_cache
)
964 return *this_prologue_cache
;
966 info
= FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache
);
967 *this_prologue_cache
= info
;
968 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
971 info
->prologue_type
= AVR_PROLOGUE_NONE
;
973 start_pc
= get_frame_func (this_frame
);
974 current_pc
= get_frame_pc (this_frame
);
975 if ((start_pc
> 0) && (start_pc
<= current_pc
))
976 avr_scan_prologue (get_frame_arch (this_frame
),
977 start_pc
, current_pc
, info
);
979 if ((info
->prologue_type
!= AVR_PROLOGUE_NONE
)
980 && (info
->prologue_type
!= AVR_PROLOGUE_MAIN
))
982 ULONGEST high_base
; /* High byte of FP */
984 /* The SP was moved to the FP. This indicates that a new frame
985 was created. Get THIS frame's FP value by unwinding it from
987 this_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
);
988 high_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
+ 1);
989 this_base
+= (high_base
<< 8);
991 /* The FP points at the last saved register. Adjust the FP back
992 to before the first saved register giving the SP. */
993 prev_sp
= this_base
+ info
->size
;
997 /* Assume that the FP is this frame's SP but with that pushed
998 stack space added back. */
999 this_base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1000 prev_sp
= this_base
+ info
->size
;
1003 /* Add 1 here to adjust for the post-decrement nature of the push
1005 info
->prev_sp
= avr_make_saddr (prev_sp
+ 1);
1006 info
->base
= avr_make_saddr (this_base
);
1008 gdbarch
= get_frame_arch (this_frame
);
1010 /* Adjust all the saved registers so that they contain addresses and not
1012 for (i
= 0; i
< gdbarch_num_regs (gdbarch
) - 1; i
++)
1013 if (info
->saved_regs
[i
].addr
> 0)
1014 info
->saved_regs
[i
].addr
= info
->prev_sp
- info
->saved_regs
[i
].addr
;
1016 /* Except for the main and startup code, the return PC is always saved on
1017 the stack and is at the base of the frame. */
1019 if (info
->prologue_type
!= AVR_PROLOGUE_MAIN
)
1020 info
->saved_regs
[AVR_PC_REGNUM
].addr
= info
->prev_sp
;
1022 /* The previous frame's SP needed to be computed. Save the computed
1024 tdep
= gdbarch_tdep (gdbarch
);
1025 trad_frame_set_value (info
->saved_regs
, AVR_SP_REGNUM
,
1026 info
->prev_sp
- 1 + tdep
->call_length
);
1032 avr_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1036 pc
= frame_unwind_register_unsigned (next_frame
, AVR_PC_REGNUM
);
1038 return avr_make_iaddr (pc
);
1042 avr_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1046 sp
= frame_unwind_register_unsigned (next_frame
, AVR_SP_REGNUM
);
1048 return avr_make_saddr (sp
);
1051 /* Given a GDB frame, determine the address of the calling function's
1052 frame. This will be used to create a new GDB frame struct. */
1055 avr_frame_this_id (struct frame_info
*this_frame
,
1056 void **this_prologue_cache
,
1057 struct frame_id
*this_id
)
1059 struct avr_unwind_cache
*info
1060 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1065 /* The FUNC is easy. */
1066 func
= get_frame_func (this_frame
);
1068 /* Hopefully the prologue analysis either correctly determined the
1069 frame's base (which is the SP from the previous frame), or set
1070 that base to "NULL". */
1071 base
= info
->prev_sp
;
1075 id
= frame_id_build (base
, func
);
1079 static struct value
*
1080 avr_frame_prev_register (struct frame_info
*this_frame
,
1081 void **this_prologue_cache
, int regnum
)
1083 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1084 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1085 struct avr_unwind_cache
*info
1086 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1088 if (regnum
== AVR_PC_REGNUM
|| regnum
== AVR_PSEUDO_PC_REGNUM
)
1090 if (trad_frame_addr_p (info
->saved_regs
, AVR_PC_REGNUM
))
1092 /* Reading the return PC from the PC register is slightly
1093 abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
1094 but in reality, only two bytes (3 in upcoming mega256) are
1095 stored on the stack.
1097 Also, note that the value on the stack is an addr to a word
1098 not a byte, so we will need to multiply it by two at some
1101 And to confuse matters even more, the return address stored
1102 on the stack is in big endian byte order, even though most
1103 everything else about the avr is little endian. Ick! */
1106 unsigned char buf
[3];
1107 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1108 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1110 read_memory (info
->saved_regs
[AVR_PC_REGNUM
].addr
,
1111 buf
, tdep
->call_length
);
1113 /* Extract the PC read from memory as a big-endian. */
1115 for (i
= 0; i
< tdep
->call_length
; i
++)
1116 pc
= (pc
<< 8) | buf
[i
];
1118 if (regnum
== AVR_PC_REGNUM
)
1121 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
1124 return frame_unwind_got_optimized (this_frame
, regnum
);
1127 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1130 static const struct frame_unwind avr_frame_unwind
= {
1133 avr_frame_prev_register
,
1135 default_frame_sniffer
1139 avr_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1141 struct avr_unwind_cache
*info
1142 = avr_frame_unwind_cache (this_frame
, this_cache
);
1147 static const struct frame_base avr_frame_base
= {
1149 avr_frame_base_address
,
1150 avr_frame_base_address
,
1151 avr_frame_base_address
1154 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1155 frame. The frame ID's base needs to match the TOS value saved by
1156 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1158 static struct frame_id
1159 avr_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1163 base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1164 return frame_id_build (avr_make_saddr (base
), get_frame_pc (this_frame
));
1167 /* When arguments must be pushed onto the stack, they go on in reverse
1168 order. The below implements a FILO (stack) to do this. */
1173 struct stack_item
*prev
;
1177 static struct stack_item
*
1178 push_stack_item (struct stack_item
*prev
, const bfd_byte
*contents
, int len
)
1180 struct stack_item
*si
;
1181 si
= xmalloc (sizeof (struct stack_item
));
1182 si
->data
= xmalloc (len
);
1185 memcpy (si
->data
, contents
, len
);
1189 static struct stack_item
*pop_stack_item (struct stack_item
*si
);
1190 static struct stack_item
*
1191 pop_stack_item (struct stack_item
*si
)
1193 struct stack_item
*dead
= si
;
1200 /* Setup the function arguments for calling a function in the inferior.
1202 On the AVR architecture, there are 18 registers (R25 to R8) which are
1203 dedicated for passing function arguments. Up to the first 18 arguments
1204 (depending on size) may go into these registers. The rest go on the stack.
1206 All arguments are aligned to start in even-numbered registers (odd-sized
1207 arguments, including char, have one free register above them). For example,
1208 an int in arg1 and a char in arg2 would be passed as such:
1213 Arguments that are larger than 2 bytes will be split between two or more
1214 registers as available, but will NOT be split between a register and the
1215 stack. Arguments that go onto the stack are pushed last arg first (this is
1216 similar to the d10v). */
1218 /* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1221 An exceptional case exists for struct arguments (and possibly other
1222 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1223 not a multiple of WORDSIZE bytes. In this case the argument is never split
1224 between the registers and the stack, but instead is copied in its entirety
1225 onto the stack, AND also copied into as many registers as there is room
1226 for. In other words, space in registers permitting, two copies of the same
1227 argument are passed in. As far as I can tell, only the one on the stack is
1228 used, although that may be a function of the level of compiler
1229 optimization. I suspect this is a compiler bug. Arguments of these odd
1230 sizes are left-justified within the word (as opposed to arguments smaller
1231 than WORDSIZE bytes, which are right-justified).
1233 If the function is to return an aggregate type such as a struct, the caller
1234 must allocate space into which the callee will copy the return value. In
1235 this case, a pointer to the return value location is passed into the callee
1236 in register R0, which displaces one of the other arguments passed in via
1237 registers R0 to R2. */
1240 avr_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1241 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1242 int nargs
, struct value
**args
, CORE_ADDR sp
,
1243 int struct_return
, CORE_ADDR struct_addr
)
1245 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1247 unsigned char buf
[3];
1248 int call_length
= gdbarch_tdep (gdbarch
)->call_length
;
1249 CORE_ADDR return_pc
= avr_convert_iaddr_to_raw (bp_addr
);
1250 int regnum
= AVR_ARGN_REGNUM
;
1251 struct stack_item
*si
= NULL
;
1255 regcache_cooked_write_unsigned
1256 (regcache
, regnum
--, (struct_addr
>> 8) & 0xff);
1257 regcache_cooked_write_unsigned
1258 (regcache
, regnum
--, struct_addr
& 0xff);
1259 /* SP being post decremented, we need to reserve one byte so that the
1260 return address won't overwrite the result (or vice-versa). */
1261 if (sp
== struct_addr
)
1265 for (i
= 0; i
< nargs
; i
++)
1269 struct value
*arg
= args
[i
];
1270 struct type
*type
= check_typedef (value_type (arg
));
1271 const bfd_byte
*contents
= value_contents (arg
);
1272 int len
= TYPE_LENGTH (type
);
1274 /* Calculate the potential last register needed. */
1275 last_regnum
= regnum
- (len
+ (len
& 1));
1277 /* If there are registers available, use them. Once we start putting
1278 stuff on the stack, all subsequent args go on stack. */
1279 if ((si
== NULL
) && (last_regnum
>= 8))
1283 /* Skip a register for odd length args. */
1287 val
= extract_unsigned_integer (contents
, len
, byte_order
);
1288 for (j
= 0; j
< len
; j
++)
1289 regcache_cooked_write_unsigned
1290 (regcache
, regnum
--, val
>> (8 * (len
- j
- 1)));
1292 /* No registers available, push the args onto the stack. */
1295 /* From here on, we don't care about regnum. */
1296 si
= push_stack_item (si
, contents
, len
);
1300 /* Push args onto the stack. */
1304 /* Add 1 to sp here to account for post decr nature of pushes. */
1305 write_memory (sp
+ 1, si
->data
, si
->len
);
1306 si
= pop_stack_item (si
);
1309 /* Set the return address. For the avr, the return address is the BP_ADDR.
1310 Need to push the return address onto the stack noting that it needs to be
1311 in big-endian order on the stack. */
1312 for (i
= 1; i
<= call_length
; i
++)
1314 buf
[call_length
- i
] = return_pc
& 0xff;
1319 /* Use 'sp + 1' since pushes are post decr ops. */
1320 write_memory (sp
+ 1, buf
, call_length
);
1322 /* Finally, update the SP register. */
1323 regcache_cooked_write_unsigned (regcache
, AVR_SP_REGNUM
,
1324 avr_convert_saddr_to_raw (sp
));
1326 /* Return SP value for the dummy frame, where the return address hasn't been
1328 return sp
+ call_length
;
1331 /* Unfortunately dwarf2 register for SP is 32. */
1334 avr_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1336 if (reg
>= 0 && reg
< 32)
1339 return AVR_SP_REGNUM
;
1341 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
1346 /* Initialize the gdbarch structure for the AVR's. */
1348 static struct gdbarch
*
1349 avr_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1351 struct gdbarch
*gdbarch
;
1352 struct gdbarch_tdep
*tdep
;
1353 struct gdbarch_list
*best_arch
;
1356 /* Avr-6 call instructions save 3 bytes. */
1357 switch (info
.bfd_arch_info
->mach
)
1372 /* If there is already a candidate, use it. */
1373 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1375 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1377 if (gdbarch_tdep (best_arch
->gdbarch
)->call_length
== call_length
)
1378 return best_arch
->gdbarch
;
1381 /* None found, create a new architecture from the information provided. */
1382 tdep
= XMALLOC (struct gdbarch_tdep
);
1383 gdbarch
= gdbarch_alloc (&info
, tdep
);
1385 tdep
->call_length
= call_length
;
1387 /* Create a type for PC. We can't use builtin types here, as they may not
1389 tdep
->void_type
= arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
1390 tdep
->func_void_type
= make_function_type (tdep
->void_type
, NULL
);
1391 tdep
->pc_type
= arch_type (gdbarch
, TYPE_CODE_PTR
, 4, NULL
);
1392 TYPE_TARGET_TYPE (tdep
->pc_type
) = tdep
->func_void_type
;
1393 TYPE_UNSIGNED (tdep
->pc_type
) = 1;
1395 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1396 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1397 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1398 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1399 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1400 set_gdbarch_addr_bit (gdbarch
, 32);
1402 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1403 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1404 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1406 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1407 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1408 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1410 set_gdbarch_read_pc (gdbarch
, avr_read_pc
);
1411 set_gdbarch_write_pc (gdbarch
, avr_write_pc
);
1413 set_gdbarch_num_regs (gdbarch
, AVR_NUM_REGS
);
1415 set_gdbarch_sp_regnum (gdbarch
, AVR_SP_REGNUM
);
1416 set_gdbarch_pc_regnum (gdbarch
, AVR_PC_REGNUM
);
1418 set_gdbarch_register_name (gdbarch
, avr_register_name
);
1419 set_gdbarch_register_type (gdbarch
, avr_register_type
);
1421 set_gdbarch_num_pseudo_regs (gdbarch
, AVR_NUM_PSEUDO_REGS
);
1422 set_gdbarch_pseudo_register_read (gdbarch
, avr_pseudo_register_read
);
1423 set_gdbarch_pseudo_register_write (gdbarch
, avr_pseudo_register_write
);
1425 set_gdbarch_return_value (gdbarch
, avr_return_value
);
1426 set_gdbarch_print_insn (gdbarch
, print_insn_avr
);
1428 set_gdbarch_push_dummy_call (gdbarch
, avr_push_dummy_call
);
1430 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, avr_dwarf_reg_to_regnum
);
1432 set_gdbarch_address_to_pointer (gdbarch
, avr_address_to_pointer
);
1433 set_gdbarch_pointer_to_address (gdbarch
, avr_pointer_to_address
);
1434 set_gdbarch_integer_to_address (gdbarch
, avr_integer_to_address
);
1436 set_gdbarch_skip_prologue (gdbarch
, avr_skip_prologue
);
1437 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1439 set_gdbarch_breakpoint_from_pc (gdbarch
, avr_breakpoint_from_pc
);
1441 frame_unwind_append_unwinder (gdbarch
, &avr_frame_unwind
);
1442 frame_base_set_default (gdbarch
, &avr_frame_base
);
1444 set_gdbarch_dummy_id (gdbarch
, avr_dummy_id
);
1446 set_gdbarch_unwind_pc (gdbarch
, avr_unwind_pc
);
1447 set_gdbarch_unwind_sp (gdbarch
, avr_unwind_sp
);
1452 /* Send a query request to the avr remote target asking for values of the io
1453 registers. If args parameter is not NULL, then the user has requested info
1454 on a specific io register [This still needs implemented and is ignored for
1455 now]. The query string should be one of these forms:
1457 "Ravr.io_reg" -> reply is "NN" number of io registers
1459 "Ravr.io_reg:addr,len" where addr is first register and len is number of
1460 registers to be read. The reply should be "<NAME>,VV;" for each io register
1461 where, <NAME> is a string, and VV is the hex value of the register.
1463 All io registers are 8-bit. */
1466 avr_io_reg_read_command (char *args
, int from_tty
)
1472 unsigned int nreg
= 0;
1476 /* Find out how many io registers the target has. */
1477 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1478 "avr.io_reg", &buf
);
1482 fprintf_unfiltered (gdb_stderr
,
1483 _("ERR: info io_registers NOT supported "
1484 "by current target\n"));
1488 if (sscanf (buf
, "%x", &nreg
) != 1)
1490 fprintf_unfiltered (gdb_stderr
,
1491 _("Error fetching number of io registers\n"));
1498 reinitialize_more_filter ();
1500 printf_unfiltered (_("Target has %u io registers:\n\n"), nreg
);
1502 /* only fetch up to 8 registers at a time to keep the buffer small */
1505 for (i
= 0; i
< nreg
; i
+= step
)
1507 /* how many registers this round? */
1510 j
= nreg
- i
; /* last block is less than 8 registers */
1512 snprintf (query
, sizeof (query
) - 1, "avr.io_reg:%x,%x", i
, j
);
1513 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1517 for (k
= i
; k
< (i
+ j
); k
++)
1519 if (sscanf (p
, "%[^,],%x;", query
, &val
) == 2)
1521 printf_filtered ("[%02x] %-15s : %02x\n", k
, query
, val
);
1522 while ((*p
!= ';') && (*p
!= '\0'))
1524 p
++; /* skip over ';' */
1534 extern initialize_file_ftype _initialize_avr_tdep
; /* -Wmissing-prototypes */
1537 _initialize_avr_tdep (void)
1539 register_gdbarch_init (bfd_arch_avr
, avr_gdbarch_init
);
1541 /* Add a new command to allow the user to query the avr remote target for
1542 the values of the io space registers in a saner way than just using
1545 /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1546 io_registers' to signify it is not available on other platforms. */
1548 add_cmd ("io_registers", class_info
, avr_io_reg_read_command
,
1549 _("query remote avr target for io space register values"),