Subversion Repositories or1k

/* GDB interface to ARM RDI library.

   Copyright 1997, 1998 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.  */

#include "defs.h"

#include "gdb_string.h"

#include <fcntl.h>

#include "frame.h"

#include "inferior.h"

#include "bfd.h"

#include "symfile.h"

#include "target.h"

#include "gdb_wait.h"

#include "gdbcmd.h"

#include "objfiles.h"

#include "gdb-stabs.h"

#include "gdbthread.h"

#include "gdbcore.h"

#include "breakpoint.h"

#ifdef USG

#include <sys/types.h>

#endif

#include <signal.h>

#include "rdi-share/ardi.h"

#include "rdi-share/adp.h"

#include "rdi-share/hsys.h"

extern int isascii PARAMS ((int));

/* Prototypes for local functions */

static void arm_rdi_files_info PARAMS ((struct target_ops * ignore));

static int arm_rdi_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,

                                        int len, int should_write,

                                        struct target_ops * target));

static void arm_rdi_prepare_to_store PARAMS ((void));

static void arm_rdi_fetch_registers PARAMS ((int regno));

static void arm_rdi_resume PARAMS ((int pid, int step,

                                    enum target_signal siggnal));

static int arm_rdi_start_remote PARAMS ((char *dummy));

static void arm_rdi_open PARAMS ((char *name, int from_tty));

static void arm_rdi_create_inferior PARAMS ((char *exec_file, char *args,

                                             char **env));

static void arm_rdi_close PARAMS ((int quitting));

static void arm_rdi_store_registers PARAMS ((int regno));

static void arm_rdi_mourn PARAMS ((void));

static void arm_rdi_send PARAMS ((char *buf));

static int arm_rdi_wait PARAMS ((int pid, struct target_waitstatus * status));

static void arm_rdi_kill PARAMS ((void));

static void arm_rdi_detach PARAMS ((char *args, int from_tty));

static void arm_rdi_interrupt PARAMS ((int signo));

static void arm_rdi_interrupt_twice PARAMS ((int signo));

static void interrupt_query PARAMS ((void));

static int arm_rdi_insert_breakpoint PARAMS ((CORE_ADDR, char *));

static int arm_rdi_remove_breakpoint PARAMS ((CORE_ADDR, char *));

static char *rdi_error_message PARAMS ((int err));

static enum target_signal rdi_error_signal PARAMS ((int err));

/* Global variables.  */

struct target_ops arm_rdi_ops;

static struct Dbg_ConfigBlock gdb_config;

static struct Dbg_HostosInterface gdb_hostif;

static int max_load_size;

static int execute_status;

/* Send heatbeat packets? */

static int rdi_heartbeat = 0;

/* Target has ROM at address 0. */

static int rom_at_zero = 0;

/* Enable logging? */

static int log_enable = 0;

/* Name of the log file. Default is "rdi.log". */

static char *log_filename;

/* A little list of breakpoints that have been set.  */

static struct local_bp_list_entry

  {

    CORE_ADDR addr;

    PointHandle point;

    struct local_bp_list_entry *next;

  }

 *local_bp_list;

/* Stub for catch_errors.  */

static int

arm_rdi_start_remote (dummy)

     char *dummy;

{

  return 1;

}

/* Helper callbacks for the "host interface" structure.  RDI functions call

   these to forward output from the target system and so forth.  */

void

voiddummy ()

{

  fprintf_unfiltered (gdb_stdout, "void dummy\n");

}

static void

myprint (arg, format, ap)

     PTR arg;

     const char *format;

     va_list ap;

{

  vfprintf_unfiltered (gdb_stdout, format, ap);

}

static void

mywritec (arg, c)

     PTR arg;

     int c;

{

  if (isascii (c))

    fputc_unfiltered (c, gdb_stdout);

}

static int

mywrite (arg, buffer, len)

     PTR arg;

     char const *buffer;

     int len;

