More model specific changes

[deliverable/binutils-gdb.git] / gdb / remote-udi.c

diff --git a/gdb/remote-udi.c b/gdb/remote-udi.c
index a17913f558de1869cf39c2ef4a44b0e2d3893782..6ade3e4804404caf30f4ff8ab962cbe24c68b3bf 100644 (file)
--- a/gdb/remote-udi.c
+++ b/gdb/remote-udi.c
@@ -1,5 +1,5 @@
 /* Remote debugging interface for AMD 29k interfaced via UDI, for GDB.
 /* Remote debugging interface for AMD 29k interfaced via UDI, for GDB.

-   Copyright 1990, 1992 Free Software Foundation, Inc.
+   Copyright 1990, 1992, 1995 Free Software Foundation, Inc.

    Written by Daniel Mann.  Contributed by AMD.
 
 This file is part of GDB.
    Written by Daniel Mann.  Contributed by AMD.
 
 This file is part of GDB.


@@ -16,7 +16,7 @@ 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
 
 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

 
 /* This is like remote.c but uses the Universal Debug Interface (UDI) to 
    talk to the target hardware (or simulator).  UDI is a TCP/IP based
 
 /* This is like remote.c but uses the Universal Debug Interface (UDI) to 
    talk to the target hardware (or simulator).  UDI is a TCP/IP based


@@ -32,6 +32,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
        MiniMON interface with UDI-p interface.   */
  
 #include "defs.h"
        MiniMON interface with UDI-p interface.   */
  
 #include "defs.h"

+#include "frame.h"

 #include "inferior.h"
 #include "wait.h"
 #include "value.h"
 #include "inferior.h"
 #include "wait.h"
 #include "value.h"


@@ -39,7 +40,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include <fcntl.h>
 #include <signal.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <errno.h>

-#include <string.h>
+#include "gdb_string.h"

 #include "terminal.h"
 #include "target.h"
 #include "29k-share/udi/udiproc.h"
 #include "terminal.h"
 #include "target.h"
 #include "29k-share/udi/udiproc.h"


@@ -50,10 +51,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 /* access the register store directly, without going through
    the normal handler functions. This avoids an extra data copy.  */
 
 /* access the register store directly, without going through
    the normal handler functions. This avoids an extra data copy.  */
 

-static int kiodebug;

 extern int stop_soon_quietly;           /* for wait_for_inferior */
 extern struct value *call_function_by_hand();
 extern int stop_soon_quietly;           /* for wait_for_inferior */
 extern struct value *call_function_by_hand();

-static void udi_resume PARAMS ((int pid, int step, int sig));
+static void udi_resume PARAMS ((int pid, int step, enum target_signal sig));

 static void udi_fetch_registers PARAMS ((int regno));
 static void udi_load PARAMS ((char *args, int from_tty));
 static void fetch_register PARAMS ((int regno));
 static void udi_fetch_registers PARAMS ((int regno));
 static void udi_load PARAMS ((char *args, int from_tty));
 static void fetch_register PARAMS ((int regno));


@@ -72,12 +72,6 @@ char   CoffFileName[100] = "";
 #define FREEZE_MODE     (read_register(CPS_REGNUM) & 0x400)
 #define USE_SHADOW_PC  ((processor_type == a29k_freeze_mode) && FREEZE_MODE)
 
 #define FREEZE_MODE     (read_register(CPS_REGNUM) & 0x400)
 #define USE_SHADOW_PC  ((processor_type == a29k_freeze_mode) && FREEZE_MODE)
 

-/* FIXME: Replace with `set remotedebug'.  Also, seems not to be used.  */
-#define LLOG_FILE "udi.log"
-#if defined (LOG_FILE)
-FILE *log_file;
-#endif
-

 static int timeout = 5;
 extern struct target_ops udi_ops;             /* Forward declaration */
 
 static int timeout = 5;
 extern struct target_ops udi_ops;             /* Forward declaration */
 


@@ -91,6 +85,7 @@ extern struct target_ops udi_ops;             /* Forward declaration */
    starts.  */
 
 UDISessionId udi_session_id = -1;
    starts.  */
 
 UDISessionId udi_session_id = -1;

+static char *udi_config_id;

 
 CPUOffset IMemStart = 0;
 CPUSizeT IMemSize = 0;
 
 CPUOffset IMemStart = 0;
 CPUSizeT IMemSize = 0;


@@ -122,10 +117,6 @@ extern     char    dfe_errmsg[];           /* error string */
 /* malloc'd name of the program on the remote system.  */
 static char *prog_name = NULL;
 
 /* malloc'd name of the program on the remote system.  */
 static char *prog_name = NULL;
 

-/* Number of SIGTRAPs we need to simulate.  That is, the next
-   NEED_ARTIFICIAL_TRAP calls to udi_wait should just return
-   SIGTRAP without actually waiting for anything.  */
-

 /* This is called not only when we first attach, but also when the
    user types "run" after having attached.  */
 
 /* This is called not only when we first attach, but also when the
    user types "run" after having attached.  */
 


