* avr-tdep.c: Ran through gdb_indent.sh.

1 files changed, 358 insertions, 353 deletions

diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index 32e8f3e..71c7796 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -72,62 +72,62 @@
 /* Constants: prefixed with AVR_ to avoid name space clashes */
 
 enum
-  {
-    AVR_REG_W         = 24,
-    AVR_REG_X         = 26,
-    AVR_REG_Y         = 28,
-    AVR_FP_REGNUM     = 28,
-    AVR_REG_Z         = 30,
-                    
-    AVR_SREG_REGNUM   = 32,
-    AVR_SP_REGNUM     = 33,
-    AVR_PC_REGNUM     = 34,
-
-    AVR_NUM_REGS      = 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
-    AVR_NUM_REG_BYTES = 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
-
-    AVR_PC_REG_INDEX  = 35,       /* index into array of registers */
-
-    AVR_MAX_PROLOGUE_SIZE = 56,   /* bytes */
-
-    /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
-    AVR_MAX_PUSHES    = 18,
-
-    /* Number of the last pushed register. r17 for current avr-gcc */
-    AVR_LAST_PUSHED_REGNUM = 17,
-
-    /* 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.
-
-       Note: I chose these values so as to be consistent with bfd vma
-       addresses.
-
-       TRoth/2002-04-08: There is already a conflict with very large programs
-       in the mega128. The mega128 has 128K instruction bytes (64K words),
-       thus the Most Significant Bit is 0x10000 which gets masked off my
-       AVR_MEM_MASK.
-
-       The problem manifests itself when trying to set a breakpoint in a
-       function which resides in the upper half of the instruction space and
-       thus requires a 17-bit address.
-
-       For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
-       from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
-       but could be for some remote targets by just adding the correct offset
-       to the address and letting the remote target handle the low-level
-       details of actually accessing the eeprom. */
-
-    AVR_IMEM_START    = 0x00000000, /* INSN memory */
-    AVR_SMEM_START    = 0x00800000, /* SRAM memory */
+{
+  AVR_REG_W = 24,
+  AVR_REG_X = 26,
+  AVR_REG_Y = 28,
+  AVR_FP_REGNUM = 28,
+  AVR_REG_Z = 30,
+
+  AVR_SREG_REGNUM = 32,
+  AVR_SP_REGNUM = 33,
+  AVR_PC_REGNUM = 34,
+
+  AVR_NUM_REGS = 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
+  AVR_NUM_REG_BYTES = 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
+
+  AVR_PC_REG_INDEX = 35,	/* index into array of registers */
+
+  AVR_MAX_PROLOGUE_SIZE = 56,	/* bytes */
+
+  /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
+  AVR_MAX_PUSHES = 18,
+
+  /* Number of the last pushed register. r17 for current avr-gcc */
+  AVR_LAST_PUSHED_REGNUM = 17,
+
+  /* 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.
+
+     Note: I chose these values so as to be consistent with bfd vma
+     addresses.
+
+     TRoth/2002-04-08: There is already a conflict with very large programs
+     in the mega128. The mega128 has 128K instruction bytes (64K words),
+     thus the Most Significant Bit is 0x10000 which gets masked off my
+     AVR_MEM_MASK.
+
+     The problem manifests itself when trying to set a breakpoint in a
+     function which resides in the upper half of the instruction space and
+     thus requires a 17-bit address.
+
+     For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
+     from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
+     but could be for some remote targets by just adding the correct offset
+     to the address and letting the remote target handle the low-level
+     details of actually accessing the eeprom. */
+
+  AVR_IMEM_START = 0x00000000,	/* INSN memory */
+  AVR_SMEM_START = 0x00800000,	/* SRAM memory */
 #if 1
-    /* No eeprom mask defined */
-    AVR_MEM_MASK      = 0x00f00000, /* mask to determine memory space */
+  /* No eeprom mask defined */
+  AVR_MEM_MASK = 0x00f00000,	/* mask to determine memory space */
 #else
-    AVR_EMEM_START    = 0x00810000, /* EEPROM memory */
-    AVR_MEM_MASK      = 0x00ff0000, /* mask to determine memory space */
+  AVR_EMEM_START = 0x00810000,	/* EEPROM memory */
+  AVR_MEM_MASK = 0x00ff0000,	/* mask to determine memory space */
 #endif
-  };
+};
 
 /* Any function with a frame looks like this
    .......    <-SP POINTS HERE
@@ -141,30 +141,29 @@ enum
    SECOND ARG */
 
 struct frame_extra_info