{

  int i;

  char *e;

  e = (char *) buffer;

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

    {

      if (isascii ((int) *e))

        {

          fputc_unfiltered ((int) *e, gdb_stdout);

          e++;

        }

    }

  return len;

}

static void

mypause (arg)

     PTR arg;

{

}

/* These last two are tricky as we have to handle the special case of

   being interrupted more carefully */

static int

myreadc (arg)

     PTR arg;

{

  return fgetc (stdin);

}

static char *

mygets (arg, buffer, len)

     PTR arg;

     char *buffer;

     int len;

{

  return fgets (buffer, len, stdin);

}

/* Prevent multiple calls to angel_RDI_close().  */

static int closed_already = 1;

/* Open a connection to a remote debugger.  NAME is the filename used

   for communication.  */

static void

arm_rdi_open (name, from_tty)

     char *name;

     int from_tty;

{

  int rslt, i;

  unsigned long arg1, arg2;

  char *openArgs = NULL;

  char *devName = NULL;

  char *p;

  if (name == NULL)

    error ("To open an RDI connection, you need to specify what serial\n\

device is attached to the remote system (e.g. /dev/ttya).");

  /* split name after whitespace, pass tail as arg to open command */

  devName = xstrdup (name);

  p = strchr (devName, ' ');

  if (p)

    {

      *p = '\0';

      ++p;

      while (*p == ' ')

        ++p;

      openArgs = p;

    }

  /* Make the basic low-level connection.  */

  arm_rdi_close (0);

  rslt = Adp_OpenDevice (devName, openArgs, rdi_heartbeat);

  if (rslt != adp_ok)

    error ("Could not open device \"%s\"", name);

  gdb_config.bytesex = 2 | (TARGET_BYTE_ORDER == BIG_ENDIAN ? 1 : 0);

  gdb_config.fpe = 1;

  gdb_config.rditype = 2;

  gdb_config.heartbeat_on = 1;

  gdb_config.flags = 2;

  gdb_hostif.dbgprint = myprint;

  gdb_hostif.dbgpause = mypause;

  gdb_hostif.dbgarg = NULL;

  gdb_hostif.writec = mywritec;

  gdb_hostif.readc = myreadc;

  gdb_hostif.write = mywrite;

  gdb_hostif.gets = mygets;

  gdb_hostif.hostosarg = NULL;

  gdb_hostif.reset = voiddummy;

  rslt = angel_RDI_open (10, &gdb_config, &gdb_hostif, NULL);

  if (rslt == RDIError_BigEndian || rslt == RDIError_LittleEndian)

    ;                           /* do nothing, this is the expected return */

  else if (rslt)

    {

      printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));

      Adp_CloseDevice ();

      error ("RID_open failed\n");

    }

  rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  rslt = angel_RDI_info (RDIInfo_Points, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  rslt = angel_RDI_info (RDIInfo_CoPro, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  rslt = angel_RDI_info (RDIInfo_SemiHosting, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  rslt = angel_RDI_info (RDIInfo_GetLoadSize, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  max_load_size = arg1;

  push_target (&arm_rdi_ops);

  target_fetch_registers (-1);

  rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);

  if (rslt)

    {

      printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));

    }

  arg1 = rom_at_zero ? 0x0 : 0x13b;

  rslt = angel_RDI_info (RDIVector_Catch, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  arg1 = (unsigned long) "";

  rslt = angel_RDI_info (RDISet_Cmdline, &arg1, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  /* Clear out any existing records of breakpoints.  */

  {

    struct local_bp_list_entry *entry, *preventry = NULL;

    for (entry = local_bp_list; entry != NULL; entry = entry->next)

      {

        if (preventry)

          free (preventry);

      }

  }

  printf_filtered ("Connected to ARM RDI target.\n");

  closed_already = 0;

  inferior_pid = 42;

}

/* Start an inferior process and set inferior_pid to its pid.

   EXEC_FILE is the file to run.

   ARGS is a string containing the arguments to the program.

   ENV is the environment vector to pass.  Errors reported with error().

   On VxWorks and various standalone systems, we ignore exec_file.  */

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

   user types "run" after having attached.  */

static void

arm_rdi_create_inferior (exec_file, args, env)

     char *exec_file;

     char *args;

     char **env;

{

  int len, rslt;

  unsigned long arg1, arg2;

  char *arg_buf;

  CORE_ADDR entry_point;

  if (exec_file == 0 || exec_bfd == 0)

    error ("No executable file specified.");

  entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);

  arm_rdi_kill ();

  remove_breakpoints ();

  init_wait_for_inferior ();

  len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;

  arg_buf = (char *) alloca (len);

  arg_buf[0] = '\0';

  strcat (arg_buf, exec_file);

  strcat (arg_buf, " ");

  strcat (arg_buf, args);

  inferior_pid = 42;

  insert_breakpoints ();        /* Needed to get correct instruction in cache */

  if (env != NULL)

    {

      while (*env)

        {

          if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)

            {

              unsigned long top_of_memory;

              char *end_of_num;

              /* Set up memory limit */

              top_of_memory = strtoul (*env + sizeof ("MEMSIZE=") - 1,

                                       &end_of_num, 0);

              printf_filtered ("Setting top-of-memory to 0x%lx\n",

                               top_of_memory);

              rslt = angel_RDI_info (RDIInfo_SetTopMem, &top_of_memory, &arg2);

              if (rslt)

                {

                  printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

                }

            }

          env++;

        }

    }

  arg1 = (unsigned long) arg_buf;

  rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *) arg_buf, &arg2);

  if (rslt)

    {

      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));

    }

  proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);

}

