X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fremote-rdp.c;h=3f956e7811b2d0c497246eb3c68dbda6de99725a;hb=54c7009d04fc3da51b50cfbefe5f5894db2cad32;hp=2acd57bcde6b2c35266de1d142bfac6964b9035f;hpb=fba45db2faf619e71856ee38ec63949c0ef6903e;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/remote-rdp.c b/gdb/remote-rdp.c
index 2acd57bcde..3f956e7811 100644
--- a/gdb/remote-rdp.c
+++ b/gdb/remote-rdp.c
@@ -1,5 +1,7 @@
 /* Remote debugging for the ARM RDP interface.
-   Copyright 1994, 1995 Free Software Foundation, Inc.
+
+   Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002 Free Software
+   Foundation, Inc.
 
    This file is part of GDB.
 
@@ -38,9 +40,8 @@
 
 #include "defs.h"
 #include "inferior.h"
-#include "gdb_wait.h"
 #include "value.h"
-#include "callback.h"
+#include "gdb/callback.h"
 #include "command.h"
 #include <ctype.h>
 #include <fcntl.h>
@@ -48,13 +49,17 @@
 #include "remote-utils.h"
 #include "gdb_string.h"
 #include "gdbcore.h"
+#include "regcache.h"
+#include "serial.h"
+
+#include "arm-tdep.h"
 
 #ifdef HAVE_TIME_H
 #include <time.h>
 #endif
 
 extern struct target_ops remote_rdp_ops;
-static serial_t io;
+static struct serial *io;
 static host_callback *callback = &default_callback;
 
 struct
@@ -167,10 +172,10 @@ static int timeout = 2;
 static char *commandline = NULL;
 
 static int
-remote_rdp_xfer_inferior_memory (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. */
@@ -178,7 +183,7 @@ remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr,
 static unsigned char
 get_byte (void)
 {
-  int c = SERIAL_READCHAR (io, timeout);
+  int c = serial_readchar (io, timeout);
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);
@@ -215,7 +220,7 @@ put_byte (char val)
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
-  SERIAL_WRITE (io, &val, 1);
+  serial_write (io, &val, 1);
 }
 
 static void
@@ -231,7 +236,7 @@ put_word (int val)
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
 
-  SERIAL_WRITE (io, b, 4);
+  serial_write (io, b, 4);
 }
 
 
@@ -262,8 +267,8 @@ rdp_init (int cold, int tty)
       int restype;
       QUIT;
 
-      SERIAL_FLUSH_INPUT (io);
-      SERIAL_FLUSH_OUTPUT (io);
+      serial_flush_input (io);
+      serial_flush_output (io);
 
       if (tty)
 	printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