-  {
-    CORE_ADDR return_pc;
-    CORE_ADDR args_pointer;
-    int locals_size;
-    int framereg;
-    int framesize;
-    int is_main;
-  };
+{
+  CORE_ADDR return_pc;
+  CORE_ADDR args_pointer;
+  int locals_size;
+  int framereg;
+  int framesize;
+  int is_main;
+};
 
 struct gdbarch_tdep
-  {
-    /* FIXME: TRoth: is there anything to put here? */
-    int foo;
-  };
+{
+  /* FIXME: TRoth: is there anything to put here? */
+  int foo;
+};
 
 /* Lookup the name of a register given it's number. */
 
 static char *
 avr_register_name (int regnum)
 {
-  static char *register_names[] =
-  {
-    "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
-    "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
+  static char *register_names[] = {
+    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
     "SREG", "SP", "PC"
@@ -310,14 +309,14 @@ avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
   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));
+      store_unsigned_integer (buf, TYPE_LENGTH (type),
+			      avr_convert_iaddr_to_raw (addr));
     }
   else
     {
       /* Strip off any upper segment bits.  */
-      store_unsigned_integer (buf, TYPE_LENGTH (type), 
-                              avr_convert_saddr_to_raw (addr));
+      store_unsigned_integer (buf, TYPE_LENGTH (type),
+			      avr_convert_saddr_to_raw (addr));
     }
 }
 
@@ -326,17 +325,18 @@ avr_pointer_to_address (struct type *type, void *buf)
 {
   CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
 
-  if ( TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)) )
+  if (TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
     {
-      fprintf_unfiltered (gdb_stderr, "CODE_SPACE ---->> ptr->addr: 0x%lx\n", addr);
-      fprintf_unfiltered (gdb_stderr, "+++ If you see this, please send me an email <troth@verinet.com>\n");
+      fprintf_unfiltered (gdb_stderr, "CODE_SPACE ---->> ptr->addr: 0x%lx\n",
+			  addr);
+      fprintf_unfiltered (gdb_stderr,
+			  "+++ If you see this, please send me an email <troth@verinet.com>\n");
     }
 
   /* 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))
-      )
+      || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
     return avr_make_iaddr (addr);
   else
     return avr_make_saddr (addr);
@@ -396,7 +396,7 @@ avr_read_fp (void)
 
 static void
 avr_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
-                                   CORE_ADDR *targ_addr, int *targ_len)
+				   CORE_ADDR *targ_addr, int *targ_len)
 {
   long out_addr;
   long out_len;
@@ -458,31 +458,32 @@ avr_scan_prologue (struct frame_info *fi)
 {
   CORE_ADDR prologue_start;
   CORE_ADDR prologue_end;
-  int       i;
-  unsigned  short insn;
-  int       regno;
-  int       scan_stage=0;
-  char      *name;
+  int i;
+  unsigned short insn;
+  int regno;
+  int scan_stage = 0;
+  char *name;
   struct minimal_symbol *msymbol;
-  int       prologue_len;
+  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))
+
+  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)  */
+      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 = prologue_start + AVR_MAX_PROLOGUE_SIZE;
 
   prologue_end = min (prologue_end, fi->pc);
 
@@ -502,81 +503,80 @@ avr_scan_prologue (struct frame_info *fi)
   if (name && strcmp ("main", name) == 0 && prologue_len == 8)
     {
       CORE_ADDR locals;
-      unsigned char img[] =
-      {
-        0xde,0xbf,              /* out __SP_H__,r29 */
-        0xcd,0xbf               /* out __SP_L__,r28 */
+      unsigned char img[] = {
+	0xde, 0xbf,		/* out __SP_H__,r29 */
+	0xcd, 0xbf		/* out __SP_L__,r28 */
       };
 
       fi->extra_info->framereg = AVR_FP_REGNUM;
       insn = EXTRACT_INSN (&prologue[vpc]);
       /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
-      if ((insn & 0xf0f0) == 0xe0c0) 
-        {
-          locals = (insn & 0xf) | ((insn & 0x0f00) >> 4);
-          insn = EXTRACT_INSN (&prologue[vpc+2]);
-          /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
-          if ((insn & 0xf0f0) == 0xe0d0)  
-            {
-              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;
-                }
-            }
-        }
+      if ((insn & 0xf0f0) == 0xe0c0)
+	{
+	  locals = (insn & 0xf) | ((insn & 0x0f00) >> 4);
+	  insn = EXTRACT_INSN (&prologue[vpc + 2]);
+	  /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
+	  if ((insn & 0xf0f0) == 0xe0d0)
+	    {
+	      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;
+		}
+	    }
+	}
     }
