X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fremote-rdp.c;h=1c9b3c385032abba1bd3358b941fa5b31095330a;hb=c65ecaf37b02a936e0d8c4074da3b5da8017e464;hp=7b979d2fb6b7f0988e9a3bdcdec88836d9fd115a;hpb=9846de1bb5d61521885ef51fa6b99121ec1be577;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/remote-rdp.c b/gdb/remote-rdp.c
index 7b979d2fb6..1c9b3c3850 100644
--- a/gdb/remote-rdp.c
+++ b/gdb/remote-rdp.c
@@ -1,5 +1,6 @@
 /* Remote debugging for the ARM RDP interface.
-   Copyright 1994, 1995 Free Software Foundation, Inc.
+   Copyright 1994, 1995, 1998, 1999, 2000, 2001
+   Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -15,7 +16,8 @@
 
    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.  
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  
 
 
  */
@@ -37,25 +39,20 @@
 
 #include "defs.h"
 #include "inferior.h"
-#include "wait.h"
 #include "value.h"
 #include "callback.h"
 #include "command.h"
-#ifdef ANSI_PROTOTYPES
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
 #include <ctype.h>
 #include <fcntl.h>
 #include "symfile.h"
 #include "remote-utils.h"
 #include "gdb_string.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
 #include "gdbcore.h"
+#include "regcache.h"
 
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
 
 extern struct target_ops remote_rdp_ops;
 static serial_t io;
@@ -168,20 +165,19 @@ ds;
 
 static int timeout = 2;
 
-static char * commandline = NULL;
+static char *commandline = NULL;
 
 static int
-remote_rdp_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
-					 char *myaddr,
-					 int len,
-					 int write,
-					 struct target_ops * target));
+remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
+				 int write, 
+				 struct mem_attrib *attrib,
+				 struct target_ops *target);
 
 
 /* Stuff for talking to the serial layer. */
 
 static unsigned char
-get_byte ()
+get_byte (void)
 {
   int c = SERIAL_READCHAR (io, timeout);
 
@@ -202,7 +198,7 @@ get_byte ()
 /* Note that the target always speaks little-endian to us,
    even if it's a big endian machine. */
 static unsigned int
-get_word ()
+get_word (void)
 {
   unsigned int val = 0;
   unsigned int c;
@@ -216,8 +212,7 @@ get_word ()
 }
 
 static void
-put_byte (val)
-     char val;
+put_byte (char val)
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
@@ -225,8 +220,7 @@ put_byte (val)
 }
 
 static void
