import gdb-1999-07-07 post reformat

1 files changed, 200 insertions, 191 deletions

diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c
index b0195e8cdbc..476dcf3785d 100644
--- a/gdb/m32r-tdep.c
+++ b/gdb/m32r-tdep.c
@@ -1,21 +1,22 @@
 /* Target-dependent code for the Mitsubishi m32r for GDB, the GNU debugger.
    Copyright 1996, Free Software Foundation, Inc.
 
-This file is part of GDB.
+   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
-(at your option) any later version.
+   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
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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.  */
+   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.  */
 
 #include "defs.h"
 #include "frame.h"
@@ -44,24 +45,25 @@ m32r_use_struct_convention (gcc_p, type)
    Doesn't really work for dummy frames, but it does pass back
    an empty frame_saved_regs, so I guess that's better than total failure */
 
-void 
+void
 m32r_frame_find_saved_regs (fi, regaddr)
      struct frame_info *fi;
      struct frame_saved_regs *regaddr;
 {
-  memcpy(regaddr, &fi->fsr, sizeof(struct frame_saved_regs));
+  memcpy (regaddr, &fi->fsr, sizeof (struct frame_saved_regs));
 }
 
 /* Turn this on if you want to see just how much instruction decoding
    if being done, its quite a lot
-   */
+ */
 #if 0
-static void dump_insn(char * commnt,CORE_ADDR pc, int insn)
+static void
+dump_insn (char *commnt, CORE_ADDR pc, int insn)
 {
-  printf_filtered("  %s %08x %08x ",
-		  commnt,(unsigned int)pc,(unsigned int) insn);
-  (*tm_print_insn)(pc,&tm_print_insn_info);
-  printf_filtered("\n");
+  printf_filtered ("  %s %08x %08x ",
+		   commnt, (unsigned int) pc, (unsigned int) insn);
+  (*tm_print_insn) (pc, &tm_print_insn_info);
+  printf_filtered ("\n");
 }
 #define insn_debug(args) { printf_filtered args; }
 #else
@@ -69,7 +71,7 @@ static void dump_insn(char * commnt,CORE_ADDR pc, int insn)
 #define insn_debug(args) {}
 #endif
 
-#define DEFAULT_SEARCH_LIMIT 44 
+#define DEFAULT_SEARCH_LIMIT 44
 
 /* Function: scan_prologue
    This function decodes the target function prologue to determine
@@ -78,43 +80,44 @@ static void dump_insn(char * commnt,CORE_ADDR pc, int insn)
    and returns the frame size.  */
 
 /*
-  The sequence it currently generates is:
-  
-	if (varargs function) { ddi sp,#n }
-	push registers
-	if (additional stack <= 256) {	addi sp,#-stack	}
-	else if (additional stack < 65k) { add3 sp,sp,#-stack
-
-	} else if (additional stack) {
-	seth sp,#(stack & 0xffff0000)
-	or3 sp,sp,#(stack & 0x0000ffff)
-	sub sp,r4
-	}
-	if (frame pointer) {
-		mv sp,fp
-	}
+   The sequence it currently generates is:
+
+   if (varargs function) { ddi sp,#n }
+   push registers
+   if (additional stack <= 256) {       addi sp,#-stack }
+   else if (additional stack < 65k) { add3 sp,sp,#-stack
+
+   } else if (additional stack) {
+   seth sp,#(stack & 0xffff0000)
+   or3 sp,sp,#(stack & 0x0000ffff)
+   sub sp,r4
+   }
+   if (frame pointer) {
+   mv sp,fp
+   }
 
-These instructions are scheduled like everything else, so you should stop at
-the first branch instruction.
- 
-*/
+   These instructions are scheduled like everything else, so you should stop at
+   the first branch instruction.
+
+ */
 
 /* This is required by skip prologue and by m32r_init_extra_frame_info. 
    The results of decoding a prologue should be cached because this
    thrashing is getting nuts.
    I am thinking of making a container class with two indexes, name and
    address. It may be better to extend the symbol table.
-   */
+ */
 
-static void decode_prologue (start_pc, scan_limit, 
-			     pl_endptr, framelength, 
-			     fi, fsr)
+static void
+decode_prologue (start_pc, scan_limit,
+		 pl_endptr, framelength,
+		 fi, fsr)
      CORE_ADDR start_pc;
      CORE_ADDR scan_limit;