-      
+
   /* Scanning `-mcall-prologues' prologue
      FIXME: mega prologue have a 12 bytes long */
 
-  while (prologue_len <= 12)    /* I'm use while to avoit many goto's */
+  while (prologue_len <= 12)	/* I'm use while to avoit many goto's */
     {
       int loc_size;
       int body_addr;
       unsigned num_pushes;
-      
+
       insn = EXTRACT_INSN (&prologue[vpc]);
       /* ldi r26,<LOCALS_SIZE> */
-      if ((insn & 0xf0f0) != 0xe0a0) 
-        break;
+      if ((insn & 0xf0f0) != 0xe0a0)
+	break;
       loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4);
-      
+
       insn = EXTRACT_INSN (&prologue[vpc + 2]);
       /* ldi r27,<LOCALS_SIZE> / 256 */
       if ((insn & 0xf0f0) != 0xe0b0)
-        break;
+	break;
       loc_size |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
-      
+
       insn = EXTRACT_INSN (&prologue[vpc + 4]);
       /* ldi r30,pm_lo8(.L_foo_body) */
       if ((insn & 0xf0f0) != 0xe0e0)
-        break;
+	break;
       body_addr = (insn & 0xf) | ((insn & 0x0f00) >> 4);
 
       insn = EXTRACT_INSN (&prologue[vpc + 6]);
       /* ldi r31,pm_hi8(.L_foo_body) */
       if ((insn & 0xf0f0) != 0xe0f0)
-        break;
+	break;
       body_addr |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
 
       if (body_addr != (prologue_start + 10) / 2)
-        break;
+	break;
 
       msymbol = lookup_minimal_symbol ("__prologue_saves__", NULL, NULL);
       if (!msymbol)
-        break;
+	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;
-      
+	break;
+
       /* Extract PC relative offset from RJMP */
       i = (insn & 0xfff) | (insn & 0x800 ? (-1 ^ 0xfff) : 0);
       /* Convert offset to byte addressable mode */
@@ -588,19 +588,19 @@ avr_scan_prologue (struct frame_info *fi)
       num_pushes = AVR_MAX_PUSHES - (i - SYMBOL_VALUE_ADDRESS (msymbol)) / 2;
 
       if (num_pushes > AVR_MAX_PUSHES)
-        num_pushes = 0;
-        
+	num_pushes = 0;
+
       if (num_pushes)
-        {
-          int from;
-          fi->saved_regs[AVR_FP_REGNUM+1] = num_pushes;
-          if (num_pushes >= 2)
-            fi->saved_regs[AVR_FP_REGNUM] = 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;
-        }
+	{
+	  int from;
+	  fi->saved_regs[AVR_FP_REGNUM + 1] = num_pushes;
+	  if (num_pushes >= 2)
+	    fi->saved_regs[AVR_FP_REGNUM] = 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;
+	}
       fi->extra_info->locals_size = loc_size;
       fi->extra_info->framesize = loc_size + num_pushes;
       fi->extra_info->framereg = AVR_FP_REGNUM;
