Subversion Repositories or1k

/* Remote debugging interface for Array Tech RAID controller..

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2001, 2002 Free Software Foundation, Inc.

   Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.

   This module talks to a debug monitor called 'MONITOR', which

   We communicate with MONITOR via either a direct serial line, or a TCP

   (or possibly TELNET) stream to a terminal multiplexor,

   which in turn talks to the target board.

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

#include "defs.h"

#include "gdbcore.h"

#include "target.h"

#include <ctype.h>

#include <sys/types.h>

#include "gdb_string.h"

#include "command.h"

#include "serial.h"

#include "monitor.h"

#include "remote-utils.h"

#include "inferior.h"

#include "version.h"

#include "regcache.h"

extern int baud_rate;

#define ARRAY_PROMPT ">> "

static void debuglogs (int, char *, ...);

static void array_open ();

static void array_close ();

static void array_detach ();

static void array_attach ();

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

static void array_fetch_register ();

static void array_store_register ();

static void array_fetch_registers ();

static void array_store_registers ();

static void array_prepare_to_store ();

static void array_files_info ();

static void array_kill ();

static void array_create_inferior ();

static void array_mourn_inferior ();

static void make_gdb_packet ();

static int array_xfer_memory ();

static ptid_t array_wait (ptid_t ptid,

                                 struct target_waitstatus *status);

static int array_insert_breakpoint ();

static int array_remove_breakpoint ();

static int tohex ();

static int to_hex ();

static int from_hex ();

static int array_send_packet ();

static int array_get_packet ();

static unsigned long ascii2hexword ();

static void hexword2ascii ();

#define LOG_FILE "monitor.log"

#if defined (LOG_FILE)

FILE *log_file;

#endif

static int timeout = 30;

/* Having this larger than 400 causes us to be incompatible with m68k-stub.c

   and i386-stub.c.  Normally, no one would notice because it only matters

   for writing large chunks of memory (e.g. in downloads).  Also, this needs

   to be more than 400 if required to hold the registers (see below, where

   we round it up based on REGISTER_BYTES).  */

#define PBUFSIZ 400

/*

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

 * array_open knows that we don't have a file open when the program starts.

 */

struct serial *array_desc = NULL;

/*

 * this array of registers need to match the indexes used by GDB. The

 * whole reason this exists is cause the various ROM monitors use

 * different strings than GDB does, and doesn't support all the

 * registers either. So, typing "info reg sp" becomes a "r30".

 */

extern char *tmp_mips_processor_type;

extern int mips_set_processor_type ();

static struct target_ops array_ops;

static void

init_array_ops (void)

{

  array_ops.to_shortname = "array";

  array_ops.to_longname =

    "Debug using the standard GDB remote protocol for the Array Tech target.",

    array_ops.to_doc =

    "Debug using the standard GDB remote protocol for the Array Tech target.\n\

Specify the serial device it is connected to (e.g. /dev/ttya).";

  array_ops.to_open = array_open;

  array_ops.to_close = array_close;

  array_ops.to_attach = NULL;

  array_ops.to_post_attach = NULL;

  array_ops.to_require_attach = NULL;

  array_ops.to_detach = array_detach;

  array_ops.to_require_detach = NULL;

  array_ops.to_resume = array_resume;

  array_ops.to_wait = array_wait;

  array_ops.to_post_wait = NULL;

  array_ops.to_fetch_registers = array_fetch_registers;

  array_ops.to_store_registers = array_store_registers;

  array_ops.to_prepare_to_store = array_prepare_to_store;

  array_ops.to_xfer_memory = array_xfer_memory;

  array_ops.to_files_info = array_files_info;

  array_ops.to_insert_breakpoint = array_insert_breakpoint;

  array_ops.to_remove_breakpoint = array_remove_breakpoint;

  array_ops.to_terminal_init = 0;

  array_ops.to_terminal_inferior = 0;

  array_ops.to_terminal_ours_for_output = 0;

  array_ops.to_terminal_ours = 0;

  array_ops.to_terminal_info = 0;

  array_ops.to_kill = array_kill;

  array_ops.to_load = 0;

  array_ops.to_lookup_symbol = 0;

  array_ops.to_create_inferior = array_create_inferior;

  array_ops.to_post_startup_inferior = NULL;

  array_ops.to_acknowledge_created_inferior = NULL;

  array_ops.to_clone_and_follow_inferior = NULL;

  array_ops.to_post_follow_inferior_by_clone = NULL;

  array_ops.to_insert_fork_catchpoint = NULL;

  array_ops.to_remove_fork_catchpoint = NULL;

  array_ops.to_insert_vfork_catchpoint = NULL;

  array_ops.to_remove_vfork_catchpoint = NULL;

  array_ops.to_has_forked = NULL;

  array_ops.to_has_vforked = NULL;

  array_ops.to_can_follow_vfork_prior_to_exec = NULL;

  array_ops.to_post_follow_vfork = NULL;

  array_ops.to_insert_exec_catchpoint = NULL;

  array_ops.to_remove_exec_catchpoint = NULL;

  array_ops.to_has_execd = NULL;

  array_ops.to_reported_exec_events_per_exec_call = NULL;

  array_ops.to_has_exited = NULL;

  array_ops.to_mourn_inferior = array_mourn_inferior;

  array_ops.to_can_run = 0;

  array_ops.to_notice_signals = 0;

  array_ops.to_thread_alive = 0;

  array_ops.to_stop = 0;

  array_ops.to_pid_to_exec_file = NULL;

  array_ops.to_stratum = process_stratum;

  array_ops.DONT_USE = 0;

  array_ops.to_has_all_memory = 1;

  array_ops.to_has_memory = 1;

  array_ops.to_has_stack = 1;

  array_ops.to_has_registers = 1;

  array_ops.to_has_execution = 1;

  array_ops.to_sections = 0;

  array_ops.to_sections_end = 0;

  array_ops.to_magic = OPS_MAGIC;

};

