Subversion Repositories or1k

/* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.

/* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.

   Copyright 1990, 1991, 1992 Free Software Foundation, Inc.

   Copyright 1990, 1991, 1992 Free Software Foundation, Inc.

   Originally written by Daniel Mann at AMD.

   Originally written by Daniel Mann at AMD.

   This file is part of GDB.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   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

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2 of the License, or

   the Free Software Foundation; either version 2 of the License, or

   (at your option) any later version.

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330,

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

   Boston, MA 02111-1307, USA.  */

/* This is like remote.c but ecpects MiniMON to be running on the Am29000

/* This is like remote.c but ecpects MiniMON to be running on the Am29000

   target hardware.

   target hardware.

   - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this

   - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this

   file to gdb 3.95.  I was unable to get this working on sun3os4

   file to gdb 3.95.  I was unable to get this working on sun3os4

   with termio, only with sgtty.  Because we are only attempting to

   with termio, only with sgtty.  Because we are only attempting to

   use this module to debug our kernel, which is already loaded when

   use this module to debug our kernel, which is already loaded when

   gdb is started up, I did not code up the file downloading facilities.

   gdb is started up, I did not code up the file downloading facilities.

   As a result this module has only the stubs to download files.

   As a result this module has only the stubs to download files.

   You should get tagged at compile time if you need to make any

   You should get tagged at compile time if you need to make any

   changes/additions.  */

   changes/additions.  */

#include "defs.h"

#include "defs.h"

#include "inferior.h"

#include "inferior.h"

#include "gdb_wait.h"

#include "gdb_wait.h"

#include "value.h"

#include "value.h"

#include <ctype.h>

#include <ctype.h>

#include <fcntl.h>

#include <fcntl.h>

#include <signal.h>

#include <signal.h>

#include <errno.h>

#include <errno.h>

#include "gdb_string.h"

#include "gdb_string.h"

#include "terminal.h"

#include "terminal.h"

#include "minimon.h"

#include "minimon.h"

#include "target.h"

#include "target.h"

/* Offset of member MEMBER in a struct of type TYPE.  */

/* Offset of member MEMBER in a struct of type TYPE.  */

#define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)

#define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)

#define DRAIN_INPUT()   (msg_recv_serial((union msg_t*)0))

#define DRAIN_INPUT()   (msg_recv_serial((union msg_t*)0))

extern int stop_soon_quietly;   /* for wait_for_inferior */

extern int stop_soon_quietly;   /* for wait_for_inferior */

static void mm_resume ();

static void mm_resume ();

static void mm_fetch_registers ();

static void mm_fetch_registers ();

static int fetch_register ();

static int fetch_register ();

static void mm_store_registers ();

static void mm_store_registers ();

static int store_register ();

static int store_register ();

static int regnum_to_srnum ();

static int regnum_to_srnum ();

static void mm_close ();

static void mm_close ();

static char *msg_str ();

static char *msg_str ();

static char *error_msg_str ();

static char *error_msg_str ();

static int expect_msg ();

static int expect_msg ();

static void init_target_mm ();

static void init_target_mm ();

static int mm_memory_space ();

static int mm_memory_space ();

#define FREEZE_MODE     (read_register(CPS_REGNUM) && 0x400)

#define FREEZE_MODE     (read_register(CPS_REGNUM) && 0x400)

#define USE_SHADOW_PC   ((processor_type == a29k_freeze_mode) && FREEZE_MODE)

#define USE_SHADOW_PC   ((processor_type == a29k_freeze_mode) && FREEZE_MODE)

/* FIXME: Replace with `set remotedebug'.  */

/* FIXME: Replace with `set remotedebug'.  */

#define LLOG_FILE "minimon.log"

#define LLOG_FILE "minimon.log"

#if defined (LOG_FILE)

#if defined (LOG_FILE)

FILE *log_file;

FILE *log_file;

#endif

#endif