@@ -611,29 +611,28 @@ avr_scan_prologue (struct frame_info *fi)
 
   if (prologue_len >= 12)
     {
-      unsigned char img[] =
-      {
-        0x78,0x94,              /* sei */
-        0x1f,0x92,              /* push r1 */
-        0x0f,0x92,              /* push r0 */
-        0x0f,0xb6,              /* in r0,0x3f SREG */
-        0x0f,0x92,              /* push r0 */
-        0x11,0x24               /* clr r1 */
+      unsigned char img[] = {
+	0x78, 0x94,		/* sei */
+	0x1f, 0x92,		/* push r1 */
+	0x0f, 0x92,		/* push r0 */
+	0x0f, 0xb6,		/* in r0,0x3f SREG */
+	0x0f, 0x92,		/* push r0 */
+	0x11, 0x24		/* clr r1 */
       };
       if (memcmp (prologue, img, sizeof (img)) == 0)
-        {
-          vpc += sizeof (img);
-          fi->saved_regs[0] = 2;
-          fi->saved_regs[1] = 1;
-          fi->extra_info->framesize += 3;
-        }
+	{
+	  vpc += sizeof (img);
+	  fi->saved_regs[0] = 2;
+	  fi->saved_regs[1] = 1;
+	  fi->extra_info->framesize += 3;
+	}
       else if (memcmp (img + 1, prologue, sizeof (img) - 1) == 0)
-        {
-          vpc += sizeof (img) - 1;
-          fi->saved_regs[0] = 2;
-          fi->saved_regs[1] = 1;
-          fi->extra_info->framesize += 3;
-        }
+	{
+	  vpc += sizeof (img) - 1;
+	  fi->saved_regs[0] = 2;
+	  fi->saved_regs[1] = 1;
+	  fi->extra_info->framesize += 3;
+	}
     }
 
   /* First stage of the prologue scanning.
@@ -642,16 +641,16 @@ avr_scan_prologue (struct frame_info *fi)
   for (; vpc <= prologue_len; 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;
-          scan_stage = 1;
-        }
+      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;
+	  scan_stage = 1;
+	}
       else
-        break;
+	break;
     }
 
   /* Second stage of the prologue scanning.
@@ -661,19 +660,18 @@ avr_scan_prologue (struct frame_info *fi)
 
   if (scan_stage == 1 && vpc + 4 <= prologue_len)
     {
-      unsigned char img[] =
-      {
-        0xcd,0xb7,              /* in r28,__SP_L__ */
-        0xde,0xb7               /* in r29,__SP_H__ */
+      unsigned char img[] = {
+	0xcd, 0xb7,		/* in r28,__SP_L__ */
+	0xde, 0xb7		/* in r29,__SP_H__ */
       };
       unsigned short insn1;
-      
+
       if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
-        {
-          vpc += 4;
-          fi->extra_info->framereg = AVR_FP_REGNUM;
-          scan_stage = 2;
-        }
+	{
+	  vpc += 4;
+	  fi->extra_info->framereg = AVR_FP_REGNUM;
+	  scan_stage = 2;
+	}
     }
 
   /* Third stage of the prologue scanning. (Really two stages)
@@ -689,40 +687,37 @@ avr_scan_prologue (struct frame_info *fi)
   if (scan_stage == 2 && vpc + 12 <= prologue_len)
     {
       int locals_size = 0;
-      unsigned char img[] =
-      {
-        0x0f,0xb6,              /* in r0,0x3f */
-        0xf8,0x94,              /* cli */
-        0xcd,0xbf,              /* out 0x3d,r28 ; SPL */
-        0x0f,0xbe,              /* out 0x3f,r0  ; SREG*/
-        0xde,0xbf               /* out 0x3e,r29 ; SPH */
+      unsigned char img[] = {
+	0x0f, 0xb6,		/* in r0,0x3f */
+	0xf8, 0x94,		/* cli */
+	0xcd, 0xbf,		/* out 0x3d,r28 ; SPL */
+	0x0f, 0xbe,		/* out 0x3f,r0  ; SREG */
+	0xde, 0xbf		/* out 0x3e,r29 ; SPH */
       };
