1 /* Target-dependent code for Atmel AVR, for GDB.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Contributed by Theodore A. Roth, troth@verinet.com */
24 /* Portions of this file were taken from the original gdb-4.18 patch developed
25 by Denis Chertykov, denisc@overta.ru */
32 #include "arch-utils.h"
37 (AVR micros are pure Harvard Architecture processors.)
39 The AVR family of microcontrollers have three distinctly different memory
40 spaces: flash, sram and eeprom. The flash is 16 bits wide and is used for
41 the most part to store program instructions. The sram is 8 bits wide and is
42 used for the stack and the heap. Some devices lack sram and some can have
43 an additional external sram added on as a peripheral.
45 The eeprom is 8 bits wide and is used to store data when the device is
46 powered down. Eeprom is not directly accessible, it can only be accessed
47 via io-registers using a special algorithm. Accessing eeprom via gdb's
48 remote serial protocol ('m' or 'M' packets) looks difficult to do and is
49 not included at this time.
51 [The eeprom could be read manually via ``x/b <eaddr + AVR_EMEM_START>'' or
52 written using ``set {unsigned char}<eaddr + AVR_EMEM_START>''. For this to
53 work, the remote target must be able to handle eeprom accesses and perform
54 the address translation.]
56 All three memory spaces have physical addresses beginning at 0x0. In
57 addition, the flash is addressed by gcc/binutils/gdb with respect to 8 bit
58 bytes instead of the 16 bit wide words used by the real device for the
61 In order for remote targets to work correctly, extra bits must be added to
62 addresses before they are send to the target or received from the target
63 via the remote serial protocol. The extra bits are the MSBs and are used to
64 decode which memory space the address is referring to. */
67 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
70 #define EXTRACT_INSN(addr) extract_unsigned_integer(addr,2)
72 /* Constants: prefixed with AVR_ to avoid name space clashes */
86 AVR_NUM_REGS
= 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
87 AVR_NUM_REG_BYTES
= 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
89 AVR_PC_REG_INDEX
= 35, /* index into array of registers */
91 AVR_MAX_PROLOGUE_SIZE
= 56, /* bytes */
93 /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
96 /* Number of the last pushed register. r17 for current avr-gcc */
97 AVR_LAST_PUSHED_REGNUM
= 17,
99 /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
100 bits? Do these have to match the bfd vma values?. It sure would make
101 things easier in the future if they didn't need to match.
103 Note: I chose these values so as to be consistent with bfd vma
106 TRoth/2002-04-08: There is already a conflict with very large programs
107 in the mega128. The mega128 has 128K instruction bytes (64K words),
108 thus the Most Significant Bit is 0x10000 which gets masked off my
111 The problem manifests itself when trying to set a breakpoint in a
112 function which resides in the upper half of the instruction space and
113 thus requires a 17-bit address.
115 For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
116 from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
117 but could be for some remote targets by just adding the correct offset
118 to the address and letting the remote target handle the low-level
119 details of actually accessing the eeprom. */
121 AVR_IMEM_START
= 0x00000000, /* INSN memory */
122 AVR_SMEM_START
= 0x00800000, /* SRAM memory */
124 /* No eeprom mask defined */
125 AVR_MEM_MASK
= 0x00f00000, /* mask to determine memory space */
127 AVR_EMEM_START
= 0x00810000, /* EEPROM memory */
128 AVR_MEM_MASK
= 0x00ff0000, /* mask to determine memory space */
132 /* Any function with a frame looks like this
133 ....... <-SP POINTS HERE
134 LOCALS1 <-FP POINTS HERE
143 struct frame_extra_info
146 CORE_ADDR args_pointer
;
155 /* FIXME: TRoth: is there anything to put here? */
159 /* Lookup the name of a register given it's number. */
162 avr_register_name (int regnum
)
164 static char *register_names
[] =
166 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
167 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
168 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
169 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
174 if (regnum
>= (sizeof (register_names
) / sizeof (*register_names
)))
176 return register_names
[regnum
];
179 /* Index within `registers' of the first byte of the space for
183 avr_register_byte (int regnum
)
185 if (regnum
< AVR_PC_REGNUM
)
188 return AVR_PC_REG_INDEX
;
191 /* Number of bytes of storage in the actual machine representation for
195 avr_register_raw_size (int regnum
)
209 /* Number of bytes of storage in the program's representation
213 avr_register_virtual_size (int regnum
)
215 return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum
));
218 /* Return the GDB type object for the "standard" data type
219 of data in register N. */
222 avr_register_virtual_type (int regnum
)
227 return builtin_type_unsigned_long
;
229 return builtin_type_unsigned_short
;
231 return builtin_type_unsigned_char
;
235 /* Instruction address checks and convertions. */
238 avr_make_iaddr (CORE_ADDR x
)
240 return ((x
) | AVR_IMEM_START
);
244 avr_iaddr_p (CORE_ADDR x
)
246 return (((x
) & AVR_MEM_MASK
) == AVR_IMEM_START
);
249 /* FIXME: TRoth: Really need to use a larger mask for instructions. Some
250 devices are already up to 128KBytes of flash space.
252 TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined. */
255 avr_convert_iaddr_to_raw (CORE_ADDR x
)
257 return ((x
) & 0xffffffff);
260 /* SRAM address checks and convertions. */
263 avr_make_saddr (CORE_ADDR x
)
265 return ((x
) | AVR_SMEM_START
);
269 avr_saddr_p (CORE_ADDR x
)
271 return (((x
) & AVR_MEM_MASK
) == AVR_SMEM_START
);
275 avr_convert_saddr_to_raw (CORE_ADDR x
)
277 return ((x
) & 0xffffffff);
280 /* EEPROM address checks and convertions. I don't know if these will ever
281 actually be used, but I've added them just the same. TRoth */
283 /* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
284 programs in the mega128. */
286 /* static CORE_ADDR */
287 /* avr_make_eaddr (CORE_ADDR x) */
289 /* return ((x) | AVR_EMEM_START); */
293 /* avr_eaddr_p (CORE_ADDR x) */
295 /* return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
298 /* static CORE_ADDR */
299 /* avr_convert_eaddr_to_raw (CORE_ADDR x) */
301 /* return ((x) & 0xffffffff); */
304 /* Convert from address to pointer and vice-versa. */
307 avr_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
309 /* Is it a code address? */
310 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
311 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
)
313 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
314 avr_convert_iaddr_to_raw (addr
));
318 /* Strip off any upper segment bits. */
319 store_unsigned_integer (buf
, TYPE_LENGTH (type
),
320 avr_convert_saddr_to_raw (addr
));
325 avr_pointer_to_address (struct type
*type
, void *buf
)
327 CORE_ADDR addr
= extract_address (buf
, TYPE_LENGTH (type
));
329 if ( TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type
)) )
331 fprintf_unfiltered (gdb_stderr
, "CODE_SPACE ---->> ptr->addr: 0x%lx\n", addr
);
332 fprintf_unfiltered (gdb_stderr
, "+++ If you see this, please send me an email <troth@verinet.com>\n");
335 /* Is it a code address? */
336 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
337 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
338 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type
))
340 return avr_make_iaddr (addr
);
342 return avr_make_saddr (addr
);
346 avr_read_pc (ptid_t ptid
)
352 save_ptid
= inferior_ptid
;
353 inferior_ptid
= ptid
;
354 pc
= (int) read_register (AVR_PC_REGNUM
);
355 inferior_ptid
= save_ptid
;
356 retval
= avr_make_iaddr (pc
);
361 avr_write_pc (CORE_ADDR val
, ptid_t ptid
)
365 save_ptid
= inferior_ptid
;
366 inferior_ptid
= ptid
;
367 write_register (AVR_PC_REGNUM
, avr_convert_iaddr_to_raw (val
));
368 inferior_ptid
= save_ptid
;
374 return (avr_make_saddr (read_register (AVR_SP_REGNUM
)));
378 avr_write_sp (CORE_ADDR val
)
380 write_register (AVR_SP_REGNUM
, avr_convert_saddr_to_raw (val
));
386 return (avr_make_saddr (read_register (AVR_FP_REGNUM
)));
389 /* Translate a GDB virtual ADDR/LEN into a format the remote target
390 understands. Returns number of bytes that can be transfered
391 starting at TARG_ADDR. Return ZERO if no bytes can be transfered
392 (segmentation fault).
394 TRoth/2002-04-08: Could this be used to check for dereferencing an invalid
398 avr_remote_translate_xfer_address (CORE_ADDR memaddr
, int nr_bytes
,
399 CORE_ADDR
*targ_addr
, int *targ_len
)
404 /* FIXME: TRoth: Do nothing for now. Will need to examine memaddr at this
405 point and see if the high bit are set with the masks that we want. */
407 *targ_addr
= memaddr
;
408 *targ_len
= nr_bytes
;
411 /* Function pointers obtained from the target are half of what gdb expects so
415 avr_convert_from_func_ptr_addr (CORE_ADDR addr
)
420 /* avr_scan_prologue is also used as the frame_init_saved_regs().
422 Put here the code to store, into fi->saved_regs, the addresses of
423 the saved registers of frame described by FRAME_INFO. This
424 includes special registers such as pc and fp saved in special ways
425 in the stack frame. sp is even more special: the address we return
426 for it IS the sp for the next frame. */
428 /* Function: avr_scan_prologue (helper function for avr_init_extra_frame_info)
429 This function decodes a AVR function prologue to determine:
430 1) the size of the stack frame
431 2) which registers are saved on it
432 3) the offsets of saved regs
433 This information is stored in the "extra_info" field of the frame_info.
435 A typical AVR function prologue might look like this:
441 sbiw r28,<LOCALS_SIZE>
442 in __tmp_reg__,__SREG__
445 out __SREG__,__tmp_reg__
448 A `-mcall-prologues' prologue look like this:
449 ldi r26,<LOCALS_SIZE>
450 ldi r27,<LOCALS_SIZE>/265
451 ldi r30,pm_lo8(.L_foo_body)
452 ldi r31,pm_hi8(.L_foo_body)
453 rjmp __prologue_saves__+RRR
457 avr_scan_prologue (struct frame_info
*fi
)
459 CORE_ADDR prologue_start
;
460 CORE_ADDR prologue_end
;
466 struct minimal_symbol
*msymbol
;
468 unsigned char prologue
[AVR_MAX_PROLOGUE_SIZE
];
471 fi
->extra_info
->framereg
= AVR_SP_REGNUM
;
473 if (find_pc_partial_function (fi
->pc
, &name
, &prologue_start
, &prologue_end
))
475 struct symtab_and_line sal
= find_pc_line (prologue_start
, 0);
477 if (sal
.line
== 0) /* no line info, use current PC */
478 prologue_end
= fi
->pc
;
479 else if (sal
.end
< prologue_end
) /* next line begins after fn end */
480 prologue_end
= sal
.end
; /* (probably means no prologue) */
483 /* We're in the boondocks: allow for */
484 /* 19 pushes, an add, and "mv fp,sp" */
485 prologue_end
= prologue_start
+ AVR_MAX_PROLOGUE_SIZE
;
487 prologue_end
= min (prologue_end
, fi
->pc
);
489 /* Search the prologue looking for instructions that set up the
490 frame pointer, adjust the stack pointer, and save registers. */
492 fi
->extra_info
->framesize
= 0;
493 prologue_len
= prologue_end
- prologue_start
;
494 read_memory (prologue_start
, prologue
, prologue_len
);
496 /* Scanning main()'s prologue
497 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
498 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
502 if (name
&& strcmp ("main", name
) == 0 && prologue_len
== 8)
505 unsigned char img
[] =
507 0xde,0xbf, /* out __SP_H__,r29 */
508 0xcd,0xbf /* out __SP_L__,r28 */
511 fi
->extra_info
->framereg
= AVR_FP_REGNUM
;
512 insn
= EXTRACT_INSN (&prologue
[vpc
]);
513 /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
514 if ((insn
& 0xf0f0) == 0xe0c0)
516 locals
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
517 insn
= EXTRACT_INSN (&prologue
[vpc
+2]);
518 /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
519 if ((insn
& 0xf0f0) == 0xe0d0)
521 locals
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
522 if (memcmp (prologue
+ vpc
+ 4, img
, sizeof (img
)) == 0)
526 /* TRoth: Does -1 mean we're in main? */
527 fi
->extra_info
->is_main
= 1;
534 /* Scanning `-mcall-prologues' prologue
535 FIXME: mega prologue have a 12 bytes long */
537 while (prologue_len
<= 12) /* I'm use while to avoit many goto's */
543 insn
= EXTRACT_INSN (&prologue
[vpc
]);
544 /* ldi r26,<LOCALS_SIZE> */
545 if ((insn
& 0xf0f0) != 0xe0a0)
547 loc_size
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
549 insn
= EXTRACT_INSN (&prologue
[vpc
+ 2]);
550 /* ldi r27,<LOCALS_SIZE> / 256 */
551 if ((insn
& 0xf0f0) != 0xe0b0)
553 loc_size
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
555 insn
= EXTRACT_INSN (&prologue
[vpc
+ 4]);
556 /* ldi r30,pm_lo8(.L_foo_body) */
557 if ((insn
& 0xf0f0) != 0xe0e0)
559 body_addr
= (insn
& 0xf) | ((insn
& 0x0f00) >> 4);
561 insn
= EXTRACT_INSN (&prologue
[vpc
+ 6]);
562 /* ldi r31,pm_hi8(.L_foo_body) */
563 if ((insn
& 0xf0f0) != 0xe0f0)
565 body_addr
|= ((insn
& 0xf) | ((insn
& 0x0f00) >> 4)) << 8;
567 if (body_addr
!= (prologue_start
+ 10) / 2)
570 msymbol
= lookup_minimal_symbol ("__prologue_saves__", NULL
, NULL
);
574 /* FIXME: prologue for mega have a JMP instead of RJMP */
575 insn
= EXTRACT_INSN (&prologue
[vpc
+ 8]);
576 /* rjmp __prologue_saves__+RRR */
577 if ((insn
& 0xf000) != 0xc000)
580 /* Extract PC relative offset from RJMP */
581 i
= (insn
& 0xfff) | (insn
& 0x800 ? (-1 ^ 0xfff) : 0);
582 /* Convert offset to byte addressable mode */
584 /* Destination address */
585 i
+= vpc
+ prologue_start
+ 10;
586 /* Resovle offset (in words) from __prologue_saves__ symbol.
587 Which is a pushes count in `-mcall-prologues' mode */
588 num_pushes
= AVR_MAX_PUSHES
- (i
- SYMBOL_VALUE_ADDRESS (msymbol
)) / 2;
590 if (num_pushes
> AVR_MAX_PUSHES
)
596 fi
->saved_regs
[AVR_FP_REGNUM
+1] = num_pushes
;
598 fi
->saved_regs
[AVR_FP_REGNUM
] = num_pushes
- 1;
600 for (from
= AVR_LAST_PUSHED_REGNUM
+ 1 - (num_pushes
- 2);
601 from
<= AVR_LAST_PUSHED_REGNUM
; ++from
)
602 fi
->saved_regs
[from
] = ++i
;
604 fi
->extra_info
->locals_size
= loc_size
;
605 fi
->extra_info
->framesize
= loc_size
+ num_pushes
;
606 fi
->extra_info
->framereg
= AVR_FP_REGNUM
;
610 /* Scan interrupt or signal function */
612 if (prologue_len
>= 12)
614 unsigned char img
[] =
617 0x1f,0x92, /* push r1 */
618 0x0f,0x92, /* push r0 */
619 0x0f,0xb6, /* in r0,0x3f SREG */
620 0x0f,0x92, /* push r0 */
621 0x11,0x24 /* clr r1 */
623 if (memcmp (prologue
, img
, sizeof (img
)) == 0)
626 fi
->saved_regs
[0] = 2;
627 fi
->saved_regs
[1] = 1;
628 fi
->extra_info
->framesize
+= 3;
630 else if (memcmp (img
+ 1, prologue
, sizeof (img
) - 1) == 0)
632 vpc
+= sizeof (img
) - 1;
633 fi
->saved_regs
[0] = 2;
634 fi
->saved_regs
[1] = 1;
635 fi
->extra_info
->framesize
+= 3;
639 /* First stage of the prologue scanning.
642 for (; vpc
<= prologue_len
; vpc
+= 2)
644 insn
= EXTRACT_INSN (&prologue
[vpc
]);
645 if ((insn
& 0xfe0f) == 0x920f) /* push rXX */
647 /* Bits 4-9 contain a mask for registers R0-R32. */
648 regno
= (insn
& 0x1f0) >> 4;
649 ++fi
->extra_info
->framesize
;
650 fi
->saved_regs
[regno
] = fi
->extra_info
->framesize
;
657 /* Second stage of the prologue scanning.
662 if (scan_stage
== 1 && vpc
+ 4 <= prologue_len
)
664 unsigned char img
[] =
666 0xcd,0xb7, /* in r28,__SP_L__ */
667 0xde,0xb7 /* in r29,__SP_H__ */
669 unsigned short insn1
;
671 if (memcmp (prologue
+ vpc
, img
, sizeof (img
)) == 0)
674 fi
->extra_info
->framereg
= AVR_FP_REGNUM
;
679 /* Third stage of the prologue scanning. (Really two stages)
681 sbiw r28,XX or subi r28,lo8(XX)
683 in __tmp_reg__,__SREG__
686 out __SREG__,__tmp_reg__
689 if (scan_stage
== 2 && vpc
+ 12 <= prologue_len
)
692 unsigned char img
[] =
694 0x0f,0xb6, /* in r0,0x3f */
696 0xcd,0xbf, /* out 0x3d,r28 ; SPL */
697 0x0f,0xbe, /* out 0x3f,r0 ; SREG*/
698 0xde,0xbf /* out 0x3e,r29 ; SPH */
700 unsigned char img_sig
[] =
702 0xcd,0xbf, /* out 0x3d,r28 ; SPL */
703 0xde,0xbf /* out 0x3e,r29 ; SPH */
705 unsigned char img_int
[] =
708 0xcd,0xbf, /* out 0x3d,r28 ; SPL */
710 0xde,0xbf /* out 0x3e,r29 ; SPH */
713 insn
= EXTRACT_INSN (&prologue
[vpc
]);
715 if ((insn
& 0xff30) == 0x9720) /* sbiw r28,XXX */
716 locals_size
= (insn
& 0xf) | ((insn
& 0xc0) >> 2);
717 else if ((insn
& 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
719 locals_size
= (insn
& 0xf) | ((insn
& 0xf00) >> 4);
720 insn
= EXTRACT_INSN (&prologue
[vpc
]);
722 locals_size
+= ((insn
& 0xf) | ((insn
& 0xf00) >> 4) << 8);
726 fi
->extra_info
->locals_size
= locals_size
;
727 fi
->extra_info
->framesize
+= locals_size
;
731 /* This function actually figures out the frame address for a given pc and
732 sp. This is tricky because we sometimes don't use an explicit
733 frame pointer, and the previous stack pointer isn't necessarily recorded
734 on the stack. The only reliable way to get this info is to
735 examine the prologue. */
738 avr_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
743 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
745 fi
->extra_info
= (struct frame_extra_info
*)
746 frame_obstack_alloc (sizeof (struct frame_extra_info
));
747 frame_saved_regs_zalloc (fi
);
749 fi
->extra_info
->return_pc
= 0;
750 fi
->extra_info
->args_pointer
= 0;
751 fi
->extra_info
->locals_size
= 0;
752 fi
->extra_info
->framereg
= 0;
753 fi
->extra_info
->framesize
= 0;
754 fi
->extra_info
->is_main
= 0;
756 avr_scan_prologue (fi
);
758 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
760 /* We need to setup fi->frame here because run_stack_dummy gets it wrong
761 by assuming it's always FP. */
762 fi
->frame
= generic_read_register_dummy (fi
->pc
, fi
->frame
,
765 else if (!fi
->next
) /* this is the innermost frame? */
766 fi
->frame
= read_register (fi
->extra_info
->framereg
);
767 else if (fi
->extra_info
->is_main
!= 1) /* not the innermost frame, not `main' */
768 /* If we have an next frame, the callee saved it. */
770 struct frame_info
* next_fi
= fi
->next
;
771 if (fi
->extra_info
->framereg
== AVR_SP_REGNUM
)
772 fi
->frame
= next_fi
->frame
+ 2 /* ret addr */ + next_fi
->extra_info
->framesize
;
773 /* FIXME: I don't analyse va_args functions */
778 unsigned int fp_low
, fp_high
;
780 /* Scan all frames */
781 for (; next_fi
; next_fi
= next_fi
->next
)
783 /* look for saved AVR_FP_REGNUM */
784 if (next_fi
->saved_regs
[AVR_FP_REGNUM
] && !fp
)
785 fp
= next_fi
->saved_regs
[AVR_FP_REGNUM
];
786 /* look for saved AVR_FP_REGNUM + 1 */
787 if (next_fi
->saved_regs
[AVR_FP_REGNUM
+ 1] && !fp1
)
788 fp1
= next_fi
->saved_regs
[AVR_FP_REGNUM
+ 1];
790 fp_low
= (fp
? read_memory_unsigned_integer (avr_make_saddr (fp
), 1)
791 : read_register (AVR_FP_REGNUM
)) & 0xff;
792 fp_high
= (fp1
? read_memory_unsigned_integer (avr_make_saddr (fp1
), 1)
793 : read_register (AVR_FP_REGNUM
+ 1)) & 0xff;
794 fi
->frame
= fp_low
| (fp_high
<< 8);
798 /* TRoth: Do we want to do this if we are in main? I don't think we should
799 since return_pc makes no sense when we are in main. */
801 if ((fi
->pc
) && (fi
->extra_info
->is_main
== 0)) /* We are not in CALL_DUMMY */
806 addr
= fi
->frame
+ fi
->extra_info
->framesize
+ 1;
808 /* Return address in stack in different endianness */
810 fi
->extra_info
->return_pc
=
811 read_memory_unsigned_integer (avr_make_saddr (addr
), 1) << 8;
812 fi
->extra_info
->return_pc
|=
813 read_memory_unsigned_integer (avr_make_saddr (addr
+ 1), 1);
815 /* This return address in words,
816 must be converted to the bytes address */
817 fi
->extra_info
->return_pc
*= 2;
819 /* Resolve a pushed registers addresses */
820 for (i
= 0; i
< NUM_REGS
; i
++)
822 if (fi
->saved_regs
[i
])
823 fi
->saved_regs
[i
] = addr
- fi
->saved_regs
[i
];
828 /* Restore the machine to the state it had before the current frame was
829 created. Usually used either by the "RETURN" command, or by
830 call_function_by_hand after the dummy_frame is finished. */
837 struct frame_info
*frame
= get_current_frame ();
839 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
841 generic_pop_dummy_frame();
845 /* TRoth: Why only loop over 8 registers? */
847 for (regnum
= 0; regnum
< 8; regnum
++)
849 /* Don't forget AVR_SP_REGNUM in a frame_saved_regs struct is the
850 actual value we want, not the address of the value we want. */
851 if (frame
->saved_regs
[regnum
] && regnum
!= AVR_SP_REGNUM
)
853 saddr
= avr_make_saddr (frame
->saved_regs
[regnum
]);
854 write_register (regnum
, read_memory_unsigned_integer (saddr
, 1));
856 else if (frame
->saved_regs
[regnum
] && regnum
== AVR_SP_REGNUM
)
857 write_register (regnum
, frame
->frame
+ 2);
860 /* Don't forget the update the PC too! */
861 write_pc (frame
->extra_info
->return_pc
);
863 flush_cached_frames ();
866 /* Return the saved PC from this frame. */
869 avr_frame_saved_pc (struct frame_info
*frame
)
871 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
872 return generic_read_register_dummy (frame
->pc
, frame
->frame
, AVR_PC_REGNUM
);
874 return frame
->extra_info
->return_pc
;
878 avr_saved_pc_after_call (struct frame_info
*frame
)
880 unsigned char m1
, m2
;
881 unsigned int sp
= read_register (AVR_SP_REGNUM
);
882 m1
= read_memory_unsigned_integer (avr_make_saddr (sp
+ 1), 1);
883 m2
= read_memory_unsigned_integer (avr_make_saddr (sp
+ 2), 1);
884 return (m2
| (m1
<< 8)) * 2;
887 /* Figure out where in REGBUF the called function has left its return value.
888 Copy that into VALBUF. */
891 avr_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
897 len
= TYPE_LENGTH(type
);
901 case 2: /* (short), (int) */
902 memcpy (valbuf
, regbuf
+ REGISTER_BYTE(24), 2);
904 case 4: /* (long), (float) */
905 memcpy (valbuf
, regbuf
+ REGISTER_BYTE(22), 4);
907 case 8: /* (double) (doesn't seem to happen, which is good,
908 because this almost certainly isn't right. */
909 error ("I don't know how a double is returned.");
914 /* Returns the return address for a dummy. */
917 avr_call_dummy_address (void)
919 return entry_point_address ();
922 /* Place the appropriate value in the appropriate registers.
923 Primarily used by the RETURN command. */
926 avr_store_return_value (struct type
*type
, char *valbuf
)
928 int wordsize
, len
, regval
;
932 len
= TYPE_LENGTH(type
);
935 case 2: /* short, int */
936 regval
= extract_address(valbuf
, len
);
937 write_register (0, regval
);
939 case 4: /* long, float */
940 regval
= extract_address(valbuf
, len
);
941 write_register (0, regval
>> 16);
942 write_register (1, regval
& 0xffff);
944 case 8: /* presumeably double, but doesn't seem to happen */
945 error ("I don't know how to return a double.");
950 /* Setup the return address for a dummy frame, as called by
951 call_function_by_hand. Only necessary when you are using an empty
955 avr_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
957 unsigned char buf
[2];
959 struct minimal_symbol
*msymbol
;
962 fprintf_unfiltered (gdb_stderr
, "avr_push_return_address() was called\n");
967 write_memory (sp
+ 1, buf
, 2);
970 /* FIXME: TRoth/2002-02-18: This should probably be removed since it's a
971 left-over from Denis' original patch which used avr-mon for the target
972 instead of the generic remote target. */
973 if ((strcmp (target_shortname
, "avr-mon") == 0)
974 && (msymbol
= lookup_minimal_symbol ("gdb_break", NULL
, NULL
)))
976 mon_brk
= SYMBOL_VALUE_ADDRESS (msymbol
);
977 store_unsigned_integer (buf
, wordsize
, mon_brk
/ 2);
979 write_memory (sp
+ 1, buf
+ 1, 1);
980 write_memory (sp
+ 2, buf
, 1);
987 avr_skip_prologue (CORE_ADDR pc
)
989 CORE_ADDR func_addr
, func_end
;
990 struct symtab_and_line sal
;
992 /* See what the symbol table says */
994 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
996 sal
= find_pc_line (func_addr
, 0);
998 if (sal
.line
!= 0 && sal
.end
< func_end
)
1002 /* Either we didn't find the start of this function (nothing we can do),
1003 or there's no line info, or the line after the prologue is after
1004 the end of the function (there probably isn't a prologue). */
1010 avr_frame_address (struct frame_info
*fi
)
1012 return avr_make_saddr (fi
->frame
);
1015 /* Given a GDB frame, determine the address of the calling function's frame.
1016 This will be used to create a new GDB frame struct, and then
1017 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
1019 For us, the frame address is its stack pointer value, so we look up
1020 the function prologue to determine the caller's sp value, and return it. */
1023 avr_frame_chain (struct frame_info
*frame
)
1025 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
1027 /* initialize the return_pc now */
1028 frame
->extra_info
->return_pc
= generic_read_register_dummy (frame
->pc
,
1031 return frame
->frame
;
1033 return (frame
->extra_info
->is_main
? 0
1034 : frame
->frame
+ frame
->extra_info
->framesize
+ 2 /* ret addr */);
1037 /* Store the address of the place in which to copy the structure the
1038 subroutine will return. This is called from call_function.
1040 We store structs through a pointer passed in the first Argument
1044 avr_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
1046 write_register (0, addr
);
1049 /* Extract from an array REGBUF containing the (raw) register state
1050 the address in which a function should return its structure value,
1051 as a CORE_ADDR (or an expression that can be used as one). */
1054 avr_extract_struct_value_address (char *regbuf
)
1056 return (extract_address ((regbuf
) + REGISTER_BYTE (0),
1057 REGISTER_RAW_SIZE (0))
1061 /* Setup the function arguments for calling a function in the inferior.
1063 On the AVR architecture, there are 18 registers (R25 to R8) which are
1064 dedicated for passing function arguments. Up to the first 18 arguments
1065 (depending on size) may go into these registers. The rest go on the stack.
1067 Arguments that are larger than WORDSIZE bytes will be split between two or
1068 more registers as available, but will NOT be split between a register and
1071 An exceptional case exists for struct arguments (and possibly other
1072 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1073 not a multiple of WORDSIZE bytes. In this case the argument is never split
1074 between the registers and the stack, but instead is copied in its entirety
1075 onto the stack, AND also copied into as many registers as there is room
1076 for. In other words, space in registers permitting, two copies of the same
1077 argument are passed in. As far as I can tell, only the one on the stack is
1078 used, although that may be a function of the level of compiler
1079 optimization. I suspect this is a compiler bug. Arguments of these odd
1080 sizes are left-justified within the word (as opposed to arguments smaller
1081 than WORDSIZE bytes, which are right-justified).
1083 If the function is to return an aggregate type such as a struct, the caller
1084 must allocate space into which the callee will copy the return value. In
1085 this case, a pointer to the return value location is passed into the callee
1086 in register R0, which displaces one of the other arguments passed in via
1087 registers R0 to R2. */
1090 avr_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
1091 int struct_return
, CORE_ADDR struct_addr
)
1093 int stack_alloc
, stack_offset
;
1105 /* Now make sure there's space on the stack */
1106 for (argnum
= 0, stack_alloc
= 0;
1107 argnum
< nargs
; argnum
++)
1108 stack_alloc
+= TYPE_LENGTH(VALUE_TYPE(args
[argnum
]));
1109 sp
-= stack_alloc
; /* make room on stack for args */
1110 /* we may over-allocate a little here, but that won't hurt anything */
1113 if (struct_return
) /* "struct return" pointer takes up one argreg */
1115 write_register (--argreg
, struct_addr
);
1118 /* Now load as many as possible of the first arguments into registers, and
1119 push the rest onto the stack. There are 3N bytes in three registers
1120 available. Loop thru args from first to last. */
1122 for (argnum
= 0, stack_offset
= 0; argnum
< nargs
; argnum
++)
1124 type
= VALUE_TYPE (args
[argnum
]);
1125 len
= TYPE_LENGTH (type
);
1126 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
1128 /* NOTE WELL!!!!! This is not an "else if" clause!!! That's because
1129 some *&^%$ things get passed on the stack AND in the registers! */
1131 { /* there's room in registers */
1133 regval
= extract_address (val
+ len
, wordsize
);
1134 write_register (argreg
--, regval
);
1140 /* Initialize the gdbarch structure for the AVR's. */
1142 static struct gdbarch
*
1143 avr_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
){
1144 /* FIXME: TRoth/2002-02-18: I have no idea if avr_call_dummy_words[] should
1145 be bigger or not. Initial testing seems to show that `call my_func()`
1146 works and backtrace from a breakpoint within the call looks correct.
1147 Admittedly, I haven't tested with more than a very simple program. */
1148 static LONGEST avr_call_dummy_words
[] = {0};
1150 struct gdbarch
*gdbarch
;
1151 struct gdbarch_tdep
*tdep
;
1153 /* Find a candidate among the list of pre-declared architectures. */
1154 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1156 return arches
->gdbarch
;
1158 /* None found, create a new architecture from the information provided. */
1159 tdep
= XMALLOC (struct gdbarch_tdep
);
1160 gdbarch
= gdbarch_alloc (&info
, tdep
);
1162 /* If we ever need to differentiate the device types, do it here. */
1163 switch (info
.bfd_arch_info
->mach
)
1173 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1174 set_gdbarch_int_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1175 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1176 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
1177 set_gdbarch_ptr_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
1178 set_gdbarch_addr_bit (gdbarch
, 32);
1179 set_gdbarch_bfd_vma_bit (gdbarch
, 32); /* FIXME: TRoth/2002-02-18: Is this needed? */
1181 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1182 set_gdbarch_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1183 set_gdbarch_long_double_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
1185 set_gdbarch_float_format (gdbarch
, &floatformat_ieee_single_little
);
1186 set_gdbarch_double_format (gdbarch
, &floatformat_ieee_single_little
);
1187 set_gdbarch_long_double_format (gdbarch
, &floatformat_ieee_single_little
);
1189 set_gdbarch_read_pc (gdbarch
, avr_read_pc
);
1190 set_gdbarch_write_pc (gdbarch
, avr_write_pc
);
1191 set_gdbarch_read_fp (gdbarch
, avr_read_fp
);
1192 set_gdbarch_read_sp (gdbarch
, avr_read_sp
);
1193 set_gdbarch_write_sp (gdbarch
, avr_write_sp
);
1195 set_gdbarch_num_regs (gdbarch
, AVR_NUM_REGS
);
1197 set_gdbarch_sp_regnum (gdbarch
, AVR_SP_REGNUM
);
1198 set_gdbarch_fp_regnum (gdbarch
, AVR_FP_REGNUM
);
1199 set_gdbarch_pc_regnum (gdbarch
, AVR_PC_REGNUM
);
1201 set_gdbarch_register_name (gdbarch
, avr_register_name
);
1202 set_gdbarch_register_size (gdbarch
, 1);
1203 set_gdbarch_register_bytes (gdbarch
, AVR_NUM_REG_BYTES
);
1204 set_gdbarch_register_byte (gdbarch
, avr_register_byte
);
1205 set_gdbarch_register_raw_size (gdbarch
, avr_register_raw_size
);
1206 set_gdbarch_max_register_raw_size (gdbarch
, 4);
1207 set_gdbarch_register_virtual_size (gdbarch
, avr_register_virtual_size
);
1208 set_gdbarch_max_register_virtual_size (gdbarch
, 4);
1209 set_gdbarch_register_virtual_type (gdbarch
, avr_register_virtual_type
);
1211 /* We might need to define our own here or define FRAME_INIT_SAVED_REGS */
1212 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1214 set_gdbarch_print_insn (gdbarch
, print_insn_avr
);
1216 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1217 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1218 set_gdbarch_call_dummy_address (gdbarch
, avr_call_dummy_address
);
1219 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1220 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1221 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1222 set_gdbarch_call_dummy_length (gdbarch
, 0);
1223 set_gdbarch_pc_in_call_dummy (gdbarch
, generic_pc_in_call_dummy
);
1224 set_gdbarch_call_dummy_p (gdbarch
, 1);
1225 set_gdbarch_call_dummy_words (gdbarch
, avr_call_dummy_words
);
1226 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1227 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1229 /* set_gdbarch_believe_pcc_promotion (gdbarch, 1); // TRoth: should this be set? */
1231 set_gdbarch_address_to_pointer (gdbarch
, avr_address_to_pointer
);
1232 set_gdbarch_pointer_to_address (gdbarch
, avr_pointer_to_address
);
1233 set_gdbarch_extract_return_value (gdbarch
, avr_extract_return_value
);
1234 set_gdbarch_push_arguments (gdbarch
, avr_push_arguments
);
1235 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1236 /* set_gdbarch_push_return_address (gdbarch, avr_push_return_address); */
1237 set_gdbarch_pop_frame (gdbarch
, avr_pop_frame
);
1239 set_gdbarch_store_return_value (gdbarch
, avr_store_return_value
);
1241 set_gdbarch_use_struct_convention (gdbarch
, generic_use_struct_convention
);
1242 set_gdbarch_store_struct_return (gdbarch
, avr_store_struct_return
);
1243 set_gdbarch_extract_struct_value_address (gdbarch
, avr_extract_struct_value_address
);
1245 set_gdbarch_frame_init_saved_regs (gdbarch
, avr_scan_prologue
);
1246 set_gdbarch_init_extra_frame_info (gdbarch
, avr_init_extra_frame_info
);
1247 set_gdbarch_skip_prologue (gdbarch
, avr_skip_prologue
);
1248 /* set_gdbarch_prologue_frameless_p (gdbarch, avr_prologue_frameless_p); */
1249 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1251 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1253 set_gdbarch_function_start_offset (gdbarch
, 0);
1254 set_gdbarch_remote_translate_xfer_address (gdbarch
, avr_remote_translate_xfer_address
);
1255 set_gdbarch_frame_args_skip (gdbarch
, 0);
1256 set_gdbarch_frameless_function_invocation (gdbarch
, frameless_look_for_prologue
); /* ??? */
1257 set_gdbarch_frame_chain (gdbarch
, avr_frame_chain
);
1258 set_gdbarch_frame_chain_valid (gdbarch
, generic_func_frame_chain_valid
);
1259 set_gdbarch_frame_saved_pc (gdbarch
, avr_frame_saved_pc
);
1260 set_gdbarch_frame_args_address (gdbarch
, avr_frame_address
);
1261 set_gdbarch_frame_locals_address (gdbarch
, avr_frame_address
);
1262 set_gdbarch_saved_pc_after_call (gdbarch
, avr_saved_pc_after_call
);
1263 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1265 set_gdbarch_convert_from_func_ptr_addr (gdbarch
, avr_convert_from_func_ptr_addr
);
1270 /* Send a query request to the avr remote target asking for values of the io
1271 registers. If args parameter is not NULL, then the user has requested info
1272 on a specific io register [This still needs implemented and is ignored for
1273 now]. The query string should be one of these forms:
1275 "Ravr.io_reg" -> reply is "NN" number of io registers
1277 "Ravr.io_reg:addr,len" where addr is first register and len is number of
1278 registers to be read. The reply should be "<NAME>,VV;" for each io register
1279 where, <NAME> is a string, and VV is the hex value of the register.
1281 All io registers are 8-bit. */
1284 avr_io_reg_read_command (char *args
, int from_tty
)
1290 unsigned int nreg
= 0;
1294 /* fprintf_unfiltered (gdb_stderr, "DEBUG: avr_io_reg_read_command (\"%s\", %d)\n", */
1295 /* args, from_tty); */
1297 if (! current_target
.to_query
)
1299 fprintf_unfiltered (gdb_stderr
, "ERR: info io_registers NOT supported by current target\n");
1303 /* Just get the maximum buffer size. */
1304 target_query ((int) 'R', 0, 0, &bufsiz
);
1305 if (bufsiz
> sizeof(buf
))
1306 bufsiz
= sizeof(buf
);
1308 /* Find out how many io registers the target has. */
1309 strcpy (query
, "avr.io_reg");
1310 target_query( (int) 'R', query
, buf
, &bufsiz
);
1312 if (strncmp (buf
, "", bufsiz
) == 0)
1314 fprintf_unfiltered (gdb_stderr
, "info io_registers NOT supported by target\n");
1318 if ( sscanf (buf
, "%x", &nreg
) != 1 )
1320 fprintf_unfiltered (gdb_stderr
, "Error fetching number of io registers\n");
1324 reinitialize_more_filter();
1326 printf_unfiltered ("Target has %u io registers:\n\n", nreg
);
1328 /* only fetch up to 8 registers at a time to keep the buffer small */
1331 for (i
=0; i
<nreg
; i
+=step
)
1333 j
= step
- (nreg
% step
); /* how many registers this round? */
1335 snprintf (query
, sizeof(query
)-1, "avr.io_reg:%x,%x", i
, j
);
1336 target_query ((int) 'R', query
, buf
, &bufsiz
);
1339 for (k
=i
; k
<(i
+j
); k
++)
1341 if (sscanf (p
, "%[^,],%x;", query
, &val
) == 2)
1343 printf_filtered ("[%02x] %-15s : %02x\n", k
, query
, val
);
1344 while ((*p
!= ';') && (*p
!= '\0'))
1346 p
++; /* skip over ';' */
1355 _initialize_avr_tdep (void)
1357 register_gdbarch_init (bfd_arch_avr
, avr_gdbarch_init
);
1359 /* Add a new command to allow the user to query the avr remote target for
1360 the values of the io space registers in a saner way than just using
1363 /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1364 io_registers' to signify it is not available on other platforms. */
1366 add_cmd ("io_registers", class_info
, avr_io_reg_read_command
,
1367 "query remote avr target for io space register values",