/*

/*

 * Size of message buffers.  I couldn't get memory reads to work when

 * Size of message buffers.  I couldn't get memory reads to work when

 * the byte_count was larger than 512 (it may be a baud rate problem).

 * the byte_count was larger than 512 (it may be a baud rate problem).

 */

 */

#define BUFER_SIZE  512

#define BUFER_SIZE  512

/*

/*

 * Size of data area in message buffer on the TARGET (remote system).

 * Size of data area in message buffer on the TARGET (remote system).

 */

 */

#define MAXDATA_T  (target_config.max_msg_size - \

#define MAXDATA_T  (target_config.max_msg_size - \

                        offsetof(struct write_r_msg_t,data[0]))

                        offsetof(struct write_r_msg_t,data[0]))

/*

/*

 * Size of data area in message buffer on the HOST (gdb).

 * Size of data area in message buffer on the HOST (gdb).

 */

 */

#define MAXDATA_H  (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))

#define MAXDATA_H  (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))

/*

/*

 * Defined as the minimum size of data areas of the two message buffers

 * Defined as the minimum size of data areas of the two message buffers

 */

 */

#define MAXDATA    (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)

#define MAXDATA    (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)

static char out_buf[BUFER_SIZE];

static char out_buf[BUFER_SIZE];

static char in_buf[BUFER_SIZE];

static char in_buf[BUFER_SIZE];

int msg_recv_serial ();

int msg_recv_serial ();

int msg_send_serial ();

int msg_send_serial ();

#define MAX_RETRIES 5000

#define MAX_RETRIES 5000

extern struct target_ops mm_ops;        /* Forward declaration */

extern struct target_ops mm_ops;        /* Forward declaration */

struct config_msg_t target_config;      /* HIF needs this */

struct config_msg_t target_config;      /* HIF needs this */

union msg_t *out_msg_buf = (union msg_t *) out_buf;

union msg_t *out_msg_buf = (union msg_t *) out_buf;

union msg_t *in_msg_buf = (union msg_t *) in_buf;

union msg_t *in_msg_buf = (union msg_t *) in_buf;

static int timeout = 5;

static int timeout = 5;

/* Descriptor for I/O to remote machine.  Initialize it to -1 so that

/* Descriptor for I/O to remote machine.  Initialize it to -1 so that

   mm_open knows that we don't have a file open when the program

   mm_open knows that we don't have a file open when the program

   starts.  */

   starts.  */

int mm_desc = -1;

int mm_desc = -1;

/* stream which is fdopen'd from mm_desc.  Only valid when

/* stream which is fdopen'd from mm_desc.  Only valid when

   mm_desc != -1.  */

   mm_desc != -1.  */

FILE *mm_stream;

FILE *mm_stream;

/* Called when SIGALRM signal sent due to alarm() timeout.  */

/* Called when SIGALRM signal sent due to alarm() timeout.  */

#ifndef HAVE_TERMIO

#ifndef HAVE_TERMIO

#ifndef __STDC__

#ifndef __STDC__

#ifndef volatile

#ifndef volatile

#define volatile

#define volatile

/**/

/**/

# endif

# endif

#endif

#endif

volatile int n_alarms;

volatile int n_alarms;

static void

static void

mm_timer ()

mm_timer ()

{

{

#if 0

#if 0

  if (kiodebug)

  if (kiodebug)

    printf ("mm_timer called\n");

    printf ("mm_timer called\n");

#endif

#endif

  n_alarms++;

  n_alarms++;

}

}

#endif  /* HAVE_TERMIO */

#endif  /* HAVE_TERMIO */

/* malloc'd name of the program on the remote system.  */

/* malloc'd name of the program on the remote system.  */

static char *prog_name = NULL;

static char *prog_name = NULL;

/* Number of SIGTRAPs we need to simulate.  That is, the next

/* Number of SIGTRAPs we need to simulate.  That is, the next

   NEED_ARTIFICIAL_TRAP calls to mm_wait should just return

   NEED_ARTIFICIAL_TRAP calls to mm_wait should just return

   SIGTRAP without actually waiting for anything.  */

   SIGTRAP without actually waiting for anything.  */