-      unsigned char img_sig[] =
-      {
-        0xcd,0xbf,              /* out 0x3d,r28 ; SPL */
-        0xde,0xbf               /* out 0x3e,r29 ; SPH */
+      unsigned char img_sig[] = {
+	0xcd, 0xbf,		/* out 0x3d,r28 ; SPL */
+	0xde, 0xbf		/* out 0x3e,r29 ; SPH */
       };
-      unsigned char img_int[] =
-      {
-        0xf8,0x94,              /* cli */
-        0xcd,0xbf,              /* out 0x3d,r28 ; SPL */
-        0x78,0x94,              /* sei */
-        0xde,0xbf               /* out 0x3e,r29 ; SPH */
+      unsigned char img_int[] = {
+	0xf8, 0x94,		/* cli */
+	0xcd, 0xbf,		/* out 0x3d,r28 ; SPL */
+	0x78, 0x94,		/* sei */
+	0xde, 0xbf		/* out 0x3e,r29 ; SPH */
       };
-        
+
       insn = EXTRACT_INSN (&prologue[vpc]);
       vpc += 2;
-      if ((insn & 0xff30) == 0x9720) /* sbiw r28,XXX */
-        locals_size = (insn & 0xf) | ((insn & 0xc0) >> 2);
-      else if ((insn & 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
-        {
-          locals_size = (insn & 0xf) | ((insn & 0xf00) >> 4);
-          insn = EXTRACT_INSN (&prologue[vpc]);
-          vpc += 2;
-          locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4) << 8);
-        }
+      if ((insn & 0xff30) == 0x9720)	/* sbiw r28,XXX */
+	locals_size = (insn & 0xf) | ((insn & 0xc0) >> 2);
+      else if ((insn & 0xf0f0) == 0x50c0)	/* subi r28,lo8(XX) */
+	{
+	  locals_size = (insn & 0xf) | ((insn & 0xf00) >> 4);
+	  insn = EXTRACT_INSN (&prologue[vpc]);
+	  vpc += 2;
+	  locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4) << 8);
+	}
       else
-        return;
+	return;
       fi->extra_info->locals_size = locals_size;
       fi->extra_info->framesize += locals_size;
     }
@@ -752,76 +747,77 @@ avr_init_extra_frame_info (int fromleaf, struct frame_info *fi)
   fi->extra_info->framereg = 0;
   fi->extra_info->framesize = 0;
   fi->extra_info->is_main = 0;
-  
+
   avr_scan_prologue (fi);
 
   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);
+      fi->frame = generic_read_register_dummy (fi->pc, fi->frame, fi->frame);
     }
