Subversion Repositories openrisc

/* Remote target communications for serial-line targets in custom GDB protocol

   Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,

   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,

   2010 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 3 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, see <http://www.gnu.org/licenses/>.  */

/* See the GDB User Guide for details of the GDB remote protocol.  */

#include "defs.h"

#include "gdb_string.h"

#include <ctype.h>

#include <fcntl.h>

#include "inferior.h"

#include "bfd.h"

#include "symfile.h"

#include "exceptions.h"

#include "target.h"

/*#include "terminal.h" */

#include "gdbcmd.h"

#include "objfiles.h"

#include "gdb-stabs.h"

#include "gdbthread.h"

#include "remote.h"

#include "regcache.h"

#include "value.h"

#include "gdb_assert.h"

#include "observer.h"

#include "solib.h"

#include "cli/cli-decode.h"

#include "cli/cli-setshow.h"

#include "target-descriptions.h"

#include <ctype.h>

#include <sys/time.h>

#include "event-loop.h"

#include "event-top.h"

#include "inf-loop.h"

#include <signal.h>

#include "serial.h"

#include "gdbcore.h" /* for exec_bfd */

#include "remote-fileio.h"

#include "gdb/fileio.h"

#include "gdb_stat.h"

#include "xml-support.h"

#include "memory-map.h"

#include "tracepoint.h"

#include "ax.h"

#include "ax-gdb.h"

/* temp hacks for tracepoint encoding migration */

static char *target_buf;

static long target_buf_size;

/*static*/ void

encode_actions (struct breakpoint *t, struct bp_location *tloc,

                char ***tdp_actions, char ***stepping_actions);

/* The size to align memory write packets, when practical.  The protocol

   does not guarantee any alignment, and gdb will generate short

   writes and unaligned writes, but even as a best-effort attempt this

   can improve bulk transfers.  For instance, if a write is misaligned

   relative to the target's data bus, the stub may need to make an extra

   round trip fetching data from the target.  This doesn't make a

   huge difference, but it's easy to do, so we try to be helpful.

   The alignment chosen is arbitrary; usually data bus width is

   important here, not the possibly larger cache line size.  */

enum { REMOTE_ALIGN_WRITES = 16 };

/* Prototypes for local functions.  */

static void cleanup_sigint_signal_handler (void *dummy);

static void initialize_sigint_signal_handler (void);

static int getpkt_sane (char **buf, long *sizeof_buf, int forever);

static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,

                                 int forever);

static void handle_remote_sigint (int);

static void handle_remote_sigint_twice (int);

static void async_remote_interrupt (gdb_client_data);

void async_remote_interrupt_twice (gdb_client_data);

static void remote_files_info (struct target_ops *ignore);

static void remote_prepare_to_store (struct regcache *regcache);

static void remote_open (char *name, int from_tty);

static void extended_remote_open (char *name, int from_tty);

static void remote_open_1 (char *, int, struct target_ops *, int extended_p);

static void remote_close (int quitting);

static void remote_mourn (struct target_ops *ops);

static void extended_remote_restart (void);

static void extended_remote_mourn (struct target_ops *);

static void remote_mourn_1 (struct target_ops *);

static void remote_send (char **buf, long *sizeof_buf_p);

static int readchar (int timeout);

static void remote_kill (struct target_ops *ops);

static int tohex (int nib);

static int remote_can_async_p (void);

static int remote_is_async_p (void);

static void remote_async (void (*callback) (enum inferior_event_type event_type,

                                            void *context), void *context);

static int remote_async_mask (int new_mask);

static void remote_detach (struct target_ops *ops, char *args, int from_tty);

static void remote_interrupt (int signo);

static void remote_interrupt_twice (int signo);

static void interrupt_query (void);

static void set_general_thread (struct ptid ptid);

static void set_continue_thread (struct ptid ptid);

static void get_offsets (void);

static void skip_frame (void);

static long read_frame (char **buf_p, long *sizeof_buf);

static int hexnumlen (ULONGEST num);

static void init_remote_ops (void);

static void init_extended_remote_ops (void);

static void remote_stop (ptid_t);

static int ishex (int ch, int *val);

