Subversion Repositories openrisc

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

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

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

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

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

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

   2010 Free Software Foundation, Inc.

   2010 Free Software Foundation, Inc.

   This file is part of GDB.

   This file is part of GDB.

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

   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

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

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

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

   (at your option) any later version.

   (at your option) any later version.

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

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

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   GNU General Public License for more details.

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

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

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

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

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

#include "defs.h"

#include "defs.h"

#include "gdb_string.h"

#include "gdb_string.h"

#include <ctype.h>

#include <ctype.h>

#include <fcntl.h>

#include <fcntl.h>

#include "inferior.h"

#include "inferior.h"

#include "bfd.h"

#include "bfd.h"

#include "symfile.h"

#include "symfile.h"

#include "exceptions.h"

#include "exceptions.h"

#include "target.h"

#include "target.h"

/*#include "terminal.h" */

/*#include "terminal.h" */

#include "gdbcmd.h"

#include "gdbcmd.h"

#include "objfiles.h"

#include "objfiles.h"

#include "gdb-stabs.h"

#include "gdb-stabs.h"

#include "gdbthread.h"

#include "gdbthread.h"

#include "remote.h"

#include "remote.h"

#include "regcache.h"

#include "regcache.h"

#include "value.h"

#include "value.h"

#include "gdb_assert.h"

#include "gdb_assert.h"

#include "observer.h"

#include "observer.h"

#include "solib.h"

#include "solib.h"

#include "cli/cli-decode.h"

#include "cli/cli-decode.h"

#include "cli/cli-setshow.h"

#include "cli/cli-setshow.h"

#include "target-descriptions.h"

#include "target-descriptions.h"

#include <ctype.h>

#include <ctype.h>

#include <sys/time.h>

#include <sys/time.h>

#include "event-loop.h"

#include "event-loop.h"

#include "event-top.h"

#include "event-top.h"

#include "inf-loop.h"

#include "inf-loop.h"

#include <signal.h>

#include <signal.h>

#include "serial.h"

#include "serial.h"

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

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

#include "remote-fileio.h"

#include "remote-fileio.h"

#include "gdb/fileio.h"

#include "gdb/fileio.h"

#include "gdb_stat.h"

#include "gdb_stat.h"

#include "xml-support.h"

#include "xml-support.h"

#include "memory-map.h"

#include "memory-map.h"

#include "tracepoint.h"

#include "tracepoint.h"

#include "ax.h"

#include "ax.h"

#include "ax-gdb.h"

#include "ax-gdb.h"

/* temp hacks for tracepoint encoding migration */

/* temp hacks for tracepoint encoding migration */

static char *target_buf;

static char *target_buf;

static long target_buf_size;

static long target_buf_size;

/*static*/ void

/*static*/ void

encode_actions (struct breakpoint *t, char ***tdp_actions,

encode_actions (struct breakpoint *t, char ***tdp_actions,

                char ***stepping_actions);

                char ***stepping_actions);

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

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

   does not guarantee any alignment, and gdb will generate short

   does not guarantee any alignment, and gdb will generate short

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

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

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

   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

   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

   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.

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

   The alignment chosen is arbitrary; usually data bus width is

   The alignment chosen is arbitrary; usually data bus width is

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

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

enum { REMOTE_ALIGN_WRITES = 16 };

enum { REMOTE_ALIGN_WRITES = 16 };

/* Prototypes for local functions.  */

/* Prototypes for local functions.  */

static void cleanup_sigint_signal_handler (void *dummy);

static void cleanup_sigint_signal_handler (void *dummy);

static void initialize_sigint_signal_handler (void);

static void initialize_sigint_signal_handler (void);

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

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

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

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

                                 int forever);

                                 int forever);

static void handle_remote_sigint (int);

static void handle_remote_sigint (int);

static void handle_remote_sigint_twice (int);

static void handle_remote_sigint_twice (int);

static void async_remote_interrupt (gdb_client_data);