@@ -150,8 +141,11 @@ udi_create_inferior (execfile, args, env)
 
   if (udi_session_id < 0)
     {
 
   if (udi_session_id < 0)
     {

-      printf("UDI connection not open yet.\n");
-      return;
+      /* If the TIP is not open, open it.  */
+      if (UDIConnect (udi_config_id, &udi_session_id))
+       error("UDIConnect() failed: %s\n", dfe_errmsg);
+      /* We will need to download the program.  */
+      entry.Offset = 0;

     }
 
   inferior_pid = 40000;
     }
 
   inferior_pid = 40000;


@@ -161,7 +155,19 @@ udi_create_inferior (execfile, args, env)
 
   args1 = alloca (strlen(execfile) + strlen(args) + 2);
 
 
   args1 = alloca (strlen(execfile) + strlen(args) + 2);
 

-  strcpy (args1, execfile);
+  if (execfile[0] == '\0')
+
+    /* It is empty.  We need to quote it somehow, or else the target
+       will think there is no argument being passed here.  According
+       to the UDI spec it is quoted "according to TIP OS rules" which
+       I guess means quoting it like the Unix shell should work
+       (sounds pretty bogus to me...).  In fact it doesn't work (with
+       isstip anyway), but passing in two quotes as the argument seems
+       like a reasonable enough behavior anyway (I guess).  */
+
+    strcpy (args1, "''");
+  else
+    strcpy (args1, execfile);

   strcat (args1, " ");
   strcat (args1, args);
 
   strcat (args1, " ");
   strcat (args1, args);
 


@@ -174,14 +180,23 @@ udi_create_inferior (execfile, args, env)
 
   init_wait_for_inferior ();
   clear_proceed_status ();
 
   init_wait_for_inferior ();
   clear_proceed_status ();

-  proceed(-1,-1,0);
+  proceed (-1, TARGET_SIGNAL_DEFAULT, 0);

 }
 
 static void
 udi_mourn()
 {
 }
 
 static void
 udi_mourn()
 {

-        pop_target ();                /* Pop back to no-child state */
-        generic_mourn_inferior ();
+#if 0
+  /* Requiring "target udi" each time you run is a major pain.  I suspect
+     this was just blindy copied from remote.c, in which "target" and
+     "run" are combined.  Having a udi target without an inferior seems
+     to work between "target udi" and "run", so why not now?  */
+  pop_target ();                /* Pop back to no-child state */
+#endif
+  /* But if we're going to want to run it again, we better remove the
+     breakpoints...  */
+  remove_breakpoints ();
+  generic_mourn_inferior ();

 }
 
 /******************************************************************** UDI_OPEN
 }
 
 /******************************************************************** UDI_OPEN


@@ -193,7 +208,6 @@ udi_mourn()
 
 /* XXX - need cleanups for udiconnect for various failures!!! */
 
 
 /* XXX - need cleanups for udiconnect for various failures!!! */
 

-static char *udi_config_id;

 static void
 udi_open (name, from_tty)
      char *name;
 static void
 udi_open (name, from_tty)
      char *name;


@@ -225,15 +239,11 @@ udi_open (name, from_tty)
   udi_config_id = strdup (strtok (name, " \t"));
 
   if (UDIConnect (udi_config_id, &udi_session_id))
   udi_config_id = strdup (strtok (name, " \t"));
 
   if (UDIConnect (udi_config_id, &udi_session_id))

+    /* FIXME: Should set udi_session_id to -1 here.  */

     error("UDIConnect() failed: %s\n", dfe_errmsg);
 
   push_target (&udi_ops);
 
     error("UDIConnect() failed: %s\n", dfe_errmsg);
 
   push_target (&udi_ops);
 

-#if defined (LOG_FILE)
-  log_file = fopen (LOG_FILE, "w");
-  if (log_file == NULL)
-    error ("udi_open: fopen(%s) %s", LOG_FILE, safe_strerror(errno));
-#endif

   /*
   ** Initialize target configuration structure (global)
   */
   /*
   ** Initialize target configuration structure (global)
   */


@@ -241,13 +251,13 @@ udi_open (name, from_tty)
                          ChipVersions, &NumberOfChips))
     error ("UDIGetTargetConfig() failed");
   if (NumberOfChips > 2)
                          ChipVersions, &NumberOfChips))
     error ("UDIGetTargetConfig() failed");
   if (NumberOfChips > 2)

