Subversion Repositories or1k

/* Remote debugging interface for boot monitors, for GDB.

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

   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 file was derived from remote-eb.c, which did a similar job, but for

   an AMD-29K running EBMON.  That file was in turn derived from remote.c

   as mentioned in the following comment (left in for comic relief):

   "This is like remote.c but is for a different situation--

   having a PC running os9000 hook up with a unix machine with

   a serial line, and running ctty com2 on the PC. os9000 has a debug

   monitor called ROMBUG running.  Not to mention that the PC

   has PC/NFS, so it can access the same executables that gdb can,

   over the net in real time."

   In reality, this module talks to a debug monitor called 'ROMBUG', which

   We communicate with ROMBUG via a direct serial line, the network version

   of ROMBUG is not available yet.

 */

/* FIXME This file needs to be rewritten if it's to work again, either

   to self-contained or to use the new monitor interface.  */

#include "defs.h"

#include "gdbcore.h"

#include "target.h"

#include "gdb_wait.h"

#include <signal.h>

#include "gdb_string.h"

#include <sys/types.h>

#include "command.h"

#include "serial.h"

#include "monitor.h"

#include "remote-utils.h"

#include "symtab.h"

#include "symfile.h"

#include "objfiles.h"

#include "gdb-stabs.h"

struct cmd_list_element *showlist;

extern struct target_ops rombug_ops;    /* Forward declaration */

extern struct monitor_ops rombug_cmds;  /* Forward declaration */

extern struct cmd_list_element *setlist;

extern struct cmd_list_element *unsetlist;

extern int attach_flag;

static void rombug_close ();

static void rombug_fetch_register ();

static void rombug_fetch_registers ();

static void rombug_store_register ();

#if 0

static int sr_get_debug ();     /* flag set by "set remotedebug" */

#endif

static int hashmark;            /* flag set by "set hash" */

static int rombug_is_open = 0;

/* FIXME: Replace with sr_get_debug ().  */

#define LOG_FILE "monitor.log"

FILE *log_file;

static int monitor_log = 0;

static int tty_xon = 0;

static int tty_xoff = 0;

static int timeout = 10;

static int is_trace_mode = 0;

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

static serial_t monitor_desc = NULL;

static CORE_ADDR bufaddr = 0;

static int buflen = 0;

static char readbuf[16];

/* Send data to monitor.  Works just like printf. */

static void

printf_monitor (char *pattern,...)

{

  va_list args;

  char buf[200];

  int i;

  va_start (args, pattern);

  vsprintf (buf, pattern, args);

  va_end (args);

  if (SERIAL_WRITE (monitor_desc, buf, strlen (buf)))

    fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));

}

/* Read a character from the remote system, doing all the fancy timeout stuff */

static int

readchar (timeout)

     int timeout;

{

  int c;

  c = SERIAL_READCHAR (monitor_desc, timeout);

  if (sr_get_debug ())

    putchar (c & 0x7f);

  if (monitor_log && isascii (c))

    putc (c & 0x7f, log_file);

  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.");

    }

  perror_with_name ("remote-monitor");

}

/* 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 (string, discard)

     char *string;

     int discard;

{

  char *p = string;

  int c;

  if (sr_get_debug ())

    printf ("Expecting \"%s\"\n", string);

  immediate_quit = 1;

  while (1)

    {

      c = readchar (timeout);

      if (!isascii (c))

        continue;

      if (c == *p++)

        {

          if (*p == '\0')

            {

              immediate_quit = 0;

              if (sr_get_debug ())

                printf ("\nMatched\n");

              return;

            }

        }

      else

        {

          if (!discard)

            {

              fwrite (string, 1, (p - 1) - string, stdout);

              putchar ((char) c);

              fflush (stdout);

            }

          p = string;

        }

    }

}

/* Keep discarding input until we see the ROMBUG prompt.

   The convention for dealing with the prompt is that you

   o give your command

   o *then* wait for the prompt.

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

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

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

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

   is a rombug_wait which does wait for the 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 (discard)

     int discard;

{

  if (monitor_log)

    /* This is a convenient place to do this.  The idea is to do it often

       enough that we never lose much data if we terminate abnormally.  */

    fflush (log_file);

  if (is_trace_mode)

    {

      expect ("trace", discard);

    }

  else

    {

      expect (PROMPT, discard);

    }

}

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

   If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */

static int

get_hex_digit (ignore_space)

     int ignore_space;

{

  int ch;

  while (1)

    {

      ch = readchar (timeout);

      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_space)

        ;

      else

        {

          expect_prompt (1);

          error ("Invalid hex digit from remote system.");

        }

    }

}

/* Get a byte from monitor and put it in *BYT.  Accept any number

   leading spaces.  */

static void

get_hex_byte (byt)

     char *byt;

{

  int val;

  val = get_hex_digit (1) << 4;

  val |= get_hex_digit (0);

  *byt = val;

}

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

   and put them in registers starting at REGNO.  */

static void

get_hex_regs (n, regno)

     int n;

     int regno;