static void async_remote_interrupt (gdb_client_data);

void async_remote_interrupt_twice (gdb_client_data);

void async_remote_interrupt_twice (gdb_client_data);

static void remote_files_info (struct target_ops *ignore);

static void remote_files_info (struct target_ops *ignore);

static void remote_prepare_to_store (struct regcache *regcache);

static void remote_prepare_to_store (struct regcache *regcache);

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

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

static void extended_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_open_1 (char *, int, struct target_ops *, int extended_p);

static void remote_close (int quitting);

static void remote_close (int quitting);

static void remote_mourn (struct target_ops *ops);

static void remote_mourn (struct target_ops *ops);

static void extended_remote_restart (void);

static void extended_remote_restart (void);

static void extended_remote_mourn (struct target_ops *);

static void extended_remote_mourn (struct target_ops *);

static void remote_mourn_1 (struct target_ops *);

static void remote_mourn_1 (struct target_ops *);

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

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

static int readchar (int timeout);

static int readchar (int timeout);

static void remote_kill (struct target_ops *ops);

static void remote_kill (struct target_ops *ops);

static int tohex (int nib);

static int tohex (int nib);

static int remote_can_async_p (void);

static int remote_can_async_p (void);

static int remote_is_async_p (void);

static int remote_is_async_p (void);

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

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

                                            void *context), void *context);

                                            void *context), void *context);

static int remote_async_mask (int new_mask);

static int remote_async_mask (int new_mask);

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

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

static void remote_interrupt (int signo);

static void remote_interrupt (int signo);

static void remote_interrupt_twice (int signo);

static void remote_interrupt_twice (int signo);

static void interrupt_query (void);

static void interrupt_query (void);

static void set_general_thread (struct ptid ptid);

static void set_general_thread (struct ptid ptid);

static void set_continue_thread (struct ptid ptid);

static void set_continue_thread (struct ptid ptid);

static void get_offsets (void);

static void get_offsets (void);

static void skip_frame (void);

static void skip_frame (void);

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

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

static int hexnumlen (ULONGEST num);

static int hexnumlen (ULONGEST num);

static void init_remote_ops (void);

static void init_remote_ops (void);

static void init_extended_remote_ops (void);

static void init_extended_remote_ops (void);

static void remote_stop (ptid_t);

static void remote_stop (ptid_t);

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

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

static int stubhex (int ch);

static int stubhex (int ch);

static int hexnumstr (char *, ULONGEST);

static int hexnumstr (char *, ULONGEST);

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

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

static CORE_ADDR remote_address_masked (CORE_ADDR);

static CORE_ADDR remote_address_masked (CORE_ADDR);

static void print_packet (char *);

static void print_packet (char *);

static unsigned long crc32 (unsigned char *, int, unsigned int);

static unsigned long crc32 (unsigned char *, int, unsigned int);

static void compare_sections_command (char *, int);

static void compare_sections_command (char *, int);

static void packet_command (char *, int);

static void packet_command (char *, int);

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

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

static ptid_t remote_current_thread (ptid_t oldptid);

static ptid_t remote_current_thread (ptid_t oldptid);

static void remote_find_new_threads (void);

static void remote_find_new_threads (void);

static void record_currthread (ptid_t currthread);

static void record_currthread (ptid_t currthread);

static int fromhex (int a);

static int fromhex (int a);

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

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

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

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

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

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

static void check_binary_download (CORE_ADDR addr);

static void check_binary_download (CORE_ADDR addr);

struct packet_config;

struct packet_config;

static void show_packet_config_cmd (struct packet_config *config);

static void show_packet_config_cmd (struct packet_config *config);

static void update_packet_config (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,

static void set_remote_protocol_packet_cmd (char *args, int from_tty,

                                            struct cmd_list_element *c);

                                            struct cmd_list_element *c);