@@ -275,7 +280,7 @@ rdp_init (int cold, int tty)
       if (cold)
 	{
 	  put_byte (RDP_RESET);
-	  while ((restype = SERIAL_READCHAR (io, 1)) > 0)
+	  while ((restype = serial_readchar (io, 1)) > 0)
 	    {
 	      switch (restype)
 		{
@@ -302,7 +307,7 @@ rdp_init (int cold, int tty)
       put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
       put_word (0);
 
-      while (!sync && (restype = SERIAL_READCHAR (io, 1)) > 0)
+      while (!sync && (restype = serial_readchar (io, 1)) > 0)
 	{
 	  if (remote_debug)
 	    fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);
@@ -313,13 +318,13 @@ rdp_init (int cold, int tty)
 	      break;
 
 	    case RDP_RESET:
-	      while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
+	      while ((restype = serial_readchar (io, 1)) == RDP_RESET)
 		;
 	      do
 		{
 		  printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
 		}
-	      while ((restype = SERIAL_READCHAR (io, 1)) > 0);
+	      while ((restype = serial_readchar (io, 1)) > 0);
 
 	      if (tty)
 		{
@@ -337,7 +342,7 @@ rdp_init (int cold, int tty)
 
 	    case RDP_RES_VALUE:
 	      {
-		int resval = SERIAL_READCHAR (io, 1);
+		int resval = serial_readchar (io, 1);
 
 		if (remote_debug)
 		  fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);
@@ -347,11 +352,11 @@ rdp_init (int cold, int tty)
 		  case SERIAL_TIMEOUT:
 		    break;
 		  case RDP_RES_VALUE_LITTLE_ENDIAN:
-		    target_byte_order = LITTLE_ENDIAN;
+		    target_byte_order = BFD_ENDIAN_LITTLE;
 		    sync = 1;
 		    break;
 		  case RDP_RES_VALUE_BIG_ENDIAN:
-		    target_byte_order = BIG_ENDIAN;
+		    target_byte_order = BFD_ENDIAN_BIG;
 		    sync = 1;
 		    break;
 		  default:
@@ -457,13 +462,13 @@ send_rdp (char *template,...)
 	  pc = va_arg (alist, char *);
 	  val = va_arg (alist, int);
 	  dst = buf;
-	  SERIAL_WRITE (io, pc, val);
+	  serial_write (io, pc, val);
 	  break;
 	case '-':
 	  /* Send whats in the queue */
 	  if (dst != buf)
 	    {
-	      SERIAL_WRITE (io, buf, dst - buf);
+	      serial_write (io, buf, dst - buf);
 	      dst = buf;
 	    }
 	  break;
@@ -472,13 +477,13 @@ send_rdp (char *template,...)
 	  *pi = get_byte ();
 	  break;
 	default:
-	  abort ();
+	  internal_error (__FILE__, __LINE__, "failed internal consistency check");
 	}
     }
   va_end (alist);
 
   if (dst != buf)
-    abort ();
+    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 }
 
 
@@ -607,17 +612,17 @@ remote_rdp_fetch_register (int regno)
     }
   else
     {
-      char buf[MAX_REGISTER_RAW_SIZE];
+      char buf[ARM_MAX_REGISTER_RAW_SIZE];
       if (regno < 15)
 	rdp_fetch_one_register (1 << regno, buf);
-      else if (regno == PC_REGNUM)
+      else if (regno == ARM_PC_REGNUM)
 	rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
-      else if (regno == PS_REGNUM)
+      else if (regno == ARM_PS_REGNUM)
 	rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
-      else if (regno == FPS_REGNUM)
+      else if (regno == ARM_FPS_REGNUM)
 	rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
-      else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
-	rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
+      else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+	rdp_fetch_one_fpu_register (1 << (regno - ARM_F0_REGNUM), buf);
       else
 	{
 	  printf ("Help me with fetch reg %d\n", regno);
@@ -637,16 +642,16 @@ remote_rdp_store_register (int regno)
     }
   else
     {
-      char tmp[MAX_REGISTER_RAW_SIZE];
-      read_register_gen (regno, tmp);
+      char tmp[ARM_MAX_REGISTER_RAW_SIZE];
+      deprecated_read_register_gen (regno, tmp);
       if (regno < 15)
 	rdp_store_one_register (1 << regno, tmp);
-      else if (regno == PC_REGNUM)
+      else if (regno == ARM_PC_REGNUM)
 	rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
-      else if (regno == PS_REGNUM)
+      else if (regno == ARM_PS_REGNUM)
 	rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
-      else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
-	rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
+      else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+	rdp_store_one_fpu_register (1 << (regno - ARM_F0_REGNUM), tmp);
       else
 	{
 	  printf ("Help me with reg %d\n", regno);
@@ -696,15 +701,9 @@ rdp_set_command_line (char *command, char *args)
    */
 
   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
@@ -873,7 +872,7 @@ exec_swi (int swi, argsin *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);
+	  remote_rdp_xfer_inferior_memory (args[1].n, copy, done, 1, 0, 0);
 	args->n = args[2].n - done;
 	return 1;
       }
@@ -905,10 +904,10 @@ exec_swi (int swi, argsin *args)
 	      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:
@@ -955,6 +954,7 @@ handle_swi (void)
 					       buf,
 					       len,
 					       0,
+					       0,
 					       0);
 	    }
 	  else
@@ -970,7 +970,7 @@ handle_swi (void)
 	  break;
 
 	default:
-	  error ("Unimplented SWI argument");
+	  error ("Unimplemented SWI argument");
 	}
 
       type = type >> 2;
@@ -998,12 +998,12 @@ rdp_execute_finish (void)
   while (running)
     {
       int res;
-      res = SERIAL_READCHAR (io, 1);
+      res = serial_readchar (io, 1);
       while (res == SERIAL_TIMEOUT)
 	{
 	  QUIT;
 	  printf_filtered ("Waiting for target..\n");
-	  res = SERIAL_READCHAR (io, 1);
+	  res = serial_readchar (io, 1);
 	}
 
       switch (res)
@@ -1094,11 +1094,11 @@ rdp_step (void)
   else
     {
       char handle[4];
-      CORE_ADDR pc = read_register (PC_REGNUM);
+      CORE_ADDR pc = read_register (ARM_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);
     }
 }
 