-  else if (!fi->next)                   /* this is the innermost 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' */
+  else if (fi->extra_info->is_main != 1)	/* not the innermost frame, not `main' */
     /* If we have an next frame,  the callee saved it. */
     {
-      struct frame_info * next_fi = fi->next;
+      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;
+	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;
-
-          /* 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);
-        }
+	{
+	  CORE_ADDR fp = 0;
+	  CORE_ADDR fp1 = 0;
+	  unsigned int fp_low, fp_high;
+
+	  /* 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);
+	}
     }
 
   /* 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. */
 
-  if ((fi->pc) && (fi->extra_info->is_main == 0)) /* We are not in CALL_DUMMY */
+  if ((fi->pc) && (fi->extra_info->is_main == 0))	/* We are not in CALL_DUMMY */
     {
       CORE_ADDR addr;
       int i;
-    
+
       addr = fi->frame + fi->extra_info->framesize + 1;
-      
+
       /* Return address in stack in different endianness */
 
       fi->extra_info->return_pc =
-          read_memory_unsigned_integer (avr_make_saddr (addr), 1) << 8;
+	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);
-    
+	read_memory_unsigned_integer (avr_make_saddr (addr + 1), 1);
+
       /* This return address in words,
          must be converted to the bytes address */
       fi->extra_info->return_pc *= 2;
 
       /* 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];
-        }
+	{
+	  if (fi->saved_regs[i])
+	    fi->saved_regs[i] = addr - fi->saved_regs[i];
+	}
     }
 }
 
@@ -836,26 +832,27 @@ avr_pop_frame (void)
   CORE_ADDR saddr;
   struct frame_info *frame = get_current_frame ();
 
-  if (PC_IN_CALL_DUMMY(frame->pc, frame->frame, frame->frame))
+  if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
     {
-      generic_pop_dummy_frame();
+      generic_pop_dummy_frame ();
     }
   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 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);
@@ -868,8 +865,9 @@ avr_pop_frame (void)
 static CORE_ADDR
 avr_frame_saved_pc (struct frame_info *frame)
 {
-  if (PC_IN_CALL_DUMMY(frame->pc, frame->frame, frame->frame))
-    return generic_read_register_dummy (frame->pc, frame->frame, AVR_PC_REGNUM);
+  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;
 }
@@ -894,21 +892,22 @@ avr_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 
   wordsize = 2;
 
-  len = TYPE_LENGTH(type);
-
-  switch (len) {
-  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;
-  }
+  len = TYPE_LENGTH (type);
+
+  switch (len)
+    {
+    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;
+    }
 }
 
 /* Returns the return address for a dummy. */
@@ -926,25 +925,26 @@ static void
 avr_store_return_value (struct type *type, char *valbuf)
 {
   int wordsize, len, regval;
-  
+
   wordsize = 2;
 
-  len = TYPE_LENGTH(type);
-  switch (len) {
-  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;
-  }
+  len = TYPE_LENGTH (type);
+  switch (len)
+    {
+    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;
+    }
 }
 
 /* Setup the return address for a dummy frame, as called by
@@ -995,8 +995,8 @@ avr_skip_prologue (CORE_ADDR pc)
     {
       sal = find_pc_line (func_addr, 0);
 
-      if (sal.line != 0 && sal.end < func_end) 
-        return sal.end;
+      if (sal.line != 0 && sal.end < func_end)
+	return sal.end;
     }
 
 /* Either we didn't find the start of this function (nothing we can do),
@@ -1026,12 +1026,13 @@ avr_frame_chain (struct frame_info *frame)
     {
       /* initialize the return_pc now */
       frame->extra_info->return_pc = generic_read_register_dummy (frame->pc,
-                                                                  frame->frame, 
-                                                                  AVR_PC_REGNUM);
+								  frame->
+								  frame,
+								  AVR_PC_REGNUM);
       return frame->frame;
     }
   return (frame->extra_info->is_main ? 0
-          : frame->frame + frame->extra_info->framesize + 2 /* ret addr */);
+	  : frame->frame + frame->extra_info->framesize + 2 /* ret addr */ );
 }
 
 /* Store the address of the place in which to copy the structure the
@@ -1054,8 +1055,7 @@ static CORE_ADDR
 avr_extract_struct_value_address (char *regbuf)
 {
   return (extract_address ((regbuf) + REGISTER_BYTE (0),
-                           REGISTER_RAW_SIZE (0))
-          | AVR_SMEM_START);
+			   REGISTER_RAW_SIZE (0)) | AVR_SMEM_START);
 }
 
 /* Setup the function arguments for calling a function in the inferior.
@@ -1088,7 +1088,7 @@ avr_extract_struct_value_address (char *regbuf)
 
 static CORE_ADDR
 avr_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
-                    int struct_return, CORE_ADDR struct_addr)
+		    int struct_return, CORE_ADDR struct_addr)
 {
   int stack_alloc, stack_offset;
   int wordsize;
@@ -1100,17 +1100,16 @@ avr_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
   char valbuf[4];
   int len;
 
-  wordsize    = 1;
+  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 */
+  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 */
+  if (struct_return)		/* "struct return" pointer takes up one argreg */
     {
       write_register (--argreg, struct_addr);
     }
@@ -1128,11 +1127,11 @@ avr_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
       /* 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);
-        }
+	{			/* there's room in registers */
+	  len -= wordsize;
+	  regval = extract_address (val + len, wordsize);
+	  write_register (argreg--, regval);
+	}
     }
   return sp;
 }
@@ -1140,15 +1139,16 @@ avr_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 /* Initialize the gdbarch structure for the AVR's. */
 
 static struct gdbarch *
-avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches){
+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};
+  static LONGEST avr_call_dummy_words[] = { 0 };
 