/**************************************************** REMOTE_CREATE_INFERIOR */

/**************************************************** REMOTE_CREATE_INFERIOR */

/* This is called not only when we first attach, but also when the

/* This is called not only when we first attach, but also when the

   user types "run" after having attached.  */

   user types "run" after having attached.  */

static void

static void

mm_create_inferior (execfile, args, env)

mm_create_inferior (execfile, args, env)

     char *execfile;

     char *execfile;

     char *args;

     char *args;

     char **env;

     char **env;

{

{

#define MAX_TOKENS 25

#define MAX_TOKENS 25

#define BUFFER_SIZE 256

#define BUFFER_SIZE 256

  int token_count;

  int token_count;

  int result;

  int result;

  char *token[MAX_TOKENS];

  char *token[MAX_TOKENS];

  char cmd_line[BUFFER_SIZE];

  char cmd_line[BUFFER_SIZE];

  if (args && *args)

  if (args && *args)

    error ("Can't pass arguments to remote mm process (yet).");

    error ("Can't pass arguments to remote mm process (yet).");

  if (execfile == 0 /* || exec_bfd == 0 */ )

  if (execfile == 0 /* || exec_bfd == 0 */ )

    error ("No executable file specified");

    error ("No executable file specified");

  if (!mm_stream)

  if (!mm_stream)

    {

    {

      printf ("Minimon not open yet.\n");

      printf ("Minimon not open yet.\n");

      return;

      return;

    }

    }

  /* On ultra3 (NYU) we assume the kernel is already running so there is

  /* On ultra3 (NYU) we assume the kernel is already running so there is

     no file to download.

     no file to download.

     FIXME: Fixed required here -> load your program, possibly with mm_load().

     FIXME: Fixed required here -> load your program, possibly with mm_load().

   */

   */

  printf_filtered ("\n\

  printf_filtered ("\n\

Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");

Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");

  /* We will get a task spawn event immediately.  */

  /* We will get a task spawn event immediately.  */

  init_wait_for_inferior ();

  init_wait_for_inferior ();

  clear_proceed_status ();

  clear_proceed_status ();

  stop_soon_quietly = 1;

  stop_soon_quietly = 1;

  proceed (-1, TARGET_SIGNAL_DEFAULT, 0);

  proceed (-1, TARGET_SIGNAL_DEFAULT, 0);

  normal_stop ();

  normal_stop ();

}

}

/**************************************************** REMOTE_MOURN_INFERIOR */

/**************************************************** REMOTE_MOURN_INFERIOR */

static void

static void

mm_mourn ()

mm_mourn ()

{

{

  pop_target ();                /* Pop back to no-child state */

  pop_target ();                /* Pop back to no-child state */

  generic_mourn_inferior ();

  generic_mourn_inferior ();

}

}

/********************************************************************** damn_b

/********************************************************************** damn_b

*/

*/

/* Translate baud rates from integers to damn B_codes.  Unix should

/* Translate baud rates from integers to damn B_codes.  Unix should

   have outgrown this crap years ago, but even POSIX wouldn't buck it.  */

   have outgrown this crap years ago, but even POSIX wouldn't buck it.  */

#ifndef B19200

#ifndef B19200

#define B19200 EXTA

#define B19200 EXTA

#endif

#endif

#ifndef B38400

#ifndef B38400

#define B38400 EXTB

#define B38400 EXTB

#endif

#endif

static struct

static struct

{

{

  int rate, damn_b;

  int rate, damn_b;

}

}

baudtab[] =

baudtab[] =

{

{

  {

  {

    0, B0

    0, B0

  }

  }

  ,

  ,

  {

  {

    50, B50

    50, B50

  }

  }

  ,

  ,

  {

  {

    75, B75

    75, B75

  }

  }

  ,

  ,

  {

  {

    110, B110

    110, B110

  }

  }

  ,

  ,

  {

  {

    134, B134

    134, B134

  }

  }

  ,

  ,

  {

  {

    150, B150

    150, B150

  }

  }

  ,

  ,

  {

  {

    200, B200

    200, B200

  }

  }

  ,

  ,

  {

  {

    300, B300

    300, B300

  }

  }

  ,

  ,

  {

  {

    600, B600

    600, B600

  }

  }

  ,

  ,

  {

  {

    1200, B1200

    1200, B1200

  }

  }

  ,

  ,

  {

  {

    1800, B1800

    1800, B1800

  }

  }

  ,

  ,

  {

  {

    2400, B2400

    2400, B2400

  }

  }

  ,

  ,

  {

  {

    4800, B4800

    4800, B4800

  }

  }

  ,

  ,

  {

  {

    9600, B9600

    9600, B9600

  }

  }

  ,

  ,

  {

  {

    19200, B19200

    19200, B19200

  }

  }

  ,

  ,

  {

  {

    38400, B38400

    38400, B38400

  }

  }

  ,

  ,

  {

  {

    -1, -1

    -1, -1

  }

  }

  ,

  ,

};

};

static int

static int

damn_b (rate)

damn_b (rate)

     int rate;

     int rate;

{

{

  int i;

  int i;

  for (i = 0; baudtab[i].rate != -1; i++)

  for (i = 0; baudtab[i].rate != -1; i++)

    if (rate == baudtab[i].rate)

    if (rate == baudtab[i].rate)

      return baudtab[i].damn_b;

      return baudtab[i].damn_b;

  return B38400;                /* Random */

  return B38400;                /* Random */

}

}

/***************************************************************** REMOTE_OPEN

/***************************************************************** REMOTE_OPEN

** Open a connection to remote minimon.

** Open a connection to remote minimon.

   NAME is the filename used for communication, then a space,

   NAME is the filename used for communication, then a space,

   then the baud rate.

   then the baud rate.

   'target adapt /dev/ttya 9600 [prognam]' for example.

   'target adapt /dev/ttya 9600 [prognam]' for example.

 */

 */

static char *dev_name;

static char *dev_name;

int baudrate = 9600;

int baudrate = 9600;

static void

static void

mm_open (name, from_tty)

mm_open (name, from_tty)

     char *name;

     char *name;

     int from_tty;

     int from_tty;

{

{

  TERMINAL sg;

  TERMINAL sg;

  unsigned int prl;

  unsigned int prl;

  char *p;

  char *p;

  /* Find the first whitespace character, it separates dev_name from

  /* Find the first whitespace character, it separates dev_name from

     prog_name.  */

     prog_name.  */

  for (p = name;

  for (p = name;

       p && *p && !isspace (*p); p++)

       p && *p && !isspace (*p); p++)

    ;

    ;

  if (p == 0 || *p == '\0')

  if (p == 0 || *p == '\0')

  erroid:

  erroid:

    error ("Usage : <command> <serial-device> <baud-rate> [progname]");

    error ("Usage : <command> <serial-device> <baud-rate> [progname]");

  dev_name = (char *) xmalloc (p - name + 1);

  dev_name = (char *) xmalloc (p - name + 1);

  strncpy (dev_name, name, p - name);

  strncpy (dev_name, name, p - name);

  dev_name[p - name] = '\0';

  dev_name[p - name] = '\0';

  /* Skip over the whitespace after dev_name */

  /* Skip over the whitespace after dev_name */

  for (; isspace (*p); p++)

  for (; isspace (*p); p++)

    /*EMPTY */ ;

    /*EMPTY */ ;

  if (1 != sscanf (p, "%d ", &baudrate))

  if (1 != sscanf (p, "%d ", &baudrate))

    goto erroid;

    goto erroid;

  /* Skip the number and then the spaces */

  /* Skip the number and then the spaces */

  for (; isdigit (*p); p++)

  for (; isdigit (*p); p++)

    /*EMPTY */ ;

    /*EMPTY */ ;

  for (; isspace (*p); p++)

  for (; isspace (*p); p++)

    /*EMPTY */ ;

    /*EMPTY */ ;

  if (prog_name != NULL)

  if (prog_name != NULL)

    free (prog_name);

    free (prog_name);

  prog_name = savestring (p, strlen (p));

  prog_name = savestring (p, strlen (p));

  if (mm_desc >= 0)

  if (mm_desc >= 0)

    close (mm_desc);

    close (mm_desc);

  mm_desc = open (dev_name, O_RDWR);

  mm_desc = open (dev_name, O_RDWR);

  if (mm_desc < 0)

  if (mm_desc < 0)

    perror_with_name (dev_name);

    perror_with_name (dev_name);

  ioctl (mm_desc, TIOCGETP, &sg);

  ioctl (mm_desc, TIOCGETP, &sg);

#ifdef HAVE_TERMIO

#ifdef HAVE_TERMIO

  sg.c_cc[VMIN] = 0;             /* read with timeout.  */

  sg.c_cc[VMIN] = 0;             /* read with timeout.  */

  sg.c_cc[VTIME] = timeout * 10;

  sg.c_cc[VTIME] = timeout * 10;

  sg.c_lflag &= ~(ICANON | ECHO);

  sg.c_lflag &= ~(ICANON | ECHO);

  sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);

  sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);

#else

#else

  sg.sg_ispeed = damn_b (baudrate);

  sg.sg_ispeed = damn_b (baudrate);

  sg.sg_ospeed = damn_b (baudrate);

  sg.sg_ospeed = damn_b (baudrate);

  sg.sg_flags |= RAW;

  sg.sg_flags |= RAW;

  sg.sg_flags |= ANYP;

  sg.sg_flags |= ANYP;

  sg.sg_flags &= ~ECHO;

  sg.sg_flags &= ~ECHO;

#endif

#endif

  ioctl (mm_desc, TIOCSETP, &sg);

  ioctl (mm_desc, TIOCSETP, &sg);

  mm_stream = fdopen (mm_desc, "r+");

  mm_stream = fdopen (mm_desc, "r+");

  push_target (&mm_ops);

  push_target (&mm_ops);

#ifndef HAVE_TERMIO

#ifndef HAVE_TERMIO

#ifndef NO_SIGINTERRUPT

#ifndef NO_SIGINTERRUPT

  /* Cause SIGALRM's to make reads fail with EINTR instead of resuming

  /* Cause SIGALRM's to make reads fail with EINTR instead of resuming

     the read.  */

     the read.  */

  if (siginterrupt (SIGALRM, 1) != 0)

  if (siginterrupt (SIGALRM, 1) != 0)

    perror ("mm_open: error in siginterrupt");

    perror ("mm_open: error in siginterrupt");

#endif

#endif

  /* Set up read timeout timer.  */

  /* Set up read timeout timer.  */

  if ((void (*)) signal (SIGALRM, mm_timer) == (void (*)) -1)

  if ((void (*)) signal (SIGALRM, mm_timer) == (void (*)) -1)

    perror ("mm_open: error in signal");

    perror ("mm_open: error in signal");

#endif

#endif

#if defined (LOG_FILE)

#if defined (LOG_FILE)

  log_file = fopen (LOG_FILE, "w");

  log_file = fopen (LOG_FILE, "w");

  if (log_file == NULL)

  if (log_file == NULL)

    perror_with_name (LOG_FILE);

    perror_with_name (LOG_FILE);

#endif

#endif

  /*

  /*

     ** Initialize target configuration structure (global)

     ** Initialize target configuration structure (global)

   */

   */

  DRAIN_INPUT ();

  DRAIN_INPUT ();

  out_msg_buf->config_req_msg.code = CONFIG_REQ;

  out_msg_buf->config_req_msg.code = CONFIG_REQ;

  out_msg_buf->config_req_msg.length = 4 * 0;

  out_msg_buf->config_req_msg.length = 4 * 0;

  msg_send_serial (out_msg_buf);        /* send config request message */

  msg_send_serial (out_msg_buf);        /* send config request message */

  expect_msg (CONFIG, in_msg_buf, 1);

  expect_msg (CONFIG, in_msg_buf, 1);

  a29k_get_processor_type ();

  a29k_get_processor_type ();

  /* Print out some stuff, letting the user now what's going on */

  /* Print out some stuff, letting the user now what's going on */

  printf_filtered ("Connected to MiniMon via %s.\n", dev_name);

  printf_filtered ("Connected to MiniMon via %s.\n", dev_name);

  /* FIXME: can this restriction be removed? */

  /* FIXME: can this restriction be removed? */

  printf_filtered ("Remote debugging using virtual addresses works only\n");

  printf_filtered ("Remote debugging using virtual addresses works only\n");

  printf_filtered ("\twhen virtual addresses map 1:1 to physical addresses.\n")

  printf_filtered ("\twhen virtual addresses map 1:1 to physical addresses.\n")

    ;

    ;

  if (processor_type != a29k_freeze_mode)

  if (processor_type != a29k_freeze_mode)

    {

    {

      fprintf_filtered (gdb_stderr,

      fprintf_filtered (gdb_stderr,

                        "Freeze-mode debugging not available, and can only be done on an A29050.\n");

                        "Freeze-mode debugging not available, and can only be done on an A29050.\n");

    }

    }

  target_config.code = CONFIG;

  target_config.code = CONFIG;

  target_config.length = 0;

  target_config.length = 0;

  target_config.processor_id = in_msg_buf->config_msg.processor_id;

  target_config.processor_id = in_msg_buf->config_msg.processor_id;

  target_config.version = in_msg_buf->config_msg.version;

  target_config.version = in_msg_buf->config_msg.version;

  target_config.I_mem_start = in_msg_buf->config_msg.I_mem_start;

  target_config.I_mem_start = in_msg_buf->config_msg.I_mem_start;

  target_config.I_mem_size = in_msg_buf->config_msg.I_mem_size;

  target_config.I_mem_size = in_msg_buf->config_msg.I_mem_size;

  target_config.D_mem_start = in_msg_buf->config_msg.D_mem_start;

  target_config.D_mem_start = in_msg_buf->config_msg.D_mem_start;

  target_config.D_mem_size = in_msg_buf->config_msg.D_mem_size;

  target_config.D_mem_size = in_msg_buf->config_msg.D_mem_size;

  target_config.ROM_start = in_msg_buf->config_msg.ROM_start;

  target_config.ROM_start = in_msg_buf->config_msg.ROM_start;

  target_config.ROM_size = in_msg_buf->config_msg.ROM_size;

  target_config.ROM_size = in_msg_buf->config_msg.ROM_size;

  target_config.max_msg_size = in_msg_buf->config_msg.max_msg_size;

  target_config.max_msg_size = in_msg_buf->config_msg.max_msg_size;

  target_config.max_bkpts = in_msg_buf->config_msg.max_bkpts;

  target_config.max_bkpts = in_msg_buf->config_msg.max_bkpts;

  target_config.coprocessor = in_msg_buf->config_msg.coprocessor;

  target_config.coprocessor = in_msg_buf->config_msg.coprocessor;

  target_config.reserved = in_msg_buf->config_msg.reserved;

  target_config.reserved = in_msg_buf->config_msg.reserved;

  if (from_tty)

  if (from_tty)

    {

    {

      printf ("Connected to MiniMON :\n");

      printf ("Connected to MiniMON :\n");

      printf ("    Debugcore version            %d.%d\n",

      printf ("    Debugcore version            %d.%d\n",

              0x0f & (target_config.version >> 4),

              0x0f & (target_config.version >> 4),

              0x0f & (target_config.version));

              0x0f & (target_config.version));

      printf ("    Configuration version        %d.%d\n",

      printf ("    Configuration version        %d.%d\n",

              0x0f & (target_config.version >> 12),

              0x0f & (target_config.version >> 12),

              0x0f & (target_config.version >> 8));

              0x0f & (target_config.version >> 8));

      printf ("    Message system version       %d.%d\n",

      printf ("    Message system version       %d.%d\n",

              0x0f & (target_config.version >> 20),

              0x0f & (target_config.version >> 20),

              0x0f & (target_config.version >> 16));

              0x0f & (target_config.version >> 16));

      printf ("    Communication driver version %d.%d\n",

      printf ("    Communication driver version %d.%d\n",

              0x0f & (target_config.version >> 28),

              0x0f & (target_config.version >> 28),

              0x0f & (target_config.version >> 24));

              0x0f & (target_config.version >> 24));

    }

    }

  /* Leave the target running...

  /* Leave the target running...

   * The above message stopped the target in the dbg core (MiniMon),

   * The above message stopped the target in the dbg core (MiniMon),

   * so restart the target out of MiniMon,

   * so restart the target out of MiniMon,

   */

   */

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.length = 0;

  out_msg_buf->go_msg.length = 0;

  msg_send_serial (out_msg_buf);

  msg_send_serial (out_msg_buf);

  /* No message to expect after a GO */

  /* No message to expect after a GO */

}

}