static int stubhex (int ch);

static int hexnumstr (char *, ULONGEST);

static int hexnumnstr (char *, ULONGEST, int);

static CORE_ADDR remote_address_masked (CORE_ADDR);

static void print_packet (char *);

static void compare_sections_command (char *, int);

static void packet_command (char *, int);

static int stub_unpack_int (char *buff, int fieldlength);

static ptid_t remote_current_thread (ptid_t oldptid);

static void remote_find_new_threads (void);

static void record_currthread (ptid_t currthread);

static int fromhex (int a);

extern int hex2bin (const char *hex, gdb_byte *bin, int count);

extern int bin2hex (const gdb_byte *bin, char *hex, int count);

static int putpkt_binary (char *buf, int cnt);

static void check_binary_download (CORE_ADDR addr);

struct packet_config;

static void show_packet_config_cmd (struct packet_config *config);

static void update_packet_config (struct packet_config *config);

static void set_remote_protocol_packet_cmd (char *args, int from_tty,

                                            struct cmd_list_element *c);

static void show_remote_protocol_packet_cmd (struct ui_file *file,

                                             int from_tty,

                                             struct cmd_list_element *c,

                                             const char *value);

static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);

static ptid_t read_ptid (char *buf, char **obuf);

static void remote_set_permissions (void);

struct remote_state;

static int remote_get_trace_status (struct trace_status *ts);

static int remote_upload_tracepoints (struct uploaded_tp **utpp);

static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);

static void remote_query_supported (void);

static void remote_check_symbols (struct objfile *objfile);

void _initialize_remote (void);

struct stop_reply;

static struct stop_reply *stop_reply_xmalloc (void);

static void stop_reply_xfree (struct stop_reply *);

static void do_stop_reply_xfree (void *arg);

static void remote_parse_stop_reply (char *buf, struct stop_reply *);

static void push_stop_reply (struct stop_reply *);

static void remote_get_pending_stop_replies (void);

static void discard_pending_stop_replies (int pid);

static int peek_stop_reply (ptid_t ptid);

static void remote_async_inferior_event_handler (gdb_client_data);

static void remote_async_get_pending_events_handler (gdb_client_data);

static void remote_terminal_ours (void);

static int remote_read_description_p (struct target_ops *target);

static void remote_console_output (char *msg);

/* The non-stop remote protocol provisions for one pending stop reply.

   This is where we keep it until it is acknowledged.  */

static struct stop_reply *pending_stop_reply = NULL;

/* For "remote".  */

static struct cmd_list_element *remote_cmdlist;

/* For "set remote" and "show remote".  */

static struct cmd_list_element *remote_set_cmdlist;

static struct cmd_list_element *remote_show_cmdlist;

/* Description of the remote protocol state for the currently

   connected target.  This is per-target state, and independent of the

   selected architecture.  */

struct remote_state

{

  /* A buffer to use for incoming packets, and its current size.  The

     buffer is grown dynamically for larger incoming packets.

     Outgoing packets may also be constructed in this buffer.

     BUF_SIZE is always at least REMOTE_PACKET_SIZE;

     REMOTE_PACKET_SIZE should be used to limit the length of outgoing

     packets.  */

  char *buf;

  long buf_size;

  /* If we negotiated packet size explicitly (and thus can bypass

     heuristics for the largest packet size that will not overflow

     a buffer in the stub), this will be set to that packet size.

     Otherwise zero, meaning to use the guessed size.  */

  long explicit_packet_size;

  /* remote_wait is normally called when the target is running and

     waits for a stop reply packet.  But sometimes we need to call it

     when the target is already stopped.  We can send a "?" packet

     and have remote_wait read the response.  Or, if we already have

     the response, we can stash it in BUF and tell remote_wait to

     skip calling getpkt.  This flag is set when BUF contains a

     stop reply packet and the target is not waiting.  */

  int cached_wait_status;

  /* True, if in no ack mode.  That is, neither GDB nor the stub will

     expect acks from each other.  The connection is assumed to be

     reliable.  */

  int noack_mode;

  /* True if we're connected in extended remote mode.  */

  int extended;