static void show_remote_protocol_packet_cmd (struct ui_file *file,

static void show_remote_protocol_packet_cmd (struct ui_file *file,

                                             int from_tty,

                                             int from_tty,

                                             struct cmd_list_element *c,

                                             struct cmd_list_element *c,

                                             const char *value);

                                             const char *value);

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

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

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

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

struct remote_state;

struct remote_state;

static int remote_get_trace_status (struct trace_status *ts);

static int remote_get_trace_status (struct trace_status *ts);

static int remote_upload_tracepoints (struct uploaded_tp **utpp);

static int remote_upload_tracepoints (struct uploaded_tp **utpp);

static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);

static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);

static void remote_query_supported (void);

static void remote_query_supported (void);

static void remote_check_symbols (struct objfile *objfile);

static void remote_check_symbols (struct objfile *objfile);

void _initialize_remote (void);

void _initialize_remote (void);

struct stop_reply;

struct stop_reply;

static struct stop_reply *stop_reply_xmalloc (void);

static struct stop_reply *stop_reply_xmalloc (void);

static void stop_reply_xfree (struct stop_reply *);

static void stop_reply_xfree (struct stop_reply *);

static void do_stop_reply_xfree (void *arg);

static void do_stop_reply_xfree (void *arg);

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

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

static void push_stop_reply (struct stop_reply *);

static void push_stop_reply (struct stop_reply *);

static void remote_get_pending_stop_replies (void);

static void remote_get_pending_stop_replies (void);

static void discard_pending_stop_replies (int pid);

static void discard_pending_stop_replies (int pid);

static int peek_stop_reply (ptid_t ptid);

static int peek_stop_reply (ptid_t ptid);

static void remote_async_inferior_event_handler (gdb_client_data);

static void remote_async_inferior_event_handler (gdb_client_data);

static void remote_async_get_pending_events_handler (gdb_client_data);

static void remote_async_get_pending_events_handler (gdb_client_data);

static void remote_terminal_ours (void);

static void remote_terminal_ours (void);

static int remote_read_description_p (struct target_ops *target);

static int remote_read_description_p (struct target_ops *target);

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

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

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

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

static struct stop_reply *pending_stop_reply = NULL;

static struct stop_reply *pending_stop_reply = NULL;

/* For "remote".  */

/* For "remote".  */

static struct cmd_list_element *remote_cmdlist;

static struct cmd_list_element *remote_cmdlist;

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

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

static struct cmd_list_element *remote_set_cmdlist;

static struct cmd_list_element *remote_set_cmdlist;

static struct cmd_list_element *remote_show_cmdlist;

static struct cmd_list_element *remote_show_cmdlist;

/* Description of the remote protocol state for the currently

/* Description of the remote protocol state for the currently

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

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

   selected architecture.  */

   selected architecture.  */

struct remote_state

struct remote_state

{

{

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

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

     buffer is grown dynamically for larger incoming packets.

     buffer is grown dynamically for larger incoming packets.

     Outgoing packets may also be constructed in this buffer.

     Outgoing packets may also be constructed in this buffer.

     BUF_SIZE is always at least REMOTE_PACKET_SIZE;

     BUF_SIZE is always at least REMOTE_PACKET_SIZE;

     REMOTE_PACKET_SIZE should be used to limit the length of outgoing

     REMOTE_PACKET_SIZE should be used to limit the length of outgoing

     packets.  */

     packets.  */

  char *buf;

  char *buf;

  long buf_size;

  long buf_size;

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

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

     heuristics for the largest packet size that will not overflow

     heuristics for the largest packet size that will not overflow

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

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

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

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

  long explicit_packet_size;

  long explicit_packet_size;

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

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

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

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

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

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

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

     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

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

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

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

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

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

  int cached_wait_status;

  int cached_wait_status;

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

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

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

     reliable.  */

     reliable.  */

  int noack_mode;

  int noack_mode;

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

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

  int extended;

  int extended;

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

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

     extensions.  */

     extensions.  */

  int multi_process_aware;

  int multi_process_aware;

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

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

     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

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

     timeout waiting for a reply that would never come and eventually

     timeout waiting for a reply that would never come and eventually

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

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

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

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

  int waiting_for_stop_reply;

  int waiting_for_stop_reply;

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

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

  int non_stop_aware;

  int non_stop_aware;

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

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

  int support_vCont_t;

  int support_vCont_t;

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

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

  int cond_tracepoints;

  int cond_tracepoints;

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

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

  int fast_tracepoints;

  int fast_tracepoints;

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

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

     disconnected.  */

     disconnected.  */

  int disconnected_tracing;

  int disconnected_tracing;

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

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

     responded to that.  */

     responded to that.  */

  int ctrlc_pending_p;

  int ctrlc_pending_p;

};

};

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

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