/*

 * printf_monitor -- send data to monitor.  Works just like printf.

 */

static void

printf_monitor (char *pattern,...)

{

  va_list args;

  char buf[PBUFSIZ];

  int i;

  va_start (args, pattern);

  vsprintf (buf, pattern, args);

  debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf);

  if (strlen (buf) > PBUFSIZ)

    error ("printf_monitor(): string too long");

  if (serial_write (array_desc, buf, strlen (buf)))

    fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",

                        safe_strerror (errno));

}

/*

 * write_monitor -- send raw data to monitor.

 */

static void

write_monitor (char data[], int len)

{

  if (serial_write (array_desc, data, len))

    fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",

                        safe_strerror (errno));

  *(data + len + 1) = '\0';

  debuglogs (1, "write_monitor(), Sending: \"%s\".", data);

}

/*

 * debuglogs -- deal with debugging info to multiple sources. This takes

 *      two real args, the first one is the level to be compared against

 *      the sr_get_debug() value, the second arg is a printf buffer and args

 *      to be formatted and printed. A CR is added after each string is printed.

 */

static void

debuglogs (int level, char *pattern,...)

{

  va_list args;

  char *p;

  unsigned char buf[PBUFSIZ];

  char newbuf[PBUFSIZ];

  int i;

  va_start (args, pattern);

  if ((level < 0) || (level > 100))

    {

      error ("Bad argument passed to debuglogs(), needs debug level");

      return;

    }

  vsprintf (buf, pattern, args);        /* format the string */

  /* convert some characters so it'll look right in the log */

  p = newbuf;

  for (i = 0; buf[i] != '\0'; i++)

    {

      if (i > PBUFSIZ)

        error ("Debug message too long");

      switch (buf[i])

        {

        case '\n':              /* newlines */

          *p++ = '\\';

          *p++ = 'n';

          continue;

        case '\r':              /* carriage returns */

          *p++ = '\\';

          *p++ = 'r';

          continue;

        case '\033':            /* escape */

          *p++ = '\\';

          *p++ = 'e';

          continue;

        case '\t':              /* tab */

          *p++ = '\\';

          *p++ = 't';

          continue;

        case '\b':              /* backspace */

          *p++ = '\\';

          *p++ = 'b';

          continue;

        default:                /* no change */

          *p++ = buf[i];

        }

      if (buf[i] < 26)

        {                       /* modify control characters */

          *p++ = '^';

          *p++ = buf[i] + 'A';

          continue;

        }

      if (buf[i] >= 128)

        {                       /* modify control characters */

          *p++ = '!';

          *p++ = buf[i] + 'A';

          continue;

        }

    }

  *p = '\0';                    /* terminate the string */

  if (sr_get_debug () > level)

    printf_unfiltered ("%s\n", newbuf);

#ifdef LOG_FILE                 /* write to the monitor log */

  if (log_file != 0x0)

    {

      fputs (newbuf, log_file);

      fputc ('\n', log_file);

      fflush (log_file);

    }

#endif

}

/* readchar -- read a character from the remote system, doing all the fancy

 *    timeout stuff.

 */

static int

readchar (int timeout)