{

  long val;

  int i;

  unsigned char b;

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

    {

      int j;

      val = 0;

      for (j = 0; j < 4; j++)

        {

          get_hex_byte (&b);

          if (TARGET_BYTE_ORDER == BIG_ENDIAN)

            val = (val << 8) + b;

          else

            val = val + (b << (j * 8));

        }

      supply_register (regno++, (char *) &val);

    }

}

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

   user types "run" after having attached.  */

static void

rombug_create_inferior (execfile, args, env)

     char *execfile;

     char *args;

     char **env;

{

  int entry_pt;

  if (args && *args)

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

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

    error ("No executable file specified");

  entry_pt = (int) bfd_get_start_address (exec_bfd);

  if (monitor_log)

    fputs ("\nIn Create_inferior()", log_file);

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

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

  init_wait_for_inferior ();

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

}

/* Open a connection to a remote debugger.

   NAME is the filename used for communication.  */

static char dev_name[100];

static void

rombug_open (args, from_tty)

     char *args;

     int from_tty;

{

  if (args == NULL)

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

`target RomBug HOST-NAME:PORT-NUMBER' to use a network connection.");

  target_preopen (from_tty);

  if (rombug_is_open)

    unpush_target (&rombug_ops);

  strcpy (dev_name, args);

  monitor_desc = SERIAL_OPEN (dev_name);

  if (monitor_desc == NULL)

    perror_with_name (dev_name);

  /* if baud rate is set by 'set remotebaud' */

  if (SERIAL_SETBAUDRATE (monitor_desc, sr_get_baud_rate ()))

    {

      SERIAL_CLOSE (monitor_desc);

      perror_with_name ("RomBug");

    }

  SERIAL_RAW (monitor_desc);

  if (tty_xon || tty_xoff)

    {

      struct hardware_ttystate

        {

          struct termios t;

        }

       *tty_s;

      tty_s = (struct hardware_ttystate *) SERIAL_GET_TTY_STATE (monitor_desc);

      if (tty_xon)

        tty_s->t.c_iflag |= IXON;

      if (tty_xoff)

        tty_s->t.c_iflag |= IXOFF;

      SERIAL_SET_TTY_STATE (monitor_desc, (serial_ttystate) tty_s);

    }

  rombug_is_open = 1;

  log_file = fopen (LOG_FILE, "w");

  if (log_file == NULL)

    perror_with_name (LOG_FILE);

  push_monitor (&rombug_cmds);

  printf_monitor ("\r");        /* CR wakes up monitor */

  expect_prompt (1);

  push_target (&rombug_ops);

  attach_flag = 1;

  if (from_tty)

    printf ("Remote %s connected to %s\n", target_shortname,

            dev_name);

  rombug_fetch_registers ();

  printf_monitor ("ov e \r");

  expect_prompt (1);

  bufaddr = 0;

  buflen = 0;

}

/*

 * Close out all files and local state before this target loses control.

 */

static void

rombug_close (quitting)

     int quitting;

{

  if (rombug_is_open)

    {

      SERIAL_CLOSE (monitor_desc);

      monitor_desc = NULL;

      rombug_is_open = 0;

    }

  if (log_file)

    {

      if (ferror (log_file))

        fprintf (stderr, "Error writing log file.\n");

      if (fclose (log_file) != 0)

        fprintf (stderr, "Error closing log file.\n");

      log_file = 0;

    }

}

int

rombug_link (mod_name, text_reloc)

     char *mod_name;

     CORE_ADDR *text_reloc;

{

  int i, j;

  unsigned long val;

  unsigned char b;

  printf_monitor ("l %s \r", mod_name);

  expect_prompt (1);

  printf_monitor (".r \r");

  expect (REG_DELIM, 1);

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

    {

      val = 0;

      for (j = 0; j < 4; j++)

        {

          get_hex_byte (&b);

          val = (val << 8) + b;

        }

    }

  expect_prompt (1);

  *text_reloc = val;

  return 1;

}

/* Terminate the open connection to the remote debugger.

   Use this when you want to detach and do something else

   with your gdb.  */

static void

rombug_detach (from_tty)

     int from_tty;

{

  if (attach_flag)

    {

      printf_monitor (GO_CMD);

      attach_flag = 0;

    }

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

  if (from_tty)

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

}

/*

 * Tell the remote machine to resume.

 */

static void

rombug_resume (pid, step, sig)

     int pid, step;

     enum target_signal sig;

{

  if (monitor_log)

    fprintf (log_file, "\nIn Resume (step=%d, sig=%d)\n", step, sig);

  if (step)

    {

      is_trace_mode = 1;

      printf_monitor (STEP_CMD);

      /* wait for the echo.  **

         expect (STEP_CMD, 1);

       */

    }

  else

    {

      printf_monitor (GO_CMD);

      /* swallow the echo.  **

         expect (GO_CMD, 1);

       */

    }

  bufaddr = 0;

  buflen = 0;

}

/*

 * Wait until the remote machine stops, then return,

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

 */

static int

rombug_wait (pid, status)

     int pid;

     struct target_waitstatus *status;

{

  int old_timeout = timeout;

  struct section_offsets *offs;

  CORE_ADDR addr, pc;

  struct obj_section *obj_sec;

  if (monitor_log)

    fputs ("\nIn wait ()", log_file);

  status->kind = TARGET_WAITKIND_EXITED;

  status->value.integer = 0;

  timeout = -1;                 /* Don't time out -- user program is running. */

  expect ("eax:", 0);            /* output any message before register display */

  expect_prompt (1);            /* Wait for prompt, outputting extraneous text */

  status->kind = TARGET_WAITKIND_STOPPED;

  status->value.sig = TARGET_SIGNAL_TRAP;

  timeout = old_timeout;

  rombug_fetch_registers ();

  bufaddr = 0;

  buflen = 0;

  pc = read_register (PC_REGNUM);

  addr = read_register (DATABASE_REG);

  obj_sec = find_pc_section (pc);

  if (obj_sec != NULL)

    {

      if (obj_sec->objfile != symfile_objfile)

        new_symfile_objfile (obj_sec->objfile, 1, 0);

      offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);

      memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS);

      ANOFFSET (offs, SECT_OFF_DATA) = addr;

      ANOFFSET (offs, SECT_OFF_BSS) = addr;

      objfile_relocate (symfile_objfile, offs);

    }

  return 0;

}

/* Return the name of register number regno in the form input and output by

   monitor.  Currently, register_names just happens to contain exactly what

   monitor wants.  Lets take advantage of that just as long as possible! */

static char *

get_reg_name (regno)

     int regno;

{

  static char buf[50];

  char *p;

  char *b;

  b = buf;

  if (regno < 0)

    return ("");

/*

   for (p = REGISTER_NAME (regno); *p; p++)

   *b++ = toupper(*p);

   *b = '\000';

 */

  p = (char *) REGISTER_NAME (regno);

  return p;

/*

   return buf;

 */

}

/* read the remote registers into the block regs.  */

static void

rombug_fetch_registers ()

{

  int regno, j, i;

  long val;

  unsigned char b;

  printf_monitor (GET_REG);

  expect ("eax:", 1);

  expect ("\n", 1);

  get_hex_regs (1, 0);

  get_hex_regs (1, 3);

  get_hex_regs (1, 1);

  get_hex_regs (1, 2);

  get_hex_regs (1, 6);

  get_hex_regs (1, 7);

  get_hex_regs (1, 5);

  get_hex_regs (1, 4);

  for (regno = 8; regno <= 15; regno++)

    {

      expect (REG_DELIM, 1);

      if (regno >= 8 && regno <= 13)

        {

          val = 0;

          for (j = 0; j < 2; j++)

            {

              get_hex_byte (&b);

              if (TARGET_BYTE_ORDER == BIG_ENDIAN)

                val = (val << 8) + b;

              else

                val = val + (b << (j * 8));

            }

          if (regno == 8)

            i = 10;

          if (regno >= 9 && regno <= 12)

            i = regno + 3;

          if (regno == 13)

            i = 11;

          supply_register (i, (char *) &val);

        }

      else if (regno == 14)

        {

          get_hex_regs (1, PC_REGNUM);

        }

      else if (regno == 15)

        {

          get_hex_regs (1, 9);

        }

      else

        {

          val = 0;

          supply_register (regno, (char *) &val);

        }

    }

  is_trace_mode = 0;

  expect_prompt (1);

}

/* Fetch register REGNO, or all registers if REGNO is -1.

   Returns errno value.  */

static void

rombug_fetch_register (regno)

     int regno;

{

  int val, j;

  unsigned char b;

  if (monitor_log)

    {

      fprintf (log_file, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno));

      fflush (log_file);

    }

  if (regno < 0)

    {

      rombug_fetch_registers ();

    }

  else

    {

      char *name = get_reg_name (regno);

      printf_monitor (GET_REG);

      if (regno >= 10 && regno <= 15)

        {

          expect ("\n", 1);

          expect ("\n", 1);

          expect (name, 1);

          expect (REG_DELIM, 1);

          val = 0;

          for (j = 0; j < 2; j++)

            {

              get_hex_byte (&b);

              if (TARGET_BYTE_ORDER == BIG_ENDIAN)

                val = (val << 8) + b;

              else

                val = val + (b << (j * 8));

            }

          supply_register (regno, (char *) &val);

        }

      else if (regno == 8 || regno == 9)

        {

          expect ("\n", 1);

          expect ("\n", 1);

          expect ("\n", 1);

          expect (name, 1);

          expect (REG_DELIM, 1);

          get_hex_regs (1, regno);

        }

      else

        {

          expect (name, 1);

          expect (REG_DELIM, 1);

          expect ("\n", 1);

          get_hex_regs (1, 0);

          get_hex_regs (1, 3);

          get_hex_regs (1, 1);

          get_hex_regs (1, 2);

          get_hex_regs (1, 6);

          get_hex_regs (1, 7);

          get_hex_regs (1, 5);

          get_hex_regs (1, 4);

        }

      expect_prompt (1);

    }

  return;

}

/* Store the remote registers from the contents of the block REGS.  */

static void

rombug_store_registers ()

{