@@ -1114,12 +1114,12 @@ remote_rdp_open (char *args, int from_tty)
 
   target_preopen (from_tty);
 
-  io = SERIAL_OPEN (args);
+  io = serial_open (args);
 
   if (!io)
     perror_with_name (args);
 
-  SERIAL_RAW (io);
+  serial_raw (io);
 
   rdp_init (1, from_tty);
 
@@ -1163,9 +1163,7 @@ remote_rdp_open (char *args, int from_tty)
   flush_cached_frames ();
   registers_changed ();
   stop_pc = read_pc ();
-  set_current_frame (create_new_frame (read_fp (), stop_pc));
-  select_frame (get_current_frame (), 0);
-  print_stack_frame (selected_frame, -1, 1);
+  print_stack_frame (get_selected_frame (), -1, 1);
 }
 
 
@@ -1177,7 +1175,7 @@ remote_rdp_close (int quitting)
 {
   callback->shutdown (callback);
   if (io)
-    SERIAL_CLOSE (io);
+    serial_close (io);
   io = 0;
 }
 
@@ -1187,7 +1185,7 @@ remote_rdp_close (int quitting)
    to the target, or zero for no signal.  */
 
 static void
-remote_rdp_resume (int pid, int step, enum target_signal siggnal)
+remote_rdp_resume (ptid_t ptid, int step, enum target_signal siggnal)
 {
   if (step)
     rdp_step ();
@@ -1199,8 +1197,8 @@ remote_rdp_resume (int pid, int step, enum target_signal siggnal)
    or -1 in case of error; store status through argument pointer STATUS,
    just as `wait' would.  */
 
-static int
-remote_rdp_wait (int pid, struct target_waitstatus *status)
+static ptid_t
+remote_rdp_wait (ptid_t ptid, struct target_waitstatus *status)
 {
   switch (ds.rdi_stopped_status)
     {
@@ -1226,7 +1224,7 @@ remote_rdp_wait (int pid, struct target_waitstatus *status)
 #endif
     }
 
-  return inferior_pid;
+  return inferior_ptid;
 }
 
 /* Get ready to modify the registers array.  On machines which store
@@ -1241,13 +1239,16 @@ 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,
+				 struct target_ops *target)
 {
   /* I infer from D Taylor's code that there's a limit on the amount
      we can transfer in one chunk.. */
@@ -1348,7 +1349,7 @@ remote_rdp_create_inferior (char *exec_file, char *allargs, char **env)
   /* This gives us a chance to set up the command line */
   rdp_set_command_line (exec_file, allargs);
 
-  inferior_pid = 42;
+  inferior_ptid = pid_to_ptid (42);
   insert_breakpoints ();	/* Needed to get correct instruction in cache */
 
   /*
@@ -1360,13 +1361,6 @@ remote_rdp_create_inferior (char *exec_file, char *allargs, char **env)
   proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
 }
 
-/* Accept any stray run/attach commands */
-static int
-remote_rdp_can_run (void)
-{
-  return 1;
-}
-
 /* Attach doesn't need to do anything */
 static void
 remote_rdp_attach (char *args, int from_tty)
@@ -1387,13 +1381,8 @@ init_remote_rdp_ops (void)
   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;
@@ -1401,48 +1390,16 @@ init_remote_rdp_ops (void)
   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;
-  remote_rdp_ops.to_post_follow_inferior_by_clone = NULL;
-  remote_rdp_ops.to_insert_fork_catchpoint = NULL;
-  remote_rdp_ops.to_remove_fork_catchpoint = NULL;
-  remote_rdp_ops.to_insert_vfork_catchpoint = NULL;
-  remote_rdp_ops.to_remove_vfork_catchpoint = NULL;
-  remote_rdp_ops.to_has_forked = NULL;
-  remote_rdp_ops.to_has_vforked = NULL;
-  remote_rdp_ops.to_can_follow_vfork_prior_to_exec = NULL;
-  remote_rdp_ops.to_post_follow_vfork = NULL;
-  remote_rdp_ops.to_insert_exec_catchpoint = NULL;
-  remote_rdp_ops.to_remove_exec_catchpoint = NULL;
-  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_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;
 }