X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Favr-tdep.c;h=a19e927b41d39a48422d8d146bdca7162d1a7567;hb=11411de309ed70574799872f9b3bec1b18bb66cf;hp=382db8764a1995deb526e49e52a6ecb1faa1de0b;hpb=983a287a6f078fd4b5eeff0083fd557db71883b7;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index 382db8764a..a19e927b41 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -1,12 +1,13 @@
 /* Target-dependent code for Atmel AVR, for GDB.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
-   Free Software Foundation, Inc.
+
+   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+   2006, 2007 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -15,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Contributed by Theodore A. Roth, troth@openavr.org */
 
@@ -25,13 +24,19 @@
    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 "gdbtypes.h"
 #include "inferior.h"
 #include "symfile.h"
 #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)
 {
@@ -304,14 +278,14 @@ avr_convert_saddr_to_raw (CORE_ADDR x)
 /* Convert from address to pointer and vice-versa. */
 
 static void
-avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
+avr_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
 {
   /* Is it a code address?  */
   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
       || 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,181 +296,163 @@ avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 }
 
 static CORE_ADDR
-avr_pointer_to_address (struct type *type, const void *buf)
+avr_pointer_to_address (struct type *type, const gdb_byte *buf)
 {
   CORE_ADDR addr = extract_unsigned_integer (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@openavr.org>\n");
-    }
-
   /* 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);
 }
 
 static CORE_ADDR
-avr_read_pc (ptid_t ptid)
+avr_read_pc (struct regcache *regcache)
 {
-  ptid_t save_ptid;
-  CORE_ADDR pc;
-  CORE_ADDR retval;
-
-  save_ptid = inferior_ptid;
-  inferior_ptid = ptid;
-  pc = (int) read_register (AVR_PC_REGNUM);
-  inferior_ptid = save_ptid;
-  retval = avr_make_iaddr (pc);
-  return retval;
+  ULONGEST pc;
+  regcache_cooked_read_unsigned (regcache, AVR_PC_REGNUM, &pc);
+  return avr_make_iaddr (pc);
 }
 
 static void
-avr_write_pc (CORE_ADDR val, ptid_t ptid)
+avr_write_pc (struct regcache *regcache, CORE_ADDR val)
 {
-  ptid_t save_ptid;
-
-  save_ptid = inferior_ptid;
-  inferior_ptid = ptid;
-  write_register (AVR_PC_REGNUM, avr_convert_iaddr_to_raw (val));
-  inferior_ptid = save_ptid;
+  regcache_cooked_write_unsigned (regcache, AVR_PC_REGNUM,
+				  avr_convert_iaddr_to_raw (val));
 }
 
-static CORE_ADDR
-avr_read_sp (void)
-{
-  return (avr_make_saddr (read_register (AVR_SP_REGNUM)));
-}
-
-static void
-avr_write_sp (CORE_ADDR val)
-{
-  write_register (AVR_SP_REGNUM, avr_convert_saddr_to_raw (val));
-}
-
-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 (struct gdbarch *gdbarch,
-				   struct regcache *regcache,
-				   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
-   deprecated_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_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
+        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_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;
 
-  get_frame_extra_info (fi)->framereg = AVR_SP_REGNUM;
-
-  if (find_pc_partial_function
-      (get_frame_pc (fi), &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 = get_frame_pc (fi);
-      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, get_frame_pc (fi));
-
-  /* Search the prologue looking for instructions that set up the
-     frame pointer, adjust the stack pointer, and save registers.  */
-
-  get_frame_extra_info (fi)->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>)
@@ -504,7 +460,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[] = {
@@ -512,7 +468,6 @@ avr_scan_prologue (struct frame_info *fi)
 	0xcd, 0xbf		/* out __SP_L__,r28 */
       };
 
-      get_frame_extra_info (fi)->framereg = AVR_FP_REGNUM;
       insn = EXTRACT_INSN (&prologue[vpc]);
       /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
       if ((insn & 0xf0f0) == 0xe0c0)
@@ -525,94 +480,124 @@ avr_scan_prologue (struct frame_info *fi)
 	      locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
 	      if (memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
 		{
-		  deprecated_update_frame_base_hack (fi, locals);
-
-		  get_frame_extra_info (fi)->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;
-	  get_frame_saved_regs (fi)[AVR_FP_REGNUM + 1] = num_pushes;
+
+	  info->saved_regs[AVR_FP_REGNUM + 1].addr = num_pushes;
 	  if (num_pushes >= 2)
-	    get_frame_saved_regs (fi)[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)
-	    get_frame_saved_regs (fi)[from] = ++i;
+	    info->saved_regs [from].addr = ++i;
 	}
-      get_frame_extra_info (fi)->locals_size = loc_size;
-      get_frame_extra_info (fi)->framesize = loc_size + num_pushes;
-      get_frame_extra_info (fi)->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 */
@@ -624,44 +609,52 @@ avr_scan_prologue (struct frame_info *fi)
       };
       if (memcmp (prologue, img, sizeof (img)) == 0)
 	{
+          info->prologue_type = AVR_PROLOGUE_INTR;
 	  vpc += sizeof (img);
-	  get_frame_saved_regs (fi)[0] = 2;
-	  get_frame_saved_regs (fi)[1] = 1;
-	  get_frame_extra_info (fi)->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;
-	  get_frame_saved_regs (fi)[0] = 2;
-	  get_frame_saved_regs (fi)[1] = 1;
-	  get_frame_extra_info (fi)->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;
-	  ++get_frame_extra_info (fi)->framesize;
-	  get_frame_saved_regs (fi)[regno] = get_frame_extra_info (fi)->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__ */
@@ -672,7 +665,6 @@ avr_scan_prologue (struct frame_info *fi)
       if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
 	{
 	  vpc += 4;
-	  get_frame_extra_info (fi)->framereg = AVR_FP_REGNUM;
 	  scan_stage = 2;
 	}
     }
@@ -680,32 +672,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]);
@@ -720,297 +712,424 @@ avr_scan_prologue (struct frame_info *fi)
 	  locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4) << 8);
 	}
       else