/**************************************************************** REMOTE_CLOSE

/**************************************************************** REMOTE_CLOSE

** Close the open connection to the minimon debugger.

** Close the open connection to the minimon debugger.

   Use this when you want to detach and do something else

   Use this when you want to detach and do something else

   with your gdb.  */

   with your gdb.  */

static void

static void

mm_close (quitting)             /*FIXME: how is quitting used */

mm_close (quitting)             /*FIXME: how is quitting used */

     int quitting;

     int quitting;

{

{

  if (mm_desc < 0)

  if (mm_desc < 0)

    error ("Can't close remote connection: not debugging remotely.");

    error ("Can't close remote connection: not debugging remotely.");

  /* We should never get here if there isn't something valid in

  /* We should never get here if there isn't something valid in

     mm_desc and mm_stream.

     mm_desc and mm_stream.

     Due to a bug in Unix, fclose closes not only the stdio stream,

     Due to a bug in Unix, fclose closes not only the stdio stream,

     but also the file descriptor.  So we don't actually close

     but also the file descriptor.  So we don't actually close

     mm_desc.  */

     mm_desc.  */

  DRAIN_INPUT ();

  DRAIN_INPUT ();

  fclose (mm_stream);

  fclose (mm_stream);

  /* close (mm_desc); */

  /* close (mm_desc); */

  /* Do not try to close mm_desc again, later in the program.  */

  /* Do not try to close mm_desc again, later in the program.  */

  mm_stream = NULL;

  mm_stream = NULL;

  mm_desc = -1;

  mm_desc = -1;

#if defined (LOG_FILE)

#if defined (LOG_FILE)

  if (ferror (log_file))

  if (ferror (log_file))

    printf ("Error writing log file.\n");

    printf ("Error writing log file.\n");

  if (fclose (log_file) != 0)

  if (fclose (log_file) != 0)

    printf ("Error closing log file.\n");

    printf ("Error closing log file.\n");

#endif

#endif

  printf ("Ending remote debugging\n");

  printf ("Ending remote debugging\n");

}

}