/* This takes a program previously attached to and detaches it.  After

   this is done, GDB can be used to debug some other program.  We

   better not have left any breakpoints in the target program or it'll

   die when it hits one.  */

static void

arm_rdi_detach (args, from_tty)

     char *args;

     int from_tty;

{

  pop_target ();

}

/* Clean up connection to a remote debugger.  */

static void

arm_rdi_close (quitting)

     int quitting;

{

  int rslt;

  if (!closed_already)

    {

      rslt = angel_RDI_close ();

      if (rslt)

        {

          printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt));

        }

      closed_already = 1;

      inferior_pid = 0;

      Adp_CloseDevice ();

      generic_mourn_inferior ();

    }

}

/* Tell the remote machine to resume.  */

static void

arm_rdi_resume (pid, step, siggnal)

     int pid, step;

     enum target_signal siggnal;

{

  int rslt;

  PointHandle point;

  if (0 /* turn on when hardware supports single-stepping */ )

    {

      rslt = angel_RDI_step (1, &point);

      if (rslt)

        {

          printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt));

        }

    }

  else

    {

      char handle[4];

      CORE_ADDR pc;

      if (step)

        {

          pc = read_register (PC_REGNUM);

          pc = arm_get_next_pc (pc);

          arm_rdi_insert_breakpoint (pc, handle);

        }

      execute_status = rslt = angel_RDI_execute (&point);

      if (rslt == RDIError_BreakpointReached)

        ;

      else if (rslt)

        {

          printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt));

        }

      if (step)

        {

          arm_rdi_remove_breakpoint (pc, handle);

        }

    }

}

/* Send ^C to target to halt it.  Target will respond, and send us a

   packet.  */

static void

arm_rdi_interrupt (signo)

     int signo;

{

}

static void (*ofunc) ();

/* The user typed ^C twice.  */

static void

arm_rdi_interrupt_twice (signo)

     int signo;

{

}

/* Ask the user what to do when an interrupt is received.  */

static void

interrupt_query ()

{

}

/* Wait until the remote machine stops, then return, storing status in

   STATUS just as `wait' would.  Returns "pid" (though it's not clear

   what, if anything, that means in the case of this target).  */