-	return;
-      get_frame_extra_info (fi)->locals_size = locals_size;
-      get_frame_extra_info (fi)->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 (get_next_frame (fi))
-    deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
+  /* 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.  */
 
-  frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
-  frame_saved_regs_zalloc (fi);
+  return pc + avr_scan_arg_moves (vpc, prologue);;
+}
 
-  get_frame_extra_info (fi)->return_pc = 0;
-  get_frame_extra_info (fi)->args_pointer = 0;
-  get_frame_extra_info (fi)->locals_size = 0;
-  get_frame_extra_info (fi)->framereg = 0;
-  get_frame_extra_info (fi)->framesize = 0;
-  get_frame_extra_info (fi)->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 (get_frame_pc (fi), get_frame_base (fi),
-				   get_frame_base (fi)))
-    {
-      /* We need to setup fi->frame here because call_function_by_hand
-         gets it wrong by assuming it's always FP.  */
-      deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi),
-									     AVR_PC_REGNUM));
-    }
-  else if (!get_next_frame (fi))
-    /* this is the innermost frame? */
-    deprecated_update_frame_base_hack (fi, read_register (get_frame_extra_info (fi)->framereg));
-  else if (get_frame_extra_info (fi)->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 = get_next_frame (fi);
-      if (get_frame_extra_info (fi)->framereg == AVR_SP_REGNUM)
-	deprecated_update_frame_base_hack (fi, (get_frame_base (next_fi)
-						+ 2 /* ret addr */
-						+ get_frame_extra_info (next_fi)->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 = get_next_frame (next_fi))
-	    {
-	      /* look for saved AVR_FP_REGNUM */
-	      if (get_frame_saved_regs (next_fi)[AVR_FP_REGNUM] && !fp)
-		fp = get_frame_saved_regs (next_fi)[AVR_FP_REGNUM];
-	      /* look for saved AVR_FP_REGNUM + 1 */
-	      if (get_frame_saved_regs (next_fi)[AVR_FP_REGNUM + 1] && !fp1)
-		fp1 = get_frame_saved_regs (next_fi)[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;
-	  deprecated_update_frame_base_hack (fi, 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 ((get_frame_pc (fi)) && (get_frame_extra_info (fi)->is_main == 0))
-    /* We are not in CALL_DUMMY */
-    {
-      CORE_ADDR addr;
-      int i;
+      prologue_end = avr_scan_prologue (pc, &info);
+
+      if (info.prologue_type == AVR_PROLOGUE_NONE)
+        return pc;
+      else
+        {
+          sal = find_pc_line (func_addr, 0);
 
-      addr = get_frame_base (fi) + get_frame_extra_info (fi)->framesize + 1;
+          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). */
 
-      get_frame_extra_info (fi)->return_pc =
-	read_memory_unsigned_integer (avr_make_saddr (addr), 1) << 8;
-      get_frame_extra_info (fi)->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 */
-      get_frame_extra_info (fi)->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 (get_frame_saved_regs (fi)[i])
-	    get_frame_saved_regs (fi)[i] = addr - get_frame_saved_regs (fi)[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,
+                          gdb_byte *valbuf)
 {
-  unsigned regnum;
-  CORE_ADDR saddr;
-  struct frame_info *frame = get_current_frame ();
-
-  if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
-				   get_frame_base (frame),
-				   get_frame_base (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? */
+      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);
+        }
+    }
+}
 
-      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 (get_frame_saved_regs (frame)[regnum] && regnum != AVR_SP_REGNUM)
-	    {
-	      saddr = avr_make_saddr (get_frame_saved_regs (frame)[regnum]);
-	      write_register (regnum,
-			      read_memory_unsigned_integer (saddr, 1));
-	    }
-	  else if (get_frame_saved_regs (frame)[regnum] && regnum == AVR_SP_REGNUM)
-	    write_register (regnum, get_frame_base (frame) + 2);
-	}
+/* Determine, for architecture GDBARCH, how a return value of TYPE
+   should be returned.  If it is supposed to be returned in registers,
+   and READBUF is non-zero, read the appropriate value from REGCACHE,
+   and copy it into READBUF.  If WRITEBUF is non-zero, write the value
+   from WRITEBUF into REGCACHE.  */
+
+enum return_value_convention
+avr_return_value (struct gdbarch *gdbarch, struct type *valtype,
+		  struct regcache *regcache, gdb_byte *readbuf,
+		  const gdb_byte *writebuf)
+{
+  int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
+			|| TYPE_CODE (valtype) == TYPE_CODE_UNION
+			|| TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
+		       && !(TYPE_LENGTH (valtype) == 1
+			    || TYPE_LENGTH (valtype) == 2
+			    || TYPE_LENGTH (valtype) == 4
+			    || TYPE_LENGTH (valtype) == 8));
+
+  if (writebuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      error (_("Cannot store return value."));
+    }
 
-      /* Don't forget the update the PC too!  */
-      write_pc (get_frame_extra_info (frame)->return_pc);
+  if (readbuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      avr_extract_return_value (valtype, regcache, readbuf);
     }
-  flush_cached_frames ();
+
+  if (struct_return)
+    return RETURN_VALUE_STRUCT_CONVENTION;
+  else
+    return RETURN_VALUE_REGISTER_CONVENTION;
 }
 
-/* Return the saved PC from this frame. */
 
-static CORE_ADDR
-avr_frame_saved_pc (struct frame_info *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. */
+
+struct avr_unwind_cache *
+avr_frame_unwind_cache (struct frame_info *next_frame,
+                        void **this_prologue_cache)
 {
-  if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
-				   get_frame_base (frame),
-				   get_frame_base (frame)))
-    return deprecated_read_register_dummy (get_frame_pc (frame),
-					   get_frame_base (frame),
-					   AVR_PC_REGNUM);
+  CORE_ADDR pc;
+  ULONGEST prev_sp;
+  ULONGEST this_base;
+  struct avr_unwind_cache *info;
+  int i;
+
+  if ((*this_prologue_cache))
+    return (*this_prologue_cache);
+
+  info = FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache);
+  (*this_prologue_cache) = info;
+  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+  info->size = 0;
+  info->prologue_type = AVR_PROLOGUE_NONE;
+
+  pc = frame_func_unwind (next_frame, NORMAL_FRAME);
+
+  if ((pc > 0) && (pc < frame_pc_unwind (next_frame)))
+    avr_scan_prologue (pc, info);
+
+  if ((info->prologue_type != AVR_PROLOGUE_NONE)
+      && (info->prologue_type != AVR_PROLOGUE_MAIN))
+    {
+      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.  */
+      this_base = frame_unwind_register_unsigned (next_frame, AVR_FP_REGNUM);
+      high_base = frame_unwind_register_unsigned (next_frame, AVR_FP_REGNUM+1);
+      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
-    return get_frame_extra_info (frame)->return_pc;
+    {
+      /* Assume that the FP is this frame's SP but with that pushed
+         stack space added back.  */
+      this_base = frame_unwind_register_unsigned (next_frame, AVR_SP_REGNUM);
+      prev_sp = this_base + info->size;
+    }
+
+  /* Add 1 here to adjust for the post-decrement nature of the push
+     instruction.*/
+  info->prev_sp = avr_make_saddr (prev_sp+1);
+
+  info->base = avr_make_saddr (this_base);
+
+  /* Adjust all the saved registers so that they contain addresses and not
+     offsets.  */
+  for (i = 0; i < gdbarch_num_regs (current_gdbarch) - 1; i++)
+    if (info->saved_regs[i].addr)
+      {
+        info->saved_regs[i].addr = (info->prev_sp - info->saved_regs[i].addr);
+      }
+
+  /* Except for the main and startup code, the return PC is always saved on
+     the stack and is at the base of the frame. */
+
+  if (info->prologue_type != AVR_PROLOGUE_MAIN)
+    {
+      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);
+
+  return info;
 }
 
 static CORE_ADDR
-avr_saved_pc_after_call (struct frame_info *frame)
+avr_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_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;
-}
+  ULONGEST pc;
 
