import gdb-1999-07-07 post reformat

1 files changed, 324 insertions, 186 deletions

diff --git a/gdb/dve3900-rom.c b/gdb/dve3900-rom.c
index c76da77..8565040 100644
--- a/gdb/dve3900-rom.c
+++ b/gdb/dve3900-rom.c
@@ -2,21 +2,22 @@
    GDB, the GNU debugger.
    Copyright 1997 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 "gdbcore.h"
@@ -30,7 +31,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Type of function passed to bfd_map_over_sections.  */
 
-typedef void (*section_map_func) PARAMS ((bfd *abfd, asection *sect, PTR obj));
+typedef void (*section_map_func) PARAMS ((bfd * abfd, asection * sect, PTR obj));
 
 /* Packet escape character used by Densan monitor.  */
 
@@ -51,40 +52,40 @@ extern void report_transfer_performance PARAMS ((unsigned long,
    This structure describes a field in a bitmapped register.  */
 
 struct bit_field
-{
-  char *prefix;		/* string appearing before the value */
-  char *suffix;		/* string appearing after the value */
-  char *user_name;	/* name used by human when entering field value */
-  int  length;		/* number of bits in the field */
-  int  start;		/* starting (least significant) bit number of field */
-};
-        
+  {
+    char *prefix;		/* string appearing before the value */
+    char *suffix;		/* string appearing after the value */
+    char *user_name;		/* name used by human when entering field value */
+    int length;			/* number of bits in the field */
+    int start;			/* starting (least significant) bit number of field */
+  };
+
 /* Local functions for register manipulation.  */
 
 static void r3900_supply_register PARAMS ((char *regname, int regnamelen,
 					   char *val, int vallen));
 static void fetch_bad_vaddr PARAMS ((void));
-static unsigned long fetch_fields PARAMS ((struct bit_field *bf));
+static unsigned long fetch_fields PARAMS ((struct bit_field * bf));
 static void fetch_bitmapped_register PARAMS ((int regno,
-						   struct bit_field *bf));
+					      struct bit_field * bf));
 static void r3900_fetch_registers PARAMS ((int regno));
 static void store_bitmapped_register PARAMS ((int regno,
-						    struct bit_field *bf));
+					      struct bit_field * bf));
 static void r3900_store_registers PARAMS ((int regno));
 
 /* Local functions for fast binary loading.  */
 
 static void write_long PARAMS ((char *buf, long n));
 static void write_long_le PARAMS ((char *buf, long n));
-static int  debug_readchar PARAMS ((int hex));
+static int debug_readchar PARAMS ((int hex));
 static void debug_write PARAMS ((unsigned char *buf, int buflen));
 static void ignore_packet PARAMS ((void));
 static void send_packet PARAMS ((char type, unsigned char *buf, int buflen,
 				 int seq));
 static void process_read_request PARAMS ((unsigned char *buf, int buflen));