static int

arm_rdi_wait (pid, status)

     int pid;

     struct target_waitstatus *status;

{

  status->kind = (execute_status == RDIError_NoError ?

                  TARGET_WAITKIND_EXITED : TARGET_WAITKIND_STOPPED);

  /* convert stopped code from target into right signal */

  status->value.sig = rdi_error_signal (execute_status);

  return inferior_pid;

}

/* Read the remote registers into the block REGS.  */

/* ARGSUSED */

static void

arm_rdi_fetch_registers (regno)

     int regno;

{

  int rslt, rdi_regmask;

  unsigned long rawreg, rawregs[32];

  char cookedreg[4];

  if (regno == -1)

    {

      rslt = angel_RDI_CPUread (255, 0x27fff, rawregs);

      if (rslt)

        {

          printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));

        }

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

        {

          store_unsigned_integer (cookedreg, 4, rawregs[regno]);

          supply_register (regno, (char *) cookedreg);

        }

      store_unsigned_integer (cookedreg, 4, rawregs[15]);

      supply_register (PS_REGNUM, (char *) cookedreg);

      arm_rdi_fetch_registers (PC_REGNUM);

    }

  else

    {

      if (regno == PC_REGNUM)

        rdi_regmask = RDIReg_PC;

      else if (regno == PS_REGNUM)

        rdi_regmask = RDIReg_CPSR;

      else if (regno < 0 || regno > 15)

        {

          rawreg = 0;

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

          return;

        }

      else

        rdi_regmask = 1 << regno;

      rslt = angel_RDI_CPUread (255, rdi_regmask, &rawreg);

      if (rslt)

        {

          printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));

        }

      store_unsigned_integer (cookedreg, 4, rawreg);

      supply_register (regno, (char *) cookedreg);

    }

}

static void

arm_rdi_prepare_to_store ()

{

  /* Nothing to do.  */

}

/* Store register REGNO, or all registers if REGNO == -1, from the contents

   of REGISTERS.  FIXME: ignores errors.  */

static void

arm_rdi_store_registers (regno)

     int regno;

{

  int rslt, rdi_regmask;

  /* These need to be able to take 'floating point register' contents */

  unsigned long rawreg[3], rawerreg[3];

  if (regno == -1)

    {

      for (regno = 0; regno < NUM_REGS; regno++)

        arm_rdi_store_registers (regno);

    }

  else

    {

      read_register_gen (regno, (char *) rawreg);

      /* RDI manipulates data in host byte order, so convert now. */

      store_unsigned_integer (rawerreg, 4, rawreg[0]);

      if (regno == PC_REGNUM)

        rdi_regmask = RDIReg_PC;

      else if (regno == PS_REGNUM)

        rdi_regmask = RDIReg_CPSR;

      else if (regno < 0 || regno > 15)

        return;

      else

        rdi_regmask = 1 << regno;

      rslt = angel_RDI_CPUwrite (255, rdi_regmask, rawerreg);

      if (rslt)

        {

          printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt));

        }

    }

}

/* Read or write LEN bytes from inferior memory at MEMADDR,

   transferring to or from debugger address MYADDR.  Write to inferior

   if SHOULD_WRITE is nonzero.  Returns length of data written or

   read; 0 for error.  */

/* ARGSUSED */

static int

arm_rdi_xfer_memory (memaddr, myaddr, len, should_write, target)

     CORE_ADDR memaddr;

     char *myaddr;

     int len;

     int should_write;

     struct target_ops *target; /* ignored */

{

  int rslt, i;

  if (should_write)

    {

      rslt = angel_RDI_write (myaddr, memaddr, &len);

      if (rslt)

        {

          printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt));

        }

    }

  else

    {

      rslt = angel_RDI_read (memaddr, myaddr, &len);

      if (rslt)

        {

          printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt));

          len = 0;

        }

    }

  return len;