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, 2010, 2011 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 gdb_assert (vpc
< AVR_MAX_PROLOGUE_SIZE
);
713 /* Handle static small stack allocation using rcall or push. */
715 while (scan_stage
== 1 && vpc
< len
)
717 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
718 if (insn
== 0xd000) /* rcall .+0 */
720 info
->size
+= gdbarch_tdep (gdbarch
)->call_length
;
723 else if (insn
== 0x920f) /* push r0 */
732 /* Second stage of the prologue scanning.
737 if (scan_stage
== 1 && vpc
< len
)
739 static const unsigned char img
[] = {
740 0xcd, 0xb7, /* in r28,__SP_L__ */
741 0xde, 0xb7 /* in r29,__SP_H__ */
743 unsigned short insn1
;
745 if (vpc
+ sizeof (img
) < len
746 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
753 /* Third stage of the prologue scanning. (Really two stages).
755 sbiw r28,XX or subi r28,lo8(XX)
757 in __tmp_reg__,__SREG__
760 out __SREG__,__tmp_reg__
763 if (scan_stage
== 2 && vpc
< len
)
766 static const unsigned char img
[] = {
767 0x0f, 0xb6, /* in r0,0x3f */
768 0xf8, 0x94, /* cli */
769 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
770 0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
771 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
773 static const unsigned char img_sig
[] = {
774 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
775 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
777 static const unsigned char img_int
[] = {
778 0xf8, 0x94, /* cli */
779 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
780 0x78, 0x94, /* sei */
781 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
784 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
785 if ((insn
& 0xff30) == 0x9720) /* sbiw r28,XXX */
787 locals_size
= (insn
& 0xf) | ((insn
& 0xc0) >> 2);
790 else if ((insn
& 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
792 locals_size
= (insn
& 0xf) | ((insn
& 0xf00) >> 4);
794 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
796 locals_size
+= ((insn
& 0xf) | ((insn
& 0xf00) >> 4)) << 8;
801 /* Scan the last part of the prologue. May not be present for interrupt
802 or signal handler functions, which is why we set the prologue type
803 when we saw the beginning of the prologue previously. */
805 if (vpc
+ sizeof (img_sig
) < len
806 && memcmp (prologue
+ vpc
, img_sig
, sizeof (img_sig
)) == 0)
808 vpc
+= sizeof (img_sig
);
810 else if (vpc
+ sizeof (img_int
) < len
811 && memcmp (prologue
+ vpc
, img_int
, sizeof (img_int
)) == 0)
813 vpc
+= sizeof (img_int
);
815 if (vpc
+ sizeof (img
) < len
816 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
818 info
->prologue_type
= AVR_PROLOGUE_NORMAL
;
822 info
->size
+= locals_size
;
827 /* If we got this far, we could not scan the prologue, so just return the pc
828 of the frame plus an adjustment for argument move insns. */
830 for (; vpc
< len
; vpc
+= 2)
832 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
833 if ((insn
& 0xff00) == 0x0100) /* movw rXX, rYY */
835 else if ((insn
& 0xfc00) == 0x2c00) /* mov rXX, rYY */
845 avr_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
847 CORE_ADDR func_addr
, func_end
;
848 CORE_ADDR post_prologue_pc
;
850 /* See what the symbol table says */
852 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
855 post_prologue_pc
= skip_prologue_using_sal (gdbarch
, func_addr
);
856 if (post_prologue_pc
!= 0)
857 return max (pc
, post_prologue_pc
);
860 CORE_ADDR prologue_end
= pc
;
861 struct avr_unwind_cache info
= {0};
862 struct trad_frame_saved_reg saved_regs
[AVR_NUM_REGS
];
864 info
.saved_regs
= saved_regs
;
866 /* Need to run the prologue scanner to figure out if the function has a
867 prologue and possibly skip over moving arguments passed via registers
868 to other registers. */
870 prologue_end
= avr_scan_prologue (gdbarch
, func_addr
, func_end
, &info
);
872 if (info
.prologue_type
!= AVR_PROLOGUE_NONE
)
876 /* Either we didn't find the start of this function (nothing we can do),
877 or there's no line info, or the line after the prologue is after
878 the end of the function (there probably isn't a prologue). */
883 /* Not all avr devices support the BREAK insn. Those that don't should treat
884 it as a NOP. Thus, it should be ok. Since the avr is currently a remote
885 only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
887 static const unsigned char *
888 avr_breakpoint_from_pc (struct gdbarch
*gdbarch
,
889 CORE_ADDR
*pcptr
, int *lenptr
)
891 static const unsigned char avr_break_insn
[] = { 0x98, 0x95 };
892 *lenptr
= sizeof (avr_break_insn
);
893 return avr_break_insn
;
896 /* Determine, for architecture GDBARCH, how a return value of TYPE
897 should be returned. If it is supposed to be returned in registers,
898 and READBUF is non-zero, read the appropriate value from REGCACHE,
899 and copy it into READBUF. If WRITEBUF is non-zero, write the value
900 from WRITEBUF into REGCACHE. */
902 static enum return_value_convention
903 avr_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
904 struct type
*valtype
, struct regcache
*regcache
,
905 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
908 /* Single byte are returned in r24.
909 Otherwise, the MSB of the return value is always in r25, calculate which
910 register holds the LSB. */
913 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
914 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
915 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
916 && TYPE_LENGTH (valtype
) > 8)
917 return RETURN_VALUE_STRUCT_CONVENTION
;
919 if (TYPE_LENGTH (valtype
) <= 2)
921 else if (TYPE_LENGTH (valtype
) <= 4)
923 else if (TYPE_LENGTH (valtype
) <= 8)
926 gdb_assert_not_reached ("unexpected type length");
928 if (writebuf
!= NULL
)
930 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
931 regcache_cooked_write (regcache
, lsb_reg
+ i
, writebuf
+ i
);
936 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
937 regcache_cooked_read (regcache
, lsb_reg
+ i
, readbuf
+ i
);
940 return RETURN_VALUE_REGISTER_CONVENTION
;
944 /* Put here the code to store, into fi->saved_regs, the addresses of
945 the saved registers of frame described by FRAME_INFO. This
946 includes special registers such as pc and fp saved in special ways
947 in the stack frame. sp is even more special: the address we return
948 for it IS the sp for the next frame. */
950 static struct avr_unwind_cache
*
951 avr_frame_unwind_cache (struct frame_info
*this_frame
,
952 void **this_prologue_cache
)
954 CORE_ADDR start_pc
, current_pc
;
957 struct avr_unwind_cache
*info
;
958 struct gdbarch
*gdbarch
;
959 struct gdbarch_tdep
*tdep
;
962 if (*this_prologue_cache
)
963 return *this_prologue_cache
;
965 info
= FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache
);
966 *this_prologue_cache
= info
;
967 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
970 info
->prologue_type
= AVR_PROLOGUE_NONE
;
972 start_pc
= get_frame_func (this_frame
);
973 current_pc
= get_frame_pc (this_frame
);
974 if ((start_pc
> 0) && (start_pc
<= current_pc
))
975 avr_scan_prologue (get_frame_arch (this_frame
),
976 start_pc
, current_pc
, info
);
978 if ((info
->prologue_type
!= AVR_PROLOGUE_NONE
)
979 && (info
->prologue_type
!= AVR_PROLOGUE_MAIN
))
981 ULONGEST high_base
; /* High byte of FP */
983 /* The SP was moved to the FP. This indicates that a new frame
984 was created. Get THIS frame's FP value by unwinding it from
986 this_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
);
987 high_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
+ 1);
988 this_base
+= (high_base
<< 8);
990 /* The FP points at the last saved register. Adjust the FP back
991 to before the first saved register giving the SP. */
992 prev_sp
= this_base
+ info
->size
;
996 /* Assume that the FP is this frame's SP but with that pushed
997 stack space added back. */
998 this_base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
999 prev_sp
= this_base
+ info
->size
;
1002 /* Add 1 here to adjust for the post-decrement nature of the push
1004 info
->prev_sp
= avr_make_saddr (prev_sp
+ 1);
1005 info
->base
= avr_make_saddr (this_base
);
1007 gdbarch
= get_frame_arch (this_frame
);
1009 /* Adjust all the saved registers so that they contain addresses and not
1011 for (i
= 0; i
< gdbarch_num_regs (gdbarch
) - 1; i
++)
1012 if (info
->saved_regs
[i
].addr
> 0)
1013 info
->saved_regs
[i
].addr
= info
->prev_sp
- info
->saved_regs
[i
].addr
;
1015 /* Except for the main and startup code, the return PC is always saved on
1016 the stack and is at the base of the frame. */
1018 if (info
->prologue_type
!= AVR_PROLOGUE_MAIN
)
1019 info
->saved_regs
[AVR_PC_REGNUM
].addr
= info
->prev_sp
;
1021 /* The previous frame's SP needed to be computed. Save the computed
1023 tdep
= gdbarch_tdep (gdbarch
);
1024 trad_frame_set_value (info
->saved_regs
, AVR_SP_REGNUM
,
1025 info
->prev_sp
- 1 + tdep
->call_length
);
1031 avr_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1035 pc
= frame_unwind_register_unsigned (next_frame
, AVR_PC_REGNUM
);
1037 return avr_make_iaddr (pc
);
1041 avr_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1045 sp
= frame_unwind_register_unsigned (next_frame
, AVR_SP_REGNUM
);
1047 return avr_make_saddr (sp
);
1050 /* Given a GDB frame, determine the address of the calling function's
1051 frame. This will be used to create a new GDB frame struct. */
1054 avr_frame_this_id (struct frame_info
*this_frame
,
1055 void **this_prologue_cache
,
1056 struct frame_id
*this_id
)
1058 struct avr_unwind_cache
*info
1059 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1064 /* The FUNC is easy. */
1065 func
= get_frame_func (this_frame
);
1067 /* Hopefully the prologue analysis either correctly determined the
1068 frame's base (which is the SP from the previous frame), or set
1069 that base to "NULL". */
1070 base
= info
->prev_sp
;
1074 id
= frame_id_build (base
, func
);
1078 static struct value
*
1079 avr_frame_prev_register (struct frame_info
*this_frame
,
1080 void **this_prologue_cache
, int regnum
)
1082 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1083 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1084 struct avr_unwind_cache
*info
1085 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1087 if (regnum
== AVR_PC_REGNUM
|| regnum
== AVR_PSEUDO_PC_REGNUM
)
1089 if (trad_frame_addr_p (info
->saved_regs
, AVR_PC_REGNUM
))
1091 /* Reading the return PC from the PC register is slightly
1092 abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
1093 but in reality, only two bytes (3 in upcoming mega256) are
1094 stored on the stack.
1096 Also, note that the value on the stack is an addr to a word
1097 not a byte, so we will need to multiply it by two at some
1100 And to confuse matters even more, the return address stored
1101 on the stack is in big endian byte order, even though most
1102 everything else about the avr is little endian. Ick! */
1105 unsigned char buf
[3];
1106 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1107 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1109 read_memory (info
->saved_regs
[AVR_PC_REGNUM
].addr
,
1110 buf
, tdep
->call_length
);
1112 /* Extract the PC read from memory as a big-endian. */
1114 for (i
= 0; i
< tdep
->call_length
; i
++)
1115 pc
= (pc
<< 8) | buf
[i
];
1117 if (regnum
== AVR_PC_REGNUM
)
1120 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
1123 return frame_unwind_got_optimized (this_frame
, regnum
);
1126 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1129 static const struct frame_unwind avr_frame_unwind
= {
1132 avr_frame_prev_register
,
1134 default_frame_sniffer
1138 avr_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1140 struct avr_unwind_cache
*info
1141 = avr_frame_unwind_cache (this_frame
, this_cache
);
1146 static const struct frame_base avr_frame_base
= {
1148 avr_frame_base_address
,
1149 avr_frame_base_address
,
1150 avr_frame_base_address
1153 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1154 frame. The frame ID's base needs to match the TOS value saved by
1155 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1157 static struct frame_id
1158 avr_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1162 base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1163 return frame_id_build (avr_make_saddr (base
), get_frame_pc (this_frame
));
1166 /* When arguments must be pushed onto the stack, they go on in reverse
1167 order. The below implements a FILO (stack) to do this. */
1172 struct stack_item
*prev
;
1176 static struct stack_item
*
1177 push_stack_item (struct stack_item
*prev
, const bfd_byte
*contents
, int len
)
1179 struct stack_item
*si
;
1180 si
= xmalloc (sizeof (struct stack_item
));
1181 si
->data
= xmalloc (len
);
1184 memcpy (si
->data
, contents
, len
);
1188 static struct stack_item
*pop_stack_item (struct stack_item
*si
);
1189 static struct stack_item
*
1190 pop_stack_item (struct stack_item
*si
)
1192 struct stack_item
*dead
= si
;
1199 /* Setup the function arguments for calling a function in the inferior.
1201 On the AVR architecture, there are 18 registers (R25 to R8) which are
1202 dedicated for passing function arguments. Up to the first 18 arguments
1203 (depending on size) may go into these registers. The rest go on the stack.
1205 All arguments are aligned to start in even-numbered registers (odd-sized
1206 arguments, including char, have one free register above them). For example,
1207 an int in arg1 and a char in arg2 would be passed as such:
1212 Arguments that are larger than 2 bytes will be split between two or more
1213 registers as available, but will NOT be split between a register and the
1214 stack. Arguments that go onto the stack are pushed last arg first (this is
1215 similar to the d10v). */
1217 /* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1220 An exceptional case exists for struct arguments (and possibly other
1221 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1222 not a multiple of WORDSIZE bytes. In this case the argument is never split
1223 between the registers and the stack, but instead is copied in its entirety
1224 onto the stack, AND also copied into as many registers as there is room
1225 for. In other words, space in registers permitting, two copies of the same
1226 argument are passed in. As far as I can tell, only the one on the stack is
1227 used, although that may be a function of the level of compiler
1228 optimization. I suspect this is a compiler bug. Arguments of these odd
1229 sizes are left-justified within the word (as opposed to arguments smaller
1230 than WORDSIZE bytes, which are right-justified).
1232 If the function is to return an aggregate type such as a struct, the caller
1233 must allocate space into which the callee will copy the return value. In
1234 this case, a pointer to the return value location is passed into the callee
1235 in register R0, which displaces one of the other arguments passed in via
1236 registers R0 to R2. */
1239 avr_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1240 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1241 int nargs
, struct value
**args
, CORE_ADDR sp
,
1242 int struct_return
, CORE_ADDR struct_addr
)
1244 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1246 unsigned char buf
[3];
1247 int call_length
= gdbarch_tdep (gdbarch
)->call_length
;
1248 CORE_ADDR return_pc
= avr_convert_iaddr_to_raw (bp_addr
);
1249 int regnum
= AVR_ARGN_REGNUM
;
1250 struct stack_item
*si
= NULL
;
1254 regcache_cooked_write_unsigned
1255 (regcache
, regnum
--, (struct_addr
>> 8) & 0xff);
1256 regcache_cooked_write_unsigned
1257 (regcache
, regnum
--, struct_addr
& 0xff);
1258 /* SP being post decremented, we need to reserve one byte so that the
1259 return address won't overwrite the result (or vice-versa). */
1260 if (sp
== struct_addr
)
1264 for (i
= 0; i
< nargs
; i
++)
1268 struct value
*arg
= args
[i
];
1269 struct type
*type
= check_typedef (value_type (arg
));
1270 const bfd_byte
*contents
= value_contents (arg
);
1271 int len
= TYPE_LENGTH (type
);
1273 /* Calculate the potential last register needed. */
1274 last_regnum
= regnum
- (len
+ (len
& 1));
1276 /* If there are registers available, use them. Once we start putting
1277 stuff on the stack, all subsequent args go on stack. */
1278 if ((si
== NULL
) && (last_regnum
>= 8))
1282 /* Skip a register for odd length args. */
1286 val
= extract_unsigned_integer (contents
, len
, byte_order
);
1287 for (j
= 0; j
< len
; j
++)
1288 regcache_cooked_write_unsigned
1289 (regcache
, regnum
--, val
>> (8 * (len
- j
- 1)));
1291 /* No registers available, push the args onto the stack. */
1294 /* From here on, we don't care about regnum. */
1295 si
= push_stack_item (si
, contents
, len
);
1299 /* Push args onto the stack. */
1303 /* Add 1 to sp here to account for post decr nature of pushes. */
1304 write_memory (sp
+ 1, si
->data
, si
->len
);
1305 si
= pop_stack_item (si
);
1308 /* Set the return address. For the avr, the return address is the BP_ADDR.
1309 Need to push the return address onto the stack noting that it needs to be
1310 in big-endian order on the stack. */
1311 for (i
= 1; i
<= call_length
; i
++)
1313 buf
[call_length
- i
] = return_pc
& 0xff;
1318 /* Use 'sp + 1' since pushes are post decr ops. */
1319 write_memory (sp
+ 1, buf
, call_length
);
1321 /* Finally, update the SP register. */
1322 regcache_cooked_write_unsigned (regcache
, AVR_SP_REGNUM
,
1323 avr_convert_saddr_to_raw (sp
));
1325 /* Return SP value for the dummy frame, where the return address hasn't been
1327 return sp
+ call_length
;
1330 /* Unfortunately dwarf2 register for SP is 32. */
1333 avr_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1335 if (reg
>= 0 && reg
< 32)
1338 return AVR_SP_REGNUM
;
1340 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
1345 /* Initialize the gdbarch structure for the AVR's. */
1347 static struct gdbarch
*
1348 avr_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1350 struct gdbarch
*gdbarch
;
1351 struct gdbarch_tdep
*tdep
;
1352 struct gdbarch_list
*best_arch
;
1355 /* Avr-6 call instructions save 3 bytes. */
1356 switch (info
.bfd_arch_info
->mach
)
1371 /* If there is already a candidate, use it. */
1372 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1374 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1376 if (gdbarch_tdep (best_arch
->gdbarch
)->call_length
== call_length
)
1377 return best_arch
->gdbarch
;
1380 /* None found, create a new architecture from the information provided. */
1381 tdep
= XMALLOC (struct gdbarch_tdep
);
1382 gdbarch
= gdbarch_alloc (&info
, tdep
);
1384 tdep
->call_length
= call_length
;
1386 /* Create a type for PC. We can't use builtin types here, as they may not
1388 tdep
->void_type
= arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
1389 tdep
->func_void_type
= make_function_type (tdep
->void_type
, NULL
);
1390 tdep
->pc_type
= arch_type (gdbarch
, TYPE_CODE_PTR
, 4, NULL
);
1391 TYPE_TARGET_TYPE (tdep
->pc_type
) = tdep
->func_void_type
;
1392 TYPE_UNSIGNED (tdep
->pc_type
) = 1;
1394 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1395 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1396 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1397 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1398 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1399 set_gdbarch_addr_bit (gdbarch
, 32);
1401 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1402 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1403 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1405 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1406 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1407 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1409 set_gdbarch_read_pc (gdbarch
, avr_read_pc
);
1410 set_gdbarch_write_pc (gdbarch
, avr_write_pc
);
1412 set_gdbarch_num_regs (gdbarch
, AVR_NUM_REGS
);
1414 set_gdbarch_sp_regnum (gdbarch
, AVR_SP_REGNUM
);
1415 set_gdbarch_pc_regnum (gdbarch
, AVR_PC_REGNUM
);
1417 set_gdbarch_register_name (gdbarch
, avr_register_name
);
1418 set_gdbarch_register_type (gdbarch
, avr_register_type
);
1420 set_gdbarch_num_pseudo_regs (gdbarch
, AVR_NUM_PSEUDO_REGS
);
1421 set_gdbarch_pseudo_register_read (gdbarch
, avr_pseudo_register_read
);
1422 set_gdbarch_pseudo_register_write (gdbarch
, avr_pseudo_register_write
);
1424 set_gdbarch_return_value (gdbarch
, avr_return_value
);
1425 set_gdbarch_print_insn (gdbarch
, print_insn_avr
);
1427 set_gdbarch_push_dummy_call (gdbarch
, avr_push_dummy_call
);
1429 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, avr_dwarf_reg_to_regnum
);
1431 set_gdbarch_address_to_pointer (gdbarch
, avr_address_to_pointer
);
1432 set_gdbarch_pointer_to_address (gdbarch
, avr_pointer_to_address
);
1433 set_gdbarch_integer_to_address (gdbarch
, avr_integer_to_address
);
1435 set_gdbarch_skip_prologue (gdbarch
, avr_skip_prologue
);
1436 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1438 set_gdbarch_breakpoint_from_pc (gdbarch
, avr_breakpoint_from_pc
);
1440 frame_unwind_append_unwinder (gdbarch
, &avr_frame_unwind
);
1441 frame_base_set_default (gdbarch
, &avr_frame_base
);
1443 set_gdbarch_dummy_id (gdbarch
, avr_dummy_id
);
1445 set_gdbarch_unwind_pc (gdbarch
, avr_unwind_pc
);
1446 set_gdbarch_unwind_sp (gdbarch
, avr_unwind_sp
);
1451 /* Send a query request to the avr remote target asking for values of the io
1452 registers. If args parameter is not NULL, then the user has requested info
1453 on a specific io register [This still needs implemented and is ignored for
1454 now]. The query string should be one of these forms:
1456 "Ravr.io_reg" -> reply is "NN" number of io registers
1458 "Ravr.io_reg:addr,len" where addr is first register and len is number of
1459 registers to be read. The reply should be "<NAME>,VV;" for each io register
1460 where, <NAME> is a string, and VV is the hex value of the register.
1462 All io registers are 8-bit. */
1465 avr_io_reg_read_command (char *args
, int from_tty
)
1471 unsigned int nreg
= 0;
1475 /* Find out how many io registers the target has. */
1476 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1477 "avr.io_reg", &buf
);
1481 fprintf_unfiltered (gdb_stderr
,
1482 _("ERR: info io_registers NOT supported "
1483 "by current target\n"));
1487 if (sscanf (buf
, "%x", &nreg
) != 1)
1489 fprintf_unfiltered (gdb_stderr
,
1490 _("Error fetching number of io registers\n"));
1497 reinitialize_more_filter ();
1499 printf_unfiltered (_("Target has %u io registers:\n\n"), nreg
);
1501 /* only fetch up to 8 registers at a time to keep the buffer small */
1504 for (i
= 0; i
< nreg
; i
+= step
)
1506 /* how many registers this round? */
1509 j
= nreg
- i
; /* last block is less than 8 registers */
1511 snprintf (query
, sizeof (query
) - 1, "avr.io_reg:%x,%x", i
, j
);
1512 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1516 for (k
= i
; k
< (i
+ j
); k
++)
1518 if (sscanf (p
, "%[^,],%x;", query
, &val
) == 2)
1520 printf_filtered ("[%02x] %-15s : %02x\n", k
, query
, val
);
1521 while ((*p
!= ';') && (*p
!= '\0'))
1523 p
++; /* skip over ';' */
1533 extern initialize_file_ftype _initialize_avr_tdep
; /* -Wmissing-prototypes */
1536 _initialize_avr_tdep (void)
1538 register_gdbarch_init (bfd_arch_avr
, avr_gdbarch_init
);
1540 /* Add a new command to allow the user to query the avr remote target for
1541 the values of the io space registers in a saner way than just using
1544 /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1545 io_registers' to signify it is not available on other platforms. */
1547 add_cmd ("io_registers", class_info
, avr_io_reg_read_command
,
1548 _("query remote avr target for io space register values"),