struct private_thread_info

struct private_thread_info

{

{

  char *extra;

  char *extra;

  int core;

  int core;

};

};

static void

static void

free_private_thread_info (struct private_thread_info *info)

free_private_thread_info (struct private_thread_info *info)

{

{

  xfree (info->extra);

  xfree (info->extra);

  xfree (info);

  xfree (info);

}

}

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

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

static int

static int

remote_multi_process_p (struct remote_state *rs)

remote_multi_process_p (struct remote_state *rs)

{

{

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

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

}

}

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

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

   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

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

   at a time.  */

   at a time.  */

static struct remote_state remote_state;

static struct remote_state remote_state;

static struct remote_state *

static struct remote_state *

get_remote_state_raw (void)

get_remote_state_raw (void)

{

{

  return &remote_state;

  return &remote_state;

}

}

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

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

struct packet_reg

struct packet_reg

{

{

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

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

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

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

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

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

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

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

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

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

     at present.  */

     at present.  */

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

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

     at present.  */

     at present.  */

};

};

struct remote_arch_state

struct remote_arch_state

{

{

  /* Description of the remote protocol registers.  */

  /* Description of the remote protocol registers.  */

  long sizeof_g_packet;

  long sizeof_g_packet;

  /* Description of the remote protocol registers indexed by REGNUM

  /* Description of the remote protocol registers indexed by REGNUM

     (making an array gdbarch_num_regs in size).  */

     (making an array gdbarch_num_regs in size).  */

  struct packet_reg *regs;

  struct packet_reg *regs;

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

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

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

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

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

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

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

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

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

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

     trailers).  */

     trailers).  */

  long actual_register_packet_size;

  long actual_register_packet_size;

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

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

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

  long remote_packet_size;

  long remote_packet_size;

};

};

long sizeof_pkt = 2000;

long sizeof_pkt = 2000;

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

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

static void

static void

trace_error (char *buf)

trace_error (char *buf)

{

{

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

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

    return;                     /* not an error msg */

    return;                     /* not an error msg */

  switch (*buf)

  switch (*buf)

    {

    {

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

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

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

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

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

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

      else

      else

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

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

               strtol (buf, NULL, 16));

               strtol (buf, NULL, 16));

    case '2':

    case '2':

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

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

    default:

    default:

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

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

    }

    }

}

}

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

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

static char *

static char *

remote_get_noisy_reply (char **buf_p,

remote_get_noisy_reply (char **buf_p,

                        long *sizeof_buf)

                        long *sizeof_buf)

{

{

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

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

    {

    {

      char *buf;

      char *buf;

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

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

      getpkt (buf_p, sizeof_buf, 0);

      getpkt (buf_p, sizeof_buf, 0);

      buf = *buf_p;

      buf = *buf_p;

      if (buf[0] == 0)

      if (buf[0] == 0)

        error (_("Target does not support this command."));

        error (_("Target does not support this command."));

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

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

        trace_error (buf);

        trace_error (buf);

      else if (buf[0] == 'O' &&

      else if (buf[0] == 'O' &&

               buf[1] != 'K')

               buf[1] != 'K')

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

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

      else

      else

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

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

    }

    }

  while (1);

  while (1);

}

}

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

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

static struct gdbarch_data *remote_gdbarch_data_handle;

