Subversion Repositories or1k

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

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,

   2001 Free Software Foundation, Inc.

   Originally written by Daniel Mann at AMD.

   This file is part of GDB.

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

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

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

   (at your option) any later version.

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

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

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

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

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

   Boston, MA 02111-1307, USA.  */

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

   target hardware.

   - 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

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

   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.

   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

   changes/additions.  */

#include "defs.h"

#include "inferior.h"

#include "value.h"

#include <ctype.h>

#include <fcntl.h>

#include <signal.h>

#include <errno.h>

#include "gdb_string.h"

#include "terminal.h"

#include "minimon.h"

#include "target.h"

#include "regcache.h"

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

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

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

extern int stop_soon_quietly;   /* for wait_for_inferior */

static void mm_resume (ptid_t ptid, int step, enum target_signal sig)

static void mm_fetch_registers ();

static int fetch_register ();

static void mm_store_registers ();

static int store_register ();

static int regnum_to_srnum ();

static void mm_close ();

static char *msg_str ();

static char *error_msg_str ();

static int expect_msg ();

static void init_target_mm ();

static int mm_memory_space ();

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

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

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

#define LLOG_FILE "minimon.log"

#if defined (LOG_FILE)

FILE *log_file;

#endif

/*

 * 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).

 */

#define BUFER_SIZE  512

/*

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

 */

#define MAXDATA_T  (target_config.max_msg_size - \

                        offsetof(struct write_r_msg_t,data[0]))

/*

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

 */

#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

 */

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

static char out_buf[BUFER_SIZE];

static char in_buf[BUFER_SIZE];

int msg_recv_serial ();

int msg_send_serial ();

#define MAX_RETRIES 5000

extern struct target_ops mm_ops;        /* Forward declaration */

struct config_msg_t target_config;      /* HIF needs this */

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

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

static int timeout = 5;

/* 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

   starts.  */

int mm_desc = -1;

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

   mm_desc != -1.  */

FILE *mm_stream;

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

#ifndef HAVE_TERMIO

volatile int n_alarms;

static void

mm_timer (void)

{

#if 0

  if (kiodebug)

    printf ("mm_timer called\n");

#endif

  n_alarms++;

}

#endif  /* HAVE_TERMIO */

/* 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 mm_wait should just return

   SIGTRAP without actually waiting for anything.  */

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

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

   user types "run" after having attached.  */

static void

mm_create_inferior (char *execfile, char *args, char **env)