-    fprintf(stderr,"Target has more than one processor\n");
+    fprintf_unfiltered(gdb_stderr,"Target has more than one processor\n");

   for (cnt=0; cnt < NumberOfRanges; cnt++)
     {
       switch(KnownMemory[cnt].Space)
        {
        default:
   for (cnt=0; cnt < NumberOfRanges; cnt++)
     {
       switch(KnownMemory[cnt].Space)
        {
        default:

-         fprintf(stderr, "UDIGetTargetConfig() unknown memory space\n");
+         fprintf_unfiltered(gdb_stderr, "UDIGetTargetConfig() unknown memory space\n");

          break;
        case UDI29KCP_S:
          break;
          break;
        case UDI29KCP_S:
          break;


@@ -269,7 +279,7 @@ udi_open (name, from_tty)
   a29k_get_processor_type ();
 
   if (UDICreateProcess (&PId))
   a29k_get_processor_type ();
 
   if (UDICreateProcess (&PId))

-     fprintf(stderr, "UDICreateProcess() failed\n");
+     fprintf_unfiltered(gdb_stderr, "UDICreateProcess() failed\n");

 
   /* Print out some stuff, letting the user now what's going on */
   if (UDICapabilities (&TIPId, &TargetId, DFEId, DFE, &TIP, &DFEIPCId,
 
   /* Print out some stuff, letting the user now what's going on */
   if (UDICapabilities (&TIPId, &TargetId, DFEId, DFE, &TIP, &DFEIPCId,


@@ -298,22 +308,20 @@ udi_close (quitting)      /*FIXME: how is quitting used */
     return;
 
   /* We should never get here if there isn't something valid in
     return;
 
   /* We should never get here if there isn't something valid in

-     udi_session_id. */
+     udi_session_id.  */

 
   if (UDIDisconnect (udi_session_id, UDITerminateSession))
 
   if (UDIDisconnect (udi_session_id, UDITerminateSession))

-    error ("UDIDisconnect() failed in udi_close");
+    {
+      if (quitting)
+       warning ("UDIDisconnect() failed in udi_close");
+      else
+       error ("UDIDisconnect() failed in udi_close");
+    }

 
   /* Do not try to close udi_session_id again, later in the program.  */
   udi_session_id = -1;
   inferior_pid = 0;
 
 
   /* Do not try to close udi_session_id again, later in the program.  */
   udi_session_id = -1;
   inferior_pid = 0;
 

-#if defined (LOG_FILE)
-  if (ferror (log_file))
-    printf ("Error writing log file.\n");
-  if (fclose (log_file) != 0)
-    printf ("Error closing log file.\n");
-#endif
-

   printf_filtered ("  Ending remote debugging\n");
 } 
 
   printf_filtered ("  Ending remote debugging\n");
 } 
 


@@ -334,18 +342,21 @@ udi_attach (args, from_tty)
   UDIBool      HostEndian = 0;
   UDIError     err;
 
   UDIBool      HostEndian = 0;
   UDIError     err;
 

+  if (args == NULL)
+    error_no_arg ("program to attach");
+

   if (udi_session_id < 0)
       error ("UDI connection not opened yet, use the 'target udi' command.\n");
        
   if (from_tty)
   if (udi_session_id < 0)
       error ("UDI connection not opened yet, use the 'target udi' command.\n");
        
   if (from_tty)

-      printf ("Attaching to remote program %s...\n", prog_name);
+      printf_unfiltered ("Attaching to remote program %s...\n", prog_name);

 
   UDIStop();
   From.Space = UDI29KSpecialRegs;
   From.Offset = 11;
   if (err = UDIRead(From, &PC_adds, Count, Size, &CountDone, HostEndian))
     error ("UDIRead failed in udi_attach");
 
   UDIStop();
   From.Space = UDI29KSpecialRegs;
   From.Offset = 11;
   if (err = UDIRead(From, &PC_adds, Count, Size, &CountDone, HostEndian))
     error ("UDIRead failed in udi_attach");

-  printf ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds);
+  printf_unfiltered ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds);

 }
 /************************************************************* UDI_DETACH */
 /* Terminate the open connection to the TIP process.
 }
 /************************************************************* UDI_DETACH */
 /* Terminate the open connection to the TIP process.


@@ -362,10 +373,15 @@ udi_detach (args,from_tty)
   if (UDIDisconnect (udi_session_id, UDIContinueSession))
     error ("UDIDisconnect() failed in udi_detach");
 
   if (UDIDisconnect (udi_session_id, UDIContinueSession))
     error ("UDIDisconnect() failed in udi_detach");
 

-  pop_target();                /* calls udi_close to do the real work */
+  /* Don't try to UDIDisconnect it again in udi_close, which is called from
+     pop_target.  */
+  udi_session_id = -1;
+  inferior_pid = 0;
+
+  pop_target();

 
   if (from_tty)
 
   if (from_tty)

-    printf ("Ending remote debugging\n");
+    printf_unfiltered ("Detaching from TIP\n");

 }
 
 
 }
 
 


@@ -374,7 +390,8 @@ udi_detach (args,from_tty)
 
 static void
 udi_resume (pid, step, sig)
 
 static void
 udi_resume (pid, step, sig)

-     int pid, step, sig;
+     int pid, step;
+     enum target_signal sig;

 {
   UDIError tip_error;
   UDIUInt32 Steps = 1;
 {
   UDIError tip_error;
   UDIUInt32 Steps = 1;


@@ -387,7 +404,7 @@ udi_resume (pid, step, sig)
       if (!tip_error)
        return;
 
       if (!tip_error)
        return;
 

-      fprintf (stderr,  "UDIStep() error = %d\n", tip_error);
+      fprintf_unfiltered (gdb_stderr,  "UDIStep() error = %d\n", tip_error);

       error ("failed in udi_resume");
     }
 
       error ("failed in udi_resume");
     }
 


@@ -400,8 +417,9 @@ udi_resume (pid, step, sig)
    storing status in STATUS just as `wait' would.  */
 
 static int
    storing status in STATUS just as `wait' would.  */
 
 static int

-udi_wait (status)
-     WAITTYPE *status;
+udi_wait (pid, status)
+     int pid;
+     struct target_waitstatus *status;

 {
   UDIInt32     MaxTime;
   UDIPId       PId;
 {
   UDIInt32     MaxTime;
   UDIPId       PId;


@@ -411,7 +429,8 @@ udi_wait (status)
   int          old_immediate_quit = immediate_quit;
   int          i;
 
   int          old_immediate_quit = immediate_quit;
   int          i;
 

-  WSETEXIT ((*status), 0);
+  status->kind = TARGET_WAITKIND_EXITED;
+  status->value.integer = 0;

 
 /* wait for message to arrive. It should be:
   If the target stops executing, udi_wait() should return.
 
 /* wait for message to arrive. It should be:
   If the target stops executing, udi_wait() should return.


@@ -434,13 +453,14 @@ udi_wait (status)
               a whole bunch of output (more than SBUF_MAX, I would
               guess).  It doesn't seem to happen with the simulator.  */
            warning ("UDIGetStdout() failed in udi_wait");
               a whole bunch of output (more than SBUF_MAX, I would
               guess).  It doesn't seem to happen with the simulator.  */
            warning ("UDIGetStdout() failed in udi_wait");

-         fwrite (sbuf, 1, CountDone, stdout);
-         fflush(stdout);
+         fwrite (sbuf, 1, CountDone, gdb_stdout);
+         gdb_flush(gdb_stdout);

          continue;
          continue;

+

        case UDIStderrReady:
          UDIGetStderr (sbuf, (UDISizeT)SBUF_MAX, &CountDone);
        case UDIStderrReady:
          UDIGetStderr (sbuf, (UDISizeT)SBUF_MAX, &CountDone);

-         fwrite (sbuf, 1, CountDone, stderr);
-         fflush(stderr);
+         fwrite (sbuf, 1, CountDone, gdb_stderr);
+         gdb_flush(gdb_stderr);

          continue;
 
        case UDIStdinNeeded:
          continue;
 
        case UDIStdinNeeded:


@@ -472,23 +492,28 @@ udi_wait (status)
   switch (StopReason & UDIGrossState)
     {
     case UDITrapped:
   switch (StopReason & UDIGrossState)
     {
     case UDITrapped:

-      printf("Am290*0 received vector number %d\n", StopReason >> 24);
+      printf_unfiltered("Am290*0 received vector number %d\n", StopReason >> 24);

          
          

-      switch (StopReason >> 8)
+      switch ((StopReason >> 8 ) & 0xff)

        {
        case 0:                 /* Illegal opcode */
        {
        case 0:                 /* Illegal opcode */

-         printf("      (break point)\n");
-         WSETSTOP ((*status), SIGTRAP);
+         printf_unfiltered("   (break point)\n");
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_TRAP;

          break;
        case 1:                 /* Unaligned Access */
          break;
        case 1:                 /* Unaligned Access */

-         WSETSTOP ((*status), SIGBUS);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_BUS;

          break;
        case 3:
        case 4:
          break;
        case 3:
        case 4:

-         WSETSTOP ((*status), SIGFPE);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_FPE;

          break;
        case 5:                 /* Protection Violation */
          break;
        case 5:                 /* Protection Violation */

-         WSETSTOP ((*status), SIGILL);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         /* Why not SEGV?  What is a Protection Violation?  */
+         status->value.sig = TARGET_SIGNAL_ILL;

          break;
        case 6:
        case 7:
          break;
        case 6:
        case 7:


@@ -496,17 +521,21 @@ udi_wait (status)
        case 9:                 /* User Data Mapping Miss */
        case 10:                /* Supervisor Instruction Mapping Miss */
        case 11:                /* Supervisor Data Mapping Miss */
        case 9:                 /* User Data Mapping Miss */
        case 10:                /* Supervisor Instruction Mapping Miss */
        case 11:                /* Supervisor Data Mapping Miss */

-         WSETSTOP ((*status), SIGSEGV);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_SEGV;

          break;
        case 12:
        case 13:
          break;
        case 12:
        case 13:

-         WSETSTOP ((*status), SIGILL);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_ILL;

          break;
        case 14:                /* Timer */
          break;
        case 14:                /* Timer */

-         WSETSTOP ((*status), SIGALRM);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_ALRM;

          break;
        case 15:                /* Trace */
          break;
        case 15:                /* Trace */

-         WSETSTOP ((*status), SIGTRAP);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_TRAP;

          break;
        case 16:                /* INTR0 */
        case 17:                /* INTR1 */
          break;
        case 16:                /* INTR0 */
        case 17:                /* INTR1 */


@@ -514,40 +543,52 @@ udi_wait (status)
        case 19:                /* INTR3/Internal */
        case 20:                /* TRAP0 */
        case 21:                /* TRAP1 */
        case 19:                /* INTR3/Internal */
        case 20:                /* TRAP0 */
        case 21:                /* TRAP1 */

-         WSETSTOP ((*status), SIGINT);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_INT;

          break;
        case 22:                /* Floating-Point Exception */
          break;
        case 22:                /* Floating-Point Exception */

-         WSETSTOP ((*status), SIGILL);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         /* Why not FPE?  */
+         status->value.sig = TARGET_SIGNAL_ILL;

          break;
        case 77:                /* assert 77 */
          break;
        case 77:                /* assert 77 */

-         WSETSTOP ((*status), SIGTRAP);
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_TRAP;

          break;
        default:
          break;
        default:

-         WSETEXIT ((*status), 0);
+         status->kind = TARGET_WAITKIND_EXITED;
+         status->value.integer = 0;

        }
       break;
     case UDINotExecuting:
        }
       break;
     case UDINotExecuting:

-      WSETSTOP ((*status), SIGTERM);
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = TARGET_SIGNAL_TERM;

       break;
     case UDIStopped:
       break;
     case UDIStopped:

-      WSETSTOP ((*status), SIGTSTP);
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = TARGET_SIGNAL_TSTP;

       break;
     case UDIWarned:
       break;
     case UDIWarned:

-      WSETSTOP ((*status), SIGURG);
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = TARGET_SIGNAL_URG;

       break;
     case UDIStepped:
     case UDIBreak:
       break;
     case UDIStepped:
     case UDIBreak:

-      WSETSTOP ((*status), SIGTRAP);
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = TARGET_SIGNAL_TRAP;

       break;
     case UDIWaiting:
       break;
     case UDIWaiting:

-      WSETSTOP ((*status), SIGSTOP);
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = TARGET_SIGNAL_STOP;

       break;
     case UDIHalted:
       break;
     case UDIHalted:

-      WSETSTOP ((*status), SIGKILL);
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = TARGET_SIGNAL_KILL;

       break;
     case UDIExited:
     default:
       break;
     case UDIExited:
     default:

-      WSETEXIT ((*status), 0);
+      status->kind = TARGET_WAITKIND_EXITED;
+      status->value.integer = 0;

     }
 
   timeout = old_timeout;       /* Restore original timeout value */
     }
 
   timeout = old_timeout;       /* Restore original timeout value */


@@ -555,6 +596,55 @@ udi_wait (status)
   return inferior_pid;
 }
 
   return inferior_pid;
 }
 

+#if 0
+/* Handy for debugging */
+udi_pc()
+{
+  UDIResource  From;
+  UDIUInt32    *To;
+  UDICount     Count;
+  UDISizeT     Size = 4;
+  UDICount     CountDone;
+  UDIBool      HostEndian = 0;
+  UDIError     err;
+  int pc[2];
+  unsigned long myregs[256];
+  int i;
+
+  From.Space = UDI29KPC;
+  From.Offset = 0;
+  To = (UDIUInt32 *)pc;
+  Count = 2;
+
+  err = UDIRead(From, To, Count, Size, &CountDone, HostEndian);
+
+  printf_unfiltered ("err = %d, CountDone = %d, pc[0] = 0x%x, pc[1] = 0x%x\n",
+         err, CountDone, pc[0], pc[1]);
+
+  udi_fetch_registers(-1);
+
+  printf_unfiltered("other pc1 = 0x%x, pc0 = 0x%x\n", *(int *)&registers[4 * PC_REGNUM],
+         *(int *)&registers[4 * NPC_REGNUM]);
+
+  /* Now, read all the registers globally */
+
+  From.Space = UDI29KGlobalRegs;
+  From.Offset = 0;
+  err = UDIRead(From, myregs, 256, 4, &CountDone, HostEndian);
+
+  printf ("err = %d, CountDone = %d\n", err, CountDone);
+
+  printf("\n");
+
+  for (i = 0; i < 256; i += 2)
+    printf("%d:\t%#10x\t%11d\t%#10x\t%11d\n", i, myregs[i], myregs[i],
+          myregs[i+1], myregs[i+1]);
+  printf("\n");
+
+  return pc[0];
+}
+#endif
+

 /********************************************************** UDI_FETCH_REGISTERS
  * Read a remote register 'regno'. 
  * If regno==-1 then read all the registers.
 /********************************************************** UDI_FETCH_REGISTERS
  * Read a remote register 'regno'. 
  * If regno==-1 then read all the registers.


@@ -658,10 +748,10 @@ int       regno;
       register_valid[i] = 1;
   }
 
       register_valid[i] = 1;
   }
 

-  if (kiodebug)
+  if (remote_debug)

     {
     {

-      printf("Fetching all registers\n");
-      printf("Fetching PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n",
+      printf_unfiltered("Fetching all registers\n");
+      printf_unfiltered("Fetching PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n",

             read_register(NPC_REGNUM), read_register(PC_REGNUM),
             read_register(PC2_REGNUM));
     }
             read_register(NPC_REGNUM), read_register(PC_REGNUM),
             read_register(PC2_REGNUM));
     }


@@ -699,10 +789,10 @@ int regno;
       return;
     }
 
       return;
     }
 

-  if (kiodebug)
+  if (remote_debug)

     {
     {

-      printf("Storing all registers\n");
-      printf("PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", read_register(NPC_REGNUM),
+      printf_unfiltered("Storing all registers\n");
+      printf_unfiltered("PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", read_register(NPC_REGNUM),

             read_register(PC_REGNUM), read_register(PC2_REGNUM));
     }
 
             read_register(PC_REGNUM), read_register(PC2_REGNUM));
     }
 


@@ -768,6 +858,15 @@ int regno;
   if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian))
     error("UDIWrite() failed in udi_store_regisetrs");
 
   if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian))
     error("UDIWrite() failed in udi_store_regisetrs");
 

+/* PC1 via UDI29KPC */
+
+  From = (UDIUInt32 *)&registers[4 * PC_REGNUM];
+  To.Space = UDI29KPC;
+  To.Offset = 0;                               /* PC1 */
+  Count = 1;
+  if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian))
+    error ("UDIWrite() failed in udi_store_regisetrs");
+

   /* LRU and MMU */
 
   From = (UDIUInt32 *)&registers[4 * SR_REGNUM(13)];
   /* LRU and MMU */
 
   From = (UDIUInt32 *)&registers[4 * SR_REGNUM(13)];


