/* Target-dependent code for Atmel AVR, for GDB.
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
- Free Software Foundation, Inc.
+
+ Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ 2005 Free Software Foundation, Inc.
This file is part of GDB.
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* Contributed by Theodore A. Roth, troth@verinet.com */
+/* Contributed by Theodore A. Roth, troth@openavr.org */
/* Portions of this file were taken from the original gdb-4.18 patch developed
by Denis Chertykov, denisc@overta.ru */
#include "defs.h"
+#include "frame.h"
+#include "frame-unwind.h"
+#include "frame-base.h"
+#include "trad-frame.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "inferior.h"
#include "arch-utils.h"
#include "regcache.h"
#include "gdb_string.h"
+#include "dis-asm.h"
/* AVR Background:
AVR_PC_REG_INDEX = 35, /* index into array of registers */
- AVR_MAX_PROLOGUE_SIZE = 56, /* bytes */
+ AVR_MAX_PROLOGUE_SIZE = 64, /* bytes */
/* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
AVR_MAX_PUSHES = 18,
/* Number of the last pushed register. r17 for current avr-gcc */
AVR_LAST_PUSHED_REGNUM = 17,
+ AVR_ARG1_REGNUM = 24, /* Single byte argument */
+ AVR_ARGN_REGNUM = 25, /* Multi byte argments */
+
+ AVR_RET1_REGNUM = 24, /* Single byte return value */
+ AVR_RETN_REGNUM = 25, /* Multi byte return value */
+
/* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
bits? Do these have to match the bfd vma values?. It sure would make
things easier in the future if they didn't need to match.
#endif
};
+/* Prologue types:
+
+ NORMAL and CALL are the typical types (the -mcall-prologues gcc option
+ causes the generation of the CALL type prologues). */
+
+enum {
+ AVR_PROLOGUE_NONE, /* No prologue */
+ AVR_PROLOGUE_NORMAL,
+ AVR_PROLOGUE_CALL, /* -mcall-prologues */
+ AVR_PROLOGUE_MAIN,
+ AVR_PROLOGUE_INTR, /* interrupt handler */
+ AVR_PROLOGUE_SIG, /* signal handler */
+};
+
/* Any function with a frame looks like this
....... <-SP POINTS HERE
LOCALS1 <-FP POINTS HERE
FIRST ARG
SECOND ARG */
-struct frame_extra_info
+struct avr_unwind_cache
{
- CORE_ADDR return_pc;
- CORE_ADDR args_pointer;
- int locals_size;
- int framereg;
- int framesize;
- int is_main;
+ /* The previous frame's inner most stack address. Used as this
+ frame ID's stack_addr. */
+ CORE_ADDR prev_sp;
+ /* The frame's base, optionally used by the high-level debug info. */
+ CORE_ADDR base;
+ int size;
+ int prologue_type;
+ /* Table indicating the location of each and every register. */
+ struct trad_frame_saved_reg *saved_regs;
};
struct gdbarch_tdep
return register_names[regnum];
}
-/* Index within `registers' of the first byte of the space for
- register REGNUM. */
-
-static int
-avr_register_byte (int regnum)
-{
- if (regnum < AVR_PC_REGNUM)
- return regnum;
- else
- return AVR_PC_REG_INDEX;
-}
-
-/* Number of bytes of storage in the actual machine representation for
- register REGNUM. */
-
-static int
-avr_register_raw_size (int regnum)
-{
- switch (regnum)
- {
- case AVR_PC_REGNUM:
- return 4;
- case AVR_SP_REGNUM:
- case AVR_FP_REGNUM:
- return 2;
- default:
- return 1;
- }
-}
-
-/* Number of bytes of storage in the program's representation
- for register N. */
-
-static int
-avr_register_virtual_size (int regnum)
-{
- return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum));
-}
-
/* Return the GDB type object for the "standard" data type
of data in register N. */
static struct type *
-avr_register_virtual_type (int regnum)
+avr_register_type (struct gdbarch *gdbarch, int reg_nr)
{
- switch (regnum)
- {
- case AVR_PC_REGNUM:
- return builtin_type_unsigned_long;
- case AVR_SP_REGNUM:
- return builtin_type_unsigned_short;
- default:
- return builtin_type_unsigned_char;
- }
+ if (reg_nr == AVR_PC_REGNUM)
+ return builtin_type_uint32;
+ if (reg_nr == AVR_SP_REGNUM)
+ return builtin_type_void_data_ptr;
+ else
+ return builtin_type_uint8;
}
/* Instruction address checks and convertions. */
return ((x) | AVR_IMEM_START);
}
-static int
-avr_iaddr_p (CORE_ADDR x)
-{
- return (((x) & AVR_MEM_MASK) == AVR_IMEM_START);
-}
-
/* FIXME: TRoth: Really need to use a larger mask for instructions. Some
devices are already up to 128KBytes of flash space.
return ((x) | AVR_SMEM_START);
}
-static int
-avr_saddr_p (CORE_ADDR x)
-{
- return (((x) & AVR_MEM_MASK) == AVR_SMEM_START);
-}
-
static CORE_ADDR
avr_convert_saddr_to_raw (CORE_ADDR x)
{
|| TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
{
store_unsigned_integer (buf, TYPE_LENGTH (type),
- avr_convert_iaddr_to_raw (addr));
+ avr_convert_iaddr_to_raw (addr >> 1));
}
else
{
}
static CORE_ADDR
-avr_pointer_to_address (struct type *type, void *buf)
+avr_pointer_to_address (struct type *type, const void *buf)
{
- CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
-
- if (TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
- {
- fprintf_unfiltered (gdb_stderr, "CODE_SPACE ---->> ptr->addr: 0x%lx\n",
- addr);
- fprintf_unfiltered (gdb_stderr,
- "+++ If you see this, please send me an email <troth@verinet.com>\n");
- }
+ CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
/* Is it a code address? */
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
|| TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
|| TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
- return avr_make_iaddr (addr);
+ return avr_make_iaddr (addr << 1);
else
return avr_make_saddr (addr);
}
avr_read_pc (ptid_t ptid)
{
ptid_t save_ptid;
- CORE_ADDR pc;
+ ULONGEST pc;
CORE_ADDR retval;
save_ptid = inferior_ptid;
inferior_ptid = ptid;
- pc = (int) read_register (AVR_PC_REGNUM);
+ regcache_cooked_read_unsigned (current_regcache, AVR_PC_REGNUM, &pc);
inferior_ptid = save_ptid;
retval = avr_make_iaddr (pc);
return retval;
static CORE_ADDR
avr_read_sp (void)
{
- return (avr_make_saddr (read_register (AVR_SP_REGNUM)));
-}
+ ULONGEST sp;
-static void
-avr_write_sp (CORE_ADDR val)
-{
- write_register (AVR_SP_REGNUM, avr_convert_saddr_to_raw (val));
+ regcache_cooked_read_unsigned (current_regcache, AVR_SP_REGNUM, &sp);
+ return (avr_make_saddr (sp));
}
-static CORE_ADDR
-avr_read_fp (void)
-{
- return (avr_make_saddr (read_register (AVR_FP_REGNUM)));
-}
-
-/* Translate a GDB virtual ADDR/LEN into a format the remote target
- understands. Returns number of bytes that can be transfered
- starting at TARG_ADDR. Return ZERO if no bytes can be transfered
- (segmentation fault).
-
- TRoth/2002-04-08: Could this be used to check for dereferencing an invalid
- pointer? */
-
-static void
-avr_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
- CORE_ADDR *targ_addr, int *targ_len)
+static int
+avr_scan_arg_moves (int vpc, unsigned char *prologue)
{
- long out_addr;
- long out_len;
-
- /* FIXME: TRoth: Do nothing for now. Will need to examine memaddr at this
- point and see if the high bit are set with the masks that we want. */
-
- *targ_addr = memaddr;
- *targ_len = nr_bytes;
-}
-
-/* Function pointers obtained from the target are half of what gdb expects so
- multiply by 2. */
+ unsigned short insn;
-static CORE_ADDR
-avr_convert_from_func_ptr_addr (CORE_ADDR addr)
-{
- return addr * 2;
+ for (; vpc < AVR_MAX_PROLOGUE_SIZE; vpc += 2)
+ {
+ insn = EXTRACT_INSN (&prologue[vpc]);
+ if ((insn & 0xff00) == 0x0100) /* movw rXX, rYY */
+ continue;
+ else if ((insn & 0xfc00) == 0x2c00) /* mov rXX, rYY */
+ continue;
+ else
+ break;
+ }
+
+ return vpc;
}
-/* avr_scan_prologue is also used as the frame_init_saved_regs().
+/* Function: avr_scan_prologue
- Put here the code to store, into fi->saved_regs, the addresses of
- the saved registers of frame described by FRAME_INFO. This
- includes special registers such as pc and fp saved in special ways
- in the stack frame. sp is even more special: the address we return
- for it IS the sp for the next frame. */
-
-/* Function: avr_scan_prologue (helper function for avr_init_extra_frame_info)
- This function decodes a AVR function prologue to determine:
+ This function decodes an AVR function prologue to determine:
1) the size of the stack frame
2) which registers are saved on it
3) the offsets of saved regs
- This information is stored in the "extra_info" field of the frame_info.
-
- A typical AVR function prologue might look like this:
- push rXX
- push r28
- push r29
- in r28,__SP_L__
- in r29,__SP_H__
- sbiw r28,<LOCALS_SIZE>
- in __tmp_reg__,__SREG__
+ This information is stored in the avr_unwind_cache structure.
+
+ Some devices lack the sbiw instruction, so on those replace this:
+ sbiw r28, XX
+ with this:
+ subi r28,lo8(XX)
+ sbci r29,hi8(XX)
+
+ A typical AVR function prologue with a frame pointer might look like this:
+ push rXX ; saved regs
+ ...
+ push r28
+ push r29
+ in r28,__SP_L__
+ in r29,__SP_H__
+ sbiw r28,<LOCALS_SIZE>
+ in __tmp_reg__,__SREG__
+ cli
+ out __SP_H__,r29
+ out __SREG__,__tmp_reg__
+ out __SP_L__,r28
+
+ A typical AVR function prologue without a frame pointer might look like
+ this:
+ push rXX ; saved regs
+ ...
+
+ A main function prologue looks like this:
+ ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
+ ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
+ out __SP_H__,r29
+ out __SP_L__,r28
+
+ A signal handler prologue looks like this:
+ push __zero_reg__
+ push __tmp_reg__
+ in __tmp_reg__, __SREG__
+ push __tmp_reg__
+ clr __zero_reg__
+ push rXX ; save registers r18:r27, r30:r31
+ ...
+ push r28 ; save frame pointer
+ push r29
+ in r28, __SP_L__
+ in r29, __SP_H__
+ sbiw r28, <LOCALS_SIZE>
+ out __SP_H__, r29
+ out __SP_L__, r28
+
+ A interrupt handler prologue looks like this:
+ sei
+ push __zero_reg__
+ push __tmp_reg__
+ in __tmp_reg__, __SREG__
+ push __tmp_reg__
+ clr __zero_reg__
+ push rXX ; save registers r18:r27, r30:r31
+ ...
+ push r28 ; save frame pointer
+ push r29
+ in r28, __SP_L__
+ in r29, __SP_H__
+ sbiw r28, <LOCALS_SIZE>
cli
- out __SP_L__,r28
- out __SREG__,__tmp_reg__
- out __SP_H__,r29
-
- A `-mcall-prologues' prologue look like this:
- ldi r26,<LOCALS_SIZE>
- ldi r27,<LOCALS_SIZE>/265
- ldi r30,pm_lo8(.L_foo_body)
- ldi r31,pm_hi8(.L_foo_body)
- rjmp __prologue_saves__+RRR
- .L_foo_body: */
+ out __SP_H__, r29
+ sei
+ out __SP_L__, r28
+
+ A `-mcall-prologues' prologue looks like this (Note that the megas use a
+ jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
+ 32 bit insn and rjmp is a 16 bit insn):
+ ldi r26,lo8(<LOCALS_SIZE>)
+ ldi r27,hi8(<LOCALS_SIZE>)
+ ldi r30,pm_lo8(.L_foo_body)
+ ldi r31,pm_hi8(.L_foo_body)
+ rjmp __prologue_saves__+RRR
+ .L_foo_body: */
+
+/* Not really part of a prologue, but still need to scan for it, is when a
+ function prologue moves values passed via registers as arguments to new
+ registers. In this case, all local variables live in registers, so there
+ may be some register saves. This is what it looks like:
+ movw rMM, rNN
+ ...
+
+ There could be multiple movw's. If the target doesn't have a movw insn, it
+ will use two mov insns. This could be done after any of the above prologue
+ types. */
-static void
-avr_scan_prologue (struct frame_info *fi)
+static CORE_ADDR
+avr_scan_prologue (CORE_ADDR pc, struct avr_unwind_cache *info)
{
- CORE_ADDR prologue_start;
- CORE_ADDR prologue_end;
int i;
unsigned short insn;
- int regno;
int scan_stage = 0;
- char *name;
struct minimal_symbol *msymbol;
- int prologue_len;
unsigned char prologue[AVR_MAX_PROLOGUE_SIZE];
int vpc = 0;
- fi->extra_info->framereg = AVR_SP_REGNUM;
-
- if (find_pc_partial_function
- (fi->pc, &name, &prologue_start, &prologue_end))
- {
- struct symtab_and_line sal = find_pc_line (prologue_start, 0);
-
- if (sal.line == 0) /* no line info, use current PC */
- prologue_end = fi->pc;
- else if (sal.end < prologue_end) /* next line begins after fn end */
- prologue_end = sal.end; /* (probably means no prologue) */
- }
- else
- /* We're in the boondocks: allow for */
- /* 19 pushes, an add, and "mv fp,sp" */
- prologue_end = prologue_start + AVR_MAX_PROLOGUE_SIZE;
-
- prologue_end = min (prologue_end, fi->pc);
-
- /* Search the prologue looking for instructions that set up the
- frame pointer, adjust the stack pointer, and save registers. */
-
- fi->extra_info->framesize = 0;
- prologue_len = prologue_end - prologue_start;
- read_memory (prologue_start, prologue, prologue_len);
+ /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
+ reading in the bytes of the prologue. The problem is that the figuring
+ out where the end of the prologue is is a bit difficult. The old code
+ tried to do that, but failed quite often. */
+ read_memory (pc, prologue, AVR_MAX_PROLOGUE_SIZE);
/* Scanning main()'s prologue
ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
out __SP_H__,r29
out __SP_L__,r28 */
- if (name && strcmp ("main", name) == 0 && prologue_len == 8)
+ if (1)
{
CORE_ADDR locals;
unsigned char img[] = {
0xcd, 0xbf /* out __SP_L__,r28 */
};
- fi->extra_info->framereg = AVR_FP_REGNUM;
insn = EXTRACT_INSN (&prologue[vpc]);
/* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
if ((insn & 0xf0f0) == 0xe0c0)
locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
if (memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
{
- fi->frame = locals;
-
- fi->extra_info->is_main = 1;
- return;
+ info->prologue_type = AVR_PROLOGUE_MAIN;
+ info->base = locals;
+ return pc + 4;
}
}
}
}
/* Scanning `-mcall-prologues' prologue
- FIXME: mega prologue have a 12 bytes long */
+ Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
- while (prologue_len <= 12) /* I'm use while to avoit many goto's */
+ while (1) /* Using a while to avoid many goto's */
{
int loc_size;
int body_addr;
unsigned num_pushes;
+ int pc_offset = 0;
insn = EXTRACT_INSN (&prologue[vpc]);
/* ldi r26,<LOCALS_SIZE> */
if ((insn & 0xf0f0) != 0xe0a0)
break;
loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4);
+ pc_offset += 2;
insn = EXTRACT_INSN (&prologue[vpc + 2]);
/* ldi r27,<LOCALS_SIZE> / 256 */
if ((insn & 0xf0f0) != 0xe0b0)
break;
loc_size |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
+ pc_offset += 2;
insn = EXTRACT_INSN (&prologue[vpc + 4]);
/* ldi r30,pm_lo8(.L_foo_body) */
if ((insn & 0xf0f0) != 0xe0e0)
break;
body_addr = (insn & 0xf) | ((insn & 0x0f00) >> 4);
+ pc_offset += 2;
insn = EXTRACT_INSN (&prologue[vpc + 6]);
/* ldi r31,pm_hi8(.L_foo_body) */
if ((insn & 0xf0f0) != 0xe0f0)
break;
body_addr |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
-
- if (body_addr != (prologue_start + 10) / 2)
- break;
+ pc_offset += 2;
msymbol = lookup_minimal_symbol ("__prologue_saves__", NULL, NULL);
if (!msymbol)
break;
- /* FIXME: prologue for mega have a JMP instead of RJMP */
insn = EXTRACT_INSN (&prologue[vpc + 8]);
/* rjmp __prologue_saves__+RRR */
- if ((insn & 0xf000) != 0xc000)
- break;
+ if ((insn & 0xf000) == 0xc000)
+ {
+ /* Extract PC relative offset from RJMP */
+ i = (insn & 0xfff) | (insn & 0x800 ? (-1 ^ 0xfff) : 0);
+ /* Convert offset to byte addressable mode */
+ i *= 2;
+ /* Destination address */
+ i += pc + 10;
+
+ if (body_addr != (pc + 10)/2)
+ break;
+
+ pc_offset += 2;
+ }
+ else if ((insn & 0xfe0e) == 0x940c)
+ {
+ /* Extract absolute PC address from JMP */
+ i = (((insn & 0x1) | ((insn & 0x1f0) >> 3) << 16)
+ | (EXTRACT_INSN (&prologue[vpc + 10]) & 0xffff));
+ /* Convert address to byte addressable mode */
+ i *= 2;
+
+ if (body_addr != (pc + 12)/2)
+ break;
+
+ pc_offset += 4;
+ }
+ else
+ break;
- /* Extract PC relative offset from RJMP */
- i = (insn & 0xfff) | (insn & 0x800 ? (-1 ^ 0xfff) : 0);
- /* Convert offset to byte addressable mode */
- i *= 2;
- /* Destination address */
- i += vpc + prologue_start + 10;
- /* Resovle offset (in words) from __prologue_saves__ symbol.
+ /* Resolve offset (in words) from __prologue_saves__ symbol.
Which is a pushes count in `-mcall-prologues' mode */
num_pushes = AVR_MAX_PUSHES - (i - SYMBOL_VALUE_ADDRESS (msymbol)) / 2;
if (num_pushes > AVR_MAX_PUSHES)
- num_pushes = 0;
+ {
+ fprintf_unfiltered (gdb_stderr, _("Num pushes too large: %d\n"),
+ num_pushes);
+ num_pushes = 0;
+ }
if (num_pushes)
{
int from;
- fi->saved_regs[AVR_FP_REGNUM + 1] = num_pushes;
+
+ info->saved_regs[AVR_FP_REGNUM + 1].addr = num_pushes;
if (num_pushes >= 2)
- fi->saved_regs[AVR_FP_REGNUM] = num_pushes - 1;
+ info->saved_regs[AVR_FP_REGNUM].addr = num_pushes - 1;
+
i = 0;
for (from = AVR_LAST_PUSHED_REGNUM + 1 - (num_pushes - 2);
from <= AVR_LAST_PUSHED_REGNUM; ++from)
- fi->saved_regs[from] = ++i;
+ info->saved_regs [from].addr = ++i;
}
- fi->extra_info->locals_size = loc_size;
- fi->extra_info->framesize = loc_size + num_pushes;
- fi->extra_info->framereg = AVR_FP_REGNUM;
- return;
+ info->size = loc_size + num_pushes;
+ info->prologue_type = AVR_PROLOGUE_CALL;
+
+ return pc + pc_offset;
}
- /* Scan interrupt or signal function */
+ /* Scan for the beginning of the prologue for an interrupt or signal
+ function. Note that we have to set the prologue type here since the
+ third stage of the prologue may not be present (e.g. no saved registered
+ or changing of the SP register). */
- if (prologue_len >= 12)
+ if (1)
{
unsigned char img[] = {
0x78, 0x94, /* sei */
};
if (memcmp (prologue, img, sizeof (img)) == 0)
{
+ info->prologue_type = AVR_PROLOGUE_INTR;
vpc += sizeof (img);
- fi->saved_regs[0] = 2;
- fi->saved_regs[1] = 1;
- fi->extra_info->framesize += 3;
+ info->saved_regs[AVR_SREG_REGNUM].addr = 3;
+ info->saved_regs[0].addr = 2;
+ info->saved_regs[1].addr = 1;
+ info->size += 3;
}
- else if (memcmp (img + 1, prologue, sizeof (img) - 1) == 0)
+ else if (memcmp (img + 2, prologue, sizeof (img) - 2) == 0)
{
- vpc += sizeof (img) - 1;
- fi->saved_regs[0] = 2;
- fi->saved_regs[1] = 1;
- fi->extra_info->framesize += 3;
+ info->prologue_type = AVR_PROLOGUE_SIG;
+ vpc += sizeof (img) - 2;
+ info->saved_regs[AVR_SREG_REGNUM].addr = 3;
+ info->saved_regs[0].addr = 2;
+ info->saved_regs[1].addr = 1;
+ info->size += 3;
}
}
/* First stage of the prologue scanning.
- Scan pushes */
+ Scan pushes (saved registers) */
- for (; vpc <= prologue_len; vpc += 2)
+ for (; vpc < AVR_MAX_PROLOGUE_SIZE; vpc += 2)
{
insn = EXTRACT_INSN (&prologue[vpc]);
if ((insn & 0xfe0f) == 0x920f) /* push rXX */
{
/* Bits 4-9 contain a mask for registers R0-R32. */
- regno = (insn & 0x1f0) >> 4;
- ++fi->extra_info->framesize;
- fi->saved_regs[regno] = fi->extra_info->framesize;
+ int regno = (insn & 0x1f0) >> 4;
+ info->size++;
+ info->saved_regs[regno].addr = info->size;
scan_stage = 1;
}
else
break;
}
+ if (vpc >= AVR_MAX_PROLOGUE_SIZE)
+ fprintf_unfiltered (gdb_stderr,
+ _("Hit end of prologue while scanning pushes\n"));
+
/* Second stage of the prologue scanning.
Scan:
in r28,__SP_L__
in r29,__SP_H__ */
- if (scan_stage == 1 && vpc + 4 <= prologue_len)
+ if (scan_stage == 1 && vpc < AVR_MAX_PROLOGUE_SIZE)
{
unsigned char img[] = {
0xcd, 0xb7, /* in r28,__SP_L__ */
if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
{
vpc += 4;
- fi->extra_info->framereg = AVR_FP_REGNUM;
scan_stage = 2;
}
}
/* Third stage of the prologue scanning. (Really two stages)
Scan for:
sbiw r28,XX or subi r28,lo8(XX)
- sbci r29,hi8(XX)
+ sbci r29,hi8(XX)
in __tmp_reg__,__SREG__
cli
- out __SP_L__,r28
+ out __SP_H__,r29
out __SREG__,__tmp_reg__
- out __SP_H__,r29 */
+ out __SP_L__,r28 */
- if (scan_stage == 2 && vpc + 12 <= prologue_len)
+ if (scan_stage == 2 && vpc < AVR_MAX_PROLOGUE_SIZE)
{
int locals_size = 0;
unsigned char img[] = {
0x0f, 0xb6, /* in r0,0x3f */
0xf8, 0x94, /* cli */
- 0xcd, 0xbf, /* out 0x3d,r28 ; SPL */
+ 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
- 0xde, 0xbf /* out 0x3e,r29 ; SPH */
+ 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
};
unsigned char img_sig[] = {
- 0xcd, 0xbf, /* out 0x3d,r28 ; SPL */
- 0xde, 0xbf /* out 0x3e,r29 ; SPH */
+ 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
+ 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
};
unsigned char img_int[] = {
0xf8, 0x94, /* cli */
- 0xcd, 0xbf, /* out 0x3d,r28 ; SPL */
+ 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
0x78, 0x94, /* sei */
- 0xde, 0xbf /* out 0x3e,r29 ; SPH */
+ 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
};
insn = EXTRACT_INSN (&prologue[vpc]);
locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4) << 8);
}
else
- return;
- fi->extra_info->locals_size = locals_size;
- fi->extra_info->framesize += locals_size;
- }
-}
+ return pc + vpc;
+
+ /* Scan the last part of the prologue. May not be present for interrupt
+ or signal handler functions, which is why we set the prologue type
+ when we saw the beginning of the prologue previously. */
+
+ if (memcmp (prologue + vpc, img_sig, sizeof (img_sig)) == 0)
+ {
+ vpc += sizeof (img_sig);
+ }
+ else if (memcmp (prologue + vpc, img_int, sizeof (img_int)) == 0)
+ {
+ vpc += sizeof (img_int);
+ }
+ if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
+ {
+ info->prologue_type = AVR_PROLOGUE_NORMAL;
+ vpc += sizeof (img);
+ }
-/* This function actually figures out the frame address for a given pc and
- sp. This is tricky because we sometimes don't use an explicit
- frame pointer, and the previous stack pointer isn't necessarily recorded
- on the stack. The only reliable way to get this info is to
- examine the prologue. */
+ info->size += locals_size;
-static void
-avr_init_extra_frame_info (int fromleaf, struct frame_info *fi)
-{
- int reg;
+ return pc + avr_scan_arg_moves (vpc, prologue);
+ }
- if (fi->next)
- fi->pc = FRAME_SAVED_PC (fi->next);
+ /* If we got this far, we could not scan the prologue, so just return the pc
+ of the frame plus an adjustment for argument move insns. */
- fi->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
- frame_saved_regs_zalloc (fi);
+ return pc + avr_scan_arg_moves (vpc, prologue);;
+}
- fi->extra_info->return_pc = 0;
- fi->extra_info->args_pointer = 0;
- fi->extra_info->locals_size = 0;
- fi->extra_info->framereg = 0;
- fi->extra_info->framesize = 0;
- fi->extra_info->is_main = 0;
+static CORE_ADDR
+avr_skip_prologue (CORE_ADDR pc)
+{
+ CORE_ADDR func_addr, func_end;
+ CORE_ADDR prologue_end = pc;
- avr_scan_prologue (fi);
+ /* See what the symbol table says */
- if (DEPRECATED_PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
- {
- /* We need to setup fi->frame here because run_stack_dummy gets it wrong
- by assuming it's always FP. */
- fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame,
- AVR_PC_REGNUM);
- }
- else if (!fi->next) /* this is the innermost frame? */
- fi->frame = read_register (fi->extra_info->framereg);
- else if (fi->extra_info->is_main != 1) /* not the innermost frame, not `main' */
- /* If we have an next frame, the callee saved it. */
+ if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
{
- struct frame_info *next_fi = fi->next;
- if (fi->extra_info->framereg == AVR_SP_REGNUM)
- fi->frame =
- next_fi->frame + 2 /* ret addr */ + next_fi->extra_info->framesize;
- /* FIXME: I don't analyse va_args functions */
- else
- {
- CORE_ADDR fp = 0;
- CORE_ADDR fp1 = 0;
- unsigned int fp_low, fp_high;
+ struct symtab_and_line sal;
+ struct avr_unwind_cache info = {0};
+ struct trad_frame_saved_reg saved_regs[AVR_NUM_REGS];
- /* Scan all frames */
- for (; next_fi; next_fi = next_fi->next)
- {
- /* look for saved AVR_FP_REGNUM */
- if (next_fi->saved_regs[AVR_FP_REGNUM] && !fp)
- fp = next_fi->saved_regs[AVR_FP_REGNUM];
- /* look for saved AVR_FP_REGNUM + 1 */
- if (next_fi->saved_regs[AVR_FP_REGNUM + 1] && !fp1)
- fp1 = next_fi->saved_regs[AVR_FP_REGNUM + 1];
- }
- fp_low = (fp ? read_memory_unsigned_integer (avr_make_saddr (fp), 1)
- : read_register (AVR_FP_REGNUM)) & 0xff;
- fp_high =
- (fp1 ? read_memory_unsigned_integer (avr_make_saddr (fp1), 1) :
- read_register (AVR_FP_REGNUM + 1)) & 0xff;
- fi->frame = fp_low | (fp_high << 8);
- }
- }
+ info.saved_regs = saved_regs;
- /* TRoth: Do we want to do this if we are in main? I don't think we should
- since return_pc makes no sense when we are in main. */
+ /* Need to run the prologue scanner to figure out if the function has a
+ prologue and possibly skip over moving arguments passed via registers
+ to other registers. */
- if ((fi->pc) && (fi->extra_info->is_main == 0)) /* We are not in CALL_DUMMY */
- {
- CORE_ADDR addr;
- int i;
+ prologue_end = avr_scan_prologue (pc, &info);
- addr = fi->frame + fi->extra_info->framesize + 1;
+ if (info.prologue_type == AVR_PROLOGUE_NONE)
+ return pc;
+ else
+ {
+ sal = find_pc_line (func_addr, 0);
+
+ if (sal.line != 0 && sal.end < func_end)
+ return sal.end;
+ }
+ }
- /* Return address in stack in different endianness */
+/* Either we didn't find the start of this function (nothing we can do),
+ or there's no line info, or the line after the prologue is after
+ the end of the function (there probably isn't a prologue). */
- fi->extra_info->return_pc =
- read_memory_unsigned_integer (avr_make_saddr (addr), 1) << 8;
- fi->extra_info->return_pc |=
- read_memory_unsigned_integer (avr_make_saddr (addr + 1), 1);
+ return prologue_end;
+}
- /* This return address in words,
- must be converted to the bytes address */
- fi->extra_info->return_pc *= 2;
+/* Not all avr devices support the BREAK insn. Those that don't should treat
+ it as a NOP. Thus, it should be ok. Since the avr is currently a remote
+ only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
- /* Resolve a pushed registers addresses */
- for (i = 0; i < NUM_REGS; i++)
- {
- if (fi->saved_regs[i])
- fi->saved_regs[i] = addr - fi->saved_regs[i];
- }
- }
+static const unsigned char *
+avr_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
+{
+ static unsigned char avr_break_insn [] = { 0x98, 0x95 };
+ *lenptr = sizeof (avr_break_insn);
+ return avr_break_insn;
}
-/* Restore the machine to the state it had before the current frame was
- created. Usually used either by the "RETURN" command, or by
- call_function_by_hand after the dummy_frame is finished. */
+/* Given a return value in `regbuf' with a type `valtype',
+ extract and copy its value into `valbuf'.
+
+ Return values are always passed via registers r25:r24:... */
static void
-avr_pop_frame (void)
+avr_extract_return_value (struct type *type, struct regcache *regcache,
+ void *valbuf)
{
- unsigned regnum;
- CORE_ADDR saddr;
- struct frame_info *frame = get_current_frame ();
-
- if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
+ ULONGEST r24, r25;
+ ULONGEST c;
+ int len;
+ if (TYPE_LENGTH (type) == 1)
{
- generic_pop_dummy_frame ();
+ regcache_cooked_read_unsigned (regcache, 24, &c);
+ store_unsigned_integer (valbuf, 1, c);
}
else
{
- /* TRoth: Why only loop over 8 registers? */
-
- for (regnum = 0; regnum < 8; regnum++)
- {
- /* Don't forget AVR_SP_REGNUM in a frame_saved_regs struct is the
- actual value we want, not the address of the value we want. */
- if (frame->saved_regs[regnum] && regnum != AVR_SP_REGNUM)
- {
- saddr = avr_make_saddr (frame->saved_regs[regnum]);
- write_register (regnum,
- read_memory_unsigned_integer (saddr, 1));
- }
- else if (frame->saved_regs[regnum] && regnum == AVR_SP_REGNUM)
- write_register (regnum, frame->frame + 2);
- }
-
- /* Don't forget the update the PC too! */
- write_pc (frame->extra_info->return_pc);
+ int i;
+ /* The MSB of the return value is always in r25, calculate which
+ register holds the LSB. */
+ int lsb_reg = 25 - TYPE_LENGTH (type) + 1;
+
+ for (i=0; i< TYPE_LENGTH (type); i++)
+ {
+ regcache_cooked_read (regcache, lsb_reg + i,
+ (bfd_byte *) valbuf + i);
+ }
}
- flush_cached_frames ();
}
-/* Return the saved PC from this frame. */
+/* Put here the code to store, into fi->saved_regs, the addresses of
+ the saved registers of frame described by FRAME_INFO. This
+ includes special registers such as pc and fp saved in special ways
+ in the stack frame. sp is even more special: the address we return
+ for it IS the sp for the next frame. */
-static CORE_ADDR
-avr_frame_saved_pc (struct frame_info *frame)
+struct avr_unwind_cache *
+avr_frame_unwind_cache (struct frame_info *next_frame,
+ void **this_prologue_cache)
{
- if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
- return deprecated_read_register_dummy (frame->pc, frame->frame,
- AVR_PC_REGNUM);
- else
- return frame->extra_info->return_pc;
-}
+ CORE_ADDR pc;
+ ULONGEST prev_sp;
+ ULONGEST this_base;
+ struct avr_unwind_cache *info;
+ int i;
-static CORE_ADDR
-avr_saved_pc_after_call (struct frame_info *frame)
-{
- unsigned char m1, m2;
- unsigned int sp = read_register (AVR_SP_REGNUM);
- m1 = read_memory_unsigned_integer (avr_make_saddr (sp + 1), 1);
- m2 = read_memory_unsigned_integer (avr_make_saddr (sp + 2), 1);
- return (m2 | (m1 << 8)) * 2;
-}
+ if ((*this_prologue_cache))
+ return (*this_prologue_cache);
-/* Figure out where in REGBUF the called function has left its return value.
- Copy that into VALBUF. */
+ info = FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache);
+ (*this_prologue_cache) = info;
+ info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
-static void
-avr_extract_return_value (struct type *type, char *regbuf, char *valbuf)
-{
- int wordsize, len;
+ info->size = 0;
+ info->prologue_type = AVR_PROLOGUE_NONE;
- wordsize = 2;
+ pc = frame_func_unwind (next_frame);
- len = TYPE_LENGTH (type);
+ if ((pc > 0) && (pc < frame_pc_unwind (next_frame)))
+ avr_scan_prologue (pc, info);
- switch (len)
+ if ((info->prologue_type != AVR_PROLOGUE_NONE)
+ && (info->prologue_type != AVR_PROLOGUE_MAIN))
{
- case 1: /* (char) */
- case 2: /* (short), (int) */
- memcpy (valbuf, regbuf + REGISTER_BYTE (24), 2);
- break;
- case 4: /* (long), (float) */
- memcpy (valbuf, regbuf + REGISTER_BYTE (22), 4);
- break;
- case 8: /* (double) (doesn't seem to happen, which is good,
- because this almost certainly isn't right. */
- error ("I don't know how a double is returned.");
- break;
+ ULONGEST high_base; /* High byte of FP */
+
+ /* The SP was moved to the FP. This indicates that a new frame
+ was created. Get THIS frame's FP value by unwinding it from
+ the next frame. */
+ frame_unwind_unsigned_register (next_frame, AVR_FP_REGNUM, &this_base);
+ frame_unwind_unsigned_register (next_frame, AVR_FP_REGNUM+1, &high_base);
+ this_base += (high_base << 8);
+
+ /* The FP points at the last saved register. Adjust the FP back
+ to before the first saved register giving the SP. */
+ prev_sp = this_base + info->size;
+ }
+ else
+ {
+ /* Assume that the FP is this frame's SP but with that pushed
+ stack space added back. */
+ frame_unwind_unsigned_register (next_frame, AVR_SP_REGNUM, &this_base);
+ prev_sp = this_base + info->size;
}
-}
-/* Returns the return address for a dummy. */
+ /* Add 1 here to adjust for the post-decrement nature of the push
+ instruction.*/
+ info->prev_sp = avr_make_saddr (prev_sp+1);
-static CORE_ADDR
-avr_call_dummy_address (void)
-{
- return entry_point_address ();
-}
+ info->base = avr_make_saddr (this_base);
-/* Place the appropriate value in the appropriate registers.
- Primarily used by the RETURN command. */
+ /* Adjust all the saved registers so that they contain addresses and not
+ offsets. */
+ for (i = 0; i < NUM_REGS - 1; i++)
+ if (info->saved_regs[i].addr)
+ {
+ info->saved_regs[i].addr = (info->prev_sp - info->saved_regs[i].addr);
+ }
-static void
-avr_store_return_value (struct type *type, char *valbuf)
-{
- int wordsize, len, regval;
-
- wordsize = 2;
+ /* Except for the main and startup code, the return PC is always saved on
+ the stack and is at the base of the frame. */
- len = TYPE_LENGTH (type);
- switch (len)
+ if (info->prologue_type != AVR_PROLOGUE_MAIN)
{
- case 1: /* char */
- case 2: /* short, int */
- regval = extract_address (valbuf, len);
- write_register (0, regval);
- break;
- case 4: /* long, float */
- regval = extract_address (valbuf, len);
- write_register (0, regval >> 16);
- write_register (1, regval & 0xffff);
- break;
- case 8: /* presumeably double, but doesn't seem to happen */
- error ("I don't know how to return a double.");
- break;
- }
-}
+ info->saved_regs[AVR_PC_REGNUM].addr = info->prev_sp;
+ }
-/* Setup the return address for a dummy frame, as called by
- call_function_by_hand. Only necessary when you are using an empty
- CALL_DUMMY. */
+ /* The previous frame's SP needed to be computed. Save the computed
+ value. */
+ trad_frame_set_value (info->saved_regs, AVR_SP_REGNUM, info->prev_sp+1);
+
+ return info;
+}
static CORE_ADDR
-avr_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
+avr_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
- unsigned char buf[2];
- int wordsize = 2;
-#if 0
- struct minimal_symbol *msymbol;
- CORE_ADDR mon_brk;
-#endif
+ ULONGEST pc;
- buf[0] = 0;
- buf[1] = 0;
- sp -= wordsize;
- write_memory (sp + 1, buf, 2);
+ frame_unwind_unsigned_register (next_frame, AVR_PC_REGNUM, &pc);
-#if 0
- /* FIXME: TRoth/2002-02-18: This should probably be removed since it's a
- left-over from Denis' original patch which used avr-mon for the target
- instead of the generic remote target. */
- if ((strcmp (target_shortname, "avr-mon") == 0)
- && (msymbol = lookup_minimal_symbol ("gdb_break", NULL, NULL)))
- {
- mon_brk = SYMBOL_VALUE_ADDRESS (msymbol);
- store_unsigned_integer (buf, wordsize, mon_brk / 2);
- sp -= wordsize;
- write_memory (sp + 1, buf + 1, 1);
- write_memory (sp + 2, buf, 1);
- }
-#endif
- return sp;
+ return avr_make_iaddr (pc);
}
-static CORE_ADDR
-avr_skip_prologue (CORE_ADDR pc)
+/* Given a GDB frame, determine the address of the calling function's
+ frame. This will be used to create a new GDB frame struct. */
+
+static void
+avr_frame_this_id (struct frame_info *next_frame,
+ void **this_prologue_cache,
+ struct frame_id *this_id)
{
- CORE_ADDR func_addr, func_end;
- struct symtab_and_line sal;
+ struct avr_unwind_cache *info
+ = avr_frame_unwind_cache (next_frame, this_prologue_cache);
+ CORE_ADDR base;
+ CORE_ADDR func;
+ struct frame_id id;
+
+ /* The FUNC is easy. */
+ func = frame_func_unwind (next_frame);
+
+ /* Hopefully the prologue analysis either correctly determined the
+ frame's base (which is the SP from the previous frame), or set
+ that base to "NULL". */
+ base = info->prev_sp;
+ if (base == 0)
+ return;
+
+ id = frame_id_build (base, func);
+ (*this_id) = id;
+}
- /* See what the symbol table says */
+static void
+avr_frame_prev_register (struct frame_info *next_frame,
+ void **this_prologue_cache,
+ int regnum, int *optimizedp,
+ enum lval_type *lvalp, CORE_ADDR *addrp,
+ int *realnump, void *bufferp)
+{
+ struct avr_unwind_cache *info
+ = avr_frame_unwind_cache (next_frame, this_prologue_cache);
- if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+ if (regnum == AVR_PC_REGNUM)
{
- sal = find_pc_line (func_addr, 0);
-
- /* troth/2002-08-05: For some very simple functions, gcc doesn't
- generate a prologue and the sal.end ends up being the 2-byte ``ret''
- instruction at the end of the function, but func_end ends up being
- the address of the first instruction of the _next_ function. By
- adjusting func_end by 2 bytes, we can catch these functions and not
- return sal.end if it is the ``ret'' instruction. */
-
- if (sal.line != 0 && sal.end < (func_end-2))
- return sal.end;
+ if (trad_frame_addr_p (info->saved_regs, regnum))
+ {
+ *optimizedp = 0;
+ *lvalp = lval_memory;
+ *addrp = info->saved_regs[regnum].addr;
+ *realnump = -1;
+ if (bufferp != NULL)
+ {
+ /* Reading the return PC from the PC register is slightly
+ abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
+ but in reality, only two bytes (3 in upcoming mega256) are
+ stored on the stack.
+
+ Also, note that the value on the stack is an addr to a word
+ not a byte, so we will need to multiply it by two at some
+ point.
+
+ And to confuse matters even more, the return address stored
+ on the stack is in big endian byte order, even though most
+ everything else about the avr is little endian. Ick! */
+
+ /* FIXME: number of bytes read here will need updated for the
+ mega256 when it is available. */
+
+ ULONGEST pc;
+ unsigned char tmp;
+ unsigned char buf[2];
+
+ read_memory (info->saved_regs[regnum].addr, buf, 2);
+
+ /* Convert the PC read from memory as a big-endian to
+ little-endian order. */
+ tmp = buf[0];
+ buf[0] = buf[1];
+ buf[1] = tmp;
+
+ pc = (extract_unsigned_integer (buf, 2) * 2);
+ store_unsigned_integer (bufferp,
+ register_size (current_gdbarch, regnum),
+ pc);
+ }
+ }
}
+ else
+ trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, bufferp);
+}
-/* Either we didn't find the start of this function (nothing we can do),
- or there's no line info, or the line after the prologue is after
- the end of the function (there probably isn't a prologue). */
+static const struct frame_unwind avr_frame_unwind = {
+ NORMAL_FRAME,
+ avr_frame_this_id,
+ avr_frame_prev_register
+};
- return pc;
+const struct frame_unwind *
+avr_frame_sniffer (struct frame_info *next_frame)
+{
+ return &avr_frame_unwind;
}
static CORE_ADDR
-avr_frame_address (struct frame_info *fi)
+avr_frame_base_address (struct frame_info *next_frame, void **this_cache)
{
- return avr_make_saddr (fi->frame);
+ struct avr_unwind_cache *info
+ = avr_frame_unwind_cache (next_frame, this_cache);
+
+ return info->base;
}
-/* Given a GDB frame, determine the address of the calling function's frame.
- This will be used to create a new GDB frame struct, and then
- INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
+static const struct frame_base avr_frame_base = {
+ &avr_frame_unwind,
+ avr_frame_base_address,
+ avr_frame_base_address,
+ avr_frame_base_address
+};
- For us, the frame address is its stack pointer value, so we look up
- the function prologue to determine the caller's sp value, and return it. */
+/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
+ dummy frame. The frame ID's base needs to match the TOS value
+ saved by save_dummy_frame_tos(), and the PC match the dummy frame's
+ breakpoint. */
-static CORE_ADDR
-avr_frame_chain (struct frame_info *frame)
+static struct frame_id
+avr_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
- if (DEPRECATED_PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
- {
- /* initialize the return_pc now */
- frame->extra_info->return_pc
- = deprecated_read_register_dummy (frame->pc, frame->frame,
- AVR_PC_REGNUM);
- return frame->frame;
- }
- return (frame->extra_info->is_main ? 0
- : frame->frame + frame->extra_info->framesize + 2 /* ret addr */ );
+ ULONGEST base;
+
+ frame_unwind_unsigned_register (next_frame, AVR_SP_REGNUM, &base);
+ return frame_id_build (avr_make_saddr (base), frame_pc_unwind (next_frame));
}
-/* Store the address of the place in which to copy the structure the
- subroutine will return. This is called from call_function.
+/* When arguments must be pushed onto the stack, they go on in reverse
+ order. The below implements a FILO (stack) to do this. */
- We store structs through a pointer passed in the first Argument
- register. */
+struct stack_item
+{
+ int len;
+ struct stack_item *prev;
+ void *data;
+};
-static void
-avr_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
+static struct stack_item *
+push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len)
{
- write_register (0, addr);
+ struct stack_item *si;
+ si = xmalloc (sizeof (struct stack_item));
+ si->data = xmalloc (len);
+ si->len = len;
+ si->prev = prev;
+ memcpy (si->data, contents, len);
+ return si;
}
-/* Extract from an array REGBUF containing the (raw) register state
- the address in which a function should return its structure value,
- as a CORE_ADDR (or an expression that can be used as one). */
-
-static CORE_ADDR
-avr_extract_struct_value_address (char *regbuf)
+static struct stack_item *pop_stack_item (struct stack_item *si);
+static struct stack_item *
+pop_stack_item (struct stack_item *si)
{
- return (extract_address ((regbuf) + REGISTER_BYTE (0),
- REGISTER_RAW_SIZE (0)) | AVR_SMEM_START);
+ struct stack_item *dead = si;
+ si = si->prev;
+ xfree (dead->data);
+ xfree (dead);
+ return si;
}
/* Setup the function arguments for calling a function in the inferior.
dedicated for passing function arguments. Up to the first 18 arguments
(depending on size) may go into these registers. The rest go on the stack.
- Arguments that are larger than WORDSIZE bytes will be split between two or
- more registers as available, but will NOT be split between a register and
- the stack.
+ All arguments are aligned to start in even-numbered registers (odd-sized
+ arguments, including char, have one free register above them). For example,
+ an int in arg1 and a char in arg2 would be passed as such:
+
+ arg1 -> r25:r24
+ arg2 -> r22
+
+ Arguments that are larger than 2 bytes will be split between two or more
+ registers as available, but will NOT be split between a register and the
+ stack. Arguments that go onto the stack are pushed last arg first (this is
+ similar to the d10v). */
+
+/* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
+ inaccurate.
An exceptional case exists for struct arguments (and possibly other
aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
registers R0 to R2. */
static CORE_ADDR
-avr_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
+avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
+ struct regcache *regcache, CORE_ADDR bp_addr,
+ int nargs, struct value **args, CORE_ADDR sp,
+ int struct_return, CORE_ADDR struct_addr)
{
- int stack_alloc, stack_offset;
- int wordsize;
- int argreg;
- int argnum;
- struct type *type;
- CORE_ADDR regval;
- char *val;
- char valbuf[4];
- int len;
+ int i;
+ unsigned char buf[2];
+ CORE_ADDR return_pc = avr_convert_iaddr_to_raw (bp_addr);
+ int regnum = AVR_ARGN_REGNUM;
+ struct stack_item *si = NULL;
- wordsize = 1;
#if 0
- /* Now make sure there's space on the stack */
- for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
- stack_alloc += TYPE_LENGTH (VALUE_TYPE (args[argnum]));
- sp -= stack_alloc; /* make room on stack for args */
- /* we may over-allocate a little here, but that won't hurt anything */
-#endif
- argreg = 25;
- if (struct_return) /* "struct return" pointer takes up one argreg */
+ /* FIXME: TRoth/2003-06-18: Not sure what to do when returning a struct. */
+ if (struct_return)
{
- write_register (--argreg, struct_addr);
+ fprintf_unfiltered (gdb_stderr, "struct_return: 0x%lx\n", struct_addr);
+ write_register (argreg--, struct_addr & 0xff);
+ write_register (argreg--, (struct_addr >>8) & 0xff);
}
+#endif
- /* Now load as many as possible of the first arguments into registers, and
- push the rest onto the stack. There are 3N bytes in three registers
- available. Loop thru args from first to last. */
+ for (i = 0; i < nargs; i++)
+ {
+ int last_regnum;
+ int j;
+ struct value *arg = args[i];
+ struct type *type = check_typedef (value_type (arg));
+ const bfd_byte *contents = value_contents (arg);
+ int len = TYPE_LENGTH (type);
+
+ /* Calculate the potential last register needed. */
+ last_regnum = regnum - (len + (len & 1));
+
+ /* If there are registers available, use them. Once we start putting
+ stuff on the stack, all subsequent args go on stack. */
+ if ((si == NULL) && (last_regnum >= 8))
+ {
+ ULONGEST val;
+
+ /* Skip a register for odd length args. */
+ if (len & 1)
+ regnum--;
+
+ val = extract_unsigned_integer (contents, len);
+ for (j=0; j<len; j++)
+ {
+ regcache_cooked_write_unsigned (regcache, regnum--,
+ val >> (8*(len-j-1)));
+ }
+ }
+ /* No registers available, push the args onto the stack. */
+ else
+ {
+ /* From here on, we don't care about regnum. */
+ si = push_stack_item (si, contents, len);
+ }
+ }
- for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
+ /* Push args onto the stack. */
+ while (si)
{
- type = VALUE_TYPE (args[argnum]);
- len = TYPE_LENGTH (type);
- val = (char *) VALUE_CONTENTS (args[argnum]);
-
- /* NOTE WELL!!!!! This is not an "else if" clause!!! That's because
- some *&^%$ things get passed on the stack AND in the registers! */
- while (len > 0)
- { /* there's room in registers */
- len -= wordsize;
- regval = extract_address (val + len, wordsize);
- write_register (argreg--, regval);
- }
+ sp -= si->len;
+ /* Add 1 to sp here to account for post decr nature of pushes. */
+ write_memory (sp+1, si->data, si->len);
+ si = pop_stack_item (si);
}
+
+ /* Set the return address. For the avr, the return address is the BP_ADDR.
+ Need to push the return address onto the stack noting that it needs to be
+ in big-endian order on the stack. */
+ buf[0] = (return_pc >> 8) & 0xff;
+ buf[1] = return_pc & 0xff;
+
+ sp -= 2;
+ write_memory (sp+1, buf, 2); /* Add one since pushes are post decr ops. */
+
+ /* Finally, update the SP register. */
+ regcache_cooked_write_unsigned (regcache, AVR_SP_REGNUM,
+ avr_convert_saddr_to_raw (sp));
+
return sp;
}
static struct gdbarch *
avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
- /* FIXME: TRoth/2002-02-18: I have no idea if avr_call_dummy_words[] should
- be bigger or not. Initial testing seems to show that `call my_func()`
- works and backtrace from a breakpoint within the call looks correct.
- Admittedly, I haven't tested with more than a very simple program. */
- static LONGEST avr_call_dummy_words[] = { 0 };
-
struct gdbarch *gdbarch;
struct gdbarch_tdep *tdep;
set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_addr_bit (gdbarch, 32);
- set_gdbarch_bfd_vma_bit (gdbarch, 32); /* FIXME: TRoth/2002-02-18: Is this needed? */
set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_read_pc (gdbarch, avr_read_pc);
set_gdbarch_write_pc (gdbarch, avr_write_pc);
- set_gdbarch_read_fp (gdbarch, avr_read_fp);
set_gdbarch_read_sp (gdbarch, avr_read_sp);
- set_gdbarch_write_sp (gdbarch, avr_write_sp);
set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS);
set_gdbarch_sp_regnum (gdbarch, AVR_SP_REGNUM);
- set_gdbarch_fp_regnum (gdbarch, AVR_FP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, AVR_PC_REGNUM);
set_gdbarch_register_name (gdbarch, avr_register_name);
- set_gdbarch_register_size (gdbarch, 1);
- set_gdbarch_register_bytes (gdbarch, AVR_NUM_REG_BYTES);
- set_gdbarch_register_byte (gdbarch, avr_register_byte);
- set_gdbarch_register_raw_size (gdbarch, avr_register_raw_size);
- set_gdbarch_max_register_raw_size (gdbarch, 4);
- set_gdbarch_register_virtual_size (gdbarch, avr_register_virtual_size);
- set_gdbarch_max_register_virtual_size (gdbarch, 4);
- set_gdbarch_register_virtual_type (gdbarch, avr_register_virtual_type);
+ set_gdbarch_register_type (gdbarch, avr_register_type);
+ set_gdbarch_extract_return_value (gdbarch, avr_extract_return_value);
set_gdbarch_print_insn (gdbarch, print_insn_avr);
- set_gdbarch_call_dummy_address (gdbarch, avr_call_dummy_address);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
- set_gdbarch_call_dummy_length (gdbarch, 0);
- set_gdbarch_call_dummy_p (gdbarch, 1);
- set_gdbarch_call_dummy_words (gdbarch, avr_call_dummy_words);
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
-
-/* set_gdbarch_believe_pcc_promotion (gdbarch, 1); // TRoth: should this be set? */
+ set_gdbarch_push_dummy_call (gdbarch, avr_push_dummy_call);
set_gdbarch_address_to_pointer (gdbarch, avr_address_to_pointer);
set_gdbarch_pointer_to_address (gdbarch, avr_pointer_to_address);
- set_gdbarch_deprecated_extract_return_value (gdbarch, avr_extract_return_value);
- set_gdbarch_push_arguments (gdbarch, avr_push_arguments);
- set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
- set_gdbarch_push_return_address (gdbarch, avr_push_return_address);
- set_gdbarch_pop_frame (gdbarch, avr_pop_frame);
-
- set_gdbarch_deprecated_store_return_value (gdbarch, avr_store_return_value);
- set_gdbarch_use_struct_convention (gdbarch, generic_use_struct_convention);
- set_gdbarch_store_struct_return (gdbarch, avr_store_struct_return);
- set_gdbarch_deprecated_extract_struct_value_address
- (gdbarch, avr_extract_struct_value_address);
-
- set_gdbarch_frame_init_saved_regs (gdbarch, avr_scan_prologue);
- set_gdbarch_init_extra_frame_info (gdbarch, avr_init_extra_frame_info);
set_gdbarch_skip_prologue (gdbarch, avr_skip_prologue);
-/* set_gdbarch_prologue_frameless_p (gdbarch, avr_prologue_frameless_p); */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
- set_gdbarch_decr_pc_after_break (gdbarch, 0);
+ set_gdbarch_breakpoint_from_pc (gdbarch, avr_breakpoint_from_pc);
+
+ frame_unwind_append_sniffer (gdbarch, avr_frame_sniffer);
+ frame_base_set_default (gdbarch, &avr_frame_base);
- set_gdbarch_function_start_offset (gdbarch, 0);
- set_gdbarch_remote_translate_xfer_address (gdbarch,
- avr_remote_translate_xfer_address);
- set_gdbarch_frame_args_skip (gdbarch, 0);
- set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue); /* ??? */
- set_gdbarch_frame_chain (gdbarch, avr_frame_chain);
- set_gdbarch_frame_chain_valid (gdbarch, generic_func_frame_chain_valid);
- set_gdbarch_frame_saved_pc (gdbarch, avr_frame_saved_pc);
- set_gdbarch_frame_args_address (gdbarch, avr_frame_address);
- set_gdbarch_frame_locals_address (gdbarch, avr_frame_address);
- set_gdbarch_saved_pc_after_call (gdbarch, avr_saved_pc_after_call);
- set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
+ set_gdbarch_unwind_dummy_id (gdbarch, avr_unwind_dummy_id);
- set_gdbarch_convert_from_func_ptr_addr (gdbarch,
- avr_convert_from_func_ptr_addr);
+ set_gdbarch_unwind_pc (gdbarch, avr_unwind_pc);
return gdbarch;
}
static void
avr_io_reg_read_command (char *args, int from_tty)
{
- int bufsiz = 0;
+ LONGEST bufsiz = 0;
char buf[400];
char query[400];
char *p;
unsigned int val;
int i, j, k, step;
-/* fprintf_unfiltered (gdb_stderr, "DEBUG: avr_io_reg_read_command (\"%s\", %d)\n", */
-/* args, from_tty); */
-
- if (!current_target.to_query)
+ /* Just get the maximum buffer size. */
+ bufsiz = target_read_partial (¤t_target, TARGET_OBJECT_AVR,
+ NULL, NULL, 0, 0);
+ if (bufsiz < 0)
{
fprintf_unfiltered (gdb_stderr,
- "ERR: info io_registers NOT supported by current target\n");
+ _("ERR: info io_registers NOT supported "
+ "by current target\n"));
return;
}
-
- /* Just get the maximum buffer size. */
- target_query ((int) 'R', 0, 0, &bufsiz);
if (bufsiz > sizeof (buf))
bufsiz = sizeof (buf);
/* Find out how many io registers the target has. */
strcpy (query, "avr.io_reg");
- target_query ((int) 'R', query, buf, &bufsiz);
+ target_read_partial (¤t_target, TARGET_OBJECT_AVR, query, buf, 0,
+ bufsiz);
if (strncmp (buf, "", bufsiz) == 0)
{
fprintf_unfiltered (gdb_stderr,
- "info io_registers NOT supported by target\n");
+ _("info io_registers NOT supported by target\n"));
return;
}
if (sscanf (buf, "%x", &nreg) != 1)
{
fprintf_unfiltered (gdb_stderr,
- "Error fetching number of io registers\n");
+ _("Error fetching number of io registers\n"));
return;
}
reinitialize_more_filter ();
- printf_unfiltered ("Target has %u io registers:\n\n", nreg);
+ printf_unfiltered (_("Target has %u io registers:\n\n"), nreg);
/* only fetch up to 8 registers at a time to keep the buffer small */
step = 8;
for (i = 0; i < nreg; i += step)
{
- j = step - (nreg % step); /* how many registers this round? */
+ /* how many registers this round? */
+ j = step;
+ if ((i+j) >= nreg)
+ j = nreg - i; /* last block is less than 8 registers */
snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j);
- target_query ((int) 'R', query, buf, &bufsiz);
+ target_read_partial (¤t_target, TARGET_OBJECT_AVR, query, buf,
+ 0, bufsiz);
p = buf;
for (k = i; k < (i + j); k++)
}
}
+extern initialize_file_ftype _initialize_avr_tdep; /* -Wmissing-prototypes */
+
void
_initialize_avr_tdep (void)
{
io_registers' to signify it is not available on other platforms. */
add_cmd ("io_registers", class_info, avr_io_reg_read_command,
- "query remote avr target for io space register values", &infolist);
+ _("query remote avr target for io space register values"), &infolist);
}
projects / deliverable / binutils-gdb.git / blobdiff