/************************************************************* REMOTE_ATACH */

/************************************************************* REMOTE_ATACH */

/* Attach to a program that is already loaded and running

/* Attach to a program that is already loaded and running

 * Upon exiting the process's execution is stopped.

 * Upon exiting the process's execution is stopped.

 */

 */

static void

static void

mm_attach (args, from_tty)

mm_attach (args, from_tty)

     char *args;

     char *args;

     int from_tty;

     int from_tty;

{

{

  if (!mm_stream)

  if (!mm_stream)

    error ("MiniMon not opened yet, use the 'target minimon' command.\n");

    error ("MiniMon not opened yet, use the 'target minimon' command.\n");

  if (from_tty)

  if (from_tty)

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

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

  /* Make sure the target is currently running, it is supposed to be. */

  /* Make sure the target is currently running, it is supposed to be. */

  /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in

  /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in

   *  the dbg core.  If so, we don't need to send this GO.

   *  the dbg core.  If so, we don't need to send this GO.

   */

   */

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.length = 0;

  out_msg_buf->go_msg.length = 0;

  msg_send_serial (out_msg_buf);

  msg_send_serial (out_msg_buf);

  sleep (2);                    /* At the worst it will stop, receive a message, continue */

  sleep (2);                    /* At the worst it will stop, receive a message, continue */

  /* Send the mm a break. */

  /* Send the mm a break. */

  out_msg_buf->break_msg.code = BREAK;

  out_msg_buf->break_msg.code = BREAK;

  out_msg_buf->break_msg.length = 0;

  out_msg_buf->break_msg.length = 0;

  msg_send_serial (out_msg_buf);

  msg_send_serial (out_msg_buf);

}

}