@@ -844,8 +943,10 @@ udi_xfer_inferior_memory (memaddr, myaddr, len, write)
 static void
 udi_files_info ()
 {
 static void
 udi_files_info ()
 {

-  printf ("\tAttached to UDI socket to %s and running program %s.\n",
-          udi_config_id, prog_name);
+  printf_unfiltered ("\tAttached to UDI socket to %s", udi_config_id);
+  if (prog_name != NULL)
+    printf_unfiltered ("and running program %s", prog_name);
+  printf_unfiltered (".\n");

 }
 
 /**************************************************** UDI_INSERT_BREAKPOINT */
 }
 
 /**************************************************** UDI_INSERT_BREAKPOINT */


@@ -922,11 +1023,24 @@ just invoke udi_close, which seems to get things right.
   inferior_pid = 0;
 
   if (from_tty)
   inferior_pid = 0;
 
   if (from_tty)

-    printf("Target has been stopped.");
-#else
+    printf_unfiltered("Target has been stopped.");
+#endif /* 0 */
+#if 0

   udi_close(0);
   udi_close(0);

-#endif

   pop_target();
   pop_target();

+#endif /* 0 */
+
+  /* Keep the target around, e.g. so "run" can do the right thing when
+     we are already debugging something.  */
+
+  if (UDIDisconnect (udi_session_id, UDITerminateSession))
+    {
+      warning ("UDIDisconnect() failed");
+    }
+
+  /* Do not try to close udi_session_id again, later in the program.  */
+  udi_session_id = -1;
+  inferior_pid = 0;

 }
 
 /* 
 }
 
 /* 


@@ -1025,8 +1139,13 @@ download(load_arg_string, from_tty)
   pbfd = bfd_openr (filename, gnutarget);
 
   if (!pbfd) 
   pbfd = bfd_openr (filename, gnutarget);
 
   if (!pbfd) 

+    /* FIXME: should be using bfd_errmsg, not assuming it was
+       bfd_error_system_call.  */

     perror_with_name (filename);
   
     perror_with_name (filename);
   