-/* Returns the return address for a dummy. */
+  pc = frame_unwind_register_unsigned (next_frame, AVR_PC_REGNUM);
 
-static CORE_ADDR
-avr_call_dummy_address (void)
-{
-  return entry_point_address ();
+  return avr_make_iaddr (pc);
 }
 
-/* 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. */
-
 static CORE_ADDR
-avr_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
+avr_unwind_sp (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 sp;
 
-  buf[0] = 0;
-  buf[1] = 0;
-  sp -= wordsize;
-  write_memory (sp + 1, buf, 2);
+  sp = frame_unwind_register_unsigned (next_frame, AVR_SP_REGNUM);
 
-#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_saddr (sp);
 }
 
-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, NORMAL_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, gdb_byte *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 (get_frame_base (fi));
+  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 DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_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 (get_frame_pc (frame),
-				   get_frame_base (frame),
-				   get_frame_base (frame)))
-    {
-      /* initialize the return_pc now */
-      get_frame_extra_info (frame)->return_pc
-	= deprecated_read_register_dummy (get_frame_pc (frame),
-					  get_frame_base (frame),
-					  AVR_PC_REGNUM);
-      return get_frame_base (frame);
-    }
-  return (get_frame_extra_info (frame)->is_main ? 0
-	  : get_frame_base (frame) + get_frame_extra_info (frame)->framesize + 2 /* ret addr */ );
+  ULONGEST base;
+
+  base = frame_unwind_register_unsigned (next_frame, AVR_SP_REGNUM);
+  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)
+{
+  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;
+}
+
+static struct stack_item *pop_stack_item (struct stack_item *si);
+static struct stack_item *
+pop_stack_item (struct stack_item *si)
 {
-  write_register (0, addr);
+  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.
@@ -1019,9 +1138,20 @@ avr_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
    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
@@ -1042,65 +1172,87 @@ avr_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
    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);