-  struct gdbarch                   *gdbarch;
-  struct gdbarch_tdep              *tdep;
+  struct gdbarch *gdbarch;
+  struct gdbarch_tdep *tdep;
 
   /* Find a candidate among the list of pre-declared architectures. */
   arches = gdbarch_list_lookup_by_info (arches, &info);
@@ -1176,7 +1176,7 @@ 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_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);
@@ -1240,7 +1240,8 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches){
 
   set_gdbarch_use_struct_convention (gdbarch, generic_use_struct_convention);
   set_gdbarch_store_struct_return (gdbarch, avr_store_struct_return);
-  set_gdbarch_extract_struct_value_address (gdbarch, avr_extract_struct_value_address);
+  set_gdbarch_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);
@@ -1251,9 +1252,10 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches){
   set_gdbarch_decr_pc_after_break (gdbarch, 0);
 
   set_gdbarch_function_start_offset (gdbarch, 0);
-  set_gdbarch_remote_translate_xfer_address (gdbarch, avr_remote_translate_xfer_address);
+  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_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);
@@ -1262,7 +1264,8 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches){
   set_gdbarch_saved_pc_after_call (gdbarch, avr_saved_pc_after_call);
   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
 
-  set_gdbarch_convert_from_func_ptr_addr (gdbarch, avr_convert_from_func_ptr_addr);
+  set_gdbarch_convert_from_func_ptr_addr (gdbarch,
+					  avr_convert_from_func_ptr_addr);
 
   return gdbarch;
 }
@@ -1283,71 +1286,74 @@ 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];
-  char          query[400];
-  char         *p;
-  unsigned int  nreg = 0;
-  unsigned int  val;
-  int           i, j, k, step;
+  int bufsiz = 0;
+  char buf[400];
+  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)
+  if (!current_target.to_query)
     {
-      fprintf_unfiltered (gdb_stderr, "ERR: info io_registers NOT supported by current target\n");
+      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);
+  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_query ((int) 'R', query, buf, &bufsiz);
 
   if (strncmp (buf, "", bufsiz) == 0)
     {
-      fprintf_unfiltered (gdb_stderr, "info io_registers NOT supported by target\n");
+      fprintf_unfiltered (gdb_stderr,
+			  "info io_registers NOT supported by target\n");
       return;
     }
 
-  if ( sscanf (buf, "%x", &nreg) != 1 )
+  if (sscanf (buf, "%x", &nreg) != 1)
     {
-      fprintf_unfiltered (gdb_stderr, "Error fetching number of io registers\n");
+      fprintf_unfiltered (gdb_stderr,
+			  "Error fetching number of io registers\n");
       return;
     }
 
-  reinitialize_more_filter();
+  reinitialize_more_filter ();
 
   printf_unfiltered ("Target has %u io registers:\n\n", nreg);
 
   /* only fetch up to 8 registers at a time to keep the buffer small */
   step = 8;
 
-  for (i=0; i<nreg; i+=step)
+  for (i = 0; i < nreg; i += step)
     {
-      j = step - (nreg % step);     /* how many registers this round? */
+      j = step - (nreg % step);	/* how many registers this round? */
 
-      snprintf (query, sizeof(query)-1, "avr.io_reg:%x,%x", i, j);
+      snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j);
       target_query ((int) 'R', query, buf, &bufsiz);
 
       p = buf;
-      for (k=i; k<(i+j); k++)
-        {
-          if (sscanf (p, "%[^,],%x;", query, &val) == 2)
-            {
-              printf_filtered ("[%02x] %-15s : %02x\n", k, query, val);
-              while ((*p != ';') && (*p != '\0'))
-                p++;
-              p++; /* skip over ';' */
-              if (*p == '\0')
-                break;
-            }
-        }
+      for (k = i; k < (i + j); k++)
+	{
+	  if (sscanf (p, "%[^,],%x;", query, &val) == 2)
+	    {
+	      printf_filtered ("[%02x] %-15s : %02x\n", k, query, val);
+	      while ((*p != ';') && (*p != '\0'))
+		p++;
+	      p++;		/* skip over ';' */
+	      if (*p == '\0')
+		break;
+	    }
+	}
     }
 }
 
@@ -1364,6 +1370,5 @@ _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);
 }