  /* True if the stub reported support for multi-process

     extensions.  */

  int multi_process_aware;

  /* True if we resumed the target and we're waiting for the target to

     stop.  In the mean time, we can't start another command/query.

     The remote server wouldn't be ready to process it, so we'd

     timeout waiting for a reply that would never come and eventually

     we'd close the connection.  This can happen in asynchronous mode

     because we allow GDB commands while the target is running.  */

  int waiting_for_stop_reply;

  /* True if the stub reports support for non-stop mode.  */

  int non_stop_aware;

  /* True if the stub reports support for vCont;t.  */

  int support_vCont_t;

  /* True if the stub reports support for conditional tracepoints.  */

  int cond_tracepoints;

  /* True if the stub reports support for fast tracepoints.  */

  int fast_tracepoints;

  /* True if the stub reports support for static tracepoints.  */

  int static_tracepoints;

  /* True if the stub can continue running a trace while GDB is

     disconnected.  */

  int disconnected_tracing;

  /* Nonzero if the user has pressed Ctrl-C, but the target hasn't

     responded to that.  */

  int ctrlc_pending_p;

};

/* Private data that we'll store in (struct thread_info)->private.  */

struct private_thread_info

{

  char *extra;

  int core;

};

static void

free_private_thread_info (struct private_thread_info *info)

{

  xfree (info->extra);

  xfree (info);

}

/* Returns true if the multi-process extensions are in effect.  */

static int

remote_multi_process_p (struct remote_state *rs)

{

  return rs->extended && rs->multi_process_aware;

}

/* This data could be associated with a target, but we do not always

   have access to the current target when we need it, so for now it is

   static.  This will be fine for as long as only one target is in use

   at a time.  */

static struct remote_state remote_state;

static struct remote_state *

get_remote_state_raw (void)

{

  return &remote_state;

}

/* Description of the remote protocol for a given architecture.  */

struct packet_reg

{

  long offset; /* Offset into G packet.  */

  long regnum; /* GDB's internal register number.  */

  LONGEST pnum; /* Remote protocol register number.  */

  int in_g_packet; /* Always part of G packet.  */

  /* long size in bytes;  == register_size (target_gdbarch, regnum);

     at present.  */

  /* char *name; == gdbarch_register_name (target_gdbarch, regnum);

     at present.  */

};

struct remote_arch_state

{

  /* Description of the remote protocol registers.  */

  long sizeof_g_packet;

  /* Description of the remote protocol registers indexed by REGNUM

     (making an array gdbarch_num_regs in size).  */

  struct packet_reg *regs;

  /* This is the size (in chars) of the first response to the ``g''

     packet.  It is used as a heuristic when determining the maximum

     size of memory-read and memory-write packets.  A target will

     typically only reserve a buffer large enough to hold the ``g''

     packet.  The size does not include packet overhead (headers and

     trailers).  */

  long actual_register_packet_size;

  /* This is the maximum size (in chars) of a non read/write packet.

     It is also used as a cap on the size of read/write packets.  */

  long remote_packet_size;

};

long sizeof_pkt = 2000;

/* Utility: generate error from an incoming stub packet.  */

static void

trace_error (char *buf)

{

  if (*buf++ != 'E')

    return;                     /* not an error msg */

  switch (*buf)

    {

    case '1':                   /* malformed packet error */

      if (*++buf == '0')        /*   general case: */

        error (_("remote.c: error in outgoing packet."));

      else

        error (_("remote.c: error in outgoing packet at field #%ld."),

               strtol (buf, NULL, 16));

    case '2':

      error (_("trace API error 0x%s."), ++buf);

    default:

      error (_("Target returns error code '%s'."), buf);

    }

}

/* Utility: wait for reply from stub, while accepting "O" packets.  */

static char *

remote_get_noisy_reply (char **buf_p,

                        long *sizeof_buf)