+      regcache_cooked_write_unsigned (regcache, argreg--, struct_addr & 0xff);
+      regcache_cooked_write_unsigned (regcache, 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_unsigned_integer (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);
     }
-  return sp;
-}
 
-/* 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  */
+  /* 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;
 
-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;
+  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;
 }
 
 /* Initialize the gdbarch structure for the AVR's. */
@@ -1108,12 +1260,6 @@ avr_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
 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;
 
@@ -1126,10 +1272,6 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep = XMALLOC (struct gdbarch_tdep);
   gdbarch = gdbarch_alloc (&info, tdep);
 
-  /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
-     ready to unwind the PC first (see frame.c:get_prev_frame()).  */
-  set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
-
   /* If we ever need to differentiate the device types, do it here. */
   switch (info.bfd_arch_info->mach)
     {
@@ -1147,75 +1289,46 @@ 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);
   set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 
-  set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little);
-  set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little);
-  set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_single_little);
+  set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
+  set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
+  set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);
 
   set_gdbarch_read_pc (gdbarch, avr_read_pc);
   set_gdbarch_write_pc (gdbarch, avr_write_pc);
-  set_gdbarch_deprecated_target_read_fp (gdbarch, avr_read_fp);
-  set_gdbarch_read_sp (gdbarch, avr_read_sp);
-  set_gdbarch_deprecated_dummy_write_sp (gdbarch, avr_write_sp);
 
   set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS);
 
   set_gdbarch_sp_regnum (gdbarch, AVR_SP_REGNUM);