-static void count_section PARAMS ((bfd *abfd, asection *s,
+static void count_section PARAMS ((bfd * abfd, asection * s,
 				   unsigned int *section_count));
-static void load_section PARAMS ((bfd *abfd, asection *s,
+static void load_section PARAMS ((bfd * abfd, asection * s,
 				  unsigned int *data_count));
 static void r3900_load PARAMS ((char *filename, int from_tty));
 
@@ -118,41 +119,176 @@ static int ethernet = 0;
 
 static char *r3900_regnames[NUM_REGS] =
 {
-  "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",
-
-  "S", 		/* PS_REGNUM */
-  "l",		/* LO_REGNUM */
-  "h",		/* HI_REGNUM */
-  "B",		/* BADVADDR_REGNUM */
-  "Pcause",	/* CAUSE_REGNUM */
-  "p"		/* PC_REGNUM */
+  "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",
+
+  "S",				/* PS_REGNUM */
+  "l",				/* LO_REGNUM */
+  "h",				/* HI_REGNUM */
+  "B",				/* BADVADDR_REGNUM */
+  "Pcause",			/* CAUSE_REGNUM */
+  "p"				/* PC_REGNUM */
 };
 
 
 /* Table of register names produced by monitor's register dump command.  */
 
 static struct reg_entry
+  {
+    char *name;
+    int regno;
+  }
+reg_table[] =
 {
-  char *name;
-  int regno;
-} reg_table[] =
-{
-  { "r0_zero", 0 },  { "r1_at",   1 },  { "r2_v0",   2 },  { "r3_v1",   3 },
-  { "r4_a0",   4 },  { "r5_a1",   5 },  { "r6_a2",   6 },  { "r7_a3",   7 },
-  { "r8_t0",   8 },  { "r9_t1",   9 },  { "r10_t2", 10 },  { "r11_t3", 11 },
-  { "r12_t4", 12 },  { "r13_t5", 13 },  { "r14_t6", 14 },  { "r15_t7", 15 },
-  { "r16_s0", 16 },  { "r17_s1", 17 },  { "r18_s2", 18 },  { "r19_s3", 19 },
-  { "r20_s4", 20 },  { "r21_s5", 21 },  { "r22_s6", 22 },  { "r23_s7", 23 },
-  { "r24_t8", 24 },  { "r25_t9", 25 },  { "r26_k0", 26 },  { "r27_k1", 27 },
-  { "r28_gp", 28 },  { "r29_sp", 29 },  { "r30_fp", 30 },  { "r31_ra", 31 },
-  { "HI",     HI_REGNUM },
-  { "LO",     LO_REGNUM },
-  { "PC",     PC_REGNUM },
-  { "BadV",   BADVADDR_REGNUM },
-  { NULL,     0 }
+  {
+    "r0_zero", 0
+  }
+  ,
+  {
+    "r1_at", 1
+  }
+  ,
+  {
+    "r2_v0", 2
+  }
+  ,
+  {
+    "r3_v1", 3
+  }
+  ,
+  {
+    "r4_a0", 4
+  }
+  ,
+  {
+    "r5_a1", 5
+  }
+  ,
+  {
+    "r6_a2", 6
+  }
+  ,
+  {
+    "r7_a3", 7
+  }
+  ,
+  {
+    "r8_t0", 8
+  }
+  ,
+  {
+    "r9_t1", 9
+  }
+  ,
+  {
+    "r10_t2", 10
+  }
+  ,
+  {
+    "r11_t3", 11
+  }
+  ,
+  {
+    "r12_t4", 12
+  }
+  ,
+  {
+    "r13_t5", 13
+  }
+  ,
+  {
+    "r14_t6", 14
+  }
+  ,
+  {
+    "r15_t7", 15
+  }
+  ,
+  {
+    "r16_s0", 16
+  }
+  ,
+  {
+    "r17_s1", 17
+  }
+  ,
+  {
+    "r18_s2", 18
+  }
+  ,
+  {
+    "r19_s3", 19
+  }
+  ,
+  {
+    "r20_s4", 20
+  }
+  ,
+  {
+    "r21_s5", 21
+  }
+  ,
+  {
+    "r22_s6", 22
+  }
+  ,
+  {
+    "r23_s7", 23
+  }
+  ,
+  {
+    "r24_t8", 24
+  }
+  ,
+  {
+    "r25_t9", 25
+  }
+  ,
+  {
+    "r26_k0", 26
+  }
+  ,
+  {
+    "r27_k1", 27
+  }
+  ,
+  {
+    "r28_gp", 28
+  }
+  ,
+  {
+    "r29_sp", 29
+  }
+  ,
+  {
+    "r30_fp", 30
+  }
+  ,
+  {
+    "r31_ra", 31
+  }
+  ,
+  {
+    "HI", HI_REGNUM
+  }
+  ,
+  {
+    "LO", LO_REGNUM
+  }
+  ,
+  {
+    "PC", PC_REGNUM
+  }
+  ,
+  {
+    "BadV", BADVADDR_REGNUM
+  }
+  ,
+  {
+    NULL, 0
+  }
 };
 
 
@@ -162,81 +298,81 @@ static struct reg_entry
    cache register that the monitor displays.  Register fields that should
    be ignored have a length of zero in the tables below.  */
 
-static struct bit_field status_fields [] =
+static struct bit_field status_fields[] =
 {
   /* Status register portion */
-  { "SR[<CU=",	" ",	"cu",	4, 28 },
-  { "RE=",	" ",	"re",	1, 25 },
-  { "BEV=",	" ",	"bev",	1, 22 },
-  { "TS=",	" ",	"ts",	1, 21 },
-  { "Nmi=",	" ",	"nmi",	1, 20 },
-  { "INT=",	" ",	"int",  6, 10 },
-  { "SW=",	">]",	"sw",   2,  8 },
-  { "[<KUO=",	" ",	"kuo",  1,  5 },
-  { "IEO=",	" ",	"ieo",  1,  4 },
-  { "KUP=",	" ",	"kup",  1,  3 },
-  { "IEP=",	" ",	"iep",  1,  2 },
-  { "KUC=",	" ",	"kuc",  1,  1 },
-  { "IEC=",	">]",	"iec",  1,  0 },
+  {"SR[<CU=", " ", "cu", 4, 28},
+  {"RE=", " ", "re", 1, 25},
+  {"BEV=", " ", "bev", 1, 22},
+  {"TS=", " ", "ts", 1, 21},
+  {"Nmi=", " ", "nmi", 1, 20},
+  {"INT=", " ", "int", 6, 10},
+  {"SW=", ">]", "sw", 2, 8},
+  {"[<KUO=", " ", "kuo", 1, 5},
+  {"IEO=", " ", "ieo", 1, 4},
+  {"KUP=", " ", "kup", 1, 3},
+  {"IEP=", " ", "iep", 1, 2},
+  {"KUC=", " ", "kuc", 1, 1},
+  {"IEC=", ">]", "iec", 1, 0},
 
   /* Cache register portion (dummy for parsing only) */
-  { "CR[<IalO="," ",	"ialo",	0, 13 },
-  { "DalO=",	" ",	"dalo",	0, 12 },
-  { "IalP=",	" ",	"ialp",	0, 11 },
-  { "DalP=",	" ",	"dalp",	0, 10 },
-  { "IalC=",	" ",	"ialc",	0,  9 },
-  { "DalC=",	">] ",	"dalc",	0,  8 },
-
-  { NULL,	NULL,	0,  0 }		/* end of table marker */
+  {"CR[<IalO=", " ", "ialo", 0, 13},
+  {"DalO=", " ", "dalo", 0, 12},
+  {"IalP=", " ", "ialp", 0, 11},
+  {"DalP=", " ", "dalp", 0, 10},
+  {"IalC=", " ", "ialc", 0, 9},
+  {"DalC=", ">] ", "dalc", 0, 8},
+
+  {NULL, NULL, 0, 0}		/* end of table marker */
 };
 
 
-#if 0	/* FIXME: Enable when we add support for modifying cache register.  */
-static struct bit_field cache_fields [] =
+#if 0				/* FIXME: Enable when we add support for modifying cache register.  */
+static struct bit_field cache_fields[] =
 {
   /* Status register portion (dummy for parsing only) */
-  { "SR[<CU=",	" ",	"cu",	0, 28 },
-  { "RE=",	" ",	"re",	0, 25 },
-  { "BEV=",	" ",	"bev",	0, 22 },
-  { "TS=",	" ",	"ts",	0, 21 },
-  { "Nmi=",	" ",	"nmi",	0, 20 },
-  { "INT=",	" ",	"int",  0, 10 },
-  { "SW=",	">]",	"sw",   0,  8 },
-  { "[<KUO=",	" ",	"kuo",  0,  5 },
-  { "IEO=",	" ",	"ieo",  0,  4 },
-  { "KUP=",	" ",	"kup",  0,  3 },
-  { "IEP=",	" ",	"iep",  0,  2 },
-  { "KUC=",	" ",	"kuc",  0,  1 },
-  { "IEC=",	">]",	"iec",  0,  0 },
+  {"SR[<CU=", " ", "cu", 0, 28},
+  {"RE=", " ", "re", 0, 25},
+  {"BEV=", " ", "bev", 0, 22},
+  {"TS=", " ", "ts", 0, 21},
+  {"Nmi=", " ", "nmi", 0, 20},
+  {"INT=", " ", "int", 0, 10},
+  {"SW=", ">]", "sw", 0, 8},
+  {"[<KUO=", " ", "kuo", 0, 5},
+  {"IEO=", " ", "ieo", 0, 4},
+  {"KUP=", " ", "kup", 0, 3},
+  {"IEP=", " ", "iep", 0, 2},
+  {"KUC=", " ", "kuc", 0, 1},
+  {"IEC=", ">]", "iec", 0, 0},
 
   /* Cache register portion  */
-  { "CR[<IalO="," ",	"ialo",	1, 13 },
-  { "DalO=",	" ",	"dalo",	1, 12 },
-  { "IalP=",	" ",	"ialp",	1, 11 },
-  { "DalP=",	" ",	"dalp",	1, 10 },
-  { "IalC=",	" ",	"ialc",	1,  9 },
-  { "DalC=",	">] ",	"dalc",	1,  8 },
-
-  { NULL,	NULL,	NULL,	0,  0 }		/* end of table marker */
+  {"CR[<IalO=", " ", "ialo", 1, 13},
+  {"DalO=", " ", "dalo", 1, 12},
+  {"IalP=", " ", "ialp", 1, 11},
+  {"DalP=", " ", "dalp", 1, 10},
+  {"IalC=", " ", "ialc", 1, 9},
+  {"DalC=", ">] ", "dalc", 1, 8},
+
+  {NULL, NULL, NULL, 0, 0}	/* end of table marker */
 };
 #endif
 
 
-static struct bit_field cause_fields[] = 
+static struct bit_field cause_fields[] =
 {
-  { "<BD=",	" ",	"bd",   1, 31 },
-  { "CE=",	" ",	"ce",   2, 28 },
-  { "IP=",	" ",	"ip",   6, 10 },
-  { "SW=", 	" ",	"sw",   2,  8 },
-  { "EC=", 	">]" ,	"ec",   5,  2 },
+  {"<BD=", " ", "bd", 1, 31},
+  {"CE=", " ", "ce", 2, 28},
+  {"IP=", " ", "ip", 6, 10},
+  {"SW=", " ", "sw", 2, 8},
+  {"EC=", ">]", "ec", 5, 2},
 
-  { NULL,	NULL,	NULL,	0,  0 }		/* end of table marker */
+  {NULL, NULL, NULL, 0, 0}	/* end of table marker */
 };
 
 
 /* The monitor prints register values in the form
 
-	regname = xxxx xxxx
+   regname = xxxx xxxx
 
    We look up the register name in a table, and remove the embedded space in
    the hex value before passing it to monitor_supply_register.  */
@@ -285,17 +421,17 @@ r3900_supply_register (regname, regnamelen, val, vallen)
    you modify it.  */
 
 static void
-fetch_bad_vaddr()
+fetch_bad_vaddr ()
 {
   char buf[20];
 
   monitor_printf ("xB\r");
   monitor_expect ("BadV=", NULL, 0);
-  monitor_expect_prompt (buf, sizeof(buf));
+  monitor_expect_prompt (buf, sizeof (buf));
   monitor_supply_register (BADVADDR_REGNUM, buf);
 }
 
-    
+
 /* Read a series of bit fields from the monitor, and return their
    combined binary value.  */
 
@@ -307,17 +443,17 @@ fetch_fields (bf)
   unsigned long val = 0;
   unsigned long bits;
 
-  for ( ; bf->prefix != NULL; bf++)
+  for (; bf->prefix != NULL; bf++)
     {
-      monitor_expect (bf->prefix, NULL, 0);		/* get prefix */
+      monitor_expect (bf->prefix, NULL, 0);	/* get prefix */
       monitor_expect (bf->suffix, buf, sizeof (buf));	/* hex value, suffix */
       if (bf->length != 0)
-        {
+	{
 	  bits = strtoul (buf, NULL, 16);	/* get field value */
 	  bits &= ((1 << bf->length) - 1);	/* mask out useless bits */
-	  val |= bits << bf->start;		/* insert into register */
+	  val |= bits << bf->start;	/* insert into register */
 	}
-	  
+
     }
 
   return val;
@@ -386,10 +522,10 @@ store_bitmapped_register (regno, bf)
   newval = read_register (regno);
 
   /* To save time, write just the fields that have changed.  */
-  for ( ; bf->prefix != NULL; bf++)
+  for (; bf->prefix != NULL; bf++)
     {
       if (bf->length != 0)
-        {
+	{
 	  unsigned long oldbits, newbits, mask;
 
 	  mask = (1 << bf->length) - 1;
@@ -459,7 +595,7 @@ static int
 debug_readchar (hex)
      int hex;
 {
-  char buf [10];
+  char buf[10];
   int c = monitor_readchar ();
 
   if (remote_debug > 0)
@@ -468,7 +604,7 @@ debug_readchar (hex)
 	sprintf (buf, "[%02x]", c & 0xff);
       else if (c == '\0')
 	strcpy (buf, "\\0");
-      else 
+      else
 	{
 	  buf[0] = c;
 	  buf[1] = '\0';
@@ -507,21 +643,21 @@ debug_write (buf, buflen)
    when its console is in "communications interface" mode.   A packet
    is of this form:
 
-      start of packet flag (one byte: 0xdc)
-      packet type (one byte)
-      length (low byte)
-      length (high byte)
-      data (length bytes)
+   start of packet flag (one byte: 0xdc)
+   packet type (one byte)
+   length (low byte)
+   length (high byte)
+   data (length bytes)
 
    The last two bytes of the data field are a checksum, but we don't
    bother to verify it.
-*/
+ */
 
 static void
 ignore_packet ()
 {
   int c;
-  int len;  
+  int len;
 
   /* Ignore lots of trash (messages about section addresses, for example)
      until we see the start of a packet.  */
@@ -535,12 +671,12 @@ ignore_packet ()
     error ("Packet header byte not found; %02x seen instead.", c);
 
   /* Read the packet type and length.  */
-  c = debug_readchar (1);			/* type */
+  c = debug_readchar (1);	/* type */
 
-  c = debug_readchar (1);			/* low byte of length */
+  c = debug_readchar (1);	/* low byte of length */
   len = c & 0xff;
 
-  c = debug_readchar (1);			/* high byte of length */
+  c = debug_readchar (1);	/* high byte of length */
   len += (c & 0xff) << 8;
 
   /* Ignore the rest of the packet.  */
@@ -554,7 +690,7 @@ ignore_packet ()
    The 'p' packet is a special case.  This is a packet we send
    in response to a read ('r') packet from the monitor.  This function
    appends a one-byte sequence number to the data field of such a packet.
-*/
+ */
 
 static void
 send_packet (type, buf, buflen, seq)
@@ -604,7 +740,7 @@ send_packet (type, buf, buflen, seq)
 	    sum += tmp << 8;
 	}
       if (type == 'p')
-        {
+	{
 	  if (buflen & 1)
 	    sum += (seq & 0xff);
 	  else
@@ -612,7 +748,7 @@ send_packet (type, buf, buflen, seq)
 	}
       sum = (sum & 0xffff) + ((sum >> 16) & 0xffff);
       sum += (sum >> 16) & 1;
-      sum = ~sum;  
+      sum = ~sum;
 
       hdr[0] = (sum >> 8) & 0xff;
       hdr[1] = sum & 0xff;
@@ -672,7 +808,7 @@ process_read_request (buf, buflen)
 
 static void
 count_section (abfd, s, section_count)
-     bfd      *abfd;
+     bfd *abfd;
      asection *s;
      unsigned int *section_count;
 {
@@ -688,42 +824,42 @@ count_section (abfd, s, section_count)
    packets containing read requests, but rather than respond
    to them in an general way, we expect them to following
    a certain pattern.
-   
+
    For example, we know that the monitor will start loading by
    issuing an 8-byte read request for the binary file header.
    We know this is coming and ignore the actual contents
    of the read request packet.
-*/
+ */
 
 static void
 load_section (abfd, s, data_count)
-     bfd      *abfd;
+     bfd *abfd;
      asection *s;
      unsigned int *data_count;
 {
   if (s->flags & SEC_LOAD)
     {
       bfd_size_type section_size = bfd_section_size (abfd, s);
-      bfd_vma       section_base = bfd_section_lma  (abfd, s);
+      bfd_vma section_base = bfd_section_lma (abfd, s);
       unsigned char *buffer;
       unsigned char header[8];
 
       /* Don't output zero-length sections.  */
       if (section_size == 0)
-        return;
+	return;
       if (data_count)
 	*data_count += section_size;
 
       /* Print some fluff about the section being loaded.  */
       printf_filtered ("Loading section %s, size 0x%lx lma ",
-		       bfd_section_name (abfd, s), (long)section_size);
+		       bfd_section_name (abfd, s), (long) section_size);
       print_address_numeric (section_base, 1, gdb_stdout);
       printf_filtered ("\n");
       gdb_flush (gdb_stdout);
 
       /* Write the section header (location and size).  */
-      write_long (&header[0], (long)section_base);
-      write_long (&header[4], (long)section_size);
+      write_long (&header[0], (long) section_base);
+      write_long (&header[4], (long) section_size);
       process_read_request (header, sizeof (header));
 
       /* Read the section contents into a buffer, write it out,
@@ -732,7 +868,7 @@ load_section (abfd, s, data_count)
       bfd_get_section_contents (abfd, s, buffer, 0, section_size);
       process_read_request (buffer, section_size);
       free (buffer);
-  }
+    }
 }
 
 
@@ -740,12 +876,12 @@ load_section (abfd, s, data_count)
    we can use the "Rm" command to do a fast binary load.  The format
    of the download data is:
 
-	number of sections (4 bytes)
-	starting address (4 bytes)
-	repeat for each section:
-	    location address (4 bytes)
-	    section size (4 bytes)
-	    binary data
+   number of sections (4 bytes)
+   starting address (4 bytes)
+   repeat for each section:
+   location address (4 bytes)
+   section size (4 bytes)
+   binary data
 
    The 4-byte fields are all in big-endian order.
 
@@ -755,9 +891,9 @@ load_section (abfd, s, data_count)
  */
 
 static void
-r3900_load (filename, from_tty) 
-    char *filename;
-    int from_tty;
+r3900_load (filename, from_tty)
+     char *filename;
+     int from_tty;
 {
   bfd *abfd;
   unsigned int data_count = 0;
@@ -794,13 +930,13 @@ r3900_load (filename, from_tty)
   monitor_printf ("Rm\r");
   ignore_packet ();
   send_packet ('a', "", 0, 0);
-  
+
   /* Output the fast load header (number of sections and starting address).  */
   bfd_map_over_sections ((bfd *) abfd, (section_map_func) count_section,
 			 &section_count);
-  write_long (&buffer[0], (long)section_count);
+  write_long (&buffer[0], (long) section_count);
   if (exec_bfd)
-    write_long (&buffer[4], (long)bfd_get_start_address (exec_bfd));
+    write_long (&buffer[4], (long) bfd_get_start_address (exec_bfd));
   else
     write_long (&buffer[4], 0);
   process_read_request (buffer, sizeof (buffer));
@@ -819,14 +955,14 @@ r3900_load (filename, from_tty)
   monitor_expect_prompt (NULL, 0);
 
   /* Print start address and download performance information.  */
-  printf_filtered ("Start address 0x%lx\n", (long)bfd_get_start_address (abfd));
+  printf_filtered ("Start address 0x%lx\n", (long) bfd_get_start_address (abfd));
   report_transfer_performance (data_count, start_time, end_time);
 
   /* Finally, make the PC point at the start address */
   if (exec_bfd)
     write_pc (bfd_get_start_address (exec_bfd));
 
-  inferior_pid = 0;             /* No process now */
+  inferior_pid = 0;		/* No process now */
 
   /* This is necessary because many things were based on the PC at the
      time that we attached to the monitor, which is no longer valid
@@ -839,19 +975,21 @@ r3900_load (filename, from_tty)
 
 
 /* Commands to send to the monitor when first connecting:
-    * The bare carriage return forces a prompt from the monitor
-      (monitor doesn't prompt immediately after a reset).
-    * The "vconsx" switches the monitor back to interactive mode
-      in case an aborted download had left it in packet mode.
-    * The "Xtr" command causes subsequent "t" (trace) commands to display
-      the general registers only.
-    * The "Xxr" command does the same thing for the "x" (examine
-      registers) command.
-    * The "bx" command clears all breakpoints.
-*/
-
-static char *r3900_inits[] = {"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
-static char *dummy_inits[] = { NULL };
+   * The bare carriage return forces a prompt from the monitor
+   (monitor doesn't prompt immediately after a reset).
+   * The "vconsx" switches the monitor back to interactive mode
+   in case an aborted download had left it in packet mode.
+   * The "Xtr" command causes subsequent "t" (trace) commands to display
+   the general registers only.
+   * The "Xxr" command does the same thing for the "x" (examine
+   registers) command.
+   * The "bx" command clears all breakpoints.
+ */
+
+static char *r3900_inits[] =
+{"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
+static char *dummy_inits[] =
+{NULL};
 
 static struct target_ops r3900_ops;
 static struct monitor_ops r3900_cmds;
@@ -883,9 +1021,9 @@ r3900_open (args, from_tty)
   ethernet = 0;
   monitor_printf ("v\r");
   if (monitor_expect ("console device :", NULL, 0) != -1)
-      if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
-	if (strstr (buf, "ethernet") != NULL)
-	  ethernet = 1;
+    if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
+      if (strstr (buf, "ethernet") != NULL)
+	ethernet = 1;
   monitor_expect_prompt (NULL, 0);
 }
 
@@ -893,39 +1031,39 @@ void
 _initialize_r3900_rom ()
 {
   r3900_cmds.flags = MO_NO_ECHO_ON_OPEN |
-		     MO_ADDR_BITS_REMOVE |
-		     MO_CLR_BREAK_USES_ADDR |
-		     MO_GETMEM_READ_SINGLE |
-		     MO_PRINT_PROGRAM_OUTPUT;
+    MO_ADDR_BITS_REMOVE |
+    MO_CLR_BREAK_USES_ADDR |
+    MO_GETMEM_READ_SINGLE |
+    MO_PRINT_PROGRAM_OUTPUT;
 
   r3900_cmds.init = dummy_inits;
   r3900_cmds.cont = "g\r";
   r3900_cmds.step = "t\r";
-  r3900_cmds.set_break = "b %A\r";		/* COREADDR */
-  r3900_cmds.clr_break = "b %A,0\r";		/* COREADDR */
-  r3900_cmds.fill = "fx %A s %x %x\r";		/* COREADDR, len, val */
+  r3900_cmds.set_break = "b %A\r";	/* COREADDR */
+  r3900_cmds.clr_break = "b %A,0\r";	/* COREADDR */
+  r3900_cmds.fill = "fx %A s %x %x\r";	/* COREADDR, len, val */
 
   r3900_cmds.setmem.cmdb = "sx %A %x\r";	/* COREADDR, val */
   r3900_cmds.setmem.cmdw = "sh %A %x\r";	/* COREADDR, val */
   r3900_cmds.setmem.cmdl = "sw %A %x\r";	/* COREADDR, val */
 
-  r3900_cmds.getmem.cmdb = "sx %A\r";		/* COREADDR */
-  r3900_cmds.getmem.cmdw = "sh %A\r";		/* COREADDR */
-  r3900_cmds.getmem.cmdl = "sw %A\r";		/* COREADDR */
+  r3900_cmds.getmem.cmdb = "sx %A\r";	/* COREADDR */
+  r3900_cmds.getmem.cmdw = "sh %A\r";	/* COREADDR */
+  r3900_cmds.getmem.cmdl = "sw %A\r";	/* COREADDR */
   r3900_cmds.getmem.resp_delim = " : ";
   r3900_cmds.getmem.term = " ";
   r3900_cmds.getmem.term_cmd = ".\r";
 
-  r3900_cmds.setreg.cmd = "x%s %x\r";		/* regname, val */
+  r3900_cmds.setreg.cmd = "x%s %x\r";	/* regname, val */
 
-  r3900_cmds.getreg.cmd = "x%s\r";		/* regname */
+  r3900_cmds.getreg.cmd = "x%s\r";	/* regname */
   r3900_cmds.getreg.resp_delim = "=";
   r3900_cmds.getreg.term = " ";
   r3900_cmds.getreg.term_cmd = ".\r";
 
   r3900_cmds.dump_registers = "x\r";
   r3900_cmds.register_pattern =
-	"\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
+    "\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
   r3900_cmds.supply_register = r3900_supply_register;
   /* S-record download, via "keyboard port".  */
   r3900_cmds.load = "r0\r";