{

  do                            /* Loop on reply from remote stub.  */

    {

      char *buf;

      QUIT;                     /* allow user to bail out with ^C */

      getpkt (buf_p, sizeof_buf, 0);

      buf = *buf_p;

      if (buf[0] == 'E')

        trace_error (buf);

      else if (strncmp (buf, "qRelocInsn:", strlen ("qRelocInsn:")) == 0)

        {

          ULONGEST ul;

          CORE_ADDR from, to, org_to;

          char *p, *pp;

          int adjusted_size = 0;

          volatile struct gdb_exception ex;

          p = buf + strlen ("qRelocInsn:");

          pp = unpack_varlen_hex (p, &ul);

          if (*pp != ';')

            error (_("invalid qRelocInsn packet: %s"), buf);

          from = ul;

          p = pp + 1;

          pp = unpack_varlen_hex (p, &ul);

          to = ul;

          org_to = to;

          TRY_CATCH (ex, RETURN_MASK_ALL)

            {

              gdbarch_relocate_instruction (target_gdbarch, &to, from);

            }

          if (ex.reason >= 0)

            {

              adjusted_size = to - org_to;

              sprintf (buf, "qRelocInsn:%x", adjusted_size);

              putpkt (buf);

            }

          else if (ex.reason < 0 && ex.error == MEMORY_ERROR)

            {

              /* Propagate memory errors silently back to the target.

                 The stub may have limited the range of addresses we

                 can write to, for example.  */

              putpkt ("E01");

            }

          else

            {

              /* Something unexpectedly bad happened.  Be verbose so

                 we can tell what, and propagate the error back to the

                 stub, so it doesn't get stuck waiting for a

                 response.  */

              exception_fprintf (gdb_stderr, ex,

                                 _("warning: relocating instruction: "));

              putpkt ("E01");

            }

        }

      else if (buf[0] == 'O' && buf[1] != 'K')

        remote_console_output (buf + 1);        /* 'O' message from stub */

      else

        return buf;             /* here's the actual reply */

    }

  while (1);

}

/* Handle for retreving the remote protocol data from gdbarch.  */

static struct gdbarch_data *remote_gdbarch_data_handle;

static struct remote_arch_state *

get_remote_arch_state (void)

{

  return gdbarch_data (target_gdbarch, remote_gdbarch_data_handle);

}

/* Fetch the global remote target state.  */

static struct remote_state *

get_remote_state (void)

{

  /* Make sure that the remote architecture state has been

     initialized, because doing so might reallocate rs->buf.  Any

     function which calls getpkt also needs to be mindful of changes

     to rs->buf, but this call limits the number of places which run

     into trouble.  */

  get_remote_arch_state ();

  return get_remote_state_raw ();

}

static int

compare_pnums (const void *lhs_, const void *rhs_)

{

  const struct packet_reg * const *lhs = lhs_;

  const struct packet_reg * const *rhs = rhs_;

  if ((*lhs)->pnum < (*rhs)->pnum)

    return -1;

  else if ((*lhs)->pnum == (*rhs)->pnum)

    return 0;

  else

    return 1;

}

static void *

init_remote_state (struct gdbarch *gdbarch)