-  set_gdbarch_deprecated_fp_regnum (gdbarch, AVR_FP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, AVR_PC_REGNUM);
 
   set_gdbarch_register_name (gdbarch, avr_register_name);
-  set_gdbarch_deprecated_register_size (gdbarch, 1);
-  set_gdbarch_deprecated_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_deprecated_max_register_raw_size (gdbarch, 4);
-  set_gdbarch_register_virtual_size (gdbarch, avr_register_virtual_size);
-  set_gdbarch_deprecated_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_return_value (gdbarch, avr_return_value);
   set_gdbarch_print_insn (gdbarch, print_insn_avr);
 
-  set_gdbarch_call_dummy_address (gdbarch, avr_call_dummy_address);
-  set_gdbarch_deprecated_call_dummy_words (gdbarch, avr_call_dummy_words);
-
-/*    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_push_arguments (gdbarch, avr_push_arguments);
-  set_gdbarch_deprecated_push_return_address (gdbarch, avr_push_return_address);
-  set_gdbarch_deprecated_pop_frame (gdbarch, avr_pop_frame);
 
-  set_gdbarch_use_struct_convention (gdbarch, generic_use_struct_convention);
-  set_gdbarch_deprecated_store_struct_return (gdbarch, avr_store_struct_return);
-
-  set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, avr_scan_prologue);
-  set_gdbarch_deprecated_init_extra_frame_info (gdbarch, avr_init_extra_frame_info);
   set_gdbarch_skip_prologue (gdbarch, avr_skip_prologue);
   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_deprecated_frame_chain (gdbarch, avr_frame_chain);
-  set_gdbarch_deprecated_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_deprecated_saved_pc_after_call (gdbarch, avr_saved_pc_after_call);
+  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_convert_from_func_ptr_addr (gdbarch,
-					  avr_convert_from_func_ptr_addr);
+  set_gdbarch_unwind_pc (gdbarch, avr_unwind_pc);
+  set_gdbarch_unwind_sp (gdbarch, avr_unwind_sp);
 
   return gdbarch;
 }
@@ -1236,50 +1349,39 @@ 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;
-  char buf[400];
+  LONGEST bufsiz = 0;
+  gdb_byte *buf;
   char query[400];
   char *p;
   unsigned int nreg = 0;
   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)
-    {
-      fprintf_unfiltered (gdb_stderr,
-			  "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);
+  bufsiz = target_read_alloc (&current_target, TARGET_OBJECT_AVR,
+			      "avr.io_reg", &buf);
 
-  if (strncmp (buf, "", bufsiz) == 0)
+  if (bufsiz <= 0)
     {
       fprintf_unfiltered (gdb_stderr,
-			  "info io_registers NOT supported by target\n");
+			  _("ERR: info io_registers NOT supported "
+			    "by current 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"));
+      xfree (buf);
       return;
     }
 
+  xfree (buf);
+
   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;
@@ -1292,7 +1394,8 @@ avr_io_reg_read_command (char *args, int from_tty)
         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);
+      bufsiz = target_read_alloc (&current_target, TARGET_OBJECT_AVR,
+				  query, &buf);
 
       p = buf;
       for (k = i; k < (i + j); k++)
@@ -1307,9 +1410,13 @@ avr_io_reg_read_command (char *args, int from_tty)
 		break;
 	    }
 	}
+
+      xfree (buf);
     }
 }
 
+extern initialize_file_ftype _initialize_avr_tdep; /* -Wmissing-prototypes */
+
 void
 _initialize_avr_tdep (void)
 {
@@ -1323,5 +1430,6 @@ _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);
 }