{

  int c;

  c = serial_readchar (array_desc, abs (timeout));

  if (sr_get_debug () > 5)

    {

      putchar (c & 0x7f);

      debuglogs (5, "readchar: timeout = %d\n", timeout);

    }

#ifdef LOG_FILE

  if (isascii (c))

    putc (c & 0x7f, log_file);

#endif

  if (c >= 0)

    return c & 0x7f;

  if (c == SERIAL_TIMEOUT)

    {

      if (timeout <= 0)

        return c;               /* Polls shouldn't generate timeout errors */

      error ("Timeout reading from remote system.");

#ifdef LOG_FILE

      fputs ("ERROR: Timeout reading from remote system", log_file);

#endif

    }

  perror_with_name ("readchar");

}

/*

 * expect --  scan input from the remote system, until STRING is found.

 *      If DISCARD is non-zero, then discard non-matching input, else print

 *      it out. Let the user break out immediately.

 */

static void

expect (char *string, int discard)

{

  char *p = string;

  int c;

  debuglogs (1, "Expecting \"%s\".", string);

  immediate_quit++;

  while (1)

    {

      c = readchar (timeout);

      if (!isascii (c))

        continue;

      if (c == *p++)

        {

          if (*p == '\0')

            {

              immediate_quit--;

              debuglogs (4, "Matched");

              return;

            }

        }

      else

        {

          if (!discard)

            {

              fputc_unfiltered (c, gdb_stdout);

            }

          p = string;

        }

    }

}

/* Keep discarding input until we see the MONITOR array_cmds->prompt.

   The convention for dealing with the expect_prompt is that you

   o give your command

   o *then* wait for the expect_prompt.

   Thus the last thing that a procedure does with the serial line

   will be an expect_prompt().  Exception:  array_resume does not

   wait for the expect_prompt, because the terminal is being handed over

   to the inferior.  However, the next thing which happens after that

   is a array_wait which does wait for the expect_prompt.

   Note that this includes abnormal exit, e.g. error().  This is

   necessary to prevent getting into states from which we can't

   recover.  */

static void

expect_prompt (int discard)

{

  expect (ARRAY_PROMPT, discard);

}

/*

 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise

 */

static int

junk (char ch)

{

  switch (ch)

    {

    case '\0':

    case ' ':

    case '-':

    case '\t':

    case '\r':

    case '\n':

      if (sr_get_debug () > 5)

        debuglogs (5, "Ignoring \'%c\'.", ch);

      return 1;

    default:

      if (sr_get_debug () > 5)

        debuglogs (5, "Accepting \'%c\'.", ch);

      return 0;

    }

}

/*

 *  get_hex_digit -- Get a hex digit from the remote system & return its value.

 *              If ignore is nonzero, ignore spaces, newline & tabs.

 */

static int

get_hex_digit (int ignore)

{

  static int ch;

  while (1)

    {

      ch = readchar (timeout);

      if (junk (ch))

        continue;

      if (sr_get_debug () > 4)

        {

          debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch, ch);

        }

      else

        {

#ifdef LOG_FILE                 /* write to the monitor log */

          if (log_file != 0x0)

            {

              fputs ("get_hex_digit() got a 0x", log_file);

              fputc (ch, log_file);

              fputc ('\n', log_file);

              fflush (log_file);

            }

#endif

        }

      if (ch >= '0' && ch <= '9')

        return ch - '0';

      else if (ch >= 'A' && ch <= 'F')

        return ch - 'A' + 10;

      else if (ch >= 'a' && ch <= 'f')

        return ch - 'a' + 10;

      else if (ch == ' ' && ignore)

        ;

      else

        {

          expect_prompt (1);

          debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch);

          error ("Invalid hex digit from remote system. (0x%x)", ch);

        }

    }

}

/* get_hex_byte -- Get a byte from monitor and put it in *BYT.

 *    Accept any number leading spaces.

 */

static void

get_hex_byte (char *byt)

{

  int val;

  val = get_hex_digit (1) << 4;

  debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val);

  val |= get_hex_digit (0);

  debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val);

  *byt = val;

  debuglogs (4, "get_hex_byte() -- Read a 0x%x", val);

}

/*

 * get_hex_word --  Get N 32-bit words from remote, each preceded by a space,

 *      and put them in registers starting at REGNO.

 */

static int

get_hex_word (void)

{

  long val, newval;

  int i;

  val = 0;

  for (i = 0; i < 8; i++)

    val = (val << 4) + get_hex_digit (i == 0);

  debuglogs (4, "get_hex_word() got a 0x%x.", val);

  return val;

}

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

   user types "run" after having attached.  */

static void

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

