static int remote_read_bytes PARAMS ((CORE_ADDR memaddr,
char *myaddr, int len));
-static void remote_files_info PARAMS ((struct target_ops *ignore));
+static void remote_files_info PARAMS ((struct target_ops * ignore));
-static int remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
+static int remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char * myaddr,
int len, int should_write,
- struct target_ops *target));
+ struct target_ops * target));
static void remote_prepare_to_store PARAMS ((void));
static int readchar PARAMS ((int timeout));
-static int remote_wait PARAMS ((int pid, struct target_waitstatus *status));
+static int remote_wait PARAMS ((int pid, struct target_waitstatus * status));
static void remote_kill PARAMS ((void));
void remote_console_output PARAMS ((char *));
+/* Define the target subroutine names */
+
void open_remote_target PARAMS ((char *, int, struct target_ops *, int));
void _initialize_remote PARAMS ((void));
#define PBUFSIZ (REGISTER_BYTES * 2 + 32)
#endif
+
/* This variable sets the number of bytes to be written to the target
in a single packet. Normally PBUFSIZ is satisfactory, but some
targets need smaller values (perhaps because the receiving end
void (*target_wait_loop_hook) PARAMS ((void));
\f
+/* ------- REMOTE Thread (or) Process support ----------------------- */
+
+
+
+static int
+stub_unpack_int PARAMS ((char *buff, int fieldlength));
+
+char *
+ unpack_varlen_hex PARAMS ((char *buff, int *result));
+
+
+static char *
+ unpack_nibble PARAMS ((char *buf, int *val));
+
+static char *
+ unpack_nibble PARAMS ((char *buf, int *val));
+
+static char *
+ pack_hex_byte PARAMS ((char *pkt, unsigned char byte));
+
+static char *
+ unpack_byte PARAMS ((char *buf, int *value));
+
+static char *
+ pack_int PARAMS ((char *buf, int value));
+
+static char *
+ unpack_int PARAMS ((char *buf, int *value));
+
+static char *
+ pack_string PARAMS ((char *pkt, char *string));
+
+static char *
+ unpack_string PARAMS ((char *src, char *dest, int length));
+
+static char *
+ pack_threadid PARAMS ((char *pkt, threadref * id));
+
+static char *
+ unpack_threadid PARAMS ((char *inbuf, threadref * id));
+
+void
+int_to_threadref PARAMS ((threadref * id, int value));
+
+
+int
+threadref_to_int PARAMS ((threadref * ref));
+
+static void
+copy_threadref PARAMS ((threadref * dest, threadref * src));
+
+static int
+threadmatch PARAMS ((threadref * dest, threadref * src));
+
+
+static char *
+ pack_threadinfo_request PARAMS ((char *pkt,
+ int mode,
+ threadref * id));
+
+static int
+remote_unpack_thread_info_response PARAMS ((
+ char *pkt,
+ threadref * expectedref,
+ struct gdb_ext_thread_info * info));
+
+
+int
+remote_get_threadinfo PARAMS ((
+ threadref * threadid,
+ int fieldset, /* TAG mask */
+ struct gdb_ext_thread_info * info));
+
+int
+adapt_remote_get_threadinfo PARAMS ((
+ 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 int
+parse_threadlist_response PARAMS ((
+ 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_newthread_step PARAMS ((
+ threadref * ref,
+ void *context));
+
+int
+remote_find_new_threads PARAMS ((void)) ;
+
+static void
+threadalive_test PARAMS ((char *cmd, int tty));
+
+
+static void
+threadset_test_cmd PARAMS ((char *cmd, int tty));
+
+static void
+threadlist_test_cmd PARAMS ((char *cmd,
+ int tty));
+
+void
+display_thread_info PARAMS ((struct gdb_ext_thread_info * info));
+
+
+int
+get_and_display_threadinfo PARAMS ((threadref * ref));
+
+
+static void
+threadinfo_test_cmd PARAMS ((char *cmd,
+ int tty));
+
+static int
+thread_display_step PARAMS ((
+ threadref * ref,
+ void *context));
+
+
+static void
+threadlist_update_test_cmd PARAMS ((char *cmd,
+ int tty));
+
+
+static void
+init_remote_threadtests PARAMS ((void));
+
/* These are the threads which we last sent to the remote system. -1 for all
or -2 for not sent yet. */
int general_thread;
int cont_thread;
+/* Call this function as a result of
+ 1) A halt indication (T packet) containing a thread id
+ 2) A direct query of currthread
+ 3) Successful execution of set thread
+ */
+
+static void
+record_currthread (currthread)
+ int currthread;
+{
+ inferior_pid = currthread;
+ general_thread = currthread;
+ cont_thread = currthread;
+}
+
static void
set_thread (th, gen)
int th;
buf[0] = 'T';
if (th < 0)
- sprintf (&buf[1], "-%x", -th);
+ sprintf (&buf[1], "-%08x", -th);
else
- sprintf (&buf[1], "%x", th);
+ sprintf (&buf[1], "%08x", th);
putpkt (buf);
getpkt (buf, 0);
return (buf[0] == 'O' && buf[1] == 'K');
}
+/*
+ About these extended threadlist and threadinfo packets.
+ They are variable length packets but, the fields within them
+ are often fixed length.
+ They are redundent enough to send over UDP as is the remote protocol
+ in general.
+ There is a matching unit test module in libstub.
+ */
+
+
+#define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES*2)
+/* encode 64 bits in 16 chars of hex */
+
+
+static const char hexchars[] = "0123456789abcdef";
+
+static int
+ishex (ch, val)
+ char ch;
+ int *val;
+{
+ if ((ch >= 'a') && (ch <= 'f'))
+ {
+ *val = ch - 'a' + 10;
+ return 1;
+ }
+ if ((ch >= 'A') && (ch <= 'F'))
+ {
+ *val = ch - 'A' + 10;
+ return 1;
+ }
+ if ((ch >= '0') && (ch <= '9'))
+ {
+ *val = ch - '0';
+ return 1;
+ }
+ return 0;
+}
+
+static int
+stubhex (ch)
+ unsigned char ch;
+{
+ if (ch >= 'a' && ch <= 'f')
+ return ch - 'a' + 10;
+ if (ch >= '0' && ch <= '9')
+ return ch - '0';
+ if (ch >= 'A' && ch <= 'F')
+ return ch - 'A' + 10;
+ return -1;
+}
+
+static int
+stub_unpack_int (buff, fieldlength)
+ char *buff;
+ int fieldlength;
+{
+ int retval = 0;
+ int nibble;
+ while (fieldlength)
+ {
+ nibble = stubhex (*buff++);
+ retval |= nibble;
+ fieldlength--;
+ if (fieldlength)
+ retval = retval << 4;
+ }
+ return retval;
+}
+
+char *
+unpack_varlen_hex (buff, result)
+ char *buff; /* packet to parse */
+ int *result;
+{
+ int nibble;
+ int retval;
+ retval = 0;
+
+ while (ishex (*buff, &nibble))
+ {
+ buff++;
+ retval = retval << 4;
+ retval |= nibble & 0x0f;
+ }
+ *result = retval;
+ return buff;
+}
+
+static char *
+unpack_nibble (buf, val)
+ char *buf;
+ int *val;
+
+{
+ ishex (*buf++, val);
+ return buf;
+}
+
+static char *
+pack_nibble (buf, nibble)
+ char *buf;
+ int nibble;
+
+{
+ *buf++ = hexchars[(nibble & 0x0f)];
+ return buf;
+}
+
+static char *
+pack_hex_byte (pkt, byte)
+ char *pkt;
+ unsigned char byte;
+{
+ *pkt++ = hexchars[(byte >> 4) & 0xf];
+ *pkt++ = hexchars[(byte & 0xf)];
+ return pkt;
+}
+
+static char *
+unpack_byte (buf, value)
+ char *buf;
+ int *value;
+{
+ *value = stub_unpack_int (buf, 2);
+ return buf + 2;
+}
+
+
+static char *
+pack_int (buf, value)
+ char *buf;
+ int value;
+{
+ buf = pack_hex_byte (buf, (value >> 24) & 0xff);
+ buf = pack_hex_byte (buf, (value >> 16) & 0xff);
+ buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
+ buf = pack_hex_byte (buf, (value & 0xff));
+ return buf;
+}
+
+
+static char *
+unpack_int (buf, value)
+ char *buf;
+ int *value;
+{
+ *value = stub_unpack_int (buf, 8);
+ return buf + 8;
+}
+
+
+static char *
+pack_string (pkt, string)
+ char *pkt;
+ char *string;
+{
+ char ch;
+ int len;
+ len = strlen (string);
+ if (len > 200)
+ len = 200; /* Bigger than most GDB packets, junk??? */
+ pkt = pack_hex_byte (pkt, len);
+ while (len-- > 0)
+ {
+ ch = *string++;
+ if ((ch == '\0') || (ch == '#'))
+ ch = '*'; /* Protect encapsulation */
+ *pkt++ = ch;
+ }
+ return pkt;
+}
+
+static char *
+unpack_string (src, dest, length)
+ char *src;
+ char *dest;
+ int length;
+{
+ while (length--)
+ *dest++ = *src++;
+ *dest = '\0';
+ return src;
+}
+
+static char *
+pack_threadid (pkt, id)
+ char *pkt;
+ threadref *id;
+{
+ char *limit;
+ unsigned char *altid;
+ altid = (unsigned char *) id;
+ limit = pkt + BUF_THREAD_ID_SIZE;
+ while (pkt < limit)
+ pkt = pack_hex_byte (pkt, *altid++);
+ return pkt;
+}
+
+
+static char *
+unpack_threadid (inbuf, id)
+ char *inbuf;
+ threadref *id;
+{
+ char *altref;
+ char *limit = inbuf + BUF_THREAD_ID_SIZE;
+ int x, y;
+ altref = (char *) id;
+
+ while (inbuf < limit)
+ {
+ x = stubhex (*inbuf++);
+ y = stubhex (*inbuf++);
+ *altref++ = (x << 4) | y;
+ }
+ return inbuf;
+}
+
+/* Externally, threadrefs are 64 bits but internally, they are still
+ ints. This is due to a mismatch of specifications.
+ We would like to use 64bit thread references internally.
+ This is an adapter function.
+ */
+
+void
+int_to_threadref (id, value)
+ threadref *id;
+ int value;
+{
+ unsigned char *scan;
+ scan = (unsigned char *) id;
+ {
+ int i = 4;
+ while (i--)
+ *scan++ = 0;
+ }
+ *scan++ = (value >> 24) & 0xff;
+ *scan++ = (value >> 16) & 0xff;
+ *scan++ = (value >> 8) & 0xff;
+ *scan++ = (value & 0xff);
+}
+
+int
+threadref_to_int (ref)
+ threadref *ref;
+{
+ int value = 0;
+ unsigned char *scan;
+ int i;
+
+ scan = (char *) ref;
+ scan += 4;
+ i = 4;
+ while (i-- > 0)
+ value = (value << 8) | ((*scan++) & 0xff);
+ return value;
+}
+
+static void
+copy_threadref (dest, src)
+ threadref *dest;
+ threadref *src;
+{
+ int i;
+ unsigned char *csrc, *cdest;
+ csrc = (unsigned char *) src;
+ cdest = (unsigned char *) dest;
+ i = 8;
+ while (i--)
+ *cdest++ = *csrc++;
+}
+
+
+
+static int
+threadmatch (dest, src)
+ threadref *dest;
+ threadref *src;
+{
+ /* things are broken right now, so just assume we got a match */
+#if 0
+ unsigned char *srcp, *destp;
+ int i, result;
+ srcp = (char *) src;
+ destp = (char *) dest;
+
+ result = 1;
+ while (i-- > 0)
+ result &= (*srcp++ == *destp++) ? 1 : 0;
+ return result;
+#endif
+ return 1;
+}
+
+#if THREAD_PKT_TRACE
+#define PKT_TRACE(title,packet) { printf_filtered("%s %s\n", title, packet);}
+#else
+#define PKT_TRACE(a,b) {}
+#endif
+
+
+/* ----- PACK_THREAD_INFO_REQUEST -------------------------------- */
+
+/*
+ threadid:1, # always request threadid
+ context_exists:2,
+ display:4,
+ unique_name:8,
+ more_display:16
+*/
+
+/* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
+
+static char *
+ pack_threadinfo_request PARAMS ((char *pkt,
+ int mode,
+ threadref * id));
+
+static char *
+pack_threadinfo_request (pkt, mode, id)
+ char *pkt;
+ int mode;
+ threadref *id;
+{
+ char *base = pkt;
+ *pkt++ = 'q'; /* Info Query */
+ *pkt++ = 'P'; /* process or thread info */
+ pkt = pack_int (pkt, mode); /* mode */
+ pkt = pack_threadid (pkt, id); /* threadid */
+ *pkt = '\0'; /* terminate */
+ PKT_TRACE ("threadinfo-req ", base);
+ return pkt;
+}
+
+
+/* These values tag the fields in a thread info response packet */
+/* Tagging the fields allows us to request specific fields and to
+ add more fields as time goes by */
+#define TAG_THREADID 1 /* Echo the thread identifier */
+#define TAG_EXISTS 2 /* It this process defined enough to
+ fetch registers and its stack */
+#define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
+#define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is */
+#define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about the process*/
+
+
+static int
+remote_unpack_thread_info_response (pkt, expectedref, info)
+ char *pkt;
+ threadref *expectedref;
+ struct gdb_ext_thread_info *info;
+{
+ int mask, length;
+ unsigned int tag;
+ threadref ref;
+ char *limit = pkt + PBUFSIZ; /* plausable parsing limit */
+ int retval = 1;
+
+ PKT_TRACE ("unpack-threadinfo ", pkt);
+
+ /* info->threadid = 0; FIXME: implement zero_threadref */
+ info->active = 0;
+ info->display[0] = '\0';
+ info->shortname[0] = '\0';
+ info->more_display[0] = '\0';
+
+ /* Assume the characters indicating the packet type have been stripped */
+ pkt = unpack_int (pkt, &mask); /* arg mask */
+ pkt = unpack_threadid (pkt, &ref);
+
+ if (mask == 0)
+ warning("Incomplete response to threadinfo request\n");
+ if (!threadmatch (&ref, expectedref))
+ { /* This is an answer to a different request */
+ warning("ERROR RMT Thread info mismatch\n");
+ return 0;
+ }
+ copy_threadref (&info->threadid, &ref);
+
+ /* Loop on tagged fields , try to bail if somthing goes wrong */
+
+ while ((pkt < limit) && mask && *pkt) /* packets are terminated with nulls */
+ {
+ pkt = unpack_int (pkt, &tag); /* tag */
+ pkt = unpack_byte (pkt, &length); /* length */
+ if (!(tag & mask)) /* tags out of synch with mask */
+ {
+ warning ("ERROR RMT: threadinfo tag mismatch\n");
+ retval = 0;
+ break;
+ }
+ if (tag == TAG_THREADID)
+ {
+ if (length != 16)
+ {
+ warning ("ERROR RMT: length of threadid is not 16\n");
+ retval = 0;
+ break;
+ }
+ pkt = unpack_threadid (pkt, &ref);
+ mask = mask & ~TAG_THREADID;
+ continue;
+ }
+ if (tag == TAG_EXISTS)
+ {
+ info->active = stub_unpack_int (pkt, length);
+ pkt += length;
+ mask = mask & ~(TAG_EXISTS);
+ if (length > 8)
+ {
+ warning ("ERROR RMT: 'exists' length too long\n");
+ retval = 0;
+ break;
+ }
+ continue;
+ }
+ if (tag == TAG_THREADNAME)
+ {
+ pkt = unpack_string (pkt, &info->shortname[0], length);
+ mask = mask & ~TAG_THREADNAME;
+ continue;
+ }
+ if (tag == TAG_DISPLAY)
+ {
+ pkt = unpack_string (pkt, &info->display[0], length);
+ mask = mask & ~TAG_DISPLAY;
+ continue;
+ }
+ if (tag == TAG_MOREDISPLAY)
+ {
+ pkt = unpack_string (pkt, &info->more_display[0], length);
+ mask = mask & ~TAG_MOREDISPLAY;
+ continue;
+ }
+ warning ("ERROR RMT: unknown thread info tag\n");
+ break; /* Not a tag we know about */
+ }
+ return retval;
+}
+
+
+/* ------ REMOTE_GET_THREADINFO -------------------------------------- */
+
+int
+remote_get_threadinfo (threadid, fieldset, info)
+ threadref *threadid;
+ int fieldset; /* TAG mask */
+ struct gdb_ext_thread_info *info;
+{
+ int result;
+ char threadinfo_pkt[PBUFSIZ];
+ pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
+ putpkt (threadinfo_pkt);
+ getpkt (threadinfo_pkt, 0);
+ result = remote_unpack_thread_info_response (threadinfo_pkt + 2, threadid, info);
+ return result;
+}
+
+/* ------- ADAPT_remote_GET_THREADINFO - */
+/* Unfortunatly, 61 but thread-ids are bugger than the internal
+ representation of a threadid. */
+
+
+int
+adapt_remote_get_threadinfo (ref, selection, info)
+ gdb_threadref *ref;
+ int selection;
+ struct gdb_ext_thread_info *info;
+{
+ threadref lclref;
+ int_to_threadref (&lclref, *ref);
+ return remote_get_threadinfo (&lclref, selection, info);
+}
+
+
+/* -------- PACK_THREADLIST-REQUEST --------------------------------- */
+/* 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;
+{
+ *pkt++ = 'q'; /* info query packet */
+ *pkt++ = 'L'; /* Process LIST or threadLIST request */
+ pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
+ pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
+ pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
+ *pkt = '\0';
+ return pkt;
+}
+
+
+/* ---------- PARSE_THREADLIST_RESPONSE ------------------------------------ */
+/* 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;
+{
+ char *limit;
+ int count, resultcount, done;
+ resultcount = 0;
+
+ /* assume the 'q' and 'M chars have been stripped */
+ PKT_TRACE ("parse-threadlist-response ", pkt);
+ limit = pkt + (PBUFSIZ - BUF_THREAD_ID_SIZE); /* done parse past here */
+ pkt = unpack_byte (pkt, &count); /* count field */
+ pkt = unpack_nibble (pkt, &done);
+ /* The first threadid is the argument threadid */
+ pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
+ while ((count-- > 0) && (pkt < limit))
+ {
+ pkt = unpack_threadid (pkt, resultlist++);
+ if (resultcount++ >= result_limit)
+ break;
+ }
+ if (doneflag)
+ *doneflag = done;
+ return resultcount; /* successvalue */
+}
+
+
+
+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;
+
+{
+ static threadref echo_nextthread;
+ char threadlist_packet[PBUFSIZ];
+ char t_response[PBUFSIZ];
+ int result = 1;
+
+ /* Trancate result limit to be smaller than the packet size */
+ if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= PBUFSIZ)
+ result_limit = (PBUFSIZ / BUF_THREAD_ID_SIZE) - 2;
+
+ pack_threadlist_request (threadlist_packet,
+ startflag, result_limit, nextthread);
+ putpkt (threadlist_packet);
+ getpkt (t_response, 0);
+ *result_count = parse_threadlist_response (
+ t_response + 2, /* strip header */
+ result_limit,
+ &echo_nextthread,
+ threadlist,
+ done);
+ if (!threadmatch (&echo_nextthread, nextthread))
+ {
+ /* FIXME: This is a good reason to drop the packet */
+ /* Possably, there is a duplicate response */
+ /* Possabilities :
+ retransmit immediatly - race conditions
+ retransmit after timeout - yes
+ exit
+ wait for packet, then exit
+ */
+ warning ("HMM: threadlist did not echo arg thread, dropping it\n");
+ return 0; /* I choose simply exiting */
+ }
+ if (*result_count <= 0)
+ {
+ if (*done != 1)
+ {
+ warning ("RMT ERROR : failed to get remote thread list\n");
+ result = 0;
+ }
+ return result; /* break; */
+ }
+ if (*result_count > result_limit)
+ {
+ *result_count = 0;
+ warning ("RMT ERROR: threadlist response longer than requested\n");
+ return 0;
+ }
+ return result;
+}
+
+
+
+/* This is the interface between remote and threads, remotes upper interface */
+/* remote_find_new_threads retreives the thread list and for each
+ thread in the list, looks up the thread in GDB's internal list,
+ ading the thread if it does not already exist.
+ This involves getting partial thread lists from the remote target so,
+ polling the quit_flag is required.
+*/
+
+typedef int (*rmt_thread_action) (
+ threadref * ref,
+ void *context
+);
+
+#define MAXTHREADLISTRESULTS 32 /* About this many threadisds fit in a packet */
+
+static int
+remote_threadlist_iterator PARAMS ((
+ rmt_thread_action stepfunction,
+ void *context,
+ int looplimit));
+
+static int
+remote_threadlist_iterator (stepfunction, context, looplimit)
+ rmt_thread_action stepfunction;
+ void *context;
+ int looplimit;
+{
+ int done, i, result_count;
+ int startflag = 1;
+ int result = 1;
+ int loopcount = 0;
+ static threadref nextthread;
+ static threadref echo_nextthread;
+ static threadref resultthreadlist[MAXTHREADLISTRESULTS];
+
+ done = 0;
+ while (!done)
+ {
+ if (loopcount++ > looplimit)
+ {
+ result = 0;
+ warning ("Remote fetch threadlist -infinite loop-\n");
+ break;
+ }
+ if (!remote_get_threadlist (startflag,
+ &nextthread,
+ MAXTHREADLISTRESULTS,
+ &done,
+ &result_count,
+ resultthreadlist))
+ {
+ result = 0;
+ break;
+ }
+ startflag = 0; /* clear for later iterations */
+ /* Setup to resume next batch of thread references , set nestthread */
+ if (result_count >= 1)
+ copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
+ /* output_threadid("last-of-batch",&nextthread); */
+ i = 0;
+ while (result_count--)
+ if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
+ break;
+ }
+ return result;
+}
+
+
+static int
+remote_newthread_step (ref, context)
+ threadref *ref;
+ void *context
+ ;
+
+{
+ int pid;
+ pid = threadref_to_int (ref);
+ if (!in_thread_list (pid))
+ add_thread (pid);
+ return 1; /* continue iterator */
+}
+
+#define CRAZY_MAX_THREADS 1000
+
+
+int
+remote_find_new_threads (void)
+{
+ return remote_threadlist_iterator (remote_newthread_step, 0, CRAZY_MAX_THREADS);
+} /* remote_find_new_threads */
+
+int
+remote_update_threads ()
+{
+ /* Right now, this is empty. But it is one of the functions
+ defined for the thread target vector so it gets called.
+ If we were to allow the modification of the registers of
+ a suspended process, this would be implemented. */
+ return 0;
+}
+
+static struct target_thread_vector remote_thread_vec;
+
+/* Initialize the thread vector which is used by threads.c */
+/* The thread stubb is a package, it has an initializer */
+void init_remote_threads ()
+{
+ remote_thread_vec.find_new_threads = remote_find_new_threads;
+ remote_thread_vec.get_thread_info = adapt_remote_get_threadinfo;
+}
+
+/* --------- UNIT_TEST for THREAD oriented PACKETS -------------------------- */
+
+#define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid */
+
+
+static void
+threadset_test_cmd (cmd, tty)
+ char *cmd;
+ int tty;
+{
+ int sample_thread = SAMPLE_THREAD;
+ printf_filtered ("Remote threadset test\n");
+ set_thread (sample_thread, 1);
+}
+
+
+static void
+threadalive_test (cmd, tty)
+ char *cmd;
+ int tty;
+{
+ int sample_thread = SAMPLE_THREAD;
+ if (remote_thread_alive (sample_thread))
+ printf_filtered ("PASS: Thread alive test\n");
+ else
+ printf_filtered ("FAIL: Thread alive test\n");
+}
+
+void
+output_threadid PARAMS ((char *title, threadref * ref));
+
+void
+output_threadid (title, ref)
+ char *title;
+ threadref *ref;
+{
+ char hexid[20];
+ pack_threadid (&hexid[0], ref); /* Convert threead id into hex */
+ hexid[16] = 0;
+ printf_filtered ("%s %s\n", title, (&hexid[0]));
+}
+
+
+static void
+threadlist_test_cmd (cmd, tty)
+ char *cmd;
+ int tty;
+{
+ int startflag = 1;
+ threadref nextthread;
+ int done, result_count;
+ threadref threadlist[3];
+
+ printf_filtered ("Remote Threadlist test\n");
+ if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
+ &result_count, &threadlist[0]))
+ printf_filtered ("FAIL: threadlist test\n");
+ else
+ {
+ threadref *scan = threadlist;
+ threadref *limit = scan + result_count;
+ while (scan < limit)
+ output_threadid (" thread ", scan++);
+ }
+}
+
+void
+display_thread_info (info)
+ struct gdb_ext_thread_info *info;
+{
+
+ output_threadid ("Threadid: ", &info->threadid);
+ /* short name */
+ printf_filtered ("Name: %s\n ", info->shortname);
+ /* format display state */
+ printf_filtered ("State: %s\n", info->display);
+ /* additional data */
+ printf_filtered ("other: %s\n\n", info->more_display);
+}
+
+int
+get_and_display_threadinfo (ref)
+ threadref *ref;
+{
+ int result;
+ int set;
+ struct gdb_ext_thread_info threadinfo;
+
+ set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
+ | TAG_MOREDISPLAY | TAG_DISPLAY;
+ if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
+ display_thread_info (&threadinfo);
+ return result;
+}
+
+static void
+threadinfo_test_cmd (cmd, tty)
+ char *cmd;
+ int tty;
+{
+ int athread = SAMPLE_THREAD;
+ threadref thread;
+ int set;
+
+ int_to_threadref (&thread, athread);
+ printf_filtered ("Remote Threadinfo test\n");
+ if (!get_and_display_threadinfo (&thread))
+ printf_filtered ("FAIL cannot get thread info\n");
+}
+
+
+static int
+thread_display_step (ref, context)
+ 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;
+{
+ printf_filtered ("Remote Threadlist update test\n");
+ remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
+}
+
+static void
+init_remote_threadtests (void)
+{
+ add_com ("tlist", class_obscure, threadlist_test_cmd,
+ "Fetch and print the remote list of thread identifiers, one pkt only");
+ add_com ("tinfo", class_obscure, threadinfo_test_cmd,
+ "Fetch and display info about one thread");
+ add_com ("tset", class_obscure, threadset_test_cmd,
+ "Test setting to a different thread");
+ add_com ("tupd", class_obscure, threadlist_update_test_cmd,
+ "Iterate through updating all remote thread info");
+ add_com ("talive", class_obscure, threadalive_test,
+ " Remote thread alive test ");
+}
+
+#define INIT_REMOTE_THREADTESTS { init_remote_threadtests();}
+/* END OF REMOTE THREAD UNIT TESTS */
+\f
+
/* Restart the remote side; this is an extended protocol operation. */
static void
puts_filtered ("\n");
}
push_target (target); /* Switch to using remote target now */
-
+ /* The target vector does not have the thread functions in it yet,
+ so we use this function to call back into the thread module and
+ register the thread vector and its contained functions. */
+ bind_target_thread_vector(&remote_thread_vec);
/* Start out by trying the 'P' request to set registers. We set this each
time that we open a new target so that if the user switches from one
stub to another, we can (if the target is closed and reopened) cope. */
regno = strtol ((const char *) p, &p_temp, 16); /* Read the register number */
p1 = (unsigned char *)p_temp;
- if (p1 == p)
+ if (p1 == p) /* No register number present here */
{
p1 = (unsigned char *) strchr ((const char *) p, ':');
if (p1 == NULL)
- warning ("Malformed packet (missing colon): %s\n\
+ warning ("Malformed packet(a) (missing colon): %s\n\
Packet: '%s'\n",
p, buf);
if (strncmp ((const char *) p, "thread", p1 - p) == 0)
{
- thread_num = strtol ((const char *) ++p1, &p_temp, 16);
+ p_temp = unpack_varlen_hex(++p1,&thread_num);
+ record_currthread(thread_num);
p = (unsigned char *)p_temp;
}
}
p = p1;
if (*p++ != ':')
- warning ("Malformed packet (missing colon): %s\n\
+ warning ("Malformed packet(b) (missing colon): %s\n\
Packet: '%s'\n",
p, buf);
}
if (*p++ != ';')
- warning ("Remote register badly formatted: %s", buf);
+ {
+ warning ("Remote register badly formatted: %s", buf);
+ warning (" here: %s",p);
+ }
}
}
/* fall through */
}
}
+
+
/* Read a packet from the remote machine, with error checking,
and store it in BUF. BUF is expected to be of size PBUFSIZ.
If FOREVER, wait forever rather than timing out; this is used
Specify the serial device it is connected to (e.g. /dev/ttya).";
remote_ops.to_open = remote_open;
remote_ops.to_close = remote_close;
- remote_ops.to_detach = remote_detach;
+ remote_ops.to_detach = remote_detach;
remote_ops.to_resume = remote_resume;
- remote_ops.to_wait = remote_wait;
+ remote_ops.to_wait = remote_wait;
remote_ops.to_fetch_registers = remote_fetch_registers;
remote_ops.to_store_registers = remote_store_registers;
remote_ops.to_prepare_to_store = remote_prepare_to_store;
}
static void
-init_extended_remote_ops ()
+init_extended_remote_ops ()
{
extended_remote_ops = remote_ops;
init_extended_remote_ops ();
add_target (&extended_remote_ops);
+ init_remote_threads();
+ INIT_REMOTE_THREADTESTS /* conditional thread packet unit test */
add_cmd ("compare-sections", class_obscure, compare_sections_command,
"Compare section data on target to the exec file.\n\
add_show_from_set (add_set_cmd ("remotetimeout", no_class,
var_integer, (char *)&remote_timeout,
- "Set timeout value for remote read.\n", &setlist),
+ "Set timeout value for remote read.\n",
+ &setlist),
&showlist);
add_show_from_set (add_set_cmd ("remotebreak", no_class,
var_integer, (char *)&remote_break,
- "Set whether to send break if interrupted.\n", &setlist),
+ "Set whether to send break if interrupted.\n",
+ &setlist),
&showlist);
add_show_from_set (add_set_cmd ("remotewritesize", no_class,
var_integer, (char *)&remote_write_size,
- "Set the maximum number of bytes in each memory write packet.\n", &setlist),
+ "Set the maximum number of bytes in each memory write packet.\n",
+ &setlist),
&showlist);
+
+
remote_address_size = TARGET_PTR_BIT;
add_show_from_set (add_set_cmd ("remoteaddresssize", class_obscure,
var_integer, (char *)&remote_address_size,
- "Set the maximum size of the address (in bits) in a memory packet.\n", &setlist),
- &showlist);
+ "Set the maximum size of the address (in bits) in a memory packet.\n",
+ &setlist),
+ &showlist);
}
+
projects / deliverable / binutils-gdb.git / blobdiff