-     CORE_ADDR * pl_endptr;  /* var parameter */
-     unsigned long * framelength;
-     struct frame_info * fi;
-     struct frame_saved_regs * fsr;
+     CORE_ADDR *pl_endptr;	/* var parameter */
+     unsigned long *framelength;
+     struct frame_info *fi;
+     struct frame_saved_regs *fsr;
 {
   unsigned long framesize;
   int insn;
@@ -127,56 +130,58 @@ static void decode_prologue (start_pc, scan_limit,
 
   framesize = 0;
   after_prologue = 0;
-  insn_debug(("rd prolog l(%d)\n",scan_limit - current_pc));
+  insn_debug (("rd prolog l(%d)\n", scan_limit - current_pc));
 
   for (current_pc = start_pc; current_pc < scan_limit; current_pc += 2)
     {
 
       insn = read_memory_unsigned_integer (current_pc, 2);
-      dump_insn("insn-1",current_pc,insn);    /* MTZ */
-      
-       /* If this is a 32 bit instruction, we dont want to examine its
-	 immediate data as though it were an instruction */
+      dump_insn ("insn-1", current_pc, insn);	/* MTZ */
+
+      /* If this is a 32 bit instruction, we dont want to examine its
+         immediate data as though it were an instruction */
       if (current_pc & 0x02)
-	{ /* Clear the parallel execution bit from 16 bit instruction */
+	{			/* Clear the parallel execution bit from 16 bit instruction */
 	  if (maybe_one_more)
-	    { /* The last instruction was a branch, usually terminates
-		 the series, but if this is a parallel instruction,
-		 it may be a stack framing instruction */
-	      if (! (insn & 0x8000))
-		{ insn_debug(("Really done"));
-		  break; /* nope, we are really done */
+	    {			/* The last instruction was a branch, usually terminates
+				   the series, but if this is a parallel instruction,
+				   it may be a stack framing instruction */
+	      if (!(insn & 0x8000))
+		{
+		  insn_debug (("Really done"));
+		  break;	/* nope, we are really done */
 		}
 	    }
-	  insn &= 0x7fff;        /* decode this instruction further */
+	  insn &= 0x7fff;	/* decode this instruction further */
 	}
       else
 	{
-	  if (maybe_one_more) 
-	    break; /* This isnt the one more */
+	  if (maybe_one_more)
+	    break;		/* This isnt the one more */
 	  if (insn & 0x8000)
 	    {
-	      insn_debug(("32 bit insn\n"));
+	      insn_debug (("32 bit insn\n"));
 	      if (current_pc == scan_limit)
-		scan_limit += 2; /* extend the search */
-	      current_pc += 2;   /* skip the immediate data */
-	      if (insn == 0x8faf)			/* add3 sp, sp, xxxx */
+		scan_limit += 2;	/* extend the search */
+	      current_pc += 2;	/* skip the immediate data */
+	      if (insn == 0x8faf)	/* add3 sp, sp, xxxx */
 		/* add 16 bit sign-extended offset */
-		{ insn_debug(("stack increment\n"));
-		framesize += -((short) read_memory_unsigned_integer (current_pc, 2));
+		{
+		  insn_debug (("stack increment\n"));
+		  framesize += -((short) read_memory_unsigned_integer (current_pc, 2));
 		}
 	      else
 		{
-		  if (((insn >> 8) == 0xe4) && /* ld24 r4, xxxxxx; sub sp, r4 */
-		      read_memory_unsigned_integer (current_pc + 2, 2) == 0x0f24)
-		    { /* subtract 24 bit sign-extended negative-offset */
-		      dump_insn("insn-2",current_pc+2,insn);
+		  if (((insn >> 8) == 0xe4) &&	/* ld24 r4, xxxxxx; sub sp, r4 */
+		  read_memory_unsigned_integer (current_pc + 2, 2) == 0x0f24)
+		    {		/* subtract 24 bit sign-extended negative-offset */
+		      dump_insn ("insn-2", current_pc + 2, insn);
 		      insn = read_memory_unsigned_integer (current_pc - 2, 4);
-		      dump_insn("insn-3(l4)",current_pc -2,insn);
+		      dump_insn ("insn-3(l4)", current_pc - 2, insn);
 		      if (insn & 0x00800000)	/* sign extend */
-			insn  |= 0xff000000;	/* negative */
+			insn |= 0xff000000;	/* negative */
 		      else
-			insn  &= 0x00ffffff;	/* positive */
+			insn &= 0x00ffffff;	/* positive */
 		      framesize += insn;
 		    }
 		}
@@ -184,18 +189,18 @@ static void decode_prologue (start_pc, scan_limit,
 	      continue;
 	    }
 	}
-      op1 = insn & 0xf000; /* isolate just the first nibble */
-      
+      op1 = insn & 0xf000;	/* isolate just the first nibble */
+
       if ((insn & 0xf0ff) == 0x207f)
-	{		/* st reg, @-sp */
+	{			/* st reg, @-sp */
 	  int regno;
-	  insn_debug(("push\n"));
-#if 0	/* No, PUSH FP is not an indication that we will use a frame pointer. */
-	  if (((insn & 0xffff) == 0x2d7f) && fi) 
+	  insn_debug (("push\n"));
+#if 0				/* No, PUSH FP is not an indication that we will use a frame pointer. */
+	  if (((insn & 0xffff) == 0x2d7f) && fi)
 	    fi->using_frame_pointer = 1;
 #endif
-	  framesize  += 4;
-#if 0 
+	  framesize += 4;
+#if 0
 /* Why should we increase the scan limit, just because we did a push? 
    And if there is a reason, surely we would only want to do it if we
    had already reached the scan limit... */
@@ -203,12 +208,12 @@ static void decode_prologue (start_pc, scan_limit,
 	    scan_limit += 2;
 #endif
 	  regno = ((insn >> 8) & 0xf);
-	  if (fsr)				/* save_regs offset */
+	  if (fsr)		/* save_regs offset */
 	    fsr->regs[regno] = framesize;
 	  after_prologue = 0;
-	    continue;
+	  continue;
 	}
-      if ((insn >> 8) == 0x4f)  		/* addi sp, xx */
+      if ((insn >> 8) == 0x4f)	/* addi sp, xx */
 	/* add 8 bit sign-extended offset */
 	{
 	  int stack_adjust = (char) (insn & 0xff);
@@ -223,48 +228,52 @@ static void decode_prologue (start_pc, scan_limit,
 	      framesize -= stack_adjust;
 	      after_prologue = 0;
 	      /* A frameless function may have no "mv fp, sp".
-		 In that case, this is the end of the prologue.  */
+	         In that case, this is the end of the prologue.  */
 	      after_stack_adjust = current_pc + 2;
 	    }
 	  continue;
 	}
-      if (insn == 0x1d8f) {	/* mv fp, sp */
-	if (fi) 
-	  fi->using_frame_pointer = 1;	/* fp is now valid */
-	insn_debug(("done fp found\n"));
-	after_prologue = current_pc + 2;
-	break;				/* end of stack adjustments */
-      }
-      if (insn ==  0x7000)  /* Nop looks like a branch, continue explicitly */
-	{ insn_debug(("nop\n"));
-	after_prologue = current_pc + 2;
-	continue; /* nop occurs between pushes */
+      if (insn == 0x1d8f)
+	{			/* mv fp, sp */
+	  if (fi)
+	    fi->using_frame_pointer = 1;	/* fp is now valid */
+	  insn_debug (("done fp found\n"));
+	  after_prologue = current_pc + 2;
+	  break;		/* end of stack adjustments */
+	}
+      if (insn == 0x7000)	/* Nop looks like a branch, continue explicitly */
+	{
+	  insn_debug (("nop\n"));
+	  after_prologue = current_pc + 2;
+	  continue;		/* nop occurs between pushes */
 	}
       /* End of prolog if any of these are branch instructions */
       if ((op1 == 0x7000)
-	  || ( op1 == 0xb000)
+	  || (op1 == 0xb000)
 	  || (op1 == 0x7000))
 	{
 	  after_prologue = current_pc;
-	  insn_debug(("Done: branch\n"));
+	  insn_debug (("Done: branch\n"));
 	  maybe_one_more = 1;
 	  continue;
 	}
       /* Some of the branch instructions are mixed with other types */
       if (op1 == 0x1000)
-	{int subop = insn & 0x0ff0;
+	{
+	  int subop = insn & 0x0ff0;
 	  if ((subop == 0x0ec0) || (subop == 0x0fc0))
-	    { insn_debug(("done: jmp\n"));
+	    {
+	      insn_debug (("done: jmp\n"));
 	      after_prologue = current_pc;
 	      maybe_one_more = 1;
-	      continue; /* jmp , jl */
+	      continue;		/* jmp , jl */
 	    }
 	}
     }
 
   if (current_pc >= scan_limit)
     {
-      if (pl_endptr) 
+      if (pl_endptr)
 	{
 #if 1
 	  if (after_stack_adjust != 0)
@@ -283,18 +292,18 @@ static void decode_prologue (start_pc, scan_limit,
 	       The way we do that is to return the original start_pc.
 	       GDB will set a breakpoint at the start of the function (etc.) */
 	    *pl_endptr = start_pc;
-	}	
+	}
       return;
     }
-  if (after_prologue == 0) 
+  if (after_prologue == 0)
     after_prologue = current_pc;
 
-  insn_debug((" framesize %d, firstline %08x\n",framesize,after_prologue));
-  if (framelength) 
+  insn_debug ((" framesize %d, firstline %08x\n", framesize, after_prologue));
+  if (framelength)
     *framelength = framesize;
-  if (pl_endptr) 
+  if (pl_endptr)
     *pl_endptr = after_prologue;
-} /*  decode_prologue */
+}				/*  decode_prologue */
 
 /* Function: skip_prologue
    Find end of function prologue */
@@ -314,8 +323,8 @@ m32r_skip_prologue (pc)
 
       if (sal.line != 0 && sal.end <= func_end)
 	{
-	  
-	  insn_debug(("BP after prologue %08x\n",sal.end));
+
+	  insn_debug (("BP after prologue %08x\n", sal.end));
 	  func_end = sal.end;
 	}
       else
@@ -323,12 +332,12 @@ m32r_skip_prologue (pc)
 	   the end of the function.  In this case, there probably isn't a
 	   prologue.  */
 	{
-	  insn_debug(("No line info, line(%x) sal_end(%x) funcend(%x)\n",
-		      sal.line,sal.end,func_end));
-	  func_end = min(func_end,func_addr + DEFAULT_SEARCH_LIMIT);
+	  insn_debug (("No line info, line(%x) sal_end(%x) funcend(%x)\n",
+		       sal.line, sal.end, func_end));
+	  func_end = min (func_end, func_addr + DEFAULT_SEARCH_LIMIT);
 	}
     }
-  else 
+  else
     func_end = pc + DEFAULT_SEARCH_LIMIT;
   decode_prologue (pc, func_end, &sal.end, 0, 0, 0);
   return sal.end;
@@ -350,25 +359,25 @@ m32r_scan_prologue (fi, fsr)
     {
       sal = find_pc_line (prologue_start, 0);
 
-      if (sal.line == 0)		/* no line info, use current PC */
+      if (sal.line == 0)	/* no line info, use current PC */
 	if (prologue_start == entry_point_address ())
 	  return 0;
     }
   else
     {
       prologue_start = fi->pc;
-      prologue_end = prologue_start + 48; /* We're in the boondocks: 
-					      allow for 16 pushes, an add, 
-					      and "mv fp,sp" */
+      prologue_end = prologue_start + 48;	/* We're in the boondocks: 
+						   allow for 16 pushes, an add, 
+						   and "mv fp,sp" */
     }
 #if 0
   prologue_end = min (prologue_end, fi->pc);
 #endif
-  insn_debug(("fipc(%08x) start(%08x) end(%08x)\n",
-	      fi->pc,prologue_start,prologue_end));
-  prologue_end = min(prologue_end, prologue_start + DEFAULT_SEARCH_LIMIT);
-  decode_prologue (prologue_start,prologue_end,&prologue_end,&framesize,
-		   fi,fsr);
+  insn_debug (("fipc(%08x) start(%08x) end(%08x)\n",
+	       fi->pc, prologue_start, prologue_end));
+  prologue_end = min (prologue_end, prologue_start + DEFAULT_SEARCH_LIMIT);
+  decode_prologue (prologue_start, prologue_end, &prologue_end, &framesize,
+		   fi, fsr);
   return framesize;
 }
 
@@ -393,12 +402,12 @@ m32r_init_extra_frame_info (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.  */
+         by assuming it's always FP.  */
       fi->frame = generic_read_register_dummy (fi->pc, fi->frame, SP_REGNUM);
       fi->framesize = 0;
       return;
     }
-  else 
+  else
     {
       fi->using_frame_pointer = 0;
       fi->framesize = m32r_scan_prologue (fi, &fi->fsr);
@@ -410,10 +419,11 @@ m32r_init_extra_frame_info (fi)
 	  }
 	else
 	  fi->frame = read_register (SP_REGNUM);
-      else 	/* fi->next means this is not the innermost frame */
-	if (fi->using_frame_pointer)		    /* we have an FP */
-	  if (fi->next->fsr.regs[FP_REGNUM] != 0)   /* caller saved our FP */
-	    fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
+      else
+	/* fi->next means this is not the innermost frame */ if (fi->using_frame_pointer)
+	/* we have an FP */
+	if (fi->next->fsr.regs[FP_REGNUM] != 0)		/* caller saved our FP */
+	  fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
       for (reg = 0; reg < NUM_REGS; reg++)
 	if (fi->fsr.regs[reg] != 0)
 	  fi->fsr.regs[reg] = fi->frame + fi->framesize - fi->fsr.regs[reg];
@@ -446,12 +456,12 @@ m32r_virtual_frame_pointer (pc, reg, offset)
   /* Results will tell us which type of frame it uses.  */
   if (fi.using_frame_pointer)
     {
-      *reg    = FP_REGNUM;
+      *reg = FP_REGNUM;
       *offset = 0;
     }
   else
     {
-      *reg    = SP_REGNUM;
+      *reg = SP_REGNUM;
       *offset = 0;
     }
 }
@@ -472,8 +482,8 @@ m32r_find_callers_reg (fi, regnum)
     if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
       return generic_read_register_dummy (fi->pc, fi->frame, regnum);
     else if (fi->fsr.regs[regnum] != 0)
-      return read_memory_integer (fi->fsr.regs[regnum], 
-				  REGISTER_RAW_SIZE(regnum));
+      return read_memory_integer (fi->fsr.regs[regnum],
+				  REGISTER_RAW_SIZE (regnum));
   return read_register (regnum);
 }
 
@@ -490,26 +500,26 @@ m32r_frame_chain (fi)
   CORE_ADDR fn_start, callers_pc, fp;
 
   /* is this a dummy frame? */
-  if (PC_IN_CALL_DUMMY(fi->pc, fi->frame, fi->frame))
-    return fi->frame;	/* dummy frame same as caller's frame */
+  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+    return fi->frame;		/* dummy frame same as caller's frame */
 
   /* is caller-of-this a dummy frame? */
-  callers_pc = FRAME_SAVED_PC(fi);  /* find out who called us: */
+  callers_pc = FRAME_SAVED_PC (fi);	/* find out who called us: */
   fp = m32r_find_callers_reg (fi, FP_REGNUM);
-  if (PC_IN_CALL_DUMMY(callers_pc, fp, fp))	
-    return fp;		/* dummy frame's frame may bear no relation to ours */
+  if (PC_IN_CALL_DUMMY (callers_pc, fp, fp))
+    return fp;			/* dummy frame's frame may bear no relation to ours */
 
   if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
     if (fn_start == entry_point_address ())
-      return 0;		/* in _start fn, don't chain further */
+      return 0;			/* in _start fn, don't chain further */
   if (fi->framesize == 0)
     {
-      printf_filtered("cannot determine frame size @ %08x , pc(%08x)\n",
-		      (unsigned long) fi->frame,
-		      (unsigned long) fi->pc );
+      printf_filtered ("cannot determine frame size @ %08x , pc(%08x)\n",
+		       (unsigned long) fi->frame,
+		       (unsigned long) fi->pc);
       return 0;
     }
-  insn_debug(("m32rx frame %08x\n",fi->frame+fi->framesize));
+  insn_debug (("m32rx frame %08x\n", fi->frame + fi->framesize));
   return fi->frame + fi->framesize;
 }
 
@@ -544,7 +554,7 @@ m32r_pop_frame (frame)
     {
       for (regnum = 0; regnum < NUM_REGS; regnum++)
 	if (frame->fsr.regs[regnum] != 0)
-	  write_register (regnum, 
+	  write_register (regnum,
 			  read_memory_integer (frame->fsr.regs[regnum], 4));
 
       write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
@@ -566,8 +576,8 @@ CORE_ADDR
 m32r_frame_saved_pc (fi)
      struct frame_info *fi;
 {
-  if (PC_IN_CALL_DUMMY(fi->pc, fi->frame, fi->frame))
-    return generic_read_register_dummy(fi->pc, fi->frame, PC_REGNUM);
+  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+    return generic_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
   else
     return m32r_find_callers_reg (fi, RP_REGNUM);
 }
@@ -584,7 +594,7 @@ m32r_frame_saved_pc (fi)
    register or a whole 32-bit word on the stack, and will be
    right-justified in the register or the stack word.  This includes
    chars, shorts, and small aggregate types.
- 
+
    Arguments of 8 bytes size are split between two registers, if 
    available.  If only one register is available, the argument will 
    be split between the register and the stack.  Otherwise it is
@@ -624,62 +634,62 @@ m32r_push_arguments (nargs, args, sp, struct_return, struct_addr)
   /* first force sp to a 4-byte alignment */
   sp = sp & ~3;
 
-  argreg = ARG0_REGNUM;  
+  argreg = ARG0_REGNUM;
   /* The "struct return pointer" pseudo-argument goes in R0 */
   if (struct_return)
-      write_register (argreg++, struct_addr);
- 
+    write_register (argreg++, struct_addr);
+
   /* 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])) + 3) & ~3);
-  sp -= stack_alloc;    /* make room on stack for args */
- 
- 
+    stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
+  sp -= stack_alloc;		/* make room on stack for args */
+
+
   /* Now load as many as possible of the first arguments into
      registers, and push the rest onto the stack.  There are 16 bytes
      in four registers available.  Loop thru args from first to last.  */
- 
+
   argreg = ARG0_REGNUM;
   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
     {
       type = VALUE_TYPE (args[argnum]);
-      len  = TYPE_LENGTH (type);
-      memset(valbuf, 0, sizeof(valbuf));
+      len = TYPE_LENGTH (type);
+      memset (valbuf, 0, sizeof (valbuf));
       if (len < 4)
-        { /* value gets right-justified in the register or stack word */
-          memcpy(valbuf + (4 - len),
-                 (char *) VALUE_CONTENTS (args[argnum]), len);
-          val = valbuf;
-        }
+	{			/* value gets right-justified in the register or stack word */
+	  memcpy (valbuf + (4 - len),
+		  (char *) VALUE_CONTENTS (args[argnum]), len);
+	  val = valbuf;
+	}
       else
-        val = (char *) VALUE_CONTENTS (args[argnum]);
- 
+	val = (char *) VALUE_CONTENTS (args[argnum]);
+
       if (len > 4 && (len & 3) != 0)
-        odd_sized_struct = 1;           /* such structs go entirely on stack */
+	odd_sized_struct = 1;	/* such structs go entirely on stack */
       else
-        odd_sized_struct = 0;
+	odd_sized_struct = 0;
       while (len > 0)
-        {
-          if (argreg > ARGLAST_REGNUM || odd_sized_struct)
-            {				/* must go on the stack */
-              write_memory (sp + stack_offset, val, 4);
-              stack_offset += 4;
-            }
-          /* NOTE WELL!!!!!  This is not an "else if" clause!!!
-             That's because some *&^%$ things get passed on the stack
-             AND in the registers!   */
-          if (argreg <= ARGLAST_REGNUM)
-            {				/* there's room in a register */
-              regval = extract_address (val, REGISTER_RAW_SIZE(argreg));
-              write_register (argreg++, regval);
-            }
-          /* Store the value 4 bytes at a time.  This means that things
-             larger than 4 bytes may go partly in registers and partly
-             on the stack.  */
-          len -= REGISTER_RAW_SIZE(argreg);
-          val += REGISTER_RAW_SIZE(argreg);
-        }
+	{
+	  if (argreg > ARGLAST_REGNUM || odd_sized_struct)
+	    {			/* must go on the stack */
+	      write_memory (sp + stack_offset, val, 4);
+	      stack_offset += 4;
+	    }
+	  /* NOTE WELL!!!!!  This is not an "else if" clause!!!
+	     That's because some *&^%$ things get passed on the stack
+	     AND in the registers!   */
+	  if (argreg <= ARGLAST_REGNUM)
+	    {			/* there's room in a register */
+	      regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
+	      write_register (argreg++, regval);
+	    }
+	  /* Store the value 4 bytes at a time.  This means that things
+	     larger than 4 bytes may go partly in registers and partly
+	     on the stack.  */
+	  len -= REGISTER_RAW_SIZE (argreg);
+	  val += REGISTER_RAW_SIZE (argreg);
+	}
     }
   return sp;
 }
@@ -714,7 +724,7 @@ m32r_write_sp (val)
 {
   unsigned long psw = read_register (PSW_REGNUM);
 
-  if (psw & 0x80)	/* stack mode: user or interrupt */
+  if (psw & 0x80)		/* stack mode: user or interrupt */
     write_register (SPU_REGNUM, val);
   else
     write_register (SPI_REGNUM, val);
@@ -726,4 +736,3 @@ _initialize_m32r_tdep ()
 {
   tm_print_insn = print_insn_m32r;
 }
-