/********************************************************** REMOTE_DETACH */

/********************************************************** REMOTE_DETACH */

/* Terminate the open connection to the remote debugger.

/* Terminate the open connection to the remote debugger.

   Use this when you want to detach and do something else

   Use this when you want to detach and do something else

   with your gdb.  Leave remote process running (with no breakpoints set). */

   with your gdb.  Leave remote process running (with no breakpoints set). */

static void

static void

mm_detach (args, from_tty)

mm_detach (args, from_tty)

     char *args;

     char *args;

     int from_tty;

     int from_tty;

{

{

  remove_breakpoints ();        /* Just in case there were any left in */

  remove_breakpoints ();        /* Just in case there were any left in */

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.length = 0;

  out_msg_buf->go_msg.length = 0;

  msg_send_serial (out_msg_buf);

  msg_send_serial (out_msg_buf);

  pop_target ();                /* calls mm_close to do the real work */

  pop_target ();                /* calls mm_close to do the real work */

}

}

/*************************************************************** REMOTE_RESUME

/*************************************************************** REMOTE_RESUME

** Tell the remote machine to resume.  */

** Tell the remote machine to resume.  */

static void

static void

mm_resume (pid, step, sig)

mm_resume (pid, step, sig)

     int pid, step;

     int pid, step;

     enum target_signal sig;

     enum target_signal sig;

