/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright 1988, 1991-2000 Free Software Foundation, Inc.
+ Copyright 1988, 1991-2000, 2001 Free Software Foundation, Inc.
This file is part of GDB.
#include "bfd.h"
#include "symfile.h"
#include "target.h"
-#include "wait.h"
+#include "gdb_wait.h"
/*#include "terminal.h" */
#include "gdbcmd.h"
#include "objfiles.h"
#include "gdbthread.h"
#include "remote.h"
-#include "dcache.h"
-
#include <ctype.h>
#include <sys/time.h>
#ifdef USG
static void initialize_sigint_signal_handler (void);
static int getpkt_sane (char *buf, long sizeof_buf, int forever);
-static void handle_remote_sigint PARAMS ((int));
-static void handle_remote_sigint_twice PARAMS ((int));
-static void async_remote_interrupt PARAMS ((gdb_client_data));
-void async_remote_interrupt_twice PARAMS ((gdb_client_data));
+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 build_remote_gdbarch_data PARAMS ((void));
+static void build_remote_gdbarch_data (void);
static int remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len);
-static int remote_read_bytes PARAMS ((CORE_ADDR memaddr,
- char *myaddr, int len));
+static int remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len);
-static void remote_files_info PARAMS ((struct target_ops * ignore));
+static void remote_files_info (struct target_ops *ignore);
-static int remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
- int len, int should_write,
- struct target_ops * target));
+static int remote_xfer_memory (CORE_ADDR memaddr, char *myaddr,
+ int len, int should_write,
+ struct mem_attrib *attrib,
+ struct target_ops *target);
-static void remote_prepare_to_store PARAMS ((void));
+static void remote_prepare_to_store (void);
-static void remote_fetch_registers PARAMS ((int regno));
+static void remote_fetch_registers (int regno);
-static void remote_resume PARAMS ((int pid, int step,
- enum target_signal siggnal));
-static void remote_async_resume PARAMS ((int pid, int step,
- enum target_signal siggnal));
-static int remote_start_remote PARAMS ((PTR));
+static void remote_resume (int pid, int step, enum target_signal siggnal);
+static void remote_async_resume (int pid, int step,
+ enum target_signal siggnal);
+static int remote_start_remote (PTR);
-static void remote_open PARAMS ((char *name, int from_tty));
-static void remote_async_open PARAMS ((char *name, int from_tty));
+static void remote_open (char *name, int from_tty);
+static void remote_async_open (char *name, int from_tty);
-static void extended_remote_open PARAMS ((char *name, int from_tty));
-static void extended_remote_async_open PARAMS ((char *name, int from_tty));
+static void extended_remote_open (char *name, int from_tty);
+static void extended_remote_async_open (char *name, int from_tty);
-static void remote_open_1 PARAMS ((char *, int, struct target_ops *,
- int extended_p));
-static void remote_async_open_1 PARAMS ((char *, int, struct target_ops *,
- int extended_p));
+static void remote_open_1 (char *, int, struct target_ops *, int extended_p);
+static void remote_async_open_1 (char *, int, struct target_ops *,
+ int extended_p);
-static void remote_close PARAMS ((int quitting));
+static void remote_close (int quitting);
-static void remote_store_registers PARAMS ((int regno));
+static void remote_store_registers (int regno);
-static void remote_mourn PARAMS ((void));
-static void remote_async_mourn PARAMS ((void));
+static void remote_mourn (void);
+static void remote_async_mourn (void);
-static void extended_remote_restart PARAMS ((void));
+static void extended_remote_restart (void);
-static void extended_remote_mourn PARAMS ((void));
+static void extended_remote_mourn (void);
-static void extended_remote_create_inferior PARAMS ((char *, char *, char **));
-static void extended_remote_async_create_inferior PARAMS ((char *, char *, char **));
+static void extended_remote_create_inferior (char *, char *, char **);
+static void extended_remote_async_create_inferior (char *, char *, char **);
-static void remote_mourn_1 PARAMS ((struct target_ops *));
+static void remote_mourn_1 (struct target_ops *);
static void remote_send (char *buf, long sizeof_buf);
-static int readchar PARAMS ((int timeout));
+static int readchar (int timeout);
-static int remote_wait PARAMS ((int pid, struct target_waitstatus * status));
-static int remote_async_wait PARAMS ((int pid, struct target_waitstatus * status));
+static int remote_wait (int pid, struct target_waitstatus *status);
+static int remote_async_wait (int pid, struct target_waitstatus *status);
-static void remote_kill PARAMS ((void));
-static void remote_async_kill PARAMS ((void));
+static void remote_kill (void);
+static void remote_async_kill (void);
-static int tohex PARAMS ((int nib));
+static int tohex (int nib);
-static void remote_detach PARAMS ((char *args, int from_tty));
-static void remote_async_detach PARAMS ((char *args, int from_tty));
+static void remote_detach (char *args, int from_tty);
+static void remote_async_detach (char *args, int from_tty);
-static void remote_interrupt PARAMS ((int signo));
+static void remote_interrupt (int signo);
-static void remote_interrupt_twice PARAMS ((int signo));
+static void remote_interrupt_twice (int signo);
-static void interrupt_query PARAMS ((void));
+static void interrupt_query (void);
-static void set_thread PARAMS ((int, int));
+static void set_thread (int, int);
-static int remote_thread_alive PARAMS ((int));
+static int remote_thread_alive (int);
-static void get_offsets PARAMS ((void));
+static void get_offsets (void);
static long read_frame (char *buf, long sizeof_buf);
-static int remote_insert_breakpoint PARAMS ((CORE_ADDR, char *));
+static int remote_insert_breakpoint (CORE_ADDR, char *);
-static int remote_remove_breakpoint PARAMS ((CORE_ADDR, char *));
+static int remote_remove_breakpoint (CORE_ADDR, char *);
-static int hexnumlen PARAMS ((ULONGEST num));
+static int hexnumlen (ULONGEST num);
-static void init_remote_ops PARAMS ((void));
+static void init_remote_ops (void);
-static void init_extended_remote_ops PARAMS ((void));
+static void init_extended_remote_ops (void);
-static void init_remote_cisco_ops PARAMS ((void));
+static void init_remote_cisco_ops (void);
static struct target_ops remote_cisco_ops;
-static void remote_stop PARAMS ((void));
+static void remote_stop (void);
-static int ishex PARAMS ((int ch, int *val));
+static int ishex (int ch, int *val);
-static int stubhex PARAMS ((int ch));
+static int stubhex (int ch);
-static int remote_query PARAMS ((int /*char */ , char *, char *, int *));
+static int remote_query (int /*char */ , char *, char *, int *);
-static int hexnumstr PARAMS ((char *, ULONGEST));
+static int hexnumstr (char *, ULONGEST);
-static int hexnumnstr PARAMS ((char *, ULONGEST, int));
+static int hexnumnstr (char *, ULONGEST, int);
-static CORE_ADDR remote_address_masked PARAMS ((CORE_ADDR));
+static CORE_ADDR remote_address_masked (CORE_ADDR);
-static void print_packet PARAMS ((char *));
+static void print_packet (char *);
-static unsigned long crc32 PARAMS ((unsigned char *, int, unsigned int));
+static unsigned long crc32 (unsigned char *, int, unsigned int);
-static void compare_sections_command PARAMS ((char *, int));
+static void compare_sections_command (char *, int);
-static void packet_command PARAMS ((char *, int));
+static void packet_command (char *, int);
-static int stub_unpack_int PARAMS ((char *buff, int fieldlength));
+static int stub_unpack_int (char *buff, int fieldlength);
-static int remote_current_thread PARAMS ((int oldpid));
+static int remote_current_thread (int oldpid);
-static void remote_find_new_threads PARAMS ((void));
+static void remote_find_new_threads (void);
-static void record_currthread PARAMS ((int currthread));
+static void record_currthread (int currthread);
/* exported functions */
-extern int fromhex PARAMS ((int a));
+extern int fromhex (int a);
-static int putpkt_binary PARAMS ((char *buf, int cnt));
+static int putpkt_binary (char *buf, int cnt);
-static void check_binary_download PARAMS ((CORE_ADDR addr));
+static void check_binary_download (CORE_ADDR addr);
struct packet_config;
-static void show_packet_config_cmd PARAMS ((struct packet_config * config));
-
-static void set_packet_config_cmd PARAMS ((struct packet_config * config,
- struct cmd_list_element * c));
-
-static void add_packet_config_cmd PARAMS ((struct packet_config * config,
- char *name,
- char *title,
- void (*set_func) (char *args, int from_tty, struct cmd_list_element * c),
- void (*show_func) (char *name, int from_tty),
- struct cmd_list_element **setlist,
- struct cmd_list_element **showlist));
-
-static void init_packet_config PARAMS ((struct packet_config * config));
-
-static void set_remote_protocol_P_packet_cmd PARAMS ((char *args,
- int from_tty,
- struct cmd_list_element * c));
-
-static void show_remote_protocol_P_packet_cmd PARAMS ((char *args,
- int from_tty));
-
-static void set_remote_protocol_Z_packet_cmd PARAMS ((char *args,
- int from_tty,
- struct cmd_list_element * c));
-
-static void show_remote_protocol_Z_packet_cmd PARAMS ((char *args,
- int from_tty));
-
-
+static void show_packet_config_cmd (struct packet_config *config);
+static void update_packet_config (struct packet_config *config);
/* Define the target subroutine names */
-void open_remote_target PARAMS ((char *, int, struct target_ops *, int));
+void open_remote_target (char *, int, struct target_ops *, int);
-void _initialize_remote PARAMS ((void));
+void _initialize_remote (void);
/* */
static struct target_ops extended_async_remote_ops;
-/* This was 5 seconds, which is a long time to sit and wait.
- Unless this is going though some terminal server or multiplexer or
- other form of hairy serial connection, I would think 2 seconds would
- be plenty. */
-
-/* Changed to allow option to set timeout value.
- was static int remote_timeout = 2; */
-extern int remote_timeout;
-
/* 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
PACKET_DISABLE
};
-enum packet_detect
- {
- PACKET_AUTO_DETECT = 0,
- PACKET_MANUAL_DETECT
- };
-
struct packet_config
{
- char *state;
char *name;
char *title;
- enum packet_detect detect;
+ enum cmd_auto_boolean detect;
enum packet_support support;
};
-static char packet_support_auto[] = "auto";
-static char packet_enable[] = "enable";
-static char packet_disable[] = "disable";
-static char *packet_support_enums[] =
+/* Analyze a packet's return value and update the packet config
+ accordingly. */
+
+enum packet_result
{
- packet_support_auto,
- packet_enable,
- packet_disable,
- 0,
+ PACKET_ERROR,
+ PACKET_OK,
+ PACKET_UNKNOWN
};
static void
-set_packet_config_cmd (config, c)
- struct packet_config *config;
- struct cmd_list_element *c;
+update_packet_config (struct packet_config *config)
{
- if (config->state == packet_enable)
+ switch (config->detect)
{
- config->detect = PACKET_MANUAL_DETECT;
+ case CMD_AUTO_BOOLEAN_TRUE:
config->support = PACKET_ENABLE;
- }
- else if (config->state == packet_disable)
- {
- config->detect = PACKET_MANUAL_DETECT;
+ break;
+ case CMD_AUTO_BOOLEAN_FALSE:
config->support = PACKET_DISABLE;
- }
- else if (config->state == packet_support_auto)
- {
- config->detect = PACKET_AUTO_DETECT;
+ break;
+ case CMD_AUTO_BOOLEAN_AUTO:
config->support = PACKET_SUPPORT_UNKNOWN;
+ break;
}
- else
- internal_error ("Bad enum value");
}
static void
-show_packet_config_cmd (config)
- struct packet_config *config;
+show_packet_config_cmd (struct packet_config *config)
{
char *support = "internal-error";
switch (config->support)
}
switch (config->detect)
{
- case PACKET_AUTO_DETECT:
+ case CMD_AUTO_BOOLEAN_AUTO:
printf_filtered ("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n",
config->name, config->title, support);
break;
- case PACKET_MANUAL_DETECT:
- printf_filtered ("Support for remote protocol `%s' (%s) is currently %s.\n",
+ case CMD_AUTO_BOOLEAN_TRUE:
+ case CMD_AUTO_BOOLEAN_FALSE:
+ printf_filtered ("Support for remote protocol `%s' (%s) packet is currently %s.\n",
config->name, config->title, support);
+ break;
}
}
static void
-add_packet_config_cmd (config, name, title, set_func, show_func,
- setlist, showlist)
- struct packet_config *config;
- char *name;
- char *title;
- void (*set_func) PARAMS ((char *args, int from_tty,
- struct cmd_list_element * c));
- void (*show_func) PARAMS ((char *name, int from_tty));
- struct cmd_list_element **setlist;
- struct cmd_list_element **showlist;
-{
- struct cmd_list_element *c;
+add_packet_config_cmd (struct packet_config *config,
+ char *name,
+ char *title,
+ void (*set_func) (char *args, int from_tty,
+ struct cmd_list_element *
+ c),
+ void (*show_func) (char *name,
+ int from_tty),
+ struct cmd_list_element **set_remote_list,
+ struct cmd_list_element **show_remote_list,
+ int legacy)
+{
+ struct cmd_list_element *set_cmd;
+ struct cmd_list_element *show_cmd;
char *set_doc;
char *show_doc;
- char *full_name;
+ char *cmd_name;
config->name = name;
config->title = title;
- asprintf (&set_doc, "Set use of remote protocol `%s' (%s) packet",
- name, title);
- asprintf (&show_doc, "Show current use of remote protocol `%s' (%s) packet",
- name, title);
- asprintf (&full_name, "%s-packet", name);
- c = add_set_enum_cmd (full_name,
- class_obscure, packet_support_enums,
- (char *) &config->state,
- set_doc, setlist);
- c->function.sfunc = set_func;
- add_cmd (full_name, class_obscure, show_func, show_doc, showlist);
+ config->detect = CMD_AUTO_BOOLEAN_AUTO;
+ config->support = PACKET_SUPPORT_UNKNOWN;
+ xasprintf (&set_doc, "Set use of remote protocol `%s' (%s) packet",
+ name, title);
+ xasprintf (&show_doc, "Show current use of remote protocol `%s' (%s) packet",
+ name, title);
+ /* set/show TITLE-packet {auto,on,off} */
+ xasprintf (&cmd_name, "%s-packet", title);
+ set_cmd = add_set_auto_boolean_cmd (cmd_name, class_obscure,
+ &config->detect, set_doc,
+ set_remote_list);
+ set_cmd->function.sfunc = set_func;
+ show_cmd = add_cmd (cmd_name, class_obscure, show_func, show_doc,
+ show_remote_list);
+ /* set/show remote NAME-packet {auto,on,off} -- legacy */
+ if (legacy)
+ {
+ char *legacy_name;
+ xasprintf (&legacy_name, "%s-packet", name);
+ add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
+ set_remote_list);
+ add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
+ show_remote_list);
+ }
}
-static void
-init_packet_config (config)
- struct packet_config *config;
+static enum packet_result
+packet_ok (const char *buf, struct packet_config *config)
{
- switch (config->detect)
+ if (buf[0] != '\0')
{
- case PACKET_AUTO_DETECT:
- config->support = PACKET_SUPPORT_UNKNOWN;
- break;
- case PACKET_MANUAL_DETECT:
- /* let the user beware */
- break;
+ /* The stub recognized the packet request. Check that the
+ operation succeeded. */
+ switch (config->support)
+ {
+ case PACKET_SUPPORT_UNKNOWN:
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog,
+ "Packet %s (%s) is supported\n",
+ config->name, config->title);
+ config->support = PACKET_ENABLE;
+ break;
+ case PACKET_DISABLE:
+ internal_error ("packet_ok: attempt to use a disabled packet");
+ break;
+ case PACKET_ENABLE:
+ break;
+ }
+ if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
+ /* "OK" - definitly OK. */
+ return PACKET_OK;
+ if (buf[0] == 'E'
+ && isxdigit (buf[1]) && isxdigit (buf[2])
+ && buf[3] == '\0')
+ /* "Enn" - definitly an error. */
+ return PACKET_ERROR;
+ /* The packet may or may not be OK. Just assume it is */
+ return PACKET_OK;
+ }
+ else
+ {
+ /* The stub does not support the packet. */
+ switch (config->support)
+ {
+ case PACKET_ENABLE:
+ if (config->detect == CMD_AUTO_BOOLEAN_AUTO)
+ /* If the stub previously indicated that the packet was
+ supported then there is a protocol error.. */
+ error ("Protocol error: %s (%s) conflicting enabled responses.",
+ config->name, config->title);
+ else
+ /* The user set it wrong. */
+ error ("Enabled packet %s (%s) not recognized by stub",
+ config->name, config->title);
+ break;
+ case PACKET_SUPPORT_UNKNOWN:
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog,
+ "Packet %s (%s) is NOT supported\n",
+ config->name, config->title);
+ config->support = PACKET_DISABLE;
+ break;
+ case PACKET_DISABLE:
+ break;
+ }
+ return PACKET_UNKNOWN;
}
}
static struct packet_config remote_protocol_P;
static void
-set_remote_protocol_P_packet_cmd (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_remote_protocol_P_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- set_packet_config_cmd (&remote_protocol_P, c);
+ update_packet_config (&remote_protocol_P);
}
static void
-show_remote_protocol_P_packet_cmd (args, from_tty)
- char *args;
- int from_tty;
+show_remote_protocol_P_packet_cmd (char *args, int from_tty)
{
show_packet_config_cmd (&remote_protocol_P);
}
-/* Should we try the 'Z' (set breakpoint) request? */
+/* Should we try one of the 'Z' requests? */
+
+enum Z_packet_type
+{
+ Z_PACKET_SOFTWARE_BP,
+ Z_PACKET_HARDWARE_BP,
+ Z_PACKET_WRITE_WP,
+ Z_PACKET_READ_WP,
+ Z_PACKET_ACCESS_WP,
+ NR_Z_PACKET_TYPES
+};
+
+static struct packet_config remote_protocol_Z[NR_Z_PACKET_TYPES];
+
+/* FIXME: Instead of having all these boiler plate functions, the
+ command callback should include a context argument. */
+
+static void
+set_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ update_packet_config (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
+}
+
+static void
+show_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty)
+{
+ show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
+}
+
+static void
+set_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ update_packet_config (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
+}
+
+static void
+show_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty)
+{
+ show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
+}
+
+static void
+set_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ update_packet_config (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
+}
+
+static void
+show_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty)
+{
+ show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
+}
+
+static void
+set_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ update_packet_config (&remote_protocol_Z[Z_PACKET_READ_WP]);
+}
-static struct packet_config remote_protocol_Z;
+static void
+show_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty)
+{
+ show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP]);
+}
static void
-set_remote_protocol_Z_packet_cmd (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- set_packet_config_cmd (&remote_protocol_Z, c);
+ update_packet_config (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
}
static void
-show_remote_protocol_Z_packet_cmd (args, from_tty)
- char *args;
- int from_tty;
+show_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty)
{
- show_packet_config_cmd (&remote_protocol_Z);
+ show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
+}
+
+/* For compatibility with older distributions. Provide a ``set remote
+ Z-packet ...'' command that updates all the Z packet types. */
+
+static enum cmd_auto_boolean remote_Z_packet_detect;
+
+static void
+set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ int i;
+ for (i = 0; i < NR_Z_PACKET_TYPES; i++)
+ {
+ remote_protocol_Z[i].detect = remote_Z_packet_detect;
+ update_packet_config (&remote_protocol_Z[i]);
+ }
+}
+
+static void
+show_remote_protocol_Z_packet_cmd (char *args, int from_tty)
+{
+ int i;
+ for (i = 0; i < NR_Z_PACKET_TYPES; i++)
+ {
+ show_packet_config_cmd (&remote_protocol_Z[i]);
+ }
}
/* Should we try the 'X' (remote binary download) packet?
static struct packet_config remote_protocol_binary_download;
+/* Should we try the 'ThreadInfo' query packet?
+
+ This variable (NOT available to the user: auto-detect only!)
+ determines whether GDB will use the new, simpler "ThreadInfo"
+ query or the older, more complex syntax for thread queries.
+ This is an auto-detect variable (set to true at each connect,
+ and set to false when the target fails to recognize it). */
+
+static int use_threadinfo_query;
+static int use_threadextra_query;
+
static void
set_remote_protocol_binary_download_cmd (char *args,
int from_tty,
struct cmd_list_element *c)
{
- set_packet_config_cmd (&remote_protocol_binary_download, c);
+ update_packet_config (&remote_protocol_binary_download);
}
static void
/* These are pointers to hook functions that may be set in order to
modify resume/wait behavior for a particular architecture. */
-void (*target_resume_hook) PARAMS ((void));
-void (*target_wait_loop_hook) PARAMS ((void));
+void (*target_resume_hook) (void);
+void (*target_wait_loop_hook) (void);
\f
*/
static void
-record_currthread (currthread)
- int currthread;
+record_currthread (int currthread)
{
general_thread = currthread;
#define MAGIC_NULL_PID 42000
static void
-set_thread (th, gen)
- int th;
- int gen;
+set_thread (int th, int gen)
{
char *buf = alloca (PBUFSIZ);
int state = gen ? general_thread : continue_thread;
/* Return nonzero if the thread TH is still alive on the remote system. */
static int
-remote_thread_alive (tid)
- int tid;
+remote_thread_alive (int tid)
{
char buf[16];
typedef int gdb_threadref; /* internal GDB thread reference */
-/* gdb_ext_thread_info is an internal GDB data structure which is
+/* gdb_ext_thread_info is an internal GDB data structure which is
equivalint to the reply of the remote threadinfo packet */
struct gdb_ext_thread_info
#define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES*2)
-char *unpack_varlen_hex PARAMS ((char *buff, int *result));
+char *unpack_varlen_hex (char *buff, int *result);
-static char *unpack_nibble PARAMS ((char *buf, int *val));
+static char *unpack_nibble (char *buf, int *val);
-static char *pack_nibble PARAMS ((char *buf, int nibble));
+static char *pack_nibble (char *buf, int nibble);
-static char *pack_hex_byte PARAMS ((char *pkt, int /*unsigned char */ byte));
+static char *pack_hex_byte (char *pkt, int /*unsigned char */ byte);
-static char *unpack_byte PARAMS ((char *buf, int *value));
+static char *unpack_byte (char *buf, int *value);
-static char *pack_int PARAMS ((char *buf, int value));
+static char *pack_int (char *buf, int value);
-static char *unpack_int PARAMS ((char *buf, int *value));
+static char *unpack_int (char *buf, int *value);
-static char *unpack_string PARAMS ((char *src, char *dest, int length));
+static char *unpack_string (char *src, char *dest, int length);
-static char *pack_threadid PARAMS ((char *pkt, threadref * id));
+static char *pack_threadid (char *pkt, threadref * id);
-static char *unpack_threadid PARAMS ((char *inbuf, threadref * id));
+static char *unpack_threadid (char *inbuf, threadref * id);
-void int_to_threadref PARAMS ((threadref * id, int value));
+void int_to_threadref (threadref * id, int value);
-static int threadref_to_int PARAMS ((threadref * ref));
+static int threadref_to_int (threadref * ref);
-static void copy_threadref PARAMS ((threadref * dest, threadref * src));
+static void copy_threadref (threadref * dest, threadref * src);
-static int threadmatch PARAMS ((threadref * dest, threadref * src));
+static int threadmatch (threadref * dest, threadref * src);
-static char *pack_threadinfo_request PARAMS ((char *pkt, int mode,
- threadref * id));
+static char *pack_threadinfo_request (char *pkt, int mode, threadref * id);
-static int remote_unpack_thread_info_response PARAMS ((char *pkt,
- threadref * expectedref,
- struct gdb_ext_thread_info * info));
+static int remote_unpack_thread_info_response (char *pkt,
+ threadref * expectedref,
+ struct gdb_ext_thread_info
+ *info);
-static int remote_get_threadinfo PARAMS ((threadref * threadid,
- int fieldset, /*TAG mask */
- struct gdb_ext_thread_info * info));
+static int remote_get_threadinfo (threadref * threadid, int fieldset, /*TAG mask */
+ struct gdb_ext_thread_info *info);
-static int adapt_remote_get_threadinfo PARAMS ((gdb_threadref * ref,
- int selection,
- struct gdb_ext_thread_info * info));
+static int adapt_remote_get_threadinfo (gdb_threadref * ref,
+ int selection,
+ struct gdb_ext_thread_info *info);
-static char *pack_threadlist_request PARAMS ((char *pkt, int startflag,
- int threadcount,
- threadref * nextthread));
+static char *pack_threadlist_request (char *pkt, int startflag,
+ int threadcount,
+ threadref * nextthread);
-static int parse_threadlist_response PARAMS ((char *pkt,
- int result_limit,
- threadref * original_echo,
- threadref * resultlist,
- int *doneflag));
+static int parse_threadlist_response (char *pkt,
+ int result_limit,
+ threadref * original_echo,
+ threadref * resultlist, int *doneflag);
-static int remote_get_threadlist PARAMS ((int startflag,
- threadref * nextthread,
- int result_limit,
- int *done,
- int *result_count,
- threadref * threadlist));
+static int remote_get_threadlist (int startflag,
+ threadref * nextthread,
+ int result_limit,
+ int *done,
+ int *result_count, threadref * threadlist);
typedef int (*rmt_thread_action) (threadref * ref, void *context);
-static int remote_threadlist_iterator PARAMS ((rmt_thread_action stepfunction,
- void *context, int looplimit));
+static int remote_threadlist_iterator (rmt_thread_action stepfunction,
+ void *context, int looplimit);
-static int remote_newthread_step PARAMS ((threadref * ref, void *context));
+static int remote_newthread_step (threadref * ref, void *context);
/* encode 64 bits in 16 chars of hex */
static const char hexchars[] = "0123456789abcdef";
static int
-ishex (ch, val)
- int ch;
- int *val;
+ishex (int ch, int *val)
{
if ((ch >= 'a') && (ch <= 'f'))
{
}
static int
-stubhex (ch)
- int ch;
+stubhex (int ch)
{
if (ch >= 'a' && ch <= 'f')
return ch - 'a' + 10;
}
static int
-stub_unpack_int (buff, fieldlength)
- char *buff;
- int fieldlength;
+stub_unpack_int (char *buff, int fieldlength)
{
int nibble;
int retval = 0;
}
char *
-unpack_varlen_hex (buff, result)
- char *buff; /* packet to parse */
- int *result;
+unpack_varlen_hex (char *buff, /* packet to parse */
+ int *result)
{
int nibble;
int retval = 0;
}
static char *
-unpack_nibble (buf, val)
- char *buf;
- int *val;
+unpack_nibble (char *buf, int *val)
{
ishex (*buf++, val);
return buf;
}
static char *
-pack_nibble (buf, nibble)
- char *buf;
- int nibble;
+pack_nibble (char *buf, int nibble)
{
*buf++ = hexchars[(nibble & 0x0f)];
return buf;
}
static char *
-pack_hex_byte (pkt, byte)
- char *pkt;
- int byte;
+pack_hex_byte (char *pkt, int byte)
{
*pkt++ = hexchars[(byte >> 4) & 0xf];
*pkt++ = hexchars[(byte & 0xf)];
}
static char *
-unpack_byte (buf, value)
- char *buf;
- int *value;
+unpack_byte (char *buf, int *value)
{
*value = stub_unpack_int (buf, 2);
return buf + 2;
}
static char *
-pack_int (buf, value)
- char *buf;
- int value;
+pack_int (char *buf, int value)
{
buf = pack_hex_byte (buf, (value >> 24) & 0xff);
buf = pack_hex_byte (buf, (value >> 16) & 0xff);
}
static char *
-unpack_int (buf, value)
- char *buf;
- int *value;
+unpack_int (char *buf, int *value)
{
*value = stub_unpack_int (buf, 8);
return buf + 8;
}
#if 0 /* currently unused, uncomment when needed */
-static char *pack_string PARAMS ((char *pkt, char *string));
+static char *pack_string (char *pkt, char *string);
static char *
-pack_string (pkt, string)
- char *pkt;
- char *string;
+pack_string (char *pkt, char *string)
{
char ch;
int len;
#endif /* 0 (unused) */
static char *
-unpack_string (src, dest, length)
- char *src;
- char *dest;
- int length;
+unpack_string (char *src, char *dest, int length)
{
while (length--)
*dest++ = *src++;
}
static char *
-pack_threadid (pkt, id)
- char *pkt;
- threadref *id;
+pack_threadid (char *pkt, threadref *id)
{
char *limit;
unsigned char *altid;
static char *
-unpack_threadid (inbuf, id)
- char *inbuf;
- threadref *id;
+unpack_threadid (char *inbuf, threadref *id)
{
char *altref;
char *limit = inbuf + BUF_THREAD_ID_SIZE;
function. */
void
-int_to_threadref (id, value)
- threadref *id;
- int value;
+int_to_threadref (threadref *id, int value)
{
unsigned char *scan;
}
static int
-threadref_to_int (ref)
- threadref *ref;
+threadref_to_int (threadref *ref)
{
int i, value = 0;
unsigned char *scan;
}
static void
-copy_threadref (dest, src)
- threadref *dest;
- threadref *src;
+copy_threadref (threadref *dest, threadref *src)
{
int i;
unsigned char *csrc, *cdest;
}
static int
-threadmatch (dest, src)
- threadref *dest;
- threadref *src;
+threadmatch (threadref *dest, threadref *src)
{
/* things are broken right now, so just assume we got a match */
#if 0
/* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
static char *
-pack_threadinfo_request (pkt, mode, id)
- char *pkt;
- int mode;
- threadref *id;
+pack_threadinfo_request (char *pkt, int mode, threadref *id)
{
*pkt++ = 'q'; /* Info Query */
*pkt++ = 'P'; /* process or thread info */
the process */
static int
-remote_unpack_thread_info_response (pkt, expectedref, info)
- char *pkt;
- threadref *expectedref;
- struct gdb_ext_thread_info *info;
+remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
+ struct gdb_ext_thread_info *info)
{
int mask, length;
unsigned int tag;
}
static int
-remote_get_threadinfo (threadid, fieldset, info)
- threadref *threadid;
- int fieldset; /* TAG mask */
- struct gdb_ext_thread_info *info;
+remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
+ struct gdb_ext_thread_info *info)
{
int result;
char *threadinfo_pkt = alloca (PBUFSIZ);
representation of a threadid. */
static int
-adapt_remote_get_threadinfo (ref, selection, info)
- gdb_threadref *ref;
- int selection;
- struct gdb_ext_thread_info *info;
+adapt_remote_get_threadinfo (gdb_threadref *ref, int selection,
+ struct gdb_ext_thread_info *info)
{
threadref lclref;
/* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
static char *
-pack_threadlist_request (pkt, startflag, threadcount, nextthread)
- char *pkt;
- int startflag;
- int threadcount;
- threadref *nextthread;
+pack_threadlist_request (char *pkt, int startflag, int threadcount,
+ threadref *nextthread)
{
*pkt++ = 'q'; /* info query packet */
*pkt++ = 'L'; /* Process LIST or threadLIST request */
/* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
static int
-parse_threadlist_response (pkt, result_limit, original_echo, resultlist,
- doneflag)
- char *pkt;
- int result_limit;
- threadref *original_echo;
- threadref *resultlist;
- int *doneflag;
+parse_threadlist_response (char *pkt, int result_limit,
+ threadref *original_echo, threadref *resultlist,
+ int *doneflag)
{
char *limit;
int count, resultcount, done;
}
static int
-remote_get_threadlist (startflag, nextthread, result_limit,
- done, result_count, threadlist)
- int startflag;
- threadref *nextthread;
- int result_limit;
- int *done;
- int *result_count;
- threadref *threadlist;
-
+remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
+ int *done, int *result_count, threadref *threadlist)
{
static threadref echo_nextthread;
char *threadlist_packet = alloca (PBUFSIZ);
#define MAXTHREADLISTRESULTS 32
static int
-remote_threadlist_iterator (stepfunction, context, looplimit)
- rmt_thread_action stepfunction;
- void *context;
- int looplimit;
+remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
+ int looplimit)
{
int done, i, result_count;
int startflag = 1;
}
static int
-remote_newthread_step (ref, context)
- threadref *ref;
- void *context;
+remote_newthread_step (threadref *ref, void *context)
{
int pid;
#define CRAZY_MAX_THREADS 1000
static int
-remote_current_thread (oldpid)
- int oldpid;
+remote_current_thread (int oldpid)
{
char *buf = alloca (PBUFSIZ);
return oldpid;
}
-/* Find new threads for info threads command. */
+/* Find new threads for info threads command.
+ * Original version, using John Metzler's thread protocol.
+ */
static void
-remote_find_new_threads ()
+remote_find_new_threads (void)
{
remote_threadlist_iterator (remote_newthread_step, 0,
CRAZY_MAX_THREADS);
inferior_pid = remote_current_thread (inferior_pid);
}
+/*
+ * Find all threads for info threads command.
+ * Uses new thread protocol contributed by Cisco.
+ * Falls back and attempts to use the older method (above)
+ * if the target doesn't respond to the new method.
+ */
+
static void
remote_threads_info (void)
{
if (remote_desc == 0) /* paranoia */
error ("Command can only be used when connected to the remote target.");
- putpkt ("qfThreadInfo");
- bufp = buf;
- getpkt (bufp, PBUFSIZ, 0);
- if (bufp[0] == '\0') /* q packet not recognized! */
- { /* try old jmetzler method */
- remote_find_new_threads ();
- return;
+ if (use_threadinfo_query)
+ {
+ putpkt ("qfThreadInfo");
+ bufp = buf;
+ getpkt (bufp, PBUFSIZ, 0);
+ if (bufp[0] != '\0') /* q packet recognized */
+ {
+ while (*bufp++ == 'm') /* reply contains one or more TID */
+ {
+ do
+ {
+ tid = strtol (bufp, &bufp, 16);
+ if (tid != 0 && !in_thread_list (tid))
+ add_thread (tid);
+ }
+ while (*bufp++ == ','); /* comma-separated list */
+ putpkt ("qsThreadInfo");
+ bufp = buf;
+ getpkt (bufp, PBUFSIZ, 0);
+ }
+ return; /* done */
+ }
+ }
+
+ /* Else fall back to old method based on jmetzler protocol. */
+ use_threadinfo_query = 0;
+ remote_find_new_threads ();
+ return;
+}
+
+/*
+ * Collect a descriptive string about the given thread.
+ * The target may say anything it wants to about the thread
+ * (typically info about its blocked / runnable state, name, etc.).
+ * This string will appear in the info threads display.
+ *
+ * Optional: targets are not required to implement this function.
+ */
+
+static char *
+remote_threads_extra_info (struct thread_info *tp)
+{
+ int result;
+ int set;
+ threadref id;
+ struct gdb_ext_thread_info threadinfo;
+ static char display_buf[100]; /* arbitrary... */
+ char *bufp = alloca (PBUFSIZ);
+ int n = 0; /* position in display_buf */
+
+ if (remote_desc == 0) /* paranoia */
+ internal_error ("remote_threads_extra_info");
+
+ if (use_threadextra_query)
+ {
+ sprintf (bufp, "qThreadExtraInfo,%x", tp->pid);
+ putpkt (bufp);
+ getpkt (bufp, PBUFSIZ, 0);
+ if (bufp[0] != 0)
+ {
+ char *p;
+
+ for (p = display_buf;
+ p < display_buf + sizeof(display_buf) - 1 &&
+ bufp[0] != 0 &&
+ bufp[1] != 0;
+ p++, bufp+=2)
+ {
+ *p = fromhex (bufp[0]) * 16 + fromhex (bufp[1]);
+ }
+ *p = 0;
+ return display_buf;
+ }
}
- else /* try new 'q' method */
- while (*bufp++ == 'm') /* reply contains one or more TID */
+
+ /* If the above query fails, fall back to the old method. */
+ use_threadextra_query = 0;
+ set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
+ | TAG_MOREDISPLAY | TAG_DISPLAY;
+ int_to_threadref (&id, tp->pid);
+ if (remote_get_threadinfo (&id, set, &threadinfo))
+ if (threadinfo.active)
{
- do
+ if (*threadinfo.shortname)
+ n += sprintf(&display_buf[0], " Name: %s,", threadinfo.shortname);
+ if (*threadinfo.display)
+ n += sprintf(&display_buf[n], " State: %s,", threadinfo.display);
+ if (*threadinfo.more_display)
+ n += sprintf(&display_buf[n], " Priority: %s",
+ threadinfo.more_display);
+
+ if (n > 0)
{
- tid = strtol (bufp, &bufp, 16);
- if (tid != 0 && !in_thread_list (tid))
- add_thread (tid);
+ /* for purely cosmetic reasons, clear up trailing commas */
+ if (',' == display_buf[n-1])
+ display_buf[n-1] = ' ';
+ return display_buf;
}
- while (*bufp++ == ','); /* comma-separated list */
- putpkt ("qsThreadInfo");
- bufp = buf;
- getpkt (bufp, PBUFSIZ, 0);
}
+ return NULL;
}
+
\f
/* Restart the remote side; this is an extended protocol operation. */
static void
-extended_remote_restart ()
+extended_remote_restart (void)
{
char *buf = alloca (PBUFSIZ);
/* ARGSUSED */
static void
-remote_close (quitting)
- int quitting;
+remote_close (int quitting)
{
if (remote_desc)
SERIAL_CLOSE (remote_desc);
/* Query the remote side for the text, data and bss offsets. */
static void
-get_offsets ()
+get_offsets (void)
{
char *buf = alloca (PBUFSIZ);
char *ptr;
offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
- ANOFFSET (offs, SECT_OFF_TEXT) = text_addr;
+ offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
/* This is a temporary kludge to force data and bss to use the same offsets
because that's what nlmconv does now. The real solution requires changes
to the stub and remote.c that I don't have time to do right now. */
- ANOFFSET (offs, SECT_OFF_DATA) = data_addr;
- ANOFFSET (offs, SECT_OFF_BSS) = data_addr;
+ offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
+ offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
objfile_relocate (symfile_objfile, offs);
}
*/
void
-remote_cisco_objfile_relocate (text_off, data_off, bss_off)
- bfd_signed_vma text_off;
- bfd_signed_vma data_off;
- bfd_signed_vma bss_off;
+remote_cisco_objfile_relocate (bfd_signed_vma text_off, bfd_signed_vma data_off,
+ bfd_signed_vma bss_off)
{
struct section_offsets *offs;
offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
- ANOFFSET (offs, SECT_OFF_TEXT) = text_off;
- ANOFFSET (offs, SECT_OFF_DATA) = data_off;
- ANOFFSET (offs, SECT_OFF_BSS) = bss_off;
+ offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_off;
+ offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_off;
+ offs->offsets[SECT_OFF_BSS (symfile_objfile)] = bss_off;
/* First call the standard objfile_relocate. */
objfile_relocate (symfile_objfile, offs);
}
static int
-remote_start_remote (dummy)
- PTR dummy;
+remote_start_remote (PTR dummy)
{
- immediate_quit = 1; /* Allow user to interrupt it */
+ immediate_quit++; /* Allow user to interrupt it */
/* Ack any packet which the remote side has already sent. */
SERIAL_WRITE (remote_desc, "+", 1);
get_offsets (); /* Get text, data & bss offsets */
putpkt ("?"); /* initiate a query from remote machine */
- immediate_quit = 0;
+ immediate_quit--;
return remote_start_remote_dummy (dummy);
}
NAME is the filename used for communication. */
static void
-remote_open (name, from_tty)
- char *name;
- int from_tty;
+remote_open (char *name, int from_tty)
{
remote_open_1 (name, from_tty, &remote_ops, 0);
}
/* Just like remote_open, but with asynchronous support. */
static void
-remote_async_open (name, from_tty)
- char *name;
- int from_tty;
+remote_async_open (char *name, int from_tty)
{
remote_async_open_1 (name, from_tty, &remote_async_ops, 0);
}
remote gdb protocol. NAME is the filename used for communication. */
static void
-extended_remote_open (name, from_tty)
- char *name;
- int from_tty;
+extended_remote_open (char *name, int from_tty)
{
remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */ );
}
/* Just like extended_remote_open, but with asynchronous support. */
static void
-extended_remote_async_open (name, from_tty)
- char *name;
- int from_tty;
+extended_remote_async_open (char *name, int from_tty)
{
remote_async_open_1 (name, from_tty, &extended_async_remote_ops, 1 /*extended_p */ );
}
/* Generic code for opening a connection to a remote target. */
-static DCACHE *remote_dcache;
+static void
+init_all_packet_configs (void)
+{
+ int i;
+ update_packet_config (&remote_protocol_P);
+ for (i = 0; i < NR_Z_PACKET_TYPES; i++)
+ update_packet_config (&remote_protocol_Z[i]);
+ /* Force remote_write_bytes to check whether target supports binary
+ downloading. */
+ update_packet_config (&remote_protocol_binary_download);
+}
static void
-remote_open_1 (name, from_tty, target, extended_p)
- char *name;
- int from_tty;
- struct target_ops *target;
- int extended_p;
+remote_open_1 (char *name, int from_tty, struct target_ops *target,
+ int extended_p)
{
if (name == 0)
error ("To open a remote debug connection, you need to specify what\n\
unpush_target (target);
- remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
-
remote_desc = SERIAL_OPEN (name);
if (!remote_desc)
perror_with_name (name);
}
push_target (target); /* Switch to using remote target now */
- init_packet_config (&remote_protocol_P);
- init_packet_config (&remote_protocol_Z);
+ init_all_packet_configs ();
general_thread = -2;
continue_thread = -2;
- /* Force remote_write_bytes to check whether target supports
- binary downloading. */
- init_packet_config (&remote_protocol_binary_download);
+ /* Probe for ability to use "ThreadInfo" query, as required. */
+ use_threadinfo_query = 1;
+ use_threadextra_query = 1;
/* Without this, some commands which require an active target (such
as kill) won't work. This variable serves (at least) double duty
/* Just like remote_open but with asynchronous support. */
static void
-remote_async_open_1 (name, from_tty, target, extended_p)
- char *name;
- int from_tty;
- struct target_ops *target;
- int extended_p;
+remote_async_open_1 (char *name, int from_tty, struct target_ops *target,
+ int extended_p)
{
if (name == 0)
error ("To open a remote debug connection, you need to specify what\n\
unpush_target (target);
- remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
-
remote_desc = SERIAL_OPEN (name);
if (!remote_desc)
perror_with_name (name);
push_target (target); /* Switch to using remote target now */
- init_packet_config (&remote_protocol_P);
- init_packet_config (&remote_protocol_Z);
+ init_all_packet_configs ();
general_thread = -2;
continue_thread = -2;
- /* Force remote_write_bytes to check whether target supports
- binary downloading. */
- init_packet_config (&remote_protocol_binary_download);
+ /* Probe for ability to use "ThreadInfo" query, as required. */
+ use_threadinfo_query = 1;
+ use_threadextra_query = 1;
/* Without this, some commands which require an active target (such
as kill) won't work. This variable serves (at least) double duty
/* FIXME: cagney/1999-09-23: During the initial connection it is
assumed that the target is already ready and able to respond to
- requests. Unfortunatly remote_start_remote() eventually calls
+ requests. Unfortunately remote_start_remote() eventually calls
wait_for_inferior() with no timeout. wait_forever_enabled_p gets
around this. Eventually a mechanism that allows
wait_for_inferior() to expect/get timeouts will be
die when it hits one. */
static void
-remote_detach (args, from_tty)
- char *args;
- int from_tty;
+remote_detach (char *args, int from_tty)
{
char *buf = alloca (PBUFSIZ);
strcpy (buf, "D");
remote_send (buf, PBUFSIZ);
- pop_target ();
+ target_mourn_inferior ();
if (from_tty)
puts_filtered ("Ending remote debugging.\n");
/* Same as remote_detach, but with async support. */
static void
-remote_async_detach (args, from_tty)
- char *args;
- int from_tty;
+remote_async_detach (char *args, int from_tty)
{
char *buf = alloca (PBUFSIZ);
if (target_is_async_p ())
SERIAL_ASYNC (remote_desc, NULL, 0);
- pop_target ();
+ target_mourn_inferior ();
if (from_tty)
puts_filtered ("Ending remote debugging.\n");
}
/* Convert hex digit A to a number. */
int
-fromhex (a)
- int a;
+fromhex (int a)
{
if (a >= '0' && a <= '9')
return a - '0';
/* Convert number NIB to a hex digit. */
static int
-tohex (nib)
- int nib;
+tohex (int nib)
{
if (nib < 10)
return '0' + nib;
static int last_sent_step;
static void
-remote_resume (pid, step, siggnal)
- int pid, step;
- enum target_signal siggnal;
+remote_resume (int pid, int step, enum target_signal siggnal)
{
char *buf = alloca (PBUFSIZ);
else
set_thread (pid, 0); /* run this thread */
- dcache_flush (remote_dcache);
-
last_sent_signal = siggnal;
last_sent_step = step;
/* Same as remote_resume, but with async support. */
static void
-remote_async_resume (pid, step, siggnal)
- int pid, step;
- enum target_signal siggnal;
+remote_async_resume (int pid, int step, enum target_signal siggnal)
{
char *buf = alloca (PBUFSIZ);
else
set_thread (pid, 0); /* run this thread */
- dcache_flush (remote_dcache);
-
last_sent_signal = siggnal;
last_sent_step = step;
/* Set up the signal handler for SIGINT, while the target is
executing, ovewriting the 'regular' SIGINT signal handler. */
static void
-initialize_sigint_signal_handler ()
+initialize_sigint_signal_handler (void)
{
sigint_remote_token =
create_async_signal_handler (async_remote_interrupt, NULL);
/* Signal handler for SIGINT, while the target is executing. */
static void
-handle_remote_sigint (sig)
- int sig;
+handle_remote_sigint (int sig)
{
signal (sig, handle_remote_sigint_twice);
sigint_remote_twice_token =
sent once. It will take effect the second time that the user sends
a ^C. */
static void
-handle_remote_sigint_twice (sig)
- int sig;
+handle_remote_sigint_twice (int sig)
{
signal (sig, handle_sigint);
sigint_remote_twice_token =
/* Perform the real interruption of the target execution, in response
to a ^C. */
static void
-async_remote_interrupt (arg)
- gdb_client_data arg;
+async_remote_interrupt (gdb_client_data arg)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
/* Perform interrupt, if the first attempt did not succeed. Just give
up on the target alltogether. */
void
-async_remote_interrupt_twice (arg)
- gdb_client_data arg;
+async_remote_interrupt_twice (gdb_client_data arg)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
/* Send ^C to target to halt it. Target will respond, and send us a
packet. */
-static void (*ofunc) PARAMS ((int));
+static void (*ofunc) (int);
/* The command line interface's stop routine. This function is installed
as a signal handler for SIGINT. The first time a user requests a
response from the target (it didn't stop when the user requested it),
we ask the user if he'd like to detach from the target. */
static void
-remote_interrupt (signo)
- int signo;
+remote_interrupt (int signo)
{
/* If this doesn't work, try more severe steps. */
signal (signo, remote_interrupt_twice);
/* The user typed ^C twice. */
static void
-remote_interrupt_twice (signo)
- int signo;
+remote_interrupt_twice (int signo)
{
signal (signo, ofunc);
interrupt_query ();
interrupt is requested, either by the command line or the GUI, we
will eventually end up here. */
static void
-remote_stop ()
+remote_stop (void)
{
/* Send a break or a ^C, depending on user preference. */
if (remote_debug)
/* Ask the user what to do when an interrupt is received. */
static void
-interrupt_query ()
+interrupt_query (void)
{
target_terminal_ours ();
remote OS, is the thread-id. */
static int
-remote_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+remote_wait (int pid, struct target_waitstatus *status)
{
unsigned char *buf = alloca (PBUFSIZ);
int thread_num = -1;
/* Async version of remote_wait. */
static int
-remote_async_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+remote_async_wait (int pid, struct target_waitstatus *status)
{
unsigned char *buf = alloca (PBUFSIZ);
int thread_num = -1;
/* ARGSUSED */
static void
-remote_fetch_registers (regno)
- int regno;
+remote_fetch_registers (int regno)
{
char *buf = alloca (PBUFSIZ);
int i;
char *p;
- char regs[REGISTER_BYTES];
+ char *regs = alloca (REGISTER_BYTES);
set_thread (inferior_pid, 1);
if (i != register_bytes_found)
{
register_bytes_found = i;
-#ifdef REGISTER_BYTES_OK
- if (!REGISTER_BYTES_OK (i))
+ if (REGISTER_BYTES_OK_P ()
+ && !REGISTER_BYTES_OK (i))
warning ("Remote reply is too short: %s", buf);
-#endif
}
supply_them:
{
supply_register (i, ®s[REGISTER_BYTE (i)]);
if (buf[REGISTER_BYTE (i) * 2] == 'x')
- register_valid[i] = -1; /* register value not available */
+ set_register_cached (i, -1);
}
}
first. */
static void
-remote_prepare_to_store ()
+remote_prepare_to_store (void)
{
/* Make sure the entire registers array is valid. */
switch (remote_protocol_P.support)
sprintf (buf, "P%x=", regno);
p = buf + strlen (buf);
- regp = ®isters[REGISTER_BYTE (regno)];
+ regp = register_buffer (regno);
for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i)
{
*p++ = tohex ((regp[i] >> 4) & 0xf);
/* Store register REGNO, or all registers if REGNO == -1, from the contents
- of REGISTERS. FIXME: ignores errors. */
+ of the register cache buffer. FIXME: ignores errors. */
static void
-remote_store_registers (regno)
- int regno;
+remote_store_registers (int regno)
{
char *buf = alloca (PBUFSIZ);
int i;
char *p;
+ char *regs;
set_thread (inferior_pid, 1);
/* Command describes registers byte by byte,
each byte encoded as two hex characters. */
+ regs = register_buffer (-1);
p = buf + 1;
/* remote_prepare_to_store insures that register_bytes_found gets set. */
for (i = 0; i < register_bytes_found; i++)
{
- *p++ = tohex ((registers[i] >> 4) & 0xf);
- *p++ = tohex (registers[i] & 0xf);
+ *p++ = tohex ((regs[i] >> 4) & 0xf);
+ *p++ = tohex (regs[i] & 0xf);
}
*p = '\0';
remote_send (buf, PBUFSIZ);
}
-
-/* Use of the data cache *used* to be disabled because it loses for looking
- at and changing hardware I/O ports and the like. Accepting `volatile'
- would perhaps be one way to fix it. Another idea would be to use the
- executable file for the text segment (for all SEC_CODE sections?
- For all SEC_READONLY sections?). This has problems if you want to
- actually see what the memory contains (e.g. self-modifying code,
- clobbered memory, user downloaded the wrong thing).
-
- Because it speeds so much up, it's now enabled, if you're playing
- with registers you turn it of (set remotecache 0). */
-
-/* Read a word from remote address ADDR and return it.
- This goes through the data cache. */
-
-#if 0 /* unused? */
-static int
-remote_fetch_word (addr)
- CORE_ADDR addr;
-{
- return dcache_fetch (remote_dcache, addr);
-}
-
-/* Write a word WORD into remote address ADDR.
- This goes through the data cache. */
-
-static void
-remote_store_word (addr, word)
- CORE_ADDR addr;
- int word;
-{
- dcache_poke (remote_dcache, addr, word);
-}
-#endif /* 0 (unused?) */
\f
-
/* Return the number of hex digits in num. */
static int
-hexnumlen (num)
- ULONGEST num;
+hexnumlen (ULONGEST num)
{
int i;
/* Set BUF to the minimum number of hex digits representing NUM. */
static int
-hexnumstr (buf, num)
- char *buf;
- ULONGEST num;
+hexnumstr (char *buf, ULONGEST num)
{
int len = hexnumlen (num);
return hexnumnstr (buf, num, len);
/* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
static int
-hexnumnstr (buf, num, width)
- char *buf;
- ULONGEST num;
- int width;
+hexnumnstr (char *buf, ULONGEST num, int width)
{
int i;
/* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
static CORE_ADDR
-remote_address_masked (addr)
- CORE_ADDR addr;
+remote_address_masked (CORE_ADDR addr)
{
if (remote_address_size > 0
&& remote_address_size < (sizeof (ULONGEST) * 8))
X-packet". */
static void
-check_binary_download (addr)
- CORE_ADDR addr;
+check_binary_download (CORE_ADDR addr)
{
switch (remote_protocol_binary_download.support)
{
todo = min (len, max_buf_size / 2);
break;
case PACKET_SUPPORT_UNKNOWN:
- internal_error ("remote_write_bytes: bad switch");
+ internal_error ("%s:%d: remote_write_bytes: bad internal state",
+ __FILE__, __LINE__);
+ default:
+ internal_error ("%s:%d: bad switch", __FILE__, __LINE__);
}
/* Append <memaddr> */
*p = '\0';
break;
case PACKET_SUPPORT_UNKNOWN:
- internal_error ("remote_write_bytes: bad switch");
+ internal_error ("%s:%d: remote_write_bytes: bad internal state",
+ __FILE__, __LINE__);
+ default:
+ internal_error ("%s:%d: bad switch", __FILE__, __LINE__);
}
putpkt_binary (buf, (int) (p - buf));
handling partial reads. */
static int
-remote_read_bytes (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)
{
char *buf;
int max_buf_size; /* Max size of packet output buffer */
/* Read or write LEN bytes from inferior memory at MEMADDR,
transferring to or from debugger address BUFFER. Write to inferior if
SHOULD_WRITE is nonzero. Returns length of data written or read; 0
- for error. */
-
-#ifndef REMOTE_TRANSLATE_XFER_ADDRESS
-#define REMOTE_TRANSLATE_XFER_ADDRESS(MEM_ADDR, MEM_LEN, TARG_ADDR, TARG_LEN) \
- (*(TARG_ADDR) = (MEM_ADDR), *(TARG_LEN) = (MEM_LEN))
-#endif
+ for error. TARGET is unused. */
/* ARGSUSED */
static int
-remote_xfer_memory (mem_addr, buffer, mem_len, should_write, target)
- CORE_ADDR mem_addr;
- char *buffer;
- int mem_len;
- int should_write;
- struct target_ops *target; /* ignored */
+remote_xfer_memory (CORE_ADDR mem_addr, char *buffer, int mem_len,
+ int should_write,
+ struct mem_attrib *attrib ATTRIBUTE_UNUSED,
+ struct target_ops *target)
{
CORE_ADDR targ_addr;
int targ_len;
+ int res;
+
REMOTE_TRANSLATE_XFER_ADDRESS (mem_addr, mem_len, &targ_addr, &targ_len);
if (targ_len <= 0)
return 0;
- return dcache_xfer_memory (remote_dcache, targ_addr, buffer,
- targ_len, should_write);
+ if (should_write)
+ res = remote_write_bytes (targ_addr, buffer, targ_len);
+ else
+ res = remote_read_bytes (targ_addr, buffer, targ_len);
+
+ return res;
}
/* Enable after 4.12. */
void
-remote_search (len, data, mask, startaddr, increment, lorange, hirange
- addr_found, data_found)
- int len;
- char *data;
- char *mask;
- CORE_ADDR startaddr;
- int increment;
- CORE_ADDR lorange;
- CORE_ADDR hirange;
- CORE_ADDR *addr_found;
- char *data_found;
+remote_search (int len, char *data, char *mask, CORE_ADDR startaddr,
+ int increment, CORE_ADDR lorange, CORE_ADDR hirange,
+ CORE_ADDR *addr_found, char *data_found)
{
if (increment == -4 && len == 4)
{
#endif /* 0 */
\f
static void
-remote_files_info (ignore)
- struct target_ops *ignore;
+remote_files_info (struct target_ops *ignore)
{
puts_filtered ("Debugging a target over a serial line.\n");
}
/* Read a single character from the remote end, masking it down to 7 bits. */
static int
-readchar (timeout)
- int timeout;
+readchar (int timeout)
{
int ch;
string notation. */
static void
-print_packet (buf)
- char *buf;
+print_packet (char *buf)
{
puts_filtered ("\"");
fputstr_filtered (buf, '"', gdb_stdout);
}
int
-putpkt (buf)
- char *buf;
+putpkt (char *buf)
{
return putpkt_binary (buf, strlen (buf));
}
debugging (remote_debug) and want to print the sent packet as a string */
static int
-putpkt_binary (buf, cnt)
- char *buf;
- int cnt;
+putpkt_binary (char *buf, int cnt)
{
int i;
unsigned char csum = 0;
switch (ch)
{
case '+':
+ case '-':
case SERIAL_TIMEOUT:
case '$':
if (started_error_output)
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "Ack\n");
return 1;
+ case '-':
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "Nak\n");
case SERIAL_TIMEOUT:
tcount++;
if (tcount > 3)
break; /* Retransmit buffer */
case '$':
{
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "Packet instead of Ack, ignoring it\n");
/* It's probably an old response, and we're out of sync.
Just gobble up the packet and ignore it. */
- getpkt (junkbuf, sizeof_junkbuf, 0);
+ read_frame (junkbuf, sizeof_junkbuf);
continue; /* Now, go look for + */
}
default:
case '#':
{
unsigned char pktcsum;
+ int check_0 = 0;
+ int check_1 = 0;
buf[bc] = '\0';
- pktcsum = fromhex (readchar (remote_timeout)) << 4;
- pktcsum |= fromhex (readchar (remote_timeout));
+ check_0 = readchar (remote_timeout);
+ if (check_0 >= 0)
+ check_1 = readchar (remote_timeout);
+
+ if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
+ {
+ if (remote_debug)
+ fputs_filtered ("Timeout in checksum, retrying\n", gdb_stdlog);
+ return -1;
+ }
+ else if (check_0 < 0 || check_1 < 0)
+ {
+ if (remote_debug)
+ fputs_filtered ("Communication error in checksum\n", gdb_stdlog);
+ return -1;
+ }
+ pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
if (csum == pktcsum)
return bc;
}
\f
static void
-remote_kill ()
+remote_kill (void)
{
/* For some mysterious reason, wait_for_inferior calls kill instead of
mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
/* Async version of remote_kill. */
static void
-remote_async_kill ()
+remote_async_kill (void)
{
/* Unregister the file descriptor from the event loop. */
if (target_is_async_p ())
}
static void
-remote_mourn ()
+remote_mourn (void)
{
remote_mourn_1 (&remote_ops);
}
static void
-remote_async_mourn ()
+remote_async_mourn (void)
{
remote_mourn_1 (&remote_async_ops);
}
static void
-extended_remote_mourn ()
+extended_remote_mourn (void)
{
/* We do _not_ want to mourn the target like this; this will
remove the extended remote target from the target stack,
/* Worker function for remote_mourn. */
static void
-remote_mourn_1 (target)
- struct target_ops *target;
+remote_mourn_1 (struct target_ops *target)
{
unpush_target (target);
generic_mourn_inferior ();
we're debugging, arguments and an environment. */
static void
-extended_remote_create_inferior (exec_file, args, env)
- char *exec_file;
- char *args;
- char **env;
+extended_remote_create_inferior (char *exec_file, char *args, char **env)
{
/* Rip out the breakpoints; we'll reinsert them after restarting
the remote server. */
/* Async version of extended_remote_create_inferior. */
static void
-extended_remote_async_create_inferior (exec_file, args, env)
- char *exec_file;
- char *args;
- char **env;
+extended_remote_async_create_inferior (char *exec_file, char *args, char **env)
{
/* Rip out the breakpoints; we'll reinsert them after restarting
the remote server. */
is accomplished via BREAKPOINT_MAX). */
static int
-remote_insert_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+remote_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
{
#ifdef REMOTE_BREAKPOINT
int val;
#endif
int bp_size;
- /* Try the "Z" packet if it is not already disabled.
- If it succeeds, then set the support to PACKET_ENABLE.
- If it fails, and the user has explicitly requested the Z support
- then report an error, otherwise, mark it disabled and go on. */
+ /* Try the "Z" s/w breakpoint packet if it is not already disabled.
+ If it succeeds, then set the support to PACKET_ENABLE. If it
+ fails, and the user has explicitly requested the Z support then
+ report an error, otherwise, mark it disabled and go on. */
- if ((remote_protocol_Z.support == PACKET_ENABLE)
- || (remote_protocol_Z.support == PACKET_SUPPORT_UNKNOWN))
+ if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
{
char *buf = alloca (PBUFSIZ);
char *p = buf;
putpkt (buf);
getpkt (buf, PBUFSIZ, 0);
- if (buf[0] != '\0')
+ switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_SOFTWARE_BP]))
{
- remote_protocol_Z.support = PACKET_ENABLE;
- return (buf[0] == 'E');
- }
-
- /* The stub does not support the 'Z' request. If the user has
- explicitly requested the Z support, or if the stub previously
- said it supported the packet, this is an error,
- otherwise, mark it disabled. */
-
- else if (remote_protocol_Z.support == PACKET_ENABLE)
- {
- error ("Protocol error: Z packet not recognized by stub");
- }
- else
- {
- remote_protocol_Z.support = PACKET_DISABLE;
+ case PACKET_ERROR:
+ return -1;
+ case PACKET_OK:
+ return 0;
+ case PACKET_UNKNOWN:
+ break;
}
}
}
static int
-remote_remove_breakpoint (addr, contents_cache)
- CORE_ADDR addr;
- char *contents_cache;
+remote_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
{
int bp_size;
- if ((remote_protocol_Z.support == PACKET_ENABLE)
- || (remote_protocol_Z.support == PACKET_SUPPORT_UNKNOWN))
+ if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
{
char *buf = alloca (PBUFSIZ);
char *p = buf;
#endif /* REMOTE_BREAKPOINT */
}
-#ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
+static int
+watchpoint_to_Z_packet (int type)
+{
+ switch (type)
+ {
+ case hw_write:
+ return 2;
+ break;
+ case hw_read:
+ return 3;
+ break;
+ case hw_access:
+ return 4;
+ break;
+ default:
+ internal_error ("hw_bp_to_z: bad watchpoint type %d", type);
+ }
+}
+
+/* FIXME: This function should be static and a member of the remote
+ target vector. */
+
int
-remote_insert_watchpoint (addr, len, type)
- CORE_ADDR addr;
- int len;
- int type;
+remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
{
char *buf = alloca (PBUFSIZ);
char *p;
+ enum Z_packet_type packet = watchpoint_to_Z_packet (type);
- if (remote_protocol_Z.support == PACKET_DISABLE)
- error ("Can't set hardware watchpoints without the 'Z' packet\n");
+ if (remote_protocol_Z[packet].support == PACKET_DISABLE)
+ error ("Can't set hardware watchpoints without the '%s' (%s) packet\n",
+ remote_protocol_Z[packet].name,
+ remote_protocol_Z[packet].title);
- sprintf (buf, "Z%x,", type + 2 );
+ sprintf (buf, "Z%x,", packet);
p = strchr (buf, '\0');
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
putpkt (buf);
getpkt (buf, PBUFSIZ, 0);
- if (buf[0] == '\0' || buf [0] == 'E')
- return -1;
-
- return 0;
+ switch (packet_ok (buf, &remote_protocol_Z[packet]))
+ {
+ case PACKET_ERROR:
+ case PACKET_UNKNOWN:
+ return -1;
+ case PACKET_OK:
+ return 0;
+ }
+ internal_error ("remote_insert_watchpoint: reached end of function");
}
+/* FIXME: This function should be static and a member of the remote
+ target vector. */
+
int
-remote_remove_watchpoint (addr, len, type)
- CORE_ADDR addr;
- int len;
- int type;
+remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
{
char *buf = alloca (PBUFSIZ);
char *p;
+ enum Z_packet_type packet = watchpoint_to_Z_packet (type);
+
+ if (remote_protocol_Z[packet].support == PACKET_DISABLE)
+ error ("Can't clear hardware watchpoints without the '%s' (%s) packet\n",
+ remote_protocol_Z[packet].name,
+ remote_protocol_Z[packet].title);
- sprintf (buf, "z%x,", type + 2 );
+ sprintf (buf, "z%x,", packet);
p = strchr (buf, '\0');
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
putpkt (buf);
getpkt (buf, PBUFSIZ, 0);
- if (buf[0] == '\0' || buf [0] == 'E')
- return -1;
-
- return 0;
+ switch (packet_ok (buf, &remote_protocol_Z[packet]))
+ {
+ case PACKET_ERROR:
+ case PACKET_UNKNOWN:
+ return -1;
+ case PACKET_OK:
+ return 0;
+ }
+ internal_error ("remote_remove_watchpoint: reached end of function");
}
+/* FIXME: This function should be static and a member of the remote
+ target vector. */
+
int
-remote_insert_hw_breakpoint (addr, len)
- CORE_ADDR addr;
- int len;
+remote_insert_hw_breakpoint (CORE_ADDR addr, int len)
{
char *buf = alloca (PBUFSIZ);
char *p = buf;
- if (remote_protocol_Z.support == PACKET_DISABLE)
- error ("Can't set hardware breakpoints without the 'Z' packet\n");
-
+ if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
+ error ("Can't set hardware breakpoint without the '%s' (%s) packet\n",
+ remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
+ remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
+
*(p++) = 'Z';
*(p++) = '1';
*(p++) = ',';
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
- *p = '\0';
+ sprintf (p, ",%x", len);
putpkt (buf);
getpkt (buf, PBUFSIZ, 0);
- if (buf[0] == '\0' || buf [0] == 'E')
- return -1;
-
- return 0;
+ switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
+ {
+ case PACKET_ERROR:
+ case PACKET_UNKNOWN:
+ return -1;
+ case PACKET_OK:
+ return 0;
+ }
+ internal_error ("remote_remove_watchpoint: reached end of function");
}
+/* FIXME: This function should be static and a member of the remote
+ target vector. */
+
int
-remote_remove_hw_breakpoint (addr, len)
- CORE_ADDR addr;
- int len;
+remote_remove_hw_breakpoint (CORE_ADDR addr, int len)
{
char *buf = alloca (PBUFSIZ);
char *p = buf;
+ if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
+ error ("Can't clear hardware breakpoint without the '%s' (%s) packet\n",
+ remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
+ remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
+
*(p++) = 'z';
*(p++) = '1';
*(p++) = ',';
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
- *p = '\0';
+ sprintf (p, ",%x", len);
putpkt(buf);
getpkt (buf, PBUFSIZ, 0);
- if (buf[0] == '\0' || buf [0] == 'E')
- return -1;
-
- return 0;
+ switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
+ {
+ case PACKET_ERROR:
+ case PACKET_UNKNOWN:
+ return -1;
+ case PACKET_OK:
+ return 0;
+ }
+ internal_error ("remote_remove_watchpoint: reached end of function");
}
-#endif
/* Some targets are only capable of doing downloads, and afterwards
they switch to the remote serial protocol. This function provides
already..." message. Usually a call to pop_target() suffices. */
void
-push_remote_target (name, from_tty)
- char *name;
- int from_tty;
+push_remote_target (char *name, int from_tty)
{
printf_filtered ("Switching to remote protocol\n");
remote_open (name, from_tty);
certain remote_ops overridden. */
void
-open_remote_target (name, from_tty, target, extended_p)
- char *name;
- int from_tty;
- struct target_ops *target;
- int extended_p;
+open_remote_target (char *name, int from_tty, struct target_ops *target,
+ int extended_p)
{
printf_filtered ("Selecting the %sremote protocol\n",
(extended_p ? "extended-" : ""));
{0, 0};
static unsigned long
-crc32 (buf, len, crc)
- unsigned char *buf;
- int len;
- unsigned int crc;
+crc32 (unsigned char *buf, int len, unsigned int crc)
{
if (!crc32_table[1])
{
generic_load()) to make use of this target functionality. */
static void
-compare_sections_command (args, from_tty)
- char *args;
- int from_tty;
+compare_sections_command (char *args, int from_tty)
{
asection *s;
unsigned long host_crc, target_crc;
/* be clever; compute the host_crc before waiting for target reply */
sectdata = xmalloc (size);
- old_chain = make_cleanup (free, sectdata);
+ old_chain = make_cleanup (xfree, sectdata);
bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
}
static int
-remote_query (query_type, buf, outbuf, bufsiz)
- int query_type;
- char *buf;
- char *outbuf;
- int *bufsiz;
+remote_query (int query_type, char *buf, char *outbuf, int *bufsiz)
{
int i;
char *buf2 = alloca (PBUFSIZ);
}
static void
-packet_command (args, from_tty)
- char *args;
- int from_tty;
+packet_command (char *args, int from_tty)
{
char *buf = alloca (PBUFSIZ);
#if 0
/* --------- UNIT_TEST for THREAD oriented PACKETS ------------------------- */
-static void display_thread_info PARAMS ((struct gdb_ext_thread_info * info));
+static void display_thread_info (struct gdb_ext_thread_info *info);
-static void threadset_test_cmd PARAMS ((char *cmd, int tty));
+static void threadset_test_cmd (char *cmd, int tty);
-static void threadalive_test PARAMS ((char *cmd, int tty));
+static void threadalive_test (char *cmd, int tty);
-static void threadlist_test_cmd PARAMS ((char *cmd, int tty));
+static void threadlist_test_cmd (char *cmd, int tty);
-int get_and_display_threadinfo PARAMS ((threadref * ref));
+int get_and_display_threadinfo (threadref * ref);
-static void threadinfo_test_cmd PARAMS ((char *cmd, int tty));
+static void threadinfo_test_cmd (char *cmd, int tty);
-static int thread_display_step PARAMS ((threadref * ref, void *context));
+static int thread_display_step (threadref * ref, void *context);
-static void threadlist_update_test_cmd PARAMS ((char *cmd, int tty));
+static void threadlist_update_test_cmd (char *cmd, int tty);
-static void init_remote_threadtests PARAMS ((void));
+static void init_remote_threadtests (void);
#define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid */
static void
-threadset_test_cmd (cmd, tty)
- char *cmd;
- int tty;
+threadset_test_cmd (char *cmd, int tty)
{
int sample_thread = SAMPLE_THREAD;
static void
-threadalive_test (cmd, tty)
- char *cmd;
- int tty;
+threadalive_test (char *cmd, int tty)
{
int sample_thread = SAMPLE_THREAD;
printf_filtered ("FAIL: Thread alive test\n");
}
-void output_threadid PARAMS ((char *title, threadref * ref));
+void output_threadid (char *title, threadref * ref);
void
-output_threadid (title, ref)
- char *title;
- threadref *ref;
+output_threadid (char *title, threadref *ref)
{
char hexid[20];
}
static void
-threadlist_test_cmd (cmd, tty)
- char *cmd;
- int tty;
+threadlist_test_cmd (char *cmd, int tty)
{
int startflag = 1;
threadref nextthread;
}
void
-display_thread_info (info)
- struct gdb_ext_thread_info *info;
+display_thread_info (struct gdb_ext_thread_info *info)
{
output_threadid ("Threadid: ", &info->threadid);
printf_filtered ("Name: %s\n ", info->shortname);
}
int
-get_and_display_threadinfo (ref)
- threadref *ref;
+get_and_display_threadinfo (threadref *ref)
{
int result;
int set;
}
static void
-threadinfo_test_cmd (cmd, tty)
- char *cmd;
- int tty;
+threadinfo_test_cmd (char *cmd, int tty)
{
int athread = SAMPLE_THREAD;
threadref thread;
}
static int
-thread_display_step (ref, context)
- threadref *ref;
- void *context;
+thread_display_step (threadref *ref, void *context)
{
/* output_threadid(" threadstep ",ref); *//* simple test */
return get_and_display_threadinfo (ref);
}
static void
-threadlist_update_test_cmd (cmd, tty)
- char *cmd;
- int tty;
+threadlist_update_test_cmd (char *cmd, int tty)
{
printf_filtered ("Remote Threadlist update test\n");
remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
#endif /* 0 */
static void
-init_remote_ops ()
+init_remote_ops (void)
{
remote_ops.to_shortname = "remote";
remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
remote_ops.to_mourn_inferior = remote_mourn;
remote_ops.to_thread_alive = remote_thread_alive;
remote_ops.to_find_new_threads = remote_threads_info;
+ remote_ops.to_extra_thread_info = remote_threads_extra_info;
remote_ops.to_stop = remote_stop;
remote_ops.to_query = remote_query;
remote_ops.to_rcmd = remote_rcmd;
remote vector and adding to it. */
static void
-init_extended_remote_ops ()
+init_extended_remote_ops (void)
{
extended_remote_ops = remote_ops;
unpush_target (&remote_cisco_ops);
- remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
-
remote_desc = SERIAL_OPEN (name);
if (!remote_desc)
perror_with_name (name);
push_target (&remote_cisco_ops); /* Switch to using cisco target now */
- init_packet_config (&remote_protocol_P);
- init_packet_config (&remote_protocol_Z);
+ init_all_packet_configs ();
general_thread = -2;
continue_thread = -2;
- /* Force remote_write_bytes to check whether target supports
- binary downloading. */
- init_packet_config (&remote_protocol_binary_download);
-
+ /* Probe for ability to use "ThreadInfo" query, as required. */
+ use_threadinfo_query = 1;
+ use_threadextra_query = 1;
+
/* Without this, some commands which require an active target (such
as kill) won't work. This variable serves (at least) double duty
as both the pid of the target process (if it has such), and as a
}
static void
- remote_cisco_mourn
-PARAMS ((void))
+remote_cisco_mourn (void)
{
remote_mourn_1 (&remote_cisco_ops);
}
}
static void
-init_remote_cisco_ops ()
+init_remote_cisco_ops (void)
{
remote_cisco_ops.to_shortname = "cisco";
remote_cisco_ops.to_longname = "Remote serial target in cisco-specific protocol";
remote_cisco_ops.to_mourn_inferior = remote_cisco_mourn;
remote_cisco_ops.to_thread_alive = remote_thread_alive;
remote_cisco_ops.to_find_new_threads = remote_threads_info;
+ remote_ops.to_extra_thread_info = remote_threads_extra_info;
remote_cisco_ops.to_stratum = process_stratum;
remote_cisco_ops.to_has_all_memory = 1;
remote_cisco_ops.to_has_memory = 1;
remote_async_ops.to_mourn_inferior = remote_async_mourn;
remote_async_ops.to_thread_alive = remote_thread_alive;
remote_async_ops.to_find_new_threads = remote_threads_info;
+ remote_ops.to_extra_thread_info = remote_threads_extra_info;
remote_async_ops.to_stop = remote_stop;
remote_async_ops.to_query = remote_query;
remote_async_ops.to_rcmd = remote_rcmd;
}
+static void
+show_remote_cmd (char *args, int from_tty)
+{
+ show_remote_protocol_Z_packet_cmd (args, from_tty);
+ show_remote_protocol_P_packet_cmd (args, from_tty);
+ show_remote_protocol_binary_download_cmd (args, from_tty);
+}
static void
-build_remote_gdbarch_data ()
+build_remote_gdbarch_data (void)
{
build_remote_packet_sizes ();
}
void
-_initialize_remote ()
+_initialize_remote (void)
{
static struct cmd_list_element *remote_set_cmdlist;
static struct cmd_list_element *remote_show_cmdlist;
init_remote_threadtests ();
#endif
+ /* set/show remote ... */
+
add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
Remote protocol specific variables\n\
Configure various remote-protocol specific variables such as\n\
the packets being used",
&remote_set_cmdlist, "set remote ",
0/*allow-unknown*/, &setlist);
- add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
+ add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, "\
Remote protocol specific variables\n\
Configure various remote-protocol specific variables such as\n\
the packets being used",
terminating `#' character and checksum.",
&maintenancelist);
- add_show_from_set
- (add_set_cmd ("remotetimeout", no_class,
- var_integer, (char *) &remote_timeout,
- "Set timeout value for remote read.\n",
- &setlist),
- &showlist);
-
add_show_from_set
(add_set_cmd ("remotebreak", no_class,
var_boolean, (char *) &remote_break,
add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
"Set the maximum number of bytes per memory write packet (deprecated).\n",
&setlist);
- add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
+ add_cmd ("remotewritesize", no_class, show_memory_write_packet_size,
"Show the maximum number of bytes per memory write packet (deprecated).\n",
&showlist);
add_cmd ("memory-write-packet-size", no_class,
"X", "binary-download",
set_remote_protocol_binary_download_cmd,
show_remote_protocol_binary_download_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist);
+ &remote_set_cmdlist, &remote_show_cmdlist,
+ 1);
#if 0
/* XXXX - should ``set remotebinarydownload'' be retained for
compatibility. */
add_info ("remote-process", remote_info_process,
"Query the remote system for process info.");
- add_packet_config_cmd (&remote_protocol_P, "P", "set-register",
+ add_packet_config_cmd (&remote_protocol_P,
+ "P", "set-register",
set_remote_protocol_P_packet_cmd,
show_remote_protocol_P_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist);
-
- add_packet_config_cmd (&remote_protocol_Z, "Z", "breakpoint",
- set_remote_protocol_Z_packet_cmd,
- show_remote_protocol_Z_packet_cmd,
- &remote_set_cmdlist, &remote_show_cmdlist);
+ &remote_set_cmdlist, &remote_show_cmdlist,
+ 1);
+
+ add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP],
+ "Z0", "software-breakpoint",
+ set_remote_protocol_Z_software_bp_packet_cmd,
+ show_remote_protocol_Z_software_bp_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist,
+ 0);
+
+ add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP],
+ "Z1", "hardware-breakpoint",
+ set_remote_protocol_Z_hardware_bp_packet_cmd,
+ show_remote_protocol_Z_hardware_bp_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist,
+ 0);
+
+ add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP],
+ "Z2", "write-watchpoint",
+ set_remote_protocol_Z_write_wp_packet_cmd,
+ show_remote_protocol_Z_write_wp_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist,
+ 0);
+
+ add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP],
+ "Z3", "read-watchpoint",
+ set_remote_protocol_Z_read_wp_packet_cmd,
+ show_remote_protocol_Z_read_wp_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist,
+ 0);
+
+ add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP],
+ "Z4", "access-watchpoint",
+ set_remote_protocol_Z_access_wp_packet_cmd,
+ show_remote_protocol_Z_access_wp_packet_cmd,
+ &remote_set_cmdlist, &remote_show_cmdlist,
+ 0);
+
+ /* Keep the old ``set remote Z-packet ...'' working. */
+ tmpcmd = add_set_auto_boolean_cmd ("Z-packet", class_obscure,
+ &remote_Z_packet_detect,
+ "\
+Set use of remote protocol `Z' packets", &remote_set_cmdlist);
+ tmpcmd->function.sfunc = set_remote_protocol_Z_packet_cmd;
+ add_cmd ("Z-packet", class_obscure, show_remote_protocol_Z_packet_cmd,
+ "Show use of remote protocol `Z' packets ",
+ &remote_show_cmdlist);
}