+  /* FIXME: should be checking for errors from bfd_close (for one thing,
+     on error it does not free all the storage associated with the
+     bfd).  */

   make_cleanup (bfd_close, pbfd);
 
   QUIT;
   make_cleanup (bfd_close, pbfd);
 
   QUIT;


@@ -1063,7 +1182,7 @@ download(load_arg_string, from_tty)
               below starts writing before it even checks the size.  */
            continue;
 
               below starts writing before it even checks the size.  */
            continue;
 

-         printf("[Loading section %s at %x (%d bytes)]\n",
+         printf_unfiltered("[Loading section %s at %x (%d bytes)]\n",

                 section_name,
                 To.Offset,
                 section_size);
                 section_name,
                 To.Offset,
                 section_size);


@@ -1152,9 +1271,9 @@ download(load_arg_string, from_tty)
 
                  xerr = UDIGetErrorMsg(err, 100, message, &Count);
                  if (!xerr)
 
                  xerr = UDIGetErrorMsg(err, 100, message, &Count);
                  if (!xerr)

-                   fprintf (stderr, "Error is %s\n", message);
+                   fprintf_unfiltered (gdb_stderr, "Error is %s\n", message);

                  else
                  else

-                   fprintf (stderr, "xerr is %d\n", xerr);
+                   fprintf_unfiltered (gdb_stderr, "xerr is %d\n", xerr);

                  error ("UDICopy failed, error = %d", err);
                }
            }
                  error ("UDICopy failed, error = %d", err);
                }
            }