-put_word (val)
-     int val;
+put_word (int val)
 {
   /* We always send in little endian */
   unsigned char b[4];
@@ -254,9 +248,7 @@ put_word (val)
 
  */
 static void
-rdp_init (cold, tty)
-     int cold;
-     int tty;
+rdp_init (int cold, int tty)
 {
   int sync = 0;
   int type = cold ? RDP_OPEN_TYPE_COLD : RDP_OPEN_TYPE_WARM;
@@ -278,9 +270,9 @@ rdp_init (cold, tty)
 	printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
 
       /*
-      ** It seems necessary to reset an EmbeddedICE to get it going.
-      ** This has the side benefit of displaying the startup banner.
-      */
+         ** It seems necessary to reset an EmbeddedICE to get it going.
+         ** This has the side benefit of displaying the startup banner.
+       */
       if (cold)
 	{
 	  put_byte (RDP_RESET);
@@ -308,7 +300,7 @@ rdp_init (cold, tty)
 
       put_byte (RDP_OPEN);
 
-      put_byte (type | RDP_OPEN_TYPE_RETURN_SEX );
+      put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
       put_word (0);
 
       while (!sync && (restype = SERIAL_READCHAR (io, 1)) > 0)
@@ -378,23 +370,13 @@ rdp_init (cold, tty)
 }
 
 
-#ifdef ANSI_PROTOTYPES
 void
 send_rdp (char *template,...)
-#else
-void
-send_rdp (char *template, va_alist)
-     va_dcl
-#endif
 {
   char buf[200];
   char *dst = buf;
   va_list alist;
-#ifdef ANSI_PROTOTYPES
   va_start (alist, template);
-#else
-  va_start (alist);
-#endif
 
   while (*template)
     {
@@ -491,21 +473,18 @@ send_rdp (char *template, va_alist)
 	  *pi = get_byte ();
 	  break;
 	default:
-	  abort ();
+	  internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	}
     }
-  va_end (args);
+  va_end (alist);
 
   if (dst != buf)
-    abort ();
+    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 }
 
 
 static int
-rdp_write (memaddr, buf, len)
-     CORE_ADDR memaddr;
-     char *buf;
-     int len;
+rdp_write (CORE_ADDR memaddr, char *buf, int len)
 {
   int res;
   int val;
@@ -521,10 +500,7 @@ rdp_write (memaddr, buf, len)
 
 
 static int
-rdp_read (memaddr, buf, len)
-     CORE_ADDR memaddr;
-     char *buf;
-     int len;
+rdp_read (CORE_ADDR memaddr, char *buf, int len)
 {
   int res;
   int val;
@@ -540,9 +516,7 @@ rdp_read (memaddr, buf, len)
 }
 
 static void
-rdp_fetch_one_register (mask, buf)
-     int mask;
-     char *buf;
+rdp_fetch_one_register (int mask, char *buf)
 {
   int val;
   send_rdp ("bbw-SWZ", RDP_CPU_READ, RDP_CPU_READWRITE_MODE_CURRENT, mask, &val);
@@ -550,9 +524,7 @@ rdp_fetch_one_register (mask, buf)
 }
 
 static void
-rdp_fetch_one_fpu_register (mask, buf)
-     int mask;
-     char *buf;
+rdp_fetch_one_fpu_register (int mask, char *buf)
 {
 #if 0
   /* !!! Since the PIE board doesn't work as documented,
@@ -579,9 +551,7 @@ rdp_fetch_one_fpu_register (mask, buf)
 
 
 static void
-rdp_store_one_register (mask, buf)
-     int mask;
-     char *buf;
+rdp_store_one_register (int mask, char *buf)
 {
   int val = extract_unsigned_integer (buf, 4);
 
@@ -591,9 +561,7 @@ rdp_store_one_register (mask, buf)
 
 
 static void
-rdp_store_one_fpu_register (mask, buf)
-     int mask;
-     char *buf;
+rdp_store_one_fpu_register (int mask, char *buf)
 {
 #if 0
   /* See comment in fetch_one_fpu_register */
@@ -631,8 +599,7 @@ rdp_store_one_fpu_register (mask, buf)
 /* Convert between GDB requests and the RDP layer. */
 
 static void
-remote_rdp_fetch_register (regno)
-     int regno;
+remote_rdp_fetch_register (int regno)
 {
   if (regno == -1)
     {
@@ -662,8 +629,7 @@ remote_rdp_fetch_register (regno)
 
 
 static void
-remote_rdp_store_register (regno)
-     int regno;
+remote_rdp_store_register (int regno)
 {
   if (regno == -1)
     {
@@ -690,14 +656,14 @@ remote_rdp_store_register (regno)
 }
 
 static void
-remote_rdp_kill ()
+remote_rdp_kill (void)
 {
   callback->shutdown (callback);
 }
 
 
 static void
-rdp_info ()
+rdp_info (void)
 {
   send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_STEP,
 	    &ds.step_info);
@@ -714,7 +680,7 @@ rdp_info ()
 
 
 static void
-rdp_execute_start ()
+rdp_execute_start (void)
 {
   /* Start it off, but don't wait for it */
   send_rdp ("bb-", RDP_EXEC, RDP_EXEC_TYPE_SYNC);
@@ -722,48 +688,40 @@ rdp_execute_start ()
 
 
 static void
-rdp_set_command_line (command, args)
-     char * command;
-     char * args;
+rdp_set_command_line (char *command, char *args)
 {
   /*
-  ** We could use RDP_INFO_SET_CMDLINE to send this, but EmbeddedICE systems
-  ** don't implement that, and get all confused at the unexpected text.
-  ** Instead, just keep a copy, and send it when the target does a SWI_GetEnv
-  */
+     ** We could use RDP_INFO_SET_CMDLINE to send this, but EmbeddedICE systems
+     ** don't implement that, and get all confused at the unexpected text.
+     ** Instead, just keep a copy, and send it when the target does a SWI_GetEnv
+   */
 
   if (commandline != NULL)
-    free (commandline);
+    xfree (commandline);
 
-  commandline = malloc (strlen (command) + strlen (args) + 2);
-  if (commandline != NULL)
-    {
-      strcpy (commandline, command);
-      strcat (commandline, " ");
-      strcat (commandline, args);
-    }
+  xasprintf (&commandline, %s %s", command, args);
 }
 
 static void
-rdp_catch_vectors ()
+rdp_catch_vectors (void)
 {
   /*
-  ** We want the target monitor to intercept the abort vectors
-  ** i.e. stop the program if any of these are used.
-  */
+     ** We want the target monitor to intercept the abort vectors
+     ** i.e. stop the program if any of these are used.
+   */
   send_rdp ("bww-SZ", RDP_INFO, RDP_INFO_VECTOR_CATCH,
-	    /*
-	    ** Specify a bitmask including
-	    **  the reset vector
-	    **  the undefined instruction vector
-	    **  the prefetch abort vector
-	    **  the data abort vector
-	    **  the address exception vector
-	    */
-	    (1<<0)|(1<<1)|(1<<3)|(1<<4)|(1<<5)
-	    );
+  /*
+     ** Specify a bitmask including
+     **  the reset vector
+     **  the undefined instruction vector
+     **  the prefetch abort vector
+     **  the data abort vector
+     **  the address exception vector
+   */
+	    (1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5)
+    );
 }
-  
+
 
 
 #define a_byte 1
@@ -817,24 +775,22 @@ argsin;
 
 static int translate_open_mode[] =
 {
-  O_RDONLY,                          /* "r"   */
-  O_RDONLY+O_BINARY,                 /* "rb"  */
-  O_RDWR,                            /* "r+"  */
-  O_RDWR  +O_BINARY,                 /* "r+b" */
-  O_WRONLY         +O_CREAT+O_TRUNC, /* "w"   */
-  O_WRONLY+O_BINARY+O_CREAT+O_TRUNC, /* "wb"  */
-  O_RDWR           +O_CREAT+O_TRUNC, /* "w+"  */
-  O_RDWR  +O_BINARY+O_CREAT+O_TRUNC, /* "w+b" */
-  O_WRONLY         +O_APPEND+O_CREAT,/* "a"   */
-  O_WRONLY+O_BINARY+O_APPEND+O_CREAT,/* "ab"  */
-  O_RDWR           +O_APPEND+O_CREAT,/* "a+"  */
-  O_RDWR  +O_BINARY+O_APPEND+O_CREAT /* "a+b" */
+  O_RDONLY,			/* "r"   */
+  O_RDONLY + O_BINARY,		/* "rb"  */
+  O_RDWR,			/* "r+"  */
+  O_RDWR + O_BINARY,		/* "r+b" */
+  O_WRONLY + O_CREAT + O_TRUNC,	/* "w"   */
+  O_WRONLY + O_BINARY + O_CREAT + O_TRUNC,	/* "wb"  */
+  O_RDWR + O_CREAT + O_TRUNC,	/* "w+"  */
+  O_RDWR + O_BINARY + O_CREAT + O_TRUNC,	/* "w+b" */
+  O_WRONLY + O_APPEND + O_CREAT,	/* "a"   */
+  O_WRONLY + O_BINARY + O_APPEND + O_CREAT,	/* "ab"  */
+  O_RDWR + O_APPEND + O_CREAT,	/* "a+"  */
+  O_RDWR + O_BINARY + O_APPEND + O_CREAT	/* "a+b" */
 };
 
 static int
-exec_swi (swi, args)
-     int swi;
-     argsin *args;
+exec_swi (int swi, argsin *args)
 {
   int i;
   char c;
@@ -861,18 +817,18 @@ exec_swi (swi, args)
       args->n = callback->time (callback, NULL);
       return 1;
 
-    case SWI_Clock :
-       /* return number of centi-seconds... */
-       args->n = 
+    case SWI_Clock:
+      /* return number of centi-seconds... */
+      args->n =
 #ifdef CLOCKS_PER_SEC
-          (CLOCKS_PER_SEC >= 100)
-             ? (clock() / (CLOCKS_PER_SEC / 100))
-             : ((clock() * 100) / CLOCKS_PER_SEC) ;
+	(CLOCKS_PER_SEC >= 100)
+	? (clock () / (CLOCKS_PER_SEC / 100))
+	: ((clock () * 100) / CLOCKS_PER_SEC);
 #else
-     /* presume unix... clock() returns microseconds */
-          clock() / 10000 ;
+      /* presume unix... clock() returns microseconds */
+	clock () / 10000;
 #endif
-       return 1 ;
+      return 1;
 
     case SWI_Remove:
       args->n = callback->unlink (callback, args->s);
@@ -882,19 +838,19 @@ exec_swi (swi, args)
       return 1;
 
     case SWI_Open:
-	/* Now we need to decode the Demon open mode */
-	i = translate_open_mode[args[1].n];
-
-	/* Filename ":tt" is special: it denotes stdin/out */
-	if (strcmp(args->s,":tt")==0)
-	  {
-	    if (i == O_RDONLY ) /* opening tty "r" */
-	      args->n = 0 /* stdin */ ;
-	    else 
-	      args->n = 1 /* stdout */ ;
-	  }
-	else
-	  args->n = callback->open (callback, args->s, i);
+      /* Now we need to decode the Demon open mode */
+      i = translate_open_mode[args[1].n];
+
+      /* Filename ":tt" is special: it denotes stdin/out */
+      if (strcmp (args->s, ":tt") == 0)
+	{
+	  if (i == O_RDONLY)	/* opening tty "r" */
+	    args->n = 0 /* stdin */ ;
+	  else
+	    args->n = 1 /* stdout */ ;
+	}
+      else
+	args->n = callback->open (callback, args->s, i);
       return 1;
 
     case SWI_Close:
@@ -912,8 +868,8 @@ exec_swi (swi, args)
 	char *copy = alloca (args[2].n);
 	int done = callback->read (callback, args[0].n, copy, args[2].n);
 	if (done > 0)
-	  remote_rdp_xfer_inferior_memory (args[1].n, copy, done, 1, 0);
-	args->n = args[2].n-done;
+	  remote_rdp_xfer_inferior_memory (args[1].n, copy, done, 1, 0, 0);
+	args->n = args[2].n - done;
 	return 1;
       }
 
@@ -941,15 +897,15 @@ exec_swi (swi, args)
 	  if (len > 255)
 	    {
 	      len = 255;
-	      commandline [255]='\0';
+	      commandline[255] = '\0';
 	    }
 	  remote_rdp_xfer_inferior_memory (args[0].n,
-					   commandline, len+1, 1, 0);
+					   commandline, len + 1, 1, 0, 0);
 	}
       else
-	remote_rdp_xfer_inferior_memory (args[0].n, "", 1, 1, 0);
+	remote_rdp_xfer_inferior_memory (args[0].n, "", 1, 1, 0, 0);
       return 1;
-      
+
     default:
       return 0;
     }
@@ -957,7 +913,7 @@ exec_swi (swi, args)
 
 
 static void
-handle_swi ()
+handle_swi (void)
 {
   argsin args[3];
   char *buf;
@@ -994,6 +950,7 @@ handle_swi ()
 					       buf,
 					       len,
 					       0,
+					       0,
 					       0);
 	    }
 	  else
@@ -1009,7 +966,7 @@ handle_swi ()
 	  break;
 
 	default:
-	  error ("Unimplented SWI argument");
+	  error ("Unimplemented SWI argument");
 	}
 
       type = type >> 2;
@@ -1030,7 +987,7 @@ handle_swi ()
 }
 
 static void
-rdp_execute_finish ()
+rdp_execute_finish (void)
 {
   int running = 1;
 
@@ -1067,16 +1024,14 @@ rdp_execute_finish ()
 
 
 static void
-rdp_execute ()
+rdp_execute (void)
 {
   rdp_execute_start ();
   rdp_execute_finish ();
 }
 
 static int
-remote_rdp_insert_breakpoint (addr, save)
-     CORE_ADDR addr;
-     char *save;
+remote_rdp_insert_breakpoint (CORE_ADDR addr, char *save)
 {
   int res;
   if (ds.rdi_level > 0)
@@ -1100,9 +1055,7 @@ remote_rdp_insert_breakpoint (addr, save)
 }
 
 static int
-remote_rdp_remove_breakpoint (addr, save)
-     CORE_ADDR addr;
-     char *save;
+remote_rdp_remove_breakpoint (CORE_ADDR addr, char *save)
 {
   int res;
   if (ds.rdi_level > 0)
@@ -1123,7 +1076,7 @@ remote_rdp_remove_breakpoint (addr, save)
 }
 
 static void
-rdp_step ()
+rdp_step (void)
 {
   if (ds.can_step && 0)
     {
@@ -1139,16 +1092,14 @@ rdp_step ()
       char handle[4];
       CORE_ADDR pc = read_register (PC_REGNUM);
       pc = arm_get_next_pc (pc);
-      remote_rdp_insert_breakpoint (pc, &handle);
+      remote_rdp_insert_breakpoint (pc, handle);
       rdp_execute ();
-      remote_rdp_remove_breakpoint (pc, &handle);
+      remote_rdp_remove_breakpoint (pc, handle);
     }
 }
 
 static void
-remote_rdp_open (args, from_tty)
-     char *args;
-     int from_tty;
+remote_rdp_open (char *args, int from_tty)
 {
   int not_icebreaker;
 
@@ -1177,32 +1128,32 @@ remote_rdp_open (args, from_tty)
   rdp_info ();
 
   /* Need to set up the vector interception state */
-  rdp_catch_vectors();
+  rdp_catch_vectors ();
 
   /*
-  ** If it's an EmbeddedICE, we need to set the processor config.
-  ** Assume we can always have ARM7TDI...
-  */
-  send_rdp ("bw-SB", RDP_INFO, RDP_INFO_ICEBREAKER, & not_icebreaker);
+     ** If it's an EmbeddedICE, we need to set the processor config.
+     ** Assume we can always have ARM7TDI...
+   */
+  send_rdp ("bw-SB", RDP_INFO, RDP_INFO_ICEBREAKER, &not_icebreaker);
   if (!not_icebreaker)
     {
-      const char * CPU = "ARM7TDI";
+      const char *CPU = "ARM7TDI";
       int ICEversion;
       int len = strlen (CPU);
-      
+
       send_rdp ("bbbbw-p-SWZ",
 		RDP_SELECT_CONFIG,
 		RDI_ConfigCPU,	/* Aspect: set the CPU */
 		len,		/* The number of bytes in the name */
 		RDI_MatchAny,	/* We'll take whatever we get */
 		0,		/* We'll take whatever version's there */
-		CPU,len,
-		& ICEversion);
+		CPU, len,
+		&ICEversion);
     }
 
-  /* command line initialised on 'run'*/
+  /* command line initialised on 'run' */
 
-  push_target (& remote_rdp_ops);
+  push_target (&remote_rdp_ops);
 
   callback->init (callback);
   flush_cached_frames ();
@@ -1218,8 +1169,7 @@ remote_rdp_open (args, from_tty)
 /* Close out all files and local state before this target loses control. */
 
 static void
-remote_rdp_close (quitting)
-     int quitting;
+remote_rdp_close (int quitting)
 {
   callback->shutdown (callback);
   if (io)
@@ -1233,9 +1183,7 @@ remote_rdp_close (quitting)
    to the target, or zero for no signal.  */
 
 static void
-remote_rdp_resume (pid, step, siggnal)
-     int pid, step;
-     enum target_signal siggnal;
+remote_rdp_resume (int pid, int step, enum target_signal siggnal)
 {
   if (step)
     rdp_step ();
@@ -1248,9 +1196,7 @@ remote_rdp_resume (pid, step, siggnal)
    just as `wait' would.  */
 
 static int
-remote_rdp_wait (pid, status)
-     int pid;
-     struct target_waitstatus *status;
+remote_rdp_wait (int pid, struct target_waitstatus *status)
 {
   switch (ds.rdi_stopped_status)
     {
@@ -1286,18 +1232,22 @@ remote_rdp_wait (pid, status)
    debugged.  */
 
 static void
-remote_rdp_prepare_to_store ()
+remote_rdp_prepare_to_store (void)
 {
   /* Do nothing, since we can store individual regs */
 }
 
+/* Transfer LEN bytes between GDB address MYADDR and target address
+   MEMADDR.  If WRITE is non-zero, transfer them to the target,
+   otherwise transfer them from the target.  TARGET is unused.
+
+   Returns the number of bytes transferred. */
+
 static int
-remote_rdp_xfer_inferior_memory (memaddr, myaddr, len, write, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
-     struct target_ops *target;	/* ignored */
+remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
+				 int write, 
+				 struct mem_attrib *attrib ATTRIBUTE_UNUSED,
+				 struct target_ops *target ATTRIBUTE_UNUSED)
 {
   /* I infer from D Taylor's code that there's a limit on the amount
      we can transfer in one chunk.. */
@@ -1362,9 +1312,7 @@ static struct yn breakinfo[] =
 
 
 static void
-dump_bits (t, info)
-     struct yn *t;
-     int info;
+dump_bits (struct yn *t, int info)
 {
   while (t->name)
     {
@@ -1374,8 +1322,7 @@ dump_bits (t, info)
 }
 
 static void
-remote_rdp_files_info (target)
-     struct target_ops *target;
+remote_rdp_files_info (struct target_ops *target)
 {
   printf_filtered ("Target capabilities:\n");
   dump_bits (stepinfo, ds.step_info);
@@ -1385,19 +1332,16 @@ remote_rdp_files_info (target)
 
 
 static void
-remote_rdp_create_inferior (exec_file, allargs, env)
-     char *  exec_file;
-     char *  allargs;
-     char ** env;
+remote_rdp_create_inferior (char *exec_file, char *allargs, char **env)
 {
   CORE_ADDR entry_point;
 
   if (exec_file == 0 || exec_bfd == 0)
-   error ("No executable file specified.");
+    error ("No executable file specified.");
 
   entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
 
-  remote_rdp_kill ();	 
+  remote_rdp_kill ();
   remove_breakpoints ();
   init_wait_for_inferior ();
 
@@ -1405,12 +1349,12 @@ remote_rdp_create_inferior (exec_file, allargs, env)
   rdp_set_command_line (exec_file, allargs);
 
   inferior_pid = 42;
-  insert_breakpoints ();  /* Needed to get correct instruction in cache */
+  insert_breakpoints ();	/* Needed to get correct instruction in cache */
 
   /*
-  ** RDP targets don't provide any facility to set the top of memory,
-  ** so we don't bother to look for MEMSIZE in the environment.
-  */
+     ** RDP targets don't provide any facility to set the top of memory,
+     ** so we don't bother to look for MEMSIZE in the environment.
+   */
 
   /* Let's go! */
   proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
@@ -1418,56 +1362,54 @@ remote_rdp_create_inferior (exec_file, allargs, env)
 
 /* Accept any stray run/attach commands */
 static int
-remote_rdp_can_run()
+remote_rdp_can_run (void)
 {
   return 1;
 }
 
 /* Attach doesn't need to do anything */
 static void
-remote_rdp_attach(args, from_tty)
-     char * args;
-     int from_tty;
+remote_rdp_attach (char *args, int from_tty)
 {
   return;
 }
-  
+
 /* Define the target subroutine names */
 
-struct target_ops remote_rdp_ops ;
+struct target_ops remote_rdp_ops;
 
-static void 
-init_remote_rdp_ops(void)
+static void
+init_remote_rdp_ops (void)
 {
-  remote_rdp_ops.to_shortname =   "rdp";
-  remote_rdp_ops.to_longname =   "Remote Target using the RDProtocol";
-  remote_rdp_ops.to_doc =   "Use a remote ARM system which uses the ARM Remote Debugging Protocol";
-  remote_rdp_ops.to_open =   remote_rdp_open;	
-  remote_rdp_ops.to_close =   remote_rdp_close;	
-  remote_rdp_ops.to_attach =   remote_rdp_attach;
+  remote_rdp_ops.to_shortname = "rdp";
+  remote_rdp_ops.to_longname = "Remote Target using the RDProtocol";
+  remote_rdp_ops.to_doc = "Use a remote ARM system which uses the ARM Remote Debugging Protocol";
+  remote_rdp_ops.to_open = remote_rdp_open;
+  remote_rdp_ops.to_close = remote_rdp_close;
+  remote_rdp_ops.to_attach = remote_rdp_attach;
   remote_rdp_ops.to_post_attach = NULL;
   remote_rdp_ops.to_require_attach = NULL;
-  remote_rdp_ops.to_detach =   NULL;
-  remote_rdp_ops.to_require_detach = NULL;		
-  remote_rdp_ops.to_resume =   remote_rdp_resume;
-  remote_rdp_ops.to_wait  =   remote_rdp_wait;
-  remote_rdp_ops.to_post_wait = NULL;	
-  remote_rdp_ops.to_fetch_registers  =   remote_rdp_fetch_register;
-  remote_rdp_ops.to_store_registers  =   remote_rdp_store_register;
-  remote_rdp_ops.to_prepare_to_store =   remote_rdp_prepare_to_store;
-  remote_rdp_ops.to_xfer_memory  =   remote_rdp_xfer_inferior_memory;
-  remote_rdp_ops.to_files_info  =   remote_rdp_files_info;
-  remote_rdp_ops.to_insert_breakpoint =   remote_rdp_insert_breakpoint;
-  remote_rdp_ops.to_remove_breakpoint =   remote_rdp_remove_breakpoint;
-  remote_rdp_ops.to_terminal_init  =   NULL;		
-  remote_rdp_ops.to_terminal_inferior =   NULL;		
-  remote_rdp_ops.to_terminal_ours_for_output =   NULL;
-  remote_rdp_ops.to_terminal_ours  =   NULL;	
-  remote_rdp_ops.to_terminal_info  =   NULL;	
-  remote_rdp_ops.to_kill  =   remote_rdp_kill;	
-  remote_rdp_ops.to_load  =   generic_load;	
-  remote_rdp_ops.to_lookup_symbol =   NULL;				
-  remote_rdp_ops.to_create_inferior =   remote_rdp_create_inferior;
+  remote_rdp_ops.to_detach = NULL;
+  remote_rdp_ops.to_require_detach = NULL;
+  remote_rdp_ops.to_resume = remote_rdp_resume;
+  remote_rdp_ops.to_wait = remote_rdp_wait;
+  remote_rdp_ops.to_post_wait = NULL;
+  remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register;
+  remote_rdp_ops.to_store_registers = remote_rdp_store_register;
+  remote_rdp_ops.to_prepare_to_store = remote_rdp_prepare_to_store;
+  remote_rdp_ops.to_xfer_memory = remote_rdp_xfer_inferior_memory;
+  remote_rdp_ops.to_files_info = remote_rdp_files_info;
+  remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint;
+  remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint;
+  remote_rdp_ops.to_terminal_init = NULL;
+  remote_rdp_ops.to_terminal_inferior = NULL;
+  remote_rdp_ops.to_terminal_ours_for_output = NULL;
+  remote_rdp_ops.to_terminal_ours = NULL;
+  remote_rdp_ops.to_terminal_info = NULL;
+  remote_rdp_ops.to_kill = remote_rdp_kill;
+  remote_rdp_ops.to_load = generic_load;
+  remote_rdp_ops.to_lookup_symbol = NULL;
+  remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior;
   remote_rdp_ops.to_post_startup_inferior = NULL;
   remote_rdp_ops.to_acknowledge_created_inferior = NULL;
   remote_rdp_ops.to_clone_and_follow_inferior = NULL;
@@ -1485,28 +1427,28 @@ init_remote_rdp_ops(void)
   remote_rdp_ops.to_has_execd = NULL;
   remote_rdp_ops.to_reported_exec_events_per_exec_call = NULL;
   remote_rdp_ops.to_has_exited = NULL;
-  remote_rdp_ops.to_mourn_inferior =   generic_mourn_inferior;
-  remote_rdp_ops.to_can_run  =   remote_rdp_can_run;
-  remote_rdp_ops.to_notice_signals =   0;	
-  remote_rdp_ops.to_thread_alive  =   0;	
-  remote_rdp_ops.to_stop  =   0;
+  remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior;
+  remote_rdp_ops.to_can_run = remote_rdp_can_run;
+  remote_rdp_ops.to_notice_signals = 0;
+  remote_rdp_ops.to_thread_alive = 0;
+  remote_rdp_ops.to_stop = 0;
   remote_rdp_ops.to_pid_to_exec_file = NULL;
-  remote_rdp_ops.to_core_file_to_sym_file = NULL;		
-  remote_rdp_ops.to_stratum =   process_stratum;
-  remote_rdp_ops.DONT_USE =   NULL;		
-  remote_rdp_ops.to_has_all_memory =   1;	
-  remote_rdp_ops.to_has_memory =   1;		
-  remote_rdp_ops.to_has_stack =   1;		
-  remote_rdp_ops.to_has_registers =   1;	
-  remote_rdp_ops.to_has_execution =   1;	
-  remote_rdp_ops.to_sections =   NULL;		
-  remote_rdp_ops.to_sections_end =   NULL;
-  remote_rdp_ops.to_magic =   OPS_MAGIC;
+  remote_rdp_ops.to_core_file_to_sym_file = NULL;
+  remote_rdp_ops.to_stratum = process_stratum;
+  remote_rdp_ops.DONT_USE = NULL;
+  remote_rdp_ops.to_has_all_memory = 1;
+  remote_rdp_ops.to_has_memory = 1;
+  remote_rdp_ops.to_has_stack = 1;
+  remote_rdp_ops.to_has_registers = 1;
+  remote_rdp_ops.to_has_execution = 1;
+  remote_rdp_ops.to_sections = NULL;
+  remote_rdp_ops.to_sections_end = NULL;
+  remote_rdp_ops.to_magic = OPS_MAGIC;
 }
 
 void
-_initialize_remote_rdp ()
+_initialize_remote_rdp (void)
 {
-  init_remote_rdp_ops() ;
+  init_remote_rdp_ops ();
   add_target (&remote_rdp_ops);
 }