{

{

  if (sig != TARGET_SIGNAL_0)

  if (sig != TARGET_SIGNAL_0)

    warning ("Can't send signals to a remote MiniMon system.");

    warning ("Can't send signals to a remote MiniMon system.");

  if (step)

  if (step)

    {

    {

      out_msg_buf->step_msg.code = STEP;

      out_msg_buf->step_msg.code = STEP;

      out_msg_buf->step_msg.length = 1 * 4;

      out_msg_buf->step_msg.length = 1 * 4;

      out_msg_buf->step_msg.count = 1;  /* step 1 instruction */

      out_msg_buf->step_msg.count = 1;  /* step 1 instruction */

      msg_send_serial (out_msg_buf);

      msg_send_serial (out_msg_buf);

    }

    }

  else

  else

    {

    {

      out_msg_buf->go_msg.code = GO;

      out_msg_buf->go_msg.code = GO;

      out_msg_buf->go_msg.length = 0;

      out_msg_buf->go_msg.length = 0;

      msg_send_serial (out_msg_buf);

      msg_send_serial (out_msg_buf);

    }

    }

}

}

/***************************************************************** REMOTE_WAIT

/***************************************************************** REMOTE_WAIT

** Wait until the remote machine stops, then return,

** Wait until the remote machine stops, then return,

   storing status in STATUS just as `wait' would.  */

   storing status in STATUS just as `wait' would.  */

static int

static int

mm_wait (status)

mm_wait (status)

     struct target_waitstatus *status;

     struct target_waitstatus *status;

{

{

  int i, result;

  int i, result;

  int old_timeout = timeout;

  int old_timeout = timeout;

  int old_immediate_quit = immediate_quit;

  int old_immediate_quit = immediate_quit;

  status->kind = TARGET_WAITKIND_EXITED;

  status->kind = TARGET_WAITKIND_EXITED;

  status->value.integer = 0;

  status->value.integer = 0;

/* wait for message to arrive. It should be:

/* wait for message to arrive. It should be:

   - A HIF service request.