@@ -1168,18 +1287,23 @@ download(load_arg_string, from_tty)
   immediate_quit--;
 }
 
   immediate_quit--;
 }
 

-/* User interface to download an image into the remote target.  See download()
- * for details on args.
- */
+/* Function to download an image into the remote target.  */

 
 static void
 
 static void

-udi_load(args, from_tty)
+udi_load (args, from_tty)

      char *args;
      int from_tty;
 {
   download (args, from_tty);
 
      char *args;
      int from_tty;
 {
   download (args, from_tty);
 

-  symbol_file_add (strtok (args, " \t"), from_tty, 0, 0, 0, 0);
+  /* As a convenience, pick up any symbol info that is in the program
+     being loaded.  Note that we assume that the program is the``mainline'';
+     if this is not always true, then this code will need to be augmented.  */
+  symbol_file_add (strtok (args, " \t"), from_tty, 0, 1, 0, 0);
+
+  /* Getting new symbols may change our opinion about what is
+     frameless.  */
+  reinit_frame_cache ();

 }
 
 /*************************************************** UDI_WRITE_INFERIOR_MEMORY
 }
 
 /*************************************************** UDI_WRITE_INFERIOR_MEMORY


@@ -1207,7 +1331,7 @@ udi_write_inferior_memory (memaddr, myaddr, len)
        if (Count > MAXDATA) Count = MAXDATA;
        To.Offset = memaddr + nwritten;
         if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian))
        if (Count > MAXDATA) Count = MAXDATA;
        To.Offset = memaddr + nwritten;
         if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian))

-       {  error("UDIWrite() failed in udi_write_inferrior_memory");
+       {  error("UDIWrite() failed in udi_write_inferior_memory");

           break;       
        }
        else
           break;       
        }
        else


@@ -1244,7 +1368,7 @@ udi_read_inferior_memory(memaddr, myaddr, len)
        if (Count > MAXDATA) Count = MAXDATA;
        From.Offset = memaddr + nread;
         if(err = UDIRead(From, To, Count, Size, &CountDone, HostEndian))
        if (Count > MAXDATA) Count = MAXDATA;
        From.Offset = memaddr + nread;
         if(err = UDIRead(From, To, Count, Size, &CountDone, HostEndian))

-       {  error("UDIRead() failed in udi_read_inferrior_memory");
+       {  error("UDIRead() failed in udi_read_inferior_memory");

           break;       
        }
        else
           break;       
        }
        else


@@ -1310,7 +1434,8 @@ fetch_register (regno)
   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)  
     {
       int val = -1;
   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)  
     {
       int val = -1;

-      supply_register(160 + (regno - FPE_REGNUM),(char *) &val);
+      /*supply_register(160 + (regno - FPE_REGNUM),(char *) &val);*/
+      supply_register(regno, (char *) &val);

       return;          /* Pretend Success */
     }
   else 
       return;          /* Pretend Success */
     }
   else 


