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
));
357 static enum register_status
358 avr_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
359 int regnum
, gdb_byte
*buf
)
362 enum register_status status
;
366 case AVR_PSEUDO_PC_REGNUM
:
367 status
= regcache_raw_read_unsigned (regcache
, AVR_PC_REGNUM
, &val
);
368 if (status
!= REG_VALID
)
371 store_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
), val
);
374 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
379 avr_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
380 int regnum
, const gdb_byte
*buf
)
386 case AVR_PSEUDO_PC_REGNUM
:
387 val
= extract_unsigned_integer (buf
, 4, gdbarch_byte_order (gdbarch
));
389 regcache_raw_write_unsigned (regcache
, AVR_PC_REGNUM
, val
);
392 internal_error (__FILE__
, __LINE__
, _("invalid regnum"));
396 /* Function: avr_scan_prologue
398 This function decodes an AVR function prologue to determine:
399 1) the size of the stack frame
400 2) which registers are saved on it
401 3) the offsets of saved regs
402 This information is stored in the avr_unwind_cache structure.
404 Some devices lack the sbiw instruction, so on those replace this:
410 A typical AVR function prologue with a frame pointer might look like this:
411 push rXX ; saved regs
417 sbiw r28,<LOCALS_SIZE>
418 in __tmp_reg__,__SREG__
421 out __SREG__,__tmp_reg__
424 A typical AVR function prologue without a frame pointer might look like
426 push rXX ; saved regs
429 A main function prologue looks like this:
430 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
431 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
435 A signal handler prologue looks like this:
438 in __tmp_reg__, __SREG__
441 push rXX ; save registers r18:r27, r30:r31
443 push r28 ; save frame pointer
447 sbiw r28, <LOCALS_SIZE>
451 A interrupt handler prologue looks like this:
455 in __tmp_reg__, __SREG__
458 push rXX ; save registers r18:r27, r30:r31
460 push r28 ; save frame pointer
464 sbiw r28, <LOCALS_SIZE>
470 A `-mcall-prologues' prologue looks like this (Note that the megas use a
471 jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
472 32 bit insn and rjmp is a 16 bit insn):
473 ldi r26,lo8(<LOCALS_SIZE>)
474 ldi r27,hi8(<LOCALS_SIZE>)
475 ldi r30,pm_lo8(.L_foo_body)
476 ldi r31,pm_hi8(.L_foo_body)
477 rjmp __prologue_saves__+RRR
480 /* Not really part of a prologue, but still need to scan for it, is when a
481 function prologue moves values passed via registers as arguments to new
482 registers. In this case, all local variables live in registers, so there
483 may be some register saves. This is what it looks like:
487 There could be multiple movw's. If the target doesn't have a movw insn, it
488 will use two mov insns. This could be done after any of the above prologue
492 avr_scan_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc_beg
, CORE_ADDR pc_end
,
493 struct avr_unwind_cache
*info
)
495 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
499 struct minimal_symbol
*msymbol
;
500 unsigned char prologue
[AVR_MAX_PROLOGUE_SIZE
];
504 len
= pc_end
- pc_beg
;
505 if (len
> AVR_MAX_PROLOGUE_SIZE
)
506 len
= AVR_MAX_PROLOGUE_SIZE
;
508 /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
509 reading in the bytes of the prologue. The problem is that the figuring
510 out where the end of the prologue is is a bit difficult. The old code
511 tried to do that, but failed quite often. */
512 read_memory (pc_beg
, prologue
, len
);
514 /* Scanning main()'s prologue
515 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
516 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
523 static const unsigned char img
[] = {
524 0xde, 0xbf, /* out __SP_H__,r29 */
525 0xcd, 0xbf /* out __SP_L__,r28 */
528 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
529 /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
530 if ((insn
& 0xf0f0) == 0xe0c0)
532 locals
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
533 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
534 /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
535 if ((insn
& 0xf0f0) == 0xe0d0)
537 locals
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
538 if (vpc
+ 4 + sizeof (img
) < len
539 && memcmp (prologue
+ vpc
+ 4, img
, sizeof (img
)) == 0)
541 info
->prologue_type
= AVR_PROLOGUE_MAIN
;
549 /* Scanning `-mcall-prologues' prologue
550 Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
552 while (1) /* Using a while to avoid many goto's */
559 /* At least the fifth instruction must have been executed to
560 modify frame shape. */
564 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
565 /* ldi r26,<LOCALS_SIZE> */
566 if ((insn
& 0xf0f0) != 0xe0a0)
568 loc_size
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
571 insn
= extract_unsigned_integer (&prologue
[vpc
+ 2], 2, byte_order
);
572 /* ldi r27,<LOCALS_SIZE> / 256 */
573 if ((insn
& 0xf0f0) != 0xe0b0)
575 loc_size
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
578 insn
= extract_unsigned_integer (&prologue
[vpc
+ 4], 2, byte_order
);
579 /* ldi r30,pm_lo8(.L_foo_body) */
580 if ((insn
& 0xf0f0) != 0xe0e0)
582 body_addr
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
585 insn
= extract_unsigned_integer (&prologue
[vpc
+ 6], 2, byte_order
);
586 /* ldi r31,pm_hi8(.L_foo_body) */
587 if ((insn
& 0xf0f0) != 0xe0f0)
589 body_addr
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
592 msymbol
= lookup_minimal_symbol ("__prologue_saves__", NULL
, NULL
);
596 insn
= extract_unsigned_integer (&prologue
[vpc
+ 8], 2, byte_order
);
597 /* rjmp __prologue_saves__+RRR */
598 if ((insn
& 0xf000) == 0xc000)
600 /* Extract PC relative offset from RJMP */
601 i
= (insn
& 0xfff) | (insn
& 0x800 ? (-1 ^ 0xfff) : 0);
602 /* Convert offset to byte addressable mode */
604 /* Destination address */
607 if (body_addr
!= (pc_beg
+ 10)/2)
612 else if ((insn
& 0xfe0e) == 0x940c)
614 /* Extract absolute PC address from JMP */
615 i
= (((insn
& 0x1) | ((insn
& 0x1f0) >> 3) << 16)
616 | (extract_unsigned_integer (&prologue
[vpc
+ 10], 2, byte_order
)
618 /* Convert address to byte addressable mode */
621 if (body_addr
!= (pc_beg
+ 12)/2)
629 /* Resolve offset (in words) from __prologue_saves__ symbol.
630 Which is a pushes count in `-mcall-prologues' mode */
631 num_pushes
= AVR_MAX_PUSHES
- (i
- SYMBOL_VALUE_ADDRESS (msymbol
)) / 2;
633 if (num_pushes
> AVR_MAX_PUSHES
)
635 fprintf_unfiltered (gdb_stderr
, _("Num pushes too large: %d\n"),
644 info
->saved_regs
[AVR_FP_REGNUM
+ 1].addr
= num_pushes
;
646 info
->saved_regs
[AVR_FP_REGNUM
].addr
= num_pushes
- 1;
649 for (from
= AVR_LAST_PUSHED_REGNUM
+ 1 - (num_pushes
- 2);
650 from
<= AVR_LAST_PUSHED_REGNUM
; ++from
)
651 info
->saved_regs
[from
].addr
= ++i
;
653 info
->size
= loc_size
+ num_pushes
;
654 info
->prologue_type
= AVR_PROLOGUE_CALL
;
656 return pc_beg
+ pc_offset
;
659 /* Scan for the beginning of the prologue for an interrupt or signal
660 function. Note that we have to set the prologue type here since the
661 third stage of the prologue may not be present (e.g. no saved registered
662 or changing of the SP register). */
666 static const unsigned char img
[] = {
667 0x78, 0x94, /* sei */
668 0x1f, 0x92, /* push r1 */
669 0x0f, 0x92, /* push r0 */
670 0x0f, 0xb6, /* in r0,0x3f SREG */
671 0x0f, 0x92, /* push r0 */
672 0x11, 0x24 /* clr r1 */
674 if (len
>= sizeof (img
)
675 && memcmp (prologue
, img
, sizeof (img
)) == 0)
677 info
->prologue_type
= AVR_PROLOGUE_INTR
;
679 info
->saved_regs
[AVR_SREG_REGNUM
].addr
= 3;
680 info
->saved_regs
[0].addr
= 2;
681 info
->saved_regs
[1].addr
= 1;
684 else if (len
>= sizeof (img
) - 2
685 && memcmp (img
+ 2, prologue
, sizeof (img
) - 2) == 0)
687 info
->prologue_type
= AVR_PROLOGUE_SIG
;
688 vpc
+= sizeof (img
) - 2;
689 info
->saved_regs
[AVR_SREG_REGNUM
].addr
= 3;
690 info
->saved_regs
[0].addr
= 2;
691 info
->saved_regs
[1].addr
= 1;
696 /* First stage of the prologue scanning.
697 Scan pushes (saved registers) */
699 for (; vpc
< len
; vpc
+= 2)
701 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
702 if ((insn
& 0xfe0f) == 0x920f) /* push rXX */
704 /* Bits 4-9 contain a mask for registers R0-R32. */
705 int regno
= (insn
& 0x1f0) >> 4;
707 info
->saved_regs
[regno
].addr
= info
->size
;
714 gdb_assert (vpc
< AVR_MAX_PROLOGUE_SIZE
);
716 /* Handle static small stack allocation using rcall or push. */
718 while (scan_stage
== 1 && vpc
< len
)
720 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
721 if (insn
== 0xd000) /* rcall .+0 */
723 info
->size
+= gdbarch_tdep (gdbarch
)->call_length
;
726 else if (insn
== 0x920f) /* push r0 */
735 /* Second stage of the prologue scanning.
740 if (scan_stage
== 1 && vpc
< len
)
742 static const unsigned char img
[] = {
743 0xcd, 0xb7, /* in r28,__SP_L__ */
744 0xde, 0xb7 /* in r29,__SP_H__ */
746 unsigned short insn1
;
748 if (vpc
+ sizeof (img
) < len
749 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
756 /* Third stage of the prologue scanning. (Really two stages).
758 sbiw r28,XX or subi r28,lo8(XX)
760 in __tmp_reg__,__SREG__
763 out __SREG__,__tmp_reg__
766 if (scan_stage
== 2 && vpc
< len
)
769 static const unsigned char img
[] = {
770 0x0f, 0xb6, /* in r0,0x3f */
771 0xf8, 0x94, /* cli */
772 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
773 0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
774 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
776 static const unsigned char img_sig
[] = {
777 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
778 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
780 static const unsigned char img_int
[] = {
781 0xf8, 0x94, /* cli */
782 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
783 0x78, 0x94, /* sei */
784 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
787 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
788 if ((insn
& 0xff30) == 0x9720) /* sbiw r28,XXX */
790 locals_size
= (insn
& 0xf) | ((insn
& 0xc0) >> 2);
793 else if ((insn
& 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
795 locals_size
= (insn
& 0xf) | ((insn
& 0xf00) >> 4);
797 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
799 locals_size
+= ((insn
& 0xf) | ((insn
& 0xf00) >> 4)) << 8;
804 /* Scan the last part of the prologue. May not be present for interrupt
805 or signal handler functions, which is why we set the prologue type
806 when we saw the beginning of the prologue previously. */
808 if (vpc
+ sizeof (img_sig
) < len
809 && memcmp (prologue
+ vpc
, img_sig
, sizeof (img_sig
)) == 0)
811 vpc
+= sizeof (img_sig
);
813 else if (vpc
+ sizeof (img_int
) < len
814 && memcmp (prologue
+ vpc
, img_int
, sizeof (img_int
)) == 0)
816 vpc
+= sizeof (img_int
);
818 if (vpc
+ sizeof (img
) < len
819 && memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
821 info
->prologue_type
= AVR_PROLOGUE_NORMAL
;
825 info
->size
+= locals_size
;
830 /* If we got this far, we could not scan the prologue, so just return the pc
831 of the frame plus an adjustment for argument move insns. */
833 for (; vpc
< len
; vpc
+= 2)
835 insn
= extract_unsigned_integer (&prologue
[vpc
], 2, byte_order
);
836 if ((insn
& 0xff00) == 0x0100) /* movw rXX, rYY */
838 else if ((insn
& 0xfc00) == 0x2c00) /* mov rXX, rYY */
848 avr_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
850 CORE_ADDR func_addr
, func_end
;
851 CORE_ADDR post_prologue_pc
;
853 /* See what the symbol table says */
855 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
858 post_prologue_pc
= skip_prologue_using_sal (gdbarch
, func_addr
);
859 if (post_prologue_pc
!= 0)
860 return max (pc
, post_prologue_pc
);
863 CORE_ADDR prologue_end
= pc
;
864 struct avr_unwind_cache info
= {0};
865 struct trad_frame_saved_reg saved_regs
[AVR_NUM_REGS
];
867 info
.saved_regs
= saved_regs
;
869 /* Need to run the prologue scanner to figure out if the function has a
870 prologue and possibly skip over moving arguments passed via registers
871 to other registers. */
873 prologue_end
= avr_scan_prologue (gdbarch
, func_addr
, func_end
, &info
);
875 if (info
.prologue_type
!= AVR_PROLOGUE_NONE
)
879 /* Either we didn't find the start of this function (nothing we can do),
880 or there's no line info, or the line after the prologue is after
881 the end of the function (there probably isn't a prologue). */
886 /* Not all avr devices support the BREAK insn. Those that don't should treat
887 it as a NOP. Thus, it should be ok. Since the avr is currently a remote
888 only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
890 static const unsigned char *
891 avr_breakpoint_from_pc (struct gdbarch
*gdbarch
,
892 CORE_ADDR
*pcptr
, int *lenptr
)
894 static const unsigned char avr_break_insn
[] = { 0x98, 0x95 };
895 *lenptr
= sizeof (avr_break_insn
);
896 return avr_break_insn
;
899 /* Determine, for architecture GDBARCH, how a return value of TYPE
900 should be returned. If it is supposed to be returned in registers,
901 and READBUF is non-zero, read the appropriate value from REGCACHE,
902 and copy it into READBUF. If WRITEBUF is non-zero, write the value
903 from WRITEBUF into REGCACHE. */
905 static enum return_value_convention
906 avr_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
907 struct type
*valtype
, struct regcache
*regcache
,
908 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
911 /* Single byte are returned in r24.
912 Otherwise, the MSB of the return value is always in r25, calculate which
913 register holds the LSB. */
916 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
917 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
918 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
919 && TYPE_LENGTH (valtype
) > 8)
920 return RETURN_VALUE_STRUCT_CONVENTION
;
922 if (TYPE_LENGTH (valtype
) <= 2)
924 else if (TYPE_LENGTH (valtype
) <= 4)
926 else if (TYPE_LENGTH (valtype
) <= 8)
929 gdb_assert_not_reached ("unexpected type length");
931 if (writebuf
!= NULL
)
933 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
934 regcache_cooked_write (regcache
, lsb_reg
+ i
, writebuf
+ i
);
939 for (i
= 0; i
< TYPE_LENGTH (valtype
); i
++)
940 regcache_cooked_read (regcache
, lsb_reg
+ i
, readbuf
+ i
);
943 return RETURN_VALUE_REGISTER_CONVENTION
;
947 /* Put here the code to store, into fi->saved_regs, the addresses of
948 the saved registers of frame described by FRAME_INFO. This
949 includes special registers such as pc and fp saved in special ways
950 in the stack frame. sp is even more special: the address we return
951 for it IS the sp for the next frame. */
953 static struct avr_unwind_cache
*
954 avr_frame_unwind_cache (struct frame_info
*this_frame
,
955 void **this_prologue_cache
)
957 CORE_ADDR start_pc
, current_pc
;
960 struct avr_unwind_cache
*info
;
961 struct gdbarch
*gdbarch
;
962 struct gdbarch_tdep
*tdep
;
965 if (*this_prologue_cache
)
966 return *this_prologue_cache
;
968 info
= FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache
);
969 *this_prologue_cache
= info
;
970 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
973 info
->prologue_type
= AVR_PROLOGUE_NONE
;
975 start_pc
= get_frame_func (this_frame
);
976 current_pc
= get_frame_pc (this_frame
);
977 if ((start_pc
> 0) && (start_pc
<= current_pc
))
978 avr_scan_prologue (get_frame_arch (this_frame
),
979 start_pc
, current_pc
, info
);
981 if ((info
->prologue_type
!= AVR_PROLOGUE_NONE
)
982 && (info
->prologue_type
!= AVR_PROLOGUE_MAIN
))
984 ULONGEST high_base
; /* High byte of FP */
986 /* The SP was moved to the FP. This indicates that a new frame
987 was created. Get THIS frame's FP value by unwinding it from
989 this_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
);
990 high_base
= get_frame_register_unsigned (this_frame
, AVR_FP_REGNUM
+ 1);
991 this_base
+= (high_base
<< 8);
993 /* The FP points at the last saved register. Adjust the FP back
994 to before the first saved register giving the SP. */
995 prev_sp
= this_base
+ info
->size
;
999 /* Assume that the FP is this frame's SP but with that pushed
1000 stack space added back. */
1001 this_base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1002 prev_sp
= this_base
+ info
->size
;
1005 /* Add 1 here to adjust for the post-decrement nature of the push
1007 info
->prev_sp
= avr_make_saddr (prev_sp
+ 1);
1008 info
->base
= avr_make_saddr (this_base
);
1010 gdbarch
= get_frame_arch (this_frame
);
1012 /* Adjust all the saved registers so that they contain addresses and not
1014 for (i
= 0; i
< gdbarch_num_regs (gdbarch
) - 1; i
++)
1015 if (info
->saved_regs
[i
].addr
> 0)
1016 info
->saved_regs
[i
].addr
= info
->prev_sp
- info
->saved_regs
[i
].addr
;
1018 /* Except for the main and startup code, the return PC is always saved on
1019 the stack and is at the base of the frame. */
1021 if (info
->prologue_type
!= AVR_PROLOGUE_MAIN
)
1022 info
->saved_regs
[AVR_PC_REGNUM
].addr
= info
->prev_sp
;
1024 /* The previous frame's SP needed to be computed. Save the computed
1026 tdep
= gdbarch_tdep (gdbarch
);
1027 trad_frame_set_value (info
->saved_regs
, AVR_SP_REGNUM
,
1028 info
->prev_sp
- 1 + tdep
->call_length
);
1034 avr_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1038 pc
= frame_unwind_register_unsigned (next_frame
, AVR_PC_REGNUM
);
1040 return avr_make_iaddr (pc
);
1044 avr_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1048 sp
= frame_unwind_register_unsigned (next_frame
, AVR_SP_REGNUM
);
1050 return avr_make_saddr (sp
);
1053 /* Given a GDB frame, determine the address of the calling function's
1054 frame. This will be used to create a new GDB frame struct. */
1057 avr_frame_this_id (struct frame_info
*this_frame
,
1058 void **this_prologue_cache
,
1059 struct frame_id
*this_id
)
1061 struct avr_unwind_cache
*info
1062 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1067 /* The FUNC is easy. */
1068 func
= get_frame_func (this_frame
);
1070 /* Hopefully the prologue analysis either correctly determined the
1071 frame's base (which is the SP from the previous frame), or set
1072 that base to "NULL". */
1073 base
= info
->prev_sp
;
1077 id
= frame_id_build (base
, func
);
1081 static struct value
*
1082 avr_frame_prev_register (struct frame_info
*this_frame
,
1083 void **this_prologue_cache
, int regnum
)
1085 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1086 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1087 struct avr_unwind_cache
*info
1088 = avr_frame_unwind_cache (this_frame
, this_prologue_cache
);
1090 if (regnum
== AVR_PC_REGNUM
|| regnum
== AVR_PSEUDO_PC_REGNUM
)
1092 if (trad_frame_addr_p (info
->saved_regs
, AVR_PC_REGNUM
))
1094 /* Reading the return PC from the PC register is slightly
1095 abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
1096 but in reality, only two bytes (3 in upcoming mega256) are
1097 stored on the stack.
1099 Also, note that the value on the stack is an addr to a word
1100 not a byte, so we will need to multiply it by two at some
1103 And to confuse matters even more, the return address stored
1104 on the stack is in big endian byte order, even though most
1105 everything else about the avr is little endian. Ick! */
1108 unsigned char buf
[3];
1109 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1110 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1112 read_memory (info
->saved_regs
[AVR_PC_REGNUM
].addr
,
1113 buf
, tdep
->call_length
);
1115 /* Extract the PC read from memory as a big-endian. */
1117 for (i
= 0; i
< tdep
->call_length
; i
++)
1118 pc
= (pc
<< 8) | buf
[i
];
1120 if (regnum
== AVR_PC_REGNUM
)
1123 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
1126 return frame_unwind_got_optimized (this_frame
, regnum
);
1129 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1132 static const struct frame_unwind avr_frame_unwind
= {
1134 default_frame_unwind_stop_reason
,
1136 avr_frame_prev_register
,
1138 default_frame_sniffer
1142 avr_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1144 struct avr_unwind_cache
*info
1145 = avr_frame_unwind_cache (this_frame
, this_cache
);
1150 static const struct frame_base avr_frame_base
= {
1152 avr_frame_base_address
,
1153 avr_frame_base_address
,
1154 avr_frame_base_address
1157 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1158 frame. The frame ID's base needs to match the TOS value saved by
1159 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1161 static struct frame_id
1162 avr_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1166 base
= get_frame_register_unsigned (this_frame
, AVR_SP_REGNUM
);
1167 return frame_id_build (avr_make_saddr (base
), get_frame_pc (this_frame
));
1170 /* When arguments must be pushed onto the stack, they go on in reverse
1171 order. The below implements a FILO (stack) to do this. */
1176 struct stack_item
*prev
;
1180 static struct stack_item
*
1181 push_stack_item (struct stack_item
*prev
, const bfd_byte
*contents
, int len
)
1183 struct stack_item
*si
;
1184 si
= xmalloc (sizeof (struct stack_item
));
1185 si
->data
= xmalloc (len
);
1188 memcpy (si
->data
, contents
, len
);
1192 static struct stack_item
*pop_stack_item (struct stack_item
*si
);
1193 static struct stack_item
*
1194 pop_stack_item (struct stack_item
*si
)
1196 struct stack_item
*dead
= si
;
1203 /* Setup the function arguments for calling a function in the inferior.
1205 On the AVR architecture, there are 18 registers (R25 to R8) which are
1206 dedicated for passing function arguments. Up to the first 18 arguments
1207 (depending on size) may go into these registers. The rest go on the stack.
1209 All arguments are aligned to start in even-numbered registers (odd-sized
1210 arguments, including char, have one free register above them). For example,
1211 an int in arg1 and a char in arg2 would be passed as such:
1216 Arguments that are larger than 2 bytes will be split between two or more
1217 registers as available, but will NOT be split between a register and the
1218 stack. Arguments that go onto the stack are pushed last arg first (this is
1219 similar to the d10v). */
1221 /* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1224 An exceptional case exists for struct arguments (and possibly other
1225 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1226 not a multiple of WORDSIZE bytes. In this case the argument is never split
1227 between the registers and the stack, but instead is copied in its entirety
1228 onto the stack, AND also copied into as many registers as there is room
1229 for. In other words, space in registers permitting, two copies of the same
1230 argument are passed in. As far as I can tell, only the one on the stack is
1231 used, although that may be a function of the level of compiler
1232 optimization. I suspect this is a compiler bug. Arguments of these odd
1233 sizes are left-justified within the word (as opposed to arguments smaller
1234 than WORDSIZE bytes, which are right-justified).
1236 If the function is to return an aggregate type such as a struct, the caller
1237 must allocate space into which the callee will copy the return value. In
1238 this case, a pointer to the return value location is passed into the callee
1239 in register R0, which displaces one of the other arguments passed in via
1240 registers R0 to R2. */
1243 avr_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1244 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1245 int nargs
, struct value
**args
, CORE_ADDR sp
,
1246 int struct_return
, CORE_ADDR struct_addr
)
1248 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1250 unsigned char buf
[3];
1251 int call_length
= gdbarch_tdep (gdbarch
)->call_length
;
1252 CORE_ADDR return_pc
= avr_convert_iaddr_to_raw (bp_addr
);
1253 int regnum
= AVR_ARGN_REGNUM
;
1254 struct stack_item
*si
= NULL
;
1258 regcache_cooked_write_unsigned
1259 (regcache
, regnum
--, (struct_addr
>> 8) & 0xff);
1260 regcache_cooked_write_unsigned
1261 (regcache
, regnum
--, struct_addr
& 0xff);
1262 /* SP being post decremented, we need to reserve one byte so that the
1263 return address won't overwrite the result (or vice-versa). */
1264 if (sp
== struct_addr
)
1268 for (i
= 0; i
< nargs
; i
++)
1272 struct value
*arg
= args
[i
];
1273 struct type
*type
= check_typedef (value_type (arg
));
1274 const bfd_byte
*contents
= value_contents (arg
);
1275 int len
= TYPE_LENGTH (type
);
1277 /* Calculate the potential last register needed. */
1278 last_regnum
= regnum
- (len
+ (len
& 1));
1280 /* If there are registers available, use them. Once we start putting
1281 stuff on the stack, all subsequent args go on stack. */
1282 if ((si
== NULL
) && (last_regnum
>= 8))
1286 /* Skip a register for odd length args. */
1290 val
= extract_unsigned_integer (contents
, len
, byte_order
);
1291 for (j
= 0; j
< len
; j
++)
1292 regcache_cooked_write_unsigned
1293 (regcache
, regnum
--, val
>> (8 * (len
- j
- 1)));
1295 /* No registers available, push the args onto the stack. */
1298 /* From here on, we don't care about regnum. */
1299 si
= push_stack_item (si
, contents
, len
);
1303 /* Push args onto the stack. */
1307 /* Add 1 to sp here to account for post decr nature of pushes. */
1308 write_memory (sp
+ 1, si
->data
, si
->len
);
1309 si
= pop_stack_item (si
);
1312 /* Set the return address. For the avr, the return address is the BP_ADDR.
1313 Need to push the return address onto the stack noting that it needs to be
1314 in big-endian order on the stack. */
1315 for (i
= 1; i
<= call_length
; i
++)
1317 buf
[call_length
- i
] = return_pc
& 0xff;
1322 /* Use 'sp + 1' since pushes are post decr ops. */
1323 write_memory (sp
+ 1, buf
, call_length
);
1325 /* Finally, update the SP register. */
1326 regcache_cooked_write_unsigned (regcache
, AVR_SP_REGNUM
,
1327 avr_convert_saddr_to_raw (sp
));
1329 /* Return SP value for the dummy frame, where the return address hasn't been
1331 return sp
+ call_length
;
1334 /* Unfortunately dwarf2 register for SP is 32. */
1337 avr_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
1339 if (reg
>= 0 && reg
< 32)
1342 return AVR_SP_REGNUM
;
1344 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
1349 /* Initialize the gdbarch structure for the AVR's. */
1351 static struct gdbarch
*
1352 avr_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1354 struct gdbarch
*gdbarch
;
1355 struct gdbarch_tdep
*tdep
;
1356 struct gdbarch_list
*best_arch
;
1359 /* Avr-6 call instructions save 3 bytes. */
1360 switch (info
.bfd_arch_info
->mach
)
1375 /* If there is already a candidate, use it. */
1376 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1378 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1380 if (gdbarch_tdep (best_arch
->gdbarch
)->call_length
== call_length
)
1381 return best_arch
->gdbarch
;
1384 /* None found, create a new architecture from the information provided. */
1385 tdep
= XMALLOC (struct gdbarch_tdep
);
1386 gdbarch
= gdbarch_alloc (&info
, tdep
);
1388 tdep
->call_length
= call_length
;
1390 /* Create a type for PC. We can't use builtin types here, as they may not
1392 tdep
->void_type
= arch_type (gdbarch
, TYPE_CODE_VOID
, 1, "void");
1393 tdep
->func_void_type
= make_function_type (tdep
->void_type
, NULL
);
1394 tdep
->pc_type
= arch_type (gdbarch
, TYPE_CODE_PTR
, 4, NULL
);
1395 TYPE_TARGET_TYPE (tdep
->pc_type
) = tdep
->func_void_type
;
1396 TYPE_UNSIGNED (tdep
->pc_type
) = 1;
1398 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1399 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1400 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1401 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1402 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1403 set_gdbarch_addr_bit (gdbarch
, 32);
1405 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1406 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1407 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1409 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1410 set_gdbarch_double_format (gdbarch
, floatformats_ieee_single
);
1411 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_single
);
1413 set_gdbarch_read_pc (gdbarch
, avr_read_pc
);
1414 set_gdbarch_write_pc (gdbarch
, avr_write_pc
);
1416 set_gdbarch_num_regs (gdbarch
, AVR_NUM_REGS
);
1418 set_gdbarch_sp_regnum (gdbarch
, AVR_SP_REGNUM
);
1419 set_gdbarch_pc_regnum (gdbarch
, AVR_PC_REGNUM
);
1421 set_gdbarch_register_name (gdbarch
, avr_register_name
);
1422 set_gdbarch_register_type (gdbarch
, avr_register_type
);
1424 set_gdbarch_num_pseudo_regs (gdbarch
, AVR_NUM_PSEUDO_REGS
);
1425 set_gdbarch_pseudo_register_read (gdbarch
, avr_pseudo_register_read
);
1426 set_gdbarch_pseudo_register_write (gdbarch
, avr_pseudo_register_write
);
1428 set_gdbarch_return_value (gdbarch
, avr_return_value
);
1429 set_gdbarch_print_insn (gdbarch
, print_insn_avr
);
1431 set_gdbarch_push_dummy_call (gdbarch
, avr_push_dummy_call
);
1433 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, avr_dwarf_reg_to_regnum
);
1435 set_gdbarch_address_to_pointer (gdbarch
, avr_address_to_pointer
);
1436 set_gdbarch_pointer_to_address (gdbarch
, avr_pointer_to_address
);
1437 set_gdbarch_integer_to_address (gdbarch
, avr_integer_to_address
);
1439 set_gdbarch_skip_prologue (gdbarch
, avr_skip_prologue
);
1440 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1442 set_gdbarch_breakpoint_from_pc (gdbarch
, avr_breakpoint_from_pc
);
1444 frame_unwind_append_unwinder (gdbarch
, &avr_frame_unwind
);
1445 frame_base_set_default (gdbarch
, &avr_frame_base
);
1447 set_gdbarch_dummy_id (gdbarch
, avr_dummy_id
);
1449 set_gdbarch_unwind_pc (gdbarch
, avr_unwind_pc
);
1450 set_gdbarch_unwind_sp (gdbarch
, avr_unwind_sp
);
1455 /* Send a query request to the avr remote target asking for values of the io
1456 registers. If args parameter is not NULL, then the user has requested info
1457 on a specific io register [This still needs implemented and is ignored for
1458 now]. The query string should be one of these forms:
1460 "Ravr.io_reg" -> reply is "NN" number of io registers
1462 "Ravr.io_reg:addr,len" where addr is first register and len is number of
1463 registers to be read. The reply should be "<NAME>,VV;" for each io register
1464 where, <NAME> is a string, and VV is the hex value of the register.
1466 All io registers are 8-bit. */
1469 avr_io_reg_read_command (char *args
, int from_tty
)
1475 unsigned int nreg
= 0;
1479 /* Find out how many io registers the target has. */
1480 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1481 "avr.io_reg", &buf
);
1485 fprintf_unfiltered (gdb_stderr
,
1486 _("ERR: info io_registers NOT supported "
1487 "by current target\n"));
1491 if (sscanf (buf
, "%x", &nreg
) != 1)
1493 fprintf_unfiltered (gdb_stderr
,
1494 _("Error fetching number of io registers\n"));
1501 reinitialize_more_filter ();
1503 printf_unfiltered (_("Target has %u io registers:\n\n"), nreg
);
1505 /* only fetch up to 8 registers at a time to keep the buffer small */
1508 for (i
= 0; i
< nreg
; i
+= step
)
1510 /* how many registers this round? */
1513 j
= nreg
- i
; /* last block is less than 8 registers */
1515 snprintf (query
, sizeof (query
) - 1, "avr.io_reg:%x,%x", i
, j
);
1516 bufsiz
= target_read_alloc (¤t_target
, TARGET_OBJECT_AVR
,
1520 for (k
= i
; k
< (i
+ j
); k
++)
1522 if (sscanf (p
, "%[^,],%x;", query
, &val
) == 2)
1524 printf_filtered ("[%02x] %-15s : %02x\n", k
, query
, val
);
1525 while ((*p
!= ';') && (*p
!= '\0'))
1527 p
++; /* skip over ';' */
1537 extern initialize_file_ftype _initialize_avr_tdep
; /* -Wmissing-prototypes */
1540 _initialize_avr_tdep (void)
1542 register_gdbarch_init (bfd_arch_avr
, avr_gdbarch_init
);
1544 /* Add a new command to allow the user to query the avr remote target for
1545 the values of the io space registers in a saner way than just using
1548 /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1549 io_registers' to signify it is not available on other platforms. */
1551 add_cmd ("io_registers", class_info
, avr_io_reg_read_command
,
1552 _("query remote avr target for io space register values"),