static struct gdbarch_data *remote_gdbarch_data_handle;

static struct remote_arch_state *

static struct remote_arch_state *

get_remote_arch_state (void)

get_remote_arch_state (void)

{

{

  return gdbarch_data (target_gdbarch, remote_gdbarch_data_handle);

  return gdbarch_data (target_gdbarch, remote_gdbarch_data_handle);

}

}

/* Fetch the global remote target state.  */

/* Fetch the global remote target state.  */

static struct remote_state *

static struct remote_state *

get_remote_state (void)

get_remote_state (void)

{

{

  /* Make sure that the remote architecture state has been

  /* Make sure that the remote architecture state has been

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

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

     function which calls getpkt also needs to be mindful of changes

     function which calls getpkt also needs to be mindful of changes

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

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

     into trouble.  */

     into trouble.  */

  get_remote_arch_state ();

  get_remote_arch_state ();

  return get_remote_state_raw ();

  return get_remote_state_raw ();

}

}

static int

static int

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

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

{

{

  const struct packet_reg * const *lhs = lhs_;

  const struct packet_reg * const *lhs = lhs_;

  const struct packet_reg * const *rhs = rhs_;

  const struct packet_reg * const *rhs = rhs_;

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

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

    return -1;

    return -1;

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

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

    return 0;

    return 0;

  else

  else

    return 1;

    return 1;

}

}

static void *

static void *

init_remote_state (struct gdbarch *gdbarch)

init_remote_state (struct gdbarch *gdbarch)

{

{

  int regnum, num_remote_regs, offset;

  int regnum, num_remote_regs, offset;

  struct remote_state *rs = get_remote_state_raw ();

  struct remote_state *rs = get_remote_state_raw ();

  struct remote_arch_state *rsa;

  struct remote_arch_state *rsa;

  struct packet_reg **remote_regs;

  struct packet_reg **remote_regs;

  rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);

  rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);

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

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

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

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

  rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,

  rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,

                                      gdbarch_num_regs (gdbarch),

                                      gdbarch_num_regs (gdbarch),

                                      struct packet_reg);

                                      struct packet_reg);

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

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

    {

    {

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

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

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

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

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

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

        r->pnum = -1;

        r->pnum = -1;

      else

      else

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

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

      r->regnum = regnum;

      r->regnum = regnum;

    }

    }

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

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

     with a remote protocol number, in order of ascending protocol

     with a remote protocol number, in order of ascending protocol

     number.  */

     number.  */

  remote_regs = alloca (gdbarch_num_regs (gdbarch)

  remote_regs = alloca (gdbarch_num_regs (gdbarch)

                          * sizeof (struct packet_reg *));

                          * sizeof (struct packet_reg *));

  for (num_remote_regs = 0, regnum = 0;

  for (num_remote_regs = 0, regnum = 0;

       regnum < gdbarch_num_regs (gdbarch);

       regnum < gdbarch_num_regs (gdbarch);

       regnum++)

       regnum++)

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

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

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

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

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

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

         compare_pnums);

         compare_pnums);

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

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

    {

    {

      remote_regs[regnum]->in_g_packet = 1;

      remote_regs[regnum]->in_g_packet = 1;

      remote_regs[regnum]->offset = offset;

      remote_regs[regnum]->offset = offset;

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

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

    }

    }

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

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

     to be smaller.  */

     to be smaller.  */

  rsa->sizeof_g_packet = offset;

  rsa->sizeof_g_packet = offset;

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

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

     remote stubs have a hardwired buffer size of 400 bytes

     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

     (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

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

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

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

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

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

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

  rsa->remote_packet_size = 400 - 1;

  rsa->remote_packet_size = 400 - 1;

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

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

  rsa->actual_register_packet_size = 0;

  rsa->actual_register_packet_size = 0;

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

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

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

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

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

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

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

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

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

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

     little.  */

     little.  */

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

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

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

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

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

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

     this architecture.  */