X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Favr-tdep.c;h=d9c16a55aa846765f2a416c673cfc5dc0726a0f3;hb=7c46b9fb41fd107882032ecc34897a8e86e8264a;hp=79d0af19df3efec2e995f852b0487575f745d34c;hpb=ced15480d01bd4e4650619a3c3c0df85d8cfaf50;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c index 79d0af19df..d9c16a55aa 100644 --- a/gdb/avr-tdep.c +++ b/gdb/avr-tdep.c @@ -1,5 +1,5 @@ /* Target-dependent code for Atmel AVR, for GDB. - Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GDB. @@ -19,12 +19,16 @@ 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" @@ -32,6 +36,7 @@ #include "arch-utils.h" #include "regcache.h" #include "gdb_string.h" +#include "dis-asm.h" /* AVR Background: @@ -89,7 +94,7 @@ enum 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, @@ -97,6 +102,12 @@ enum /* 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. @@ -130,6 +141,20 @@ enum #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 @@ -141,14 +166,17 @@ enum 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 @@ -176,60 +204,18 @@ avr_register_name (int regnum) 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. */ @@ -240,12 +226,6 @@ avr_make_iaddr (CORE_ADDR x) 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. @@ -265,12 +245,6 @@ avr_make_saddr (CORE_ADDR x) 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) { @@ -311,7 +285,7 @@ avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) || 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 { @@ -322,23 +296,15 @@ avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) } 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 \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); } @@ -347,12 +313,12 @@ static CORE_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; @@ -372,128 +338,141 @@ avr_write_pc (CORE_ADDR val, ptid_t ptid) 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, - 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, + 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( - ) + ldi r29,hi8( - ) + 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, + 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, cli - out __SP_L__,r28 - out __SREG__,__tmp_reg__ - out __SP_H__,r29 - - A `-mcall-prologues' prologue look like this: - ldi r26, - ldi r27,/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() + ldi r27,hi8() + 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( - ) @@ -501,7 +480,7 @@ avr_scan_prologue (struct frame_info *fi) 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[] = { @@ -509,7 +488,6 @@ avr_scan_prologue (struct frame_info *fi) 0xcd, 0xbf /* out __SP_L__,r28 */ }; - fi->extra_info->framereg = AVR_FP_REGNUM; insn = EXTRACT_INSN (&prologue[vpc]); /* ldi r28,lo8( - ) */ if ((insn & 0xf0f0) == 0xe0c0) @@ -522,95 +500,124 @@ avr_scan_prologue (struct frame_info *fi) locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8; if (memcmp (prologue + vpc + 4, img, sizeof (img)) == 0) { - fi->frame = locals; - - /* TRoth: Does -1 mean we're in main? */ - 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, */ if ((insn & 0xf0f0) != 0xe0a0) break; loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4); + pc_offset += 2; insn = EXTRACT_INSN (&prologue[vpc + 2]); /* ldi r27, / 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 */ @@ -622,44 +629,52 @@ avr_scan_prologue (struct frame_info *fi) }; 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__ */ @@ -670,7 +685,6 @@ avr_scan_prologue (struct frame_info *fi) if (memcmp (prologue + vpc, img, sizeof (img)) == 0) { vpc += 4; - fi->extra_info->framereg = AVR_FP_REGNUM; scan_stage = 2; } } @@ -678,32 +692,32 @@ avr_scan_prologue (struct frame_info *fi) /* 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]); @@ -718,352 +732,388 @@ avr_scan_prologue (struct frame_info *fi) 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 (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 = generic_read_register_dummy (fi->pc, fi->frame, fi->frame); - } - 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); - /* Return address in stack in different endianness */ + if (sal.line != 0 && sal.end < func_end) + return sal.end; + } + } - 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); +/* 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). */ - /* This return address in words, - must be converted to the bytes address */ - fi->extra_info->return_pc *= 2; + return prologue_end; +} - /* 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]; - } - } +/* 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 */ + +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 (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 (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame)) - return generic_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. */ - -static void -avr_store_return_value (struct type *type, char *valbuf) -{ - int wordsize, len, regval; + /* 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); + } - 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; + } + + /* 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); -/* 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. */ + 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; - struct minimal_symbol *msymbol; - CORE_ADDR mon_brk; + ULONGEST pc; - fprintf_unfiltered (gdb_stderr, "avr_push_return_address() was called\n"); + frame_unwind_unsigned_register (next_frame, AVR_PC_REGNUM, &pc); - buf[0] = 0; - buf[1] = 0; - sp -= wordsize; - write_memory (sp + 1, buf, 2); - -#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); + + /* Check that we're not going round in circles with the same frame + ID (but avoid applying the test to sentinel frames which do go + round in circles). Can't use frame_id_eq() as that doesn't yet + compare the frame's PC value. */ + if (frame_relative_level (next_frame) >= 0 + && get_frame_type (next_frame) != DUMMY_FRAME + && frame_id_eq (get_frame_id (next_frame), id)) + return; + + (*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_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 (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame)) - { - /* initialize the return_pc now */ - frame->extra_info->return_pc = generic_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, + void *contents, int len); +static struct stack_item * +push_stack_item (struct stack_item *prev, void *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. @@ -1072,9 +1122,20 @@ avr_extract_struct_value_address (char *regbuf) 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 @@ -1095,52 +1156,86 @@ avr_extract_struct_value_address (char *regbuf) 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, CORE_ADDR func_addr, + 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)); + char *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> (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; } @@ -1149,12 +1244,6 @@ avr_push_arguments (int nargs, struct value **args, CORE_ADDR 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; @@ -1184,7 +1273,6 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); @@ -1196,84 +1284,39 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); - - /* We might need to define our own here or define FRAME_INIT_SAVED_REGS */ - set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register); + 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_use_generic_dummy_frames (gdbarch, 1); - set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT); - 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_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy); - 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_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); - 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_deprecated_frameless_function_invocation (gdbarch, legacy_frameless_look_for_prologue); - set_gdbarch_convert_from_func_ptr_addr (gdbarch, - avr_convert_from_func_ptr_addr); + frame_unwind_append_sniffer (gdbarch, avr_frame_sniffer); + frame_base_set_default (gdbarch, &avr_frame_base); + + set_gdbarch_unwind_dummy_id (gdbarch, avr_unwind_dummy_id); + + set_gdbarch_unwind_pc (gdbarch, avr_unwind_pc); return gdbarch; } @@ -1294,7 +1337,7 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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; @@ -1302,24 +1345,23 @@ avr_io_reg_read_command (char *args, int from_tty) 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) { @@ -1344,10 +1386,14 @@ avr_io_reg_read_command (char *args, int from_tty) 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++) @@ -1365,6 +1411,8 @@ avr_io_reg_read_command (char *args, int from_tty) } } +extern initialize_file_ftype _initialize_avr_tdep; /* -Wmissing-prototypes */ + void _initialize_avr_tdep (void) {