{

  int entry_pt;

  if (args && *args)

    error ("Can't pass arguments to remote MONITOR process");

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

    error ("No executable file specified");

  entry_pt = (int) bfd_get_start_address (exec_bfd);

/* The "process" (board) is already stopped awaiting our commands, and

   the program is already downloaded.  We just set its PC and go.  */

  clear_proceed_status ();

  /* Tell wait_for_inferior that we've started a new process.  */

  init_wait_for_inferior ();

  /* Set up the "saved terminal modes" of the inferior

     based on what modes we are starting it with.  */

  target_terminal_init ();

  /* Install inferior's terminal modes.  */

  target_terminal_inferior ();

  /* insert_step_breakpoint ();  FIXME, do we need this?  */

  /* Let 'er rip... */

  proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);

}

/*

 * array_open -- open a connection to a remote debugger.

 *      NAME is the filename used for communication.

 */

static int baudrate = 9600;

static char dev_name[100];

static void

array_open (char *args, char *name, int from_tty)

{

  char packet[PBUFSIZ];

  if (args == NULL)

    error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\

`target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);

/*  if (is_open) */

  array_close (0);

  target_preopen (from_tty);

  unpush_target (&array_ops);

  tmp_mips_processor_type = "lsi33k";   /* change the default from r3051 */

  mips_set_processor_type_command ("lsi33k", 0);

  strcpy (dev_name, args);

  array_desc = serial_open (dev_name);

  if (array_desc == NULL)

    perror_with_name (dev_name);

  if (baud_rate != -1)

    {

      if (serial_setbaudrate (array_desc, baud_rate))

        {

          serial_close (array_desc);

          perror_with_name (name);

        }

    }

  serial_raw (array_desc);

#if defined (LOG_FILE)

  log_file = fopen (LOG_FILE, "w");

  if (log_file == NULL)

    perror_with_name (LOG_FILE);

  fprintf (log_file, "GDB %s (%s", version, host_name);

  fprintf (log_file, " --target %s)\n", array_ops.to_shortname);

  fprintf (log_file, "Remote target %s connected to %s\n\n", array_ops.to_shortname, dev_name);

#endif

  /* see if the target is alive. For a ROM monitor, we can just try to force the

     expect_prompt to print a few times. For the GDB remote protocol, the application

     being debugged is sitting at a breakpoint and waiting for GDB to initialize

     the connection. We force it to give us an empty packet to see if it's alive.

   */

  debuglogs (3, "Trying to ACK the target's debug stub");

  /* unless your are on the new hardware, the old board won't initialize

     because the '@' doesn't flush output like it does on the new ROMS.

   */

  printf_monitor ("@");         /* ask for the last signal */

  expect_prompt (1);            /* See if we get a expect_prompt */

#ifdef TEST_ARRAY               /* skip packet for testing */

  make_gdb_packet (packet, "?");        /* ask for a bogus packet */

  if (array_send_packet (packet) == 0)

    error ("Couldn't transmit packet\n");

  printf_monitor ("@\n");       /* force it to flush stdout */

  expect_prompt (1);            /* See if we get a expect_prompt */

#endif

  push_target (&array_ops);

  if (from_tty)

    printf ("Remote target %s connected to %s\n", array_ops.to_shortname, dev_name);

}

/*

 * array_close -- Close out all files and local state before this

 *      target loses control.

 */

static void

array_close (int quitting)

{

  serial_close (array_desc);

  array_desc = NULL;

  debuglogs (1, "array_close (quitting=%d)", quitting);

#if defined (LOG_FILE)

  if (log_file)

    {

      if (ferror (log_file))

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

      if (fclose (log_file) != 0)

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

    }

#endif

}

/*

 * array_detach -- terminate the open connection to the remote

 *      debugger. Use this when you want to detach and do something

 *      else with your gdb.

 */

static void

array_detach (int from_tty)

{

  debuglogs (1, "array_detach ()");

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

  if (from_tty)

    printf ("Ending remote %s debugging\n", target_shortname);

}

/*

 * array_attach -- attach GDB to the target.

 */

static void

array_attach (char *args, int from_tty)

{

  if (from_tty)

    printf ("Starting remote %s debugging\n", target_shortname);

  debuglogs (1, "array_attach (args=%s)", args);

  printf_monitor ("go %x\n");

  /* swallow the echo.  */

  expect ("go %x\n", 1);

}

/*

 * array_resume -- Tell the remote machine to resume.

 */

static void

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

{

  debuglogs (1, "array_resume (step=%d, sig=%d)", step, sig);

  if (step)

    {

      printf_monitor ("s\n");

    }

  else

    {

      printf_monitor ("go\n");

    }

}