@@ -1324,8 +1449,8 @@ fetch_register (regno)
 
   supply_register(regno, (char *) &To);
 
 
   supply_register(regno, (char *) &To);
 

-  if (kiodebug)
-    printf("Fetching register %s = 0x%x\n", reg_names[regno], To);
+  if (remote_debug)
+    printf_unfiltered("Fetching register %s = 0x%x\n", reg_names[regno], To);

 }
 /*****************************************************************************/ 
 /* Store a single register indicated by 'regno'. 
 }
 /*****************************************************************************/ 
 /* Store a single register indicated by 'regno'. 


@@ -1345,53 +1470,68 @@ store_register (regno)
 
   From =  read_register (regno);       /* get data value */
 
 
   From =  read_register (regno);       /* get data value */
 

-  if (kiodebug)
-    printf("Storing register %s = 0x%x\n", reg_names[regno], From);
+  if (remote_debug)
+    printf_unfiltered("Storing register %s = 0x%x\n", reg_names[regno], From);

 
   if (regno == GR1_REGNUM)
 
   if (regno == GR1_REGNUM)

-  { To.Space = UDI29KGlobalRegs;
-    To.Offset = 1;
-    result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
-    /* Setting GR1 changes the numbers of all the locals, so invalidate the 
-     * register cache.  Do this *after* calling read_register, because we want 
-     * read_register to return the value that write_register has just stuffed 
-     * into the registers array, not the value of the register fetched from 
-     * the inferior.  
-     */
-    registers_changed ();
-  }
+    {
+      To.Space = UDI29KGlobalRegs;
+      To.Offset = 1;
+      result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
+      /* Setting GR1 changes the numbers of all the locals, so invalidate the 
+       * register cache.  Do this *after* calling read_register, because we want 
+       * read_register to return the value that write_register has just stuffed 
+       * into the registers array, not the value of the register fetched from 
+       * the inferior.  
+       */
+      registers_changed ();
+    }

 #if defined(GR64_REGNUM)
   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
 #if defined(GR64_REGNUM)
   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )

-  { To.Space = UDI29KGlobalRegs;
-    To.Offset = (regno - GR64_REGNUM) + 64;
-    result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
-  }
+    {
+      To.Space = UDI29KGlobalRegs;
+      To.Offset = (regno - GR64_REGNUM) + 64;
+      result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
+    }

 #endif /* GR64_REGNUM */
   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
 #endif /* GR64_REGNUM */
   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)

-  { To.Space = UDI29KGlobalRegs;
-    To.Offset = (regno - GR96_REGNUM) + 96;
-    result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
-  }
+    {
+      To.Space = UDI29KGlobalRegs;
+      To.Offset = (regno - GR96_REGNUM) + 96;
+      result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
+    }

   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)

-  { To.Space = UDI29KLocalRegs;
-    To.Offset = (regno - LR0_REGNUM);
-    result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
-  }
-  else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)  
-  { 
+    {
+      To.Space = UDI29KLocalRegs;
+      To.Offset = (regno - LR0_REGNUM);
+      result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
+    }
+  else if (regno >= FPE_REGNUM && regno <= EXO_REGNUM)  

     return 0;          /* Pretend Success */
     return 0;          /* Pretend Success */

-  }
+  else if (regno == PC_REGNUM)
+    {    
+      /* PC1 via UDI29KPC */
+
+      To.Space = UDI29KPC;
+      To.Offset = 0;           /* PC1 */
+      result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian);
+
+      /* Writing to this loc actually changes the values of pc0 & pc1 */
+
+      register_valid[PC_REGNUM] = 0; /* pc1 */
+      register_valid[NPC_REGNUM] = 0; /* pc0 */
+    }

   else         /* An unprotected or protected special register */
   else         /* An unprotected or protected special register */

-  { To.Space = UDI29KSpecialRegs;
-    To.Offset = regnum_to_srnum(regno); 
-    result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
-  }
+    {
+      To.Space = UDI29KSpecialRegs;
+      To.Offset = regnum_to_srnum(regno); 
+      result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
+    }

 
 

-  if(result)
-  { result = -1;
+  if (result != 0)

     error("UDIWrite() failed in store_registers");
     error("UDIWrite() failed in store_registers");

-  }
-  return result;
+
+  return 0;

 }
 /********************************************************** REGNUM_TO_SRNUM */
 /* 
 }
 /********************************************************** REGNUM_TO_SRNUM */
 /* 


@@ -1465,9 +1605,17 @@ CORE_ADDR        addr;
 
 void  convert16() {;}
 void  convert32() {;}
 
 void  convert16() {;}
 void  convert32() {;}

-FILE* EchoFile = 0;            /* used for debugging */
+GDB_FILE * EchoFile = 0;               /* used for debugging */

 int   QuietMode = 0;           /* used for debugging */
 \f
 int   QuietMode = 0;           /* used for debugging */
 \f

+#ifdef NO_HIF_SUPPORT
+service_HIF(msg)
+     union msg_t *msg;
+{
+  return(0);                   /* Emulate a failure */
+}
+#endif
+\f

 /* Target_ops vector.  Not static because there does not seem to be
    any portable way to do a forward declaration of a static variable.
    The RS/6000 doesn't like "extern" followed by "static"; SunOS
 /* Target_ops vector.  Not static because there does not seem to be
    any portable way to do a forward declaration of a static variable.
    The RS/6000 doesn't like "extern" followed by "static"; SunOS


@@ -1514,12 +1662,13 @@ Arguments are\n\
        0,                      /* terminal_ours */
        0,                      /* terminal_info */
         udi_kill,              /* FIXME, kill */
        0,                      /* terminal_ours */
        0,                      /* terminal_info */
         udi_kill,              /* FIXME, kill */

-        udi_load,
+        udi_load,              /* to_load */

         0,                      /* lookup_symbol */
         udi_create_inferior,
         udi_mourn,             /* mourn_inferior FIXME */
        0,                      /* can_run */
        0,                      /* notice_signals */
         0,                      /* lookup_symbol */
         udi_create_inferior,
         udi_mourn,             /* mourn_inferior FIXME */
        0,                      /* can_run */
        0,                      /* notice_signals */

+        0,                     /* to_stop */

         process_stratum,
        0,                      /* next */
         1,                     /* has_all_memory */
         process_stratum,
        0,                      /* next */
         1,                     /* has_all_memory */


@@ -1532,22 +1681,8 @@ Arguments are\n\
        OPS_MAGIC,              /* Always the last thing */
 };
 
        OPS_MAGIC,              /* Always the last thing */
 };
 

-void _initialize_remote_udi()
+void
+_initialize_remote_udi ()

 {
   add_target (&udi_ops);
 {
   add_target (&udi_ops);

-  add_show_from_set (
-                    add_set_cmd ("remotedebug", no_class, var_boolean,
-                                 (char *)&kiodebug,
-                                 "Set debugging of UDI I/O.\n\
-When enabled, debugging info is displayed.",
-                                 &setlist),
-                    &showlist);

 }
 }

-
-#ifdef NO_HIF_SUPPORT
-service_HIF(msg)
-union msg_t    *msg;
-{
-       return(0);      /* Emulate a failure */
-}
-#endif