{

#define MAX_TOKENS 25

#define BUFFER_SIZE 256

  int token_count;

  int result;

  char *token[MAX_TOKENS];

  char cmd_line[BUFFER_SIZE];

  if (args && *args)

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

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

    error ("No executable file specified");

  if (!mm_stream)

    {

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

      return;

    }

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

     no file to download.

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

   */

  printf_filtered ("\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.  */

  init_wait_for_inferior ();

  clear_proceed_status ();

  stop_soon_quietly = 1;

  proceed (-1, TARGET_SIGNAL_DEFAULT, 0);

  normal_stop ();

}

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

static void

mm_mourn (void)

{

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

  generic_mourn_inferior ();

}

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

*/

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

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

#ifndef B19200

#define B19200 EXTA

#endif

#ifndef B38400

#define B38400 EXTB

#endif

static struct

{

  int rate, damn_b;

}

baudtab[] =

{

  {

    0, B0

  }

  ,

  {

    50, B50

  }

  ,

  {

    75, B75

  }

  ,

  {

    110, B110

  }

  ,

  {

    134, B134

  }

  ,

  {

    150, B150

  }

  ,

  {

    200, B200

  }

  ,

  {

    300, B300

  }

  ,

  {

    600, B600

  }

  ,

  {

    1200, B1200

  }

  ,

  {

    1800, B1800

  }

  ,

  {

    2400, B2400

  }

  ,

  {

    4800, B4800

  }

  ,

  {

    9600, B9600

  }

  ,

  {

    19200, B19200

  }

  ,

  {

    38400, B38400

  }

  ,

  {

    -1, -1

  }

  ,

};

static int

damn_b (int rate)

{

  int i;

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

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

      return baudtab[i].damn_b;

  return B38400;                /* Random */

}

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

** Open a connection to remote minimon.

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

   then the baud rate.

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

 */

static char *dev_name;

int baudrate = 9600;

static void

mm_open (char *name, int from_tty)

{

  TERMINAL sg;

  unsigned int prl;

  char *p;

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

     prog_name.  */

  for (p = name;

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

    ;

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

  erroid:

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

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

  strncpy (dev_name, name, p - name);

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

  /* Skip over the whitespace after dev_name */

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

    /*EMPTY */ ;

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

    goto erroid;

  /* Skip the number and then the spaces */

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

    /*EMPTY */ ;

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

    /*EMPTY */ ;

  if (prog_name != NULL)

    xfree (prog_name);

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

  if (mm_desc >= 0)

    close (mm_desc);

  mm_desc = open (dev_name, O_RDWR);

  if (mm_desc < 0)

    perror_with_name (dev_name);

  ioctl (mm_desc, TIOCGETP, &sg);

#ifdef HAVE_TERMIO

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

  sg.c_cc[VTIME] = timeout * 10;

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

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

#else

  sg.sg_ispeed = damn_b (baudrate);

  sg.sg_ospeed = damn_b (baudrate);

  sg.sg_flags |= RAW;

  sg.sg_flags |= ANYP;

  sg.sg_flags &= ~ECHO;

#endif

  ioctl (mm_desc, TIOCSETP, &sg);

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

  push_target (&mm_ops);

#ifndef HAVE_TERMIO

#ifndef NO_SIGINTERRUPT

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

     the read.  */

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

    perror ("mm_open: error in siginterrupt");

#endif

  /* Set up read timeout timer.  */

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

    perror ("mm_open: error in signal");

#endif

#if defined (LOG_FILE)

  log_file = fopen (LOG_FILE, "w");

  if (log_file == NULL)

    perror_with_name (LOG_FILE);

#endif

  /*

     ** Initialize target configuration structure (global)

   */

  DRAIN_INPUT ();

  out_msg_buf->config_req_msg.code = CONFIG_REQ;

  out_msg_buf->config_req_msg.length = 4 * 0;

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

  expect_msg (CONFIG, in_msg_buf, 1);

  a29k_get_processor_type ();

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

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

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

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

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

    ;

  if (processor_type != a29k_freeze_mode)

    {

      fprintf_filtered (gdb_stderr,

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

    }

  target_config.code = CONFIG;

  target_config.length = 0;

  target_config.processor_id = in_msg_buf->config_msg.processor_id;

  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_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_size = in_msg_buf->config_msg.D_mem_size;

  target_config.ROM_start = in_msg_buf->config_msg.ROM_start;

  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_bkpts = in_msg_buf->config_msg.max_bkpts;

  target_config.coprocessor = in_msg_buf->config_msg.coprocessor;

  target_config.reserved = in_msg_buf->config_msg.reserved;

  if (from_tty)

    {

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

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

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

              0x0f & (target_config.version));

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

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

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

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

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

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

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

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

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

    }

  /* Leave the target running...

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

   * so restart the target out of MiniMon,

   */

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.length = 0;

  msg_send_serial (out_msg_buf);

  /* No message to expect after a GO */

}

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

** Close the open connection to the minimon debugger.

   Use this when you want to detach and do something else

   with your gdb.  */

static void

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

           int quitting)

{

  if (mm_desc < 0)

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

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

     mm_desc and mm_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

     mm_desc.  */

  DRAIN_INPUT ();

  fclose (mm_stream);

  /* close (mm_desc); */

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

  mm_stream = NULL;

  mm_desc = -1;

#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 ("Ending remote debugging\n");

}

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

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

 * Upon exiting the process's execution is stopped.

 */

static void

mm_attach (char *args, int from_tty)

{

  if (!mm_stream)

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

  if (from_tty)

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

  /* 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

   *  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.length = 0;

  msg_send_serial (out_msg_buf);

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

  /* Send the mm a break. */

  out_msg_buf->break_msg.code = BREAK;

  out_msg_buf->break_msg.length = 0;

  msg_send_serial (out_msg_buf);

}

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

/* Terminate the open connection to the remote debugger.

   Use this when you want to detach and do something else

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

static void

mm_detach (char *args, int from_tty)

{

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

  out_msg_buf->go_msg.code = GO;

  out_msg_buf->go_msg.length = 0;

  msg_send_serial (out_msg_buf);

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

}

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

** Tell the remote machine to resume.  */

static void

mm_resume (ptid_t ptid, int step, enum target_signal sig)

{

  if (sig != TARGET_SIGNAL_0)

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

  if (step)

    {

      out_msg_buf->step_msg.code = STEP;

      out_msg_buf->step_msg.length = 1 * 4;

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

      msg_send_serial (out_msg_buf);

    }

  else

    {

      out_msg_buf->go_msg.code = GO;

      out_msg_buf->go_msg.length = 0;

      msg_send_serial (out_msg_buf);

    }

}

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

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

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

static ptid_t

mm_wait (ptid_t ptid, struct target_waitstatus *status)

{

  int i, result;

  int old_timeout = timeout;

  int old_immediate_quit = immediate_quit;

  status->kind = TARGET_WAITKIND_EXITED;

  status->value.integer = 0;

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

   - A HIF service request.

   - A HIF exit service request.

   - A CHANNEL0_ACK.

   - A CHANNEL1 request.

   - a debugcore HALT message.

   HIF services must be responded too, and while-looping continued.

   If the target stops executing, mm_wait() should return.

 */

  timeout = 0;                   /* Wait indefinetly for a message */

  immediate_quit = 1;           /* Helps ability to QUIT */

  while (1)

    {

      while (msg_recv_serial (in_msg_buf))

        {

          QUIT;                 /* Let user quit if they want */

        }

      switch (in_msg_buf->halt_msg.code)

        {

        case HIF_CALL:

          i = in_msg_buf->hif_call_rtn_msg.service_number;

          result = service_HIF (in_msg_buf);

          if (i == 1)           /* EXIT */

            goto exit;

          if (result)

            printf ("Warning: failure during HIF service %d\n", i);

          break;

        case CHANNEL0_ACK:

          service_HIF (in_msg_buf);

          break;

        case CHANNEL1:

          i = in_msg_buf->channel1_msg.length;

          in_msg_buf->channel1_msg.data[i] = '\0';

          printf ("%s", in_msg_buf->channel1_msg.data);

          gdb_flush (gdb_stdout);

          /* Send CHANNEL1_ACK message */

          out_msg_buf->channel1_ack_msg.code = CHANNEL1_ACK;

          out_msg_buf->channel1_ack_msg.length = 0;

          result = msg_send_serial (out_msg_buf);

          break;

        case HALT:

          goto halted;

        default:

          goto halted;

        }

    }

halted:

  /* FIXME, these printfs should not be here.  This is a source level

     debugger, guys!  */

  if (in_msg_buf->halt_msg.trap_number == 0)

    {

      printf ("Am290*0 received vector number %d (break point)\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_TRAP;

    }

  else if (in_msg_buf->halt_msg.trap_number == 1)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_BUS;

    }

  else if (in_msg_buf->halt_msg.trap_number == 3

           || in_msg_buf->halt_msg.trap_number == 4)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_FPE;

    }

  else if (in_msg_buf->halt_msg.trap_number == 5)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_ILL;

    }

  else if (in_msg_buf->halt_msg.trap_number >= 6

           && in_msg_buf->halt_msg.trap_number <= 11)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_SEGV;

    }

  else if (in_msg_buf->halt_msg.trap_number == 12

           || in_msg_buf->halt_msg.trap_number == 13)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_ILL;

    }

  else if (in_msg_buf->halt_msg.trap_number == 14)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_ALRM;

    }

  else if (in_msg_buf->halt_msg.trap_number == 15)

    {

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_TRAP;

    }

  else if (in_msg_buf->halt_msg.trap_number >= 16

           && in_msg_buf->halt_msg.trap_number <= 21)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_INT;

    }

  else if (in_msg_buf->halt_msg.trap_number == 22)

    {

      printf ("Am290*0 received vector number %d\n",

              in_msg_buf->halt_msg.trap_number);

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_ILL;

    }                           /* BREAK message was sent */

  else if (in_msg_buf->halt_msg.trap_number == 75)

    {

      status->kind = TARGET_WAITKIND_STOPPED;

      status->value.sig = TARGET_SIGNAL_TRAP;

    }

  else

  exit:

    {

      status->kind = TARGET_WAITKIND_EXITED;

      status->value.integer = 0;

    }

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

  immediate_quit = old_immediate_quit;

  return inferior_ptid;

}

/******************************************************* REMOTE_FETCH_REGISTERS

 * Read a remote register 'regno'.