{

  int regnum, num_remote_regs, offset;

  struct remote_state *rs = get_remote_state_raw ();

  struct remote_arch_state *rsa;

  struct packet_reg **remote_regs;

  rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);

  /* Use the architecture to build a regnum<->pnum table, which will be

     1:1 unless a feature set specifies otherwise.  */

  rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,

                                      gdbarch_num_regs (gdbarch),

                                      struct packet_reg);

  for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)

    {

      struct packet_reg *r = &rsa->regs[regnum];

      if (register_size (gdbarch, regnum) == 0)

        /* Do not try to fetch zero-sized (placeholder) registers.  */

        r->pnum = -1;

      else

        r->pnum = gdbarch_remote_register_number (gdbarch, regnum);

      r->regnum = regnum;

    }

  /* Define the g/G packet format as the contents of each register

     with a remote protocol number, in order of ascending protocol

     number.  */

  remote_regs = alloca (gdbarch_num_regs (gdbarch)

                          * sizeof (struct packet_reg *));

  for (num_remote_regs = 0, regnum = 0;

       regnum < gdbarch_num_regs (gdbarch);

       regnum++)

    if (rsa->regs[regnum].pnum != -1)

      remote_regs[num_remote_regs++] = &rsa->regs[regnum];

  qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),

         compare_pnums);

  for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)

    {

      remote_regs[regnum]->in_g_packet = 1;

      remote_regs[regnum]->offset = offset;

      offset += register_size (gdbarch, remote_regs[regnum]->regnum);

    }

  /* Record the maximum possible size of the g packet - it may turn out

     to be smaller.  */

  rsa->sizeof_g_packet = offset;

  /* Default maximum number of characters in a packet body. Many

     remote stubs have a hardwired buffer size of 400 bytes

     (c.f. BUFMAX in m68k-stub.c and i386-stub.c).  BUFMAX-1 is used

     as the maximum packet-size to ensure that the packet and an extra

     NUL character can always fit in the buffer.  This stops GDB

     trashing stubs that try to squeeze an extra NUL into what is

     already a full buffer (As of 1999-12-04 that was most stubs).  */

  rsa->remote_packet_size = 400 - 1;

  /* This one is filled in when a ``g'' packet is received.  */

  rsa->actual_register_packet_size = 0;

  /* Should rsa->sizeof_g_packet needs more space than the

     default, adjust the size accordingly. Remember that each byte is

     encoded as two characters. 32 is the overhead for the packet

     header / footer. NOTE: cagney/1999-10-26: I suspect that 8

     (``$NN:G...#NN'') is a better guess, the below has been padded a

     little.  */

  if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))

    rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);

  /* Make sure that the packet buffer is plenty big enough for

     this architecture.  */

  if (rs->buf_size < rsa->remote_packet_size)

    {

      rs->buf_size = 2 * rsa->remote_packet_size;

      rs->buf = xrealloc (rs->buf, rs->buf_size);

    }

  return rsa;

}

/* Return the current allowed size of a remote packet.  This is

   inferred from the current architecture, and should be used to

   limit the length of outgoing packets.  */

static long

get_remote_packet_size (void)

{

  struct remote_state *rs = get_remote_state ();

  struct remote_arch_state *rsa = get_remote_arch_state ();

  if (rs->explicit_packet_size)

    return rs->explicit_packet_size;

  return rsa->remote_packet_size;

}

static struct packet_reg *

packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)

{

  if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch))

    return NULL;

  else

    {

      struct packet_reg *r = &rsa->regs[regnum];

      gdb_assert (r->regnum == regnum);

      return r;

    }

}

static struct packet_reg *

packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)

{

  int i;

  for (i = 0; i < gdbarch_num_regs (target_gdbarch); i++)

    {

      struct packet_reg *r = &rsa->regs[i];

      if (r->pnum == pnum)

        return r;

    }

  return NULL;

}

/* FIXME: graces/2002-08-08: These variables should eventually be

   bound to an instance of the target object (as in gdbarch-tdep()),

   when such a thing exists.  */

/* This is set to the data address of the access causing the target

   to stop for a watchpoint.  */

static CORE_ADDR remote_watch_data_address;

/* This is non-zero if target stopped for a watchpoint.  */

static int remote_stopped_by_watchpoint_p;

static struct target_ops remote_ops;

static struct target_ops extended_remote_ops;

static int remote_async_mask_value = 1;

/* FIXME: cagney/1999-09-23: Even though getpkt was called with

   ``forever'' still use the normal timeout mechanism.  This is

   currently used by the ASYNC code to guarentee that target reads

   during the initial connect always time-out.  Once getpkt has been

   modified to return a timeout indication and, in turn

   remote_wait()/wait_for_inferior() have gained a timeout parameter

   this can go away.  */

static int wait_forever_enabled_p = 1;

/* Allow the user to specify what sequence to send to the remote

   when he requests a program interruption: Although ^C is usually

   what remote systems expect (this is the default, here), it is

   sometimes preferable to send a break.  On other systems such

   as the Linux kernel, a break followed by g, which is Magic SysRq g

   is required in order to interrupt the execution.  */

const char interrupt_sequence_control_c[] = "Ctrl-C";

const char interrupt_sequence_break[] = "BREAK";

const char interrupt_sequence_break_g[] = "BREAK-g";

static const char *interrupt_sequence_modes[] =

  {