From: Michael Snyder Date: Thu, 4 Jun 1998 15:29:58 +0000 (+0000) Subject: Thu Jun 4 08:25:38 1998 Michael Snyder X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=b85cf6aec0e6bce191a4ba41fa41491432fad502;p=binutils-gdb.git Thu Jun 4 08:25:38 1998 Michael Snyder * remote.c (remote_compare_command): New function, new command. Compare object file binary image with corresponding memory on remote target. Report differences. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index bc922ef006c..01e24969ef2 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,9 @@ +Thu Jun 4 08:25:38 1998 Michael Snyder + + * remote.c (remote_compare_command): New function, new command. + Compare object file binary image with corresponding memory on + remote target. Report differences. + Tue Jun 2 19:05:04 1998 Mark Alexander * sparc-tdep.c (sparc_target_architecture_hook): Set target diff --git a/gdb/remote.c b/gdb/remote.c index 02b31ccd0d3..00f7dbcd678 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -725,8 +725,4173 @@ device is attached to the remote system (e.g. /dev/ttya)."); (we'd be in an inconsistent state otherwise). */ if (!catch_errors (remote_start_remote, (char *)0, "Couldn't establish connection to remote target\n", RETURN_MASK_ALL)) - pop_target(); + { + pop_target(); + return; + } + + if (extended_p) + { + /* tell the remote that we're using the extended protocol. */ + char buf[PBUFSIZ]; + putpkt ("!"); + getpkt (buf, 0); + } +} + +/* This takes a program previously attached to and detaches it. After + this is done, GDB can be used to debug some other program. We + better not have left any breakpoints in the target program or it'll + die when it hits one. */ + +static void +remote_detach (args, from_tty) + char *args; + int from_tty; +{ + char buf[PBUFSIZ]; + + if (args) + error ("Argument given to \"detach\" when remotely debugging."); + + /* Tell the remote target to detach. */ + strcpy (buf, "D"); + remote_send (buf); + + pop_target (); + if (from_tty) + puts_filtered ("Ending remote debugging.\n"); +} + +/* Convert hex digit A to a number. */ + +int +fromhex (a) + int a; +{ + if (a >= '0' && a <= '9') + return a - '0'; + else if (a >= 'a' && a <= 'f') + return a - 'a' + 10; + else if (a >= 'A' && a <= 'F') + return a - 'A' + 10; + else + error ("Reply contains invalid hex digit %d", a); +} + +/* Convert number NIB to a hex digit. */ + +static int +tohex (nib) + int nib; +{ + if (nib < 10) + return '0'+nib; + else + return 'a'+nib-10; +} + +/* Tell the remote machine to resume. */ + +static enum target_signal last_sent_signal = TARGET_SIGNAL_0; +int last_sent_step; + +static void +remote_resume (pid, step, siggnal) + int pid, step; + enum target_signal siggnal; +{ + char buf[PBUFSIZ]; + + if (pid == -1) + set_thread (inferior_pid, 0); + else + set_thread (pid, 0); + + dcache_flush (remote_dcache); + + last_sent_signal = siggnal; + last_sent_step = step; + + /* A hook for when we need to do something at the last moment before + resumption. */ + if (target_resume_hook) + (*target_resume_hook) (); + + if (siggnal != TARGET_SIGNAL_0) + { + buf[0] = step ? 'S' : 'C'; + buf[1] = tohex (((int)siggnal >> 4) & 0xf); + buf[2] = tohex ((int)siggnal & 0xf); + buf[3] = '\0'; + } + else + strcpy (buf, step ? "s": "c"); + + putpkt (buf); +} + +/* Send ^C to target to halt it. Target will respond, and send us a + packet. */ + +static void +remote_interrupt (signo) + int signo; +{ + /* If this doesn't work, try more severe steps. */ + signal (signo, remote_interrupt_twice); + + if (remote_debug) + printf_unfiltered ("remote_interrupt called\n"); + + /* Send a break or a ^C, depending on user preference. */ + if (remote_break) + SERIAL_SEND_BREAK (remote_desc); + else + SERIAL_WRITE (remote_desc, "\003", 1); +} + +static void (*ofunc)(); + +/* The user typed ^C twice. */ +static void +remote_interrupt_twice (signo) + int signo; +{ + signal (signo, ofunc); + + interrupt_query (); + + signal (signo, remote_interrupt); +} + +/* Ask the user what to do when an interrupt is received. */ + +static void +interrupt_query () +{ + target_terminal_ours (); + + if (query ("Interrupted while waiting for the program.\n\ +Give up (and stop debugging it)? ")) + { + target_mourn_inferior (); + return_to_top_level (RETURN_QUIT); + } + + target_terminal_inferior (); +} + +/* If nonzero, ignore the next kill. */ +int kill_kludge; + +void +remote_console_output (msg) + char *msg; +{ + char *p; + + for (p = msg; *p; p +=2) + { + char tb[2]; + char c = fromhex (p[0]) * 16 + fromhex (p[1]); + tb[0] = c; + tb[1] = 0; + if (target_output_hook) + target_output_hook (tb); + else + fputs_filtered (tb, gdb_stdout); + } +} + +/* Wait until the remote machine stops, then return, + storing status in STATUS just as `wait' would. + Returns "pid" (though it's not clear what, if anything, that + means in the case of this target). */ + +static int +remote_wait (pid, status) + int pid; + struct target_waitstatus *status; +{ + unsigned char buf[PBUFSIZ]; + int thread_num = -1; + + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; + + while (1) + { + unsigned char *p; + + ofunc = (void (*)()) signal (SIGINT, remote_interrupt); + getpkt ((char *) buf, 1); + signal (SIGINT, ofunc); + + /* This is a hook for when we need to do something (perhaps the + collection of trace data) every time the target stops. */ + if (target_wait_loop_hook) + (*target_wait_loop_hook) (); + + switch (buf[0]) + { + case 'E': /* Error of some sort */ + warning ("Remote failure reply: %s", buf); + continue; + case 'T': /* Status with PC, SP, FP, ... */ + { + int i; + long regno; + char regs[MAX_REGISTER_RAW_SIZE]; + + /* Expedited reply, containing Signal, {regno, reg} repeat */ + /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where + ss = signal number + n... = register number + r... = register contents + */ + p = &buf[3]; /* after Txx */ + + while (*p) + { + unsigned char *p1; + char *p_temp; + + regno = strtol ((const char *) p, &p_temp, 16); /* Read the register number */ + p1 = (unsigned char *)p_temp; + + if (p1 == p) + { + p1 = (unsigned char *) strchr ((const char *) p, ':'); + if (p1 == NULL) + warning ("Malformed packet (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 = (unsigned char *)p_temp; + } + } + else + { + p = p1; + + if (*p++ != ':') + warning ("Malformed packet (missing colon): %s\n\ +Packet: '%s'\n", + p, buf); + + if (regno >= NUM_REGS) + warning ("Remote sent bad register number %ld: %s\n\ +Packet: '%s'\n", + regno, p, buf); + + for (i = 0; i < REGISTER_RAW_SIZE (regno); i++) + { + if (p[0] == 0 || p[1] == 0) + warning ("Remote reply is too short: %s", buf); + regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); + p += 2; + } + supply_register (regno, regs); + } + + if (*p++ != ';') + warning ("Remote register badly formatted: %s", buf); + } + } + /* fall through */ + case 'S': /* Old style status, just signal only */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = (enum target_signal) + (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))); + + goto got_status; + case 'W': /* Target exited */ + { + /* The remote process exited. */ + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]); + goto got_status; + } + case 'X': + status->kind = TARGET_WAITKIND_SIGNALLED; + status->value.sig = (enum target_signal) + (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))); + kill_kludge = 1; + + goto got_status; + case 'O': /* Console output */ + remote_console_output (buf + 1); + continue; + case '\0': + if (last_sent_signal != TARGET_SIGNAL_0) + { + /* Zero length reply means that we tried 'S' or 'C' and + the remote system doesn't support it. */ + target_terminal_ours_for_output (); + printf_filtered + ("Can't send signals to this remote system. %s not sent.\n", + target_signal_to_name (last_sent_signal)); + last_sent_signal = TARGET_SIGNAL_0; + target_terminal_inferior (); + + strcpy ((char *) buf, last_sent_step ? "s" : "c"); + putpkt ((char *) buf); + continue; + } + /* else fallthrough */ + default: + warning ("Invalid remote reply: %s", buf); + continue; + } + } + got_status: + if (thread_num != -1) + { + /* Initial thread value can only be acquired via wait, so deal with + this marker which is used before the first thread value is + acquired. */ + if (inferior_pid == 42000) + { + inferior_pid = thread_num; + add_thread (inferior_pid); + } + return thread_num; + } + return inferior_pid; +} + +/* Number of bytes of registers this stub implements. */ +static int register_bytes_found; + +/* Read the remote registers into the block REGS. */ +/* Currently we just read all the registers, so we don't use regno. */ +/* ARGSUSED */ +static void +remote_fetch_registers (regno) + int regno; +{ + char buf[PBUFSIZ]; + int i; + char *p; + char regs[REGISTER_BYTES]; + + set_thread (inferior_pid, 1); + + sprintf (buf, "g"); + remote_send (buf); + + if (remote_register_buf_size == 0) + remote_register_buf_size = strlen (buf); + + /* Unimplemented registers read as all bits zero. */ + memset (regs, 0, REGISTER_BYTES); + + /* We can get out of synch in various cases. If the first character + in the buffer is not a hex character, assume that has happened + and try to fetch another packet to read. */ + while ((buf[0] < '0' || buf[0] > '9') + && (buf[0] < 'a' || buf[0] > 'f')) + { + if (remote_debug) + printf_unfiltered ("Bad register packet; fetching a new packet\n"); + getpkt (buf, 0); + } + + /* Reply describes registers byte by byte, each byte encoded as two + hex characters. Suck them all up, then supply them to the + register cacheing/storage mechanism. */ + + p = buf; + for (i = 0; i < REGISTER_BYTES; i++) + { + if (p[0] == 0) + break; + if (p[1] == 0) + { + warning ("Remote reply is of odd length: %s", buf); + /* Don't change register_bytes_found in this case, and don't + print a second warning. */ + goto supply_them; + } + regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); + p += 2; + } + + if (i != register_bytes_found) + { + register_bytes_found = i; +#ifdef REGISTER_BYTES_OK + if (!REGISTER_BYTES_OK (i)) + warning ("Remote reply is too short: %s", buf); +#endif + } + + supply_them: + for (i = 0; i < NUM_REGS; i++) + supply_register (i, ®s[REGISTER_BYTE(i)]); +} + +/* Prepare to store registers. Since we may send them all (using a + 'G' request), we have to read out the ones we don't want to change + first. */ + +static void +remote_prepare_to_store () +{ + /* Make sure the entire registers array is valid. */ + read_register_bytes (0, (char *)NULL, REGISTER_BYTES); +} + +/* Store register REGNO, or all registers if REGNO == -1, from the contents + of REGISTERS. FIXME: ignores errors. */ + +static void +remote_store_registers (regno) + int regno; +{ + char buf[PBUFSIZ]; + int i; + char *p; + + set_thread (inferior_pid, 1); + + if (regno >= 0 && stub_supports_P) + { + /* Try storing a single register. */ + char *regp; + + sprintf (buf, "P%x=", regno); + p = buf + strlen (buf); + regp = ®isters[REGISTER_BYTE (regno)]; + for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i) + { + *p++ = tohex ((regp[i] >> 4) & 0xf); + *p++ = tohex (regp[i] & 0xf); + } + *p = '\0'; + remote_send (buf); + if (buf[0] != '\0') + { + /* The stub understands the 'P' request. We are done. */ + return; + } + + /* The stub does not support the 'P' request. Use 'G' instead, + and don't try using 'P' in the future (it will just waste our + time). */ + stub_supports_P = 0; + } + + buf[0] = 'G'; + + /* Command describes registers byte by byte, + each byte encoded as two hex characters. */ + + 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 = '\0'; + + remote_send (buf); +} + +/* + 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?) */ + + + +/* Return the number of hex digits in num. */ + +static int +hexnumlen (num) + ULONGEST num; +{ + int i; + + for (i = 0; num != 0; i++) + num >>= 4; + + return max (i, 1); +} + +/* Write memory data directly to the remote machine. + This does not inform the data cache; the data cache uses this. + MEMADDR is the address in the remote memory space. + MYADDR is the address of the buffer in our space. + LEN is the number of bytes. + + Returns number of bytes transferred, or 0 for error. */ + +static int +remote_write_bytes (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int max_buf_size; /* Max size of packet output buffer */ + int origlen; + + /* Chop the transfer down if necessary */ + + max_buf_size = min (remote_write_size, PBUFSIZ); + if (remote_register_buf_size != 0) + max_buf_size = min (max_buf_size, remote_register_buf_size); + + /* Subtract header overhead from max payload size - $M,:#nn */ + max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4; + + origlen = len; + while (len > 0) + { + char buf[PBUFSIZ]; + char *p; + int todo; + int i; + + todo = min (len, max_buf_size / 2); /* num bytes that will fit */ + + /* FIXME-32x64: Need a version of print_address_numeric which puts the + result in a buffer like sprintf. */ + sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); + + /* We send target system values byte by byte, in increasing byte addresses, + each byte encoded as two hex characters. */ + + p = buf + strlen (buf); + for (i = 0; i < todo; i++) + { + *p++ = tohex ((myaddr[i] >> 4) & 0xf); + *p++ = tohex (myaddr[i] & 0xf); + } + *p = '\0'; + + putpkt (buf); + getpkt (buf, 0); + + if (buf[0] == 'E') + { + /* There is no correspondance between what the remote protocol uses + for errors and errno codes. We would like a cleaner way of + representing errors (big enough to include errno codes, bfd_error + codes, and others). But for now just return EIO. */ + errno = EIO; + return 0; + } + myaddr += todo; + memaddr += todo; + len -= todo; + } + return origlen; +} + +/* Read memory data directly from the remote machine. + This does not use the data cache; the data cache uses this. + MEMADDR is the address in the remote memory space. + MYADDR is the address of the buffer in our space. + LEN is the number of bytes. + + Returns number of bytes transferred, or 0 for error. */ + +static int +remote_read_bytes (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int max_buf_size; /* Max size of packet output buffer */ + int origlen; + + /* Chop the transfer down if necessary */ + + max_buf_size = min (remote_write_size, PBUFSIZ); + if (remote_register_buf_size != 0) + max_buf_size = min (max_buf_size, remote_register_buf_size); + + origlen = len; + while (len > 0) + { + char buf[PBUFSIZ]; + char *p; + int todo; + int i; + + todo = min (len, max_buf_size / 2); /* num bytes that will fit */ + + /* FIXME-32x64: Need a version of print_address_numeric which puts the + result in a buffer like sprintf. */ + sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); + putpkt (buf); + getpkt (buf, 0); + + if (buf[0] == 'E') + { + /* There is no correspondance between what the remote protocol uses + for errors and errno codes. We would like a cleaner way of + representing errors (big enough to include errno codes, bfd_error + codes, and others). But for now just return EIO. */ + errno = EIO; + return 0; + } + + /* Reply describes memory byte by byte, + each byte encoded as two hex characters. */ + + p = buf; + for (i = 0; i < todo; i++) + { + if (p[0] == 0 || p[1] == 0) + /* Reply is short. This means that we were able to read only part + of what we wanted to. */ + return i + (origlen - len); + myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]); + p += 2; + } + myaddr += todo; + memaddr += todo; + len -= todo; + } + return origlen; +} + +/* Read or write LEN bytes from inferior memory at MEMADDR, transferring + to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is + nonzero. Returns length of data written or read; 0 for error. */ + +/* ARGSUSED */ +static int +remote_xfer_memory(memaddr, myaddr, len, should_write, target) + CORE_ADDR memaddr; + char *myaddr; + int len; + int should_write; + struct target_ops *target; /* ignored */ +{ +#ifdef REMOTE_TRANSLATE_XFER_ADDRESS + CORE_ADDR targaddr; + int targlen; + REMOTE_TRANSLATE_XFER_ADDRESS (memaddr, len, targaddr, targlen); + if (targlen == 0) + return 0; + memaddr = targaddr; + len = targlen; +#endif + + return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, should_write); +} + + +#if 0 +/* 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; +{ + if (increment == -4 && len == 4) + { + long mask_long, data_long; + long data_found_long; + CORE_ADDR addr_we_found; + char buf[PBUFSIZ]; + long returned_long[2]; + char *p; + + mask_long = extract_unsigned_integer (mask, len); + data_long = extract_unsigned_integer (data, len); + sprintf (buf, "t%x:%x,%x", startaddr, data_long, mask_long); + putpkt (buf); + getpkt (buf, 0); + if (buf[0] == '\0') + { + /* The stub doesn't support the 't' request. We might want to + remember this fact, but on the other hand the stub could be + switched on us. Maybe we should remember it only until + the next "target remote". */ + generic_search (len, data, mask, startaddr, increment, lorange, + hirange, addr_found, data_found); + return; + } + + if (buf[0] == 'E') + /* There is no correspondance between what the remote protocol uses + for errors and errno codes. We would like a cleaner way of + representing errors (big enough to include errno codes, bfd_error + codes, and others). But for now just use EIO. */ + memory_error (EIO, startaddr); + p = buf; + addr_we_found = 0; + while (*p != '\0' && *p != ',') + addr_we_found = (addr_we_found << 4) + fromhex (*p++); + if (*p == '\0') + error ("Protocol error: short return for search"); + + data_found_long = 0; + while (*p != '\0' && *p != ',') + data_found_long = (data_found_long << 4) + fromhex (*p++); + /* Ignore anything after this comma, for future extensions. */ + + if (addr_we_found < lorange || addr_we_found >= hirange) + { + *addr_found = 0; + return; + } + + *addr_found = addr_we_found; + *data_found = store_unsigned_integer (data_we_found, len); + return; + } + generic_search (len, data, mask, startaddr, increment, lorange, + hirange, addr_found, data_found); +} +#endif /* 0 */ + +static void +remote_files_info (ignore) + struct target_ops *ignore; +{ + puts_filtered ("Debugging a target over a serial line.\n"); +} + +/* Stuff for dealing with the packets which are part of this protocol. + See comment at top of file for details. */ + +/* Read a single character from the remote end, masking it down to 7 bits. */ + +static int +readchar (timeout) + int timeout; +{ + int ch; + + ch = SERIAL_READCHAR (remote_desc, timeout); + + switch (ch) + { + case SERIAL_EOF: + error ("Remote connection closed"); + case SERIAL_ERROR: + perror_with_name ("Remote communication error"); + case SERIAL_TIMEOUT: + return ch; + default: + return ch & 0x7f; + } +} + +/* Send the command in BUF to the remote machine, + and read the reply into BUF. + Report an error if we get an error reply. */ + +static void +remote_send (buf) + char *buf; +{ + putpkt (buf); + getpkt (buf, 0); + + if (buf[0] == 'E') + error ("Remote failure reply: %s", buf); +} + +/* Send a packet to the remote machine, with error checking. + The data of the packet is in BUF. */ + +int +putpkt (buf) + char *buf; +{ + int i; + unsigned char csum = 0; + char buf2[PBUFSIZ]; + int cnt = strlen (buf); + int ch; + int tcount = 0; + char *p; + + /* Copy the packet into buffer BUF2, encapsulating it + and giving it a checksum. */ + + if (cnt > (int) sizeof (buf2) - 5) /* Prosanity check */ + abort(); + + p = buf2; + *p++ = '$'; + + for (i = 0; i < cnt; i++) + { + csum += buf[i]; + *p++ = buf[i]; + } + *p++ = '#'; + *p++ = tohex ((csum >> 4) & 0xf); + *p++ = tohex (csum & 0xf); + + /* Send it over and over until we get a positive ack. */ + + while (1) + { + int started_error_output = 0; + + if (remote_debug) + { + *p = '\0'; + printf_unfiltered ("Sending packet: %s...", buf2); + gdb_flush(gdb_stdout); + } + if (SERIAL_WRITE (remote_desc, buf2, p - buf2)) + perror_with_name ("putpkt: write failed"); + + /* read until either a timeout occurs (-2) or '+' is read */ + while (1) + { + ch = readchar (remote_timeout); + + if (remote_debug) + { + switch (ch) + { + case '+': + case SERIAL_TIMEOUT: + case '$': + if (started_error_output) + { + putchar_unfiltered ('\n'); + started_error_output = 0; + } + } + } + + switch (ch) + { + case '+': + if (remote_debug) + printf_unfiltered("Ack\n"); + return 1; + case SERIAL_TIMEOUT: + tcount ++; + if (tcount > 3) + return 0; + break; /* Retransmit buffer */ + case '$': + { + char junkbuf[PBUFSIZ]; + + /* It's probably an old response, and we're out of sync. Just + gobble up the packet and ignore it. */ + getpkt (junkbuf, 0); + continue; /* Now, go look for + */ + } + default: + if (remote_debug) + { + if (!started_error_output) + { + started_error_output = 1; + printf_unfiltered ("putpkt: Junk: "); + } + putchar_unfiltered (ch & 0177); + } + continue; + } + break; /* Here to retransmit */ + } + +#if 0 + /* This is wrong. If doing a long backtrace, the user should be + able to get out next time we call QUIT, without anything as violent + as interrupt_query. If we want to provide a way out of here + without getting to the next QUIT, it should be based on hitting + ^C twice as in remote_wait. */ + if (quit_flag) + { + quit_flag = 0; + interrupt_query (); + } +#endif + } +} + +/* Come here after finding the start of the frame. Collect the rest into BUF, + verifying the checksum, length, and handling run-length compression. + Returns 0 on any error, 1 on success. */ + +static int +read_frame (buf) + char *buf; +{ + unsigned char csum; + char *bp; + int c; + + csum = 0; + bp = buf; + + while (1) + { + c = readchar (remote_timeout); + + switch (c) + { + case SERIAL_TIMEOUT: + if (remote_debug) + puts_filtered ("Timeout in mid-packet, retrying\n"); + return 0; + case '$': + if (remote_debug) + puts_filtered ("Saw new packet start in middle of old one\n"); + return 0; /* Start a new packet, count retries */ + case '#': + { + unsigned char pktcsum; + + *bp = '\000'; + + pktcsum = fromhex (readchar (remote_timeout)) << 4; + pktcsum |= fromhex (readchar (remote_timeout)); + + if (csum == pktcsum) + return 1; + + if (remote_debug) + { + printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=", + pktcsum, csum); + puts_filtered (buf); + puts_filtered ("\n"); + } + return 0; + } + case '*': /* Run length encoding */ + csum += c; + c = readchar (remote_timeout); + csum += c; + c = c - ' ' + 3; /* Compute repeat count */ + + + if (c > 0 && c < 255 && bp + c - 1 < buf + PBUFSIZ - 1) + { + memset (bp, *(bp - 1), c); + bp += c; + continue; + } + + *bp = '\0'; + printf_filtered ("Repeat count %d too large for buffer: ", c); + puts_filtered (buf); + puts_filtered ("\n"); + return 0; + + default: + if (bp < buf + PBUFSIZ - 1) + { + *bp++ = c; + csum += c; + continue; + } + + *bp = '\0'; + puts_filtered ("Remote packet too long: "); + puts_filtered (buf); + puts_filtered ("\n"); + + return 0; + } + } +} + +/* 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 + while the target is executing user code. */ + +void +getpkt (buf, forever) + char *buf; + int forever; +{ + int c; + int tries; + int timeout; + int val; + + strcpy (buf,"timeout"); + + if (forever) + { +#ifdef MAINTENANCE_CMDS + timeout = watchdog > 0 ? watchdog : -1; +#else + timeout = -1; +#endif + } + + else + timeout = remote_timeout; + +#define MAX_TRIES 3 + + for (tries = 1; tries <= MAX_TRIES; tries++) + { + /* This can loop forever if the remote side sends us characters + continuously, but if it pauses, we'll get a zero from readchar + because of timeout. Then we'll count that as a retry. */ + + /* Note that we will only wait forever prior to the start of a packet. + After that, we expect characters to arrive at a brisk pace. They + should show up within remote_timeout intervals. */ + + do + { + c = readchar (timeout); + + if (c == SERIAL_TIMEOUT) + { +#ifdef MAINTENANCE_CMDS + if (forever) /* Watchdog went off. Kill the target. */ + { + target_mourn_inferior (); + error ("Watchdog has expired. Target detached.\n"); + } +#endif + if (remote_debug) + puts_filtered ("Timed out.\n"); + goto retry; + } + } + while (c != '$'); + + /* We've found the start of a packet, now collect the data. */ + + val = read_frame (buf); + + if (val == 1) + { + if (remote_debug) + fprintf_unfiltered (gdb_stdout, "Packet received: %s\n", buf); + SERIAL_WRITE (remote_desc, "+", 1); + return; + } + + /* Try the whole thing again. */ + retry: + SERIAL_WRITE (remote_desc, "-", 1); + } + + /* We have tried hard enough, and just can't receive the packet. Give up. */ + + printf_unfiltered ("Ignoring packet error, continuing...\n"); + SERIAL_WRITE (remote_desc, "+", 1); +} + +static void +remote_kill () +{ + /* For some mysterious reason, wait_for_inferior calls kill instead of + mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */ + if (kill_kludge) + { + kill_kludge = 0; + target_mourn_inferior (); + return; + } + + /* Use catch_errors so the user can quit from gdb even when we aren't on + speaking terms with the remote system. */ + catch_errors (putpkt, "k", "", RETURN_MASK_ERROR); + + /* Don't wait for it to die. I'm not really sure it matters whether + we do or not. For the existing stubs, kill is a noop. */ + target_mourn_inferior (); +} + +static void +remote_mourn () +{ + remote_mourn_1 (&remote_ops); +} + +static void +extended_remote_mourn () +{ + /* We do _not_ want to mourn the target like this; this will + remove the extended remote target from the target stack, + and the next time the user says "run" it'll fail. + + FIXME: What is the right thing to do here? */ +#if 0 + remote_mourn_1 (&extended_remote_ops); +#endif +} + +/* Worker function for remote_mourn. */ +static void +remote_mourn_1 (target) + struct target_ops *target; +{ + unpush_target (target); + generic_mourn_inferior (); +} + +/* In the extended protocol we want to be able to do things like + "run" and have them basically work as expected. So we need + a special create_inferior function. + + FIXME: One day add support for changing the exec file + we're debugging, arguments and an environment. */ + +static void +extended_remote_create_inferior (exec_file, args, env) + char *exec_file; + char *args; + char **env; +{ + /* Rip out the breakpoints; we'll reinsert them after restarting + the remote server. */ + remove_breakpoints (); + + /* Now restart the remote server. */ + extended_remote_restart (); + + /* Now put the breakpoints back in. This way we're safe if the + restart function works via a unix fork on the remote side. */ + insert_breakpoints (); + + /* Clean up from the last time we were running. */ + clear_proceed_status (); + + /* Let the remote process run. */ + proceed (-1, TARGET_SIGNAL_0, 0); +} + + +/* On some machines, e.g. 68k, we may use a different breakpoint instruction + than other targets; in those use REMOTE_BREAKPOINT instead of just + BREAKPOINT. Also, bi-endian targets may define LITTLE_REMOTE_BREAKPOINT + and BIG_REMOTE_BREAKPOINT. If none of these are defined, we just call + the standard routines that are in mem-break.c. */ + +/* FIXME, these ought to be done in a more dynamic fashion. For instance, + the choice of breakpoint instruction affects target program design and + vice versa, and by making it user-tweakable, the special code here + goes away and we need fewer special GDB configurations. */ + +#if defined (LITTLE_REMOTE_BREAKPOINT) && defined (BIG_REMOTE_BREAKPOINT) && !defined(REMOTE_BREAKPOINT) +#define REMOTE_BREAKPOINT +#endif + +#ifdef REMOTE_BREAKPOINT + +/* If the target isn't bi-endian, just pretend it is. */ +#if !defined (LITTLE_REMOTE_BREAKPOINT) && !defined (BIG_REMOTE_BREAKPOINT) +#define LITTLE_REMOTE_BREAKPOINT REMOTE_BREAKPOINT +#define BIG_REMOTE_BREAKPOINT REMOTE_BREAKPOINT +#endif + +static unsigned char big_break_insn[] = BIG_REMOTE_BREAKPOINT; +static unsigned char little_break_insn[] = LITTLE_REMOTE_BREAKPOINT; + +#endif /* REMOTE_BREAKPOINT */ + +/* Insert a breakpoint on targets that don't have any better breakpoint + support. We read the contents of the target location and stash it, + then overwrite it with a breakpoint instruction. ADDR is the target + location in the target machine. CONTENTS_CACHE is a pointer to + memory allocated for saving the target contents. It is guaranteed + by the caller to be long enough to save sizeof BREAKPOINT bytes (this + is accomplished via BREAKPOINT_MAX). */ + +static int +remote_insert_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ +#ifdef REMOTE_BREAKPOINT + int val; + + val = target_read_memory (addr, contents_cache, sizeof big_break_insn); + + if (val == 0) + { + if (TARGET_BYTE_ORDER == BIG_ENDIAN) + val = target_write_memory (addr, (char *) big_break_insn, + sizeof big_break_insn); + else + val = target_write_memory (addr, (char *) little_break_insn, + sizeof little_break_insn); + } + + return val; +#else + return memory_insert_breakpoint (addr, contents_cache); +#endif /* REMOTE_BREAKPOINT */ +} + +static int +remote_remove_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ +#ifdef REMOTE_BREAKPOINT + return target_write_memory (addr, contents_cache, sizeof big_break_insn); +#else + return memory_remove_breakpoint (addr, contents_cache); +#endif /* REMOTE_BREAKPOINT */ +} + +/* Some targets are only capable of doing downloads, and afterwards they switch + to the remote serial protocol. This function provides a clean way to get + from the download target to the remote target. It's basically just a + wrapper so that we don't have to expose any of the internal workings of + remote.c. + + Prior to calling this routine, you should shutdown the current target code, + else you will get the "A program is being debugged already..." message. + Usually a call to pop_target() suffices. +*/ + +void +push_remote_target (name, from_tty) + char *name; + int from_tty; +{ + printf_filtered ("Switching to remote protocol\n"); + remote_open (name, from_tty); +} + +/* Other targets want to use the entire remote serial module but with + 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; +{ + printf_filtered ("Selecting the %sremote protocol\n", + (extended_p ? "extended-" : "")); + remote_open_1 (name, from_tty, target, extended_p); +} + +/* Remote target communications for serial-line targets in custom GDB protocol + Copyright 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* Remote communication protocol. + + A debug packet whose contents are + is encapsulated for transmission in the form: + + $ # CSUM1 CSUM2 + + must be ASCII alphanumeric and cannot include characters + '$' or '#'. If starts with two characters followed by + ':', then the existing stubs interpret this as a sequence number. + + CSUM1 and CSUM2 are ascii hex representation of an 8-bit + checksum of , the most significant nibble is sent first. + the hex digits 0-9,a-f are used. + + Receiver responds with: + + + - if CSUM is correct and ready for next packet + - - if CSUM is incorrect + + is as follows: + Most values are encoded in ascii hex digits. Signal numbers are according + to the numbering in target.h. + + Request Packet + + set thread Hct... Set thread for subsequent operations. + c = 'c' for thread used in step and + continue; t... can be -1 for all + threads. + c = 'g' for thread used in other + operations. If zero, pick a thread, + any thread. + reply OK for success + ENN for an error. + + read registers g + reply XX....X Each byte of register data + is described by two hex digits. + Registers are in the internal order + for GDB, and the bytes in a register + are in the same order the machine uses. + or ENN for an error. + + write regs GXX..XX Each byte of register data + is described by two hex digits. + reply OK for success + ENN for an error + + write reg Pn...=r... Write register n... with value r..., + which contains two hex digits for each + byte in the register (target byte + order). + reply OK for success + ENN for an error + (not supported by all stubs). + + read mem mAA..AA,LLLL AA..AA is address, LLLL is length. + reply XX..XX XX..XX is mem contents + Can be fewer bytes than requested + if able to read only part of the data. + or ENN NN is errno + + write mem MAA..AA,LLLL:XX..XX + AA..AA is address, + LLLL is number of bytes, + XX..XX is data + reply OK for success + ENN for an error (this includes the case + where only part of the data was + written). + + continue cAA..AA AA..AA is address to resume + If AA..AA is omitted, + resume at same address. + + step sAA..AA AA..AA is address to resume + If AA..AA is omitted, + resume at same address. + + continue with Csig;AA..AA Continue with signal sig (hex signal + signal number). If ;AA..AA is omitted, resume + at same address. + + step with Ssig;AA..AA Like 'C' but step not continue. + signal + + last signal ? Reply the current reason for stopping. + This is the same reply as is generated + for step or cont : SAA where AA is the + signal number. + + detach D Reply OK. + + There is no immediate reply to step or cont. + The reply comes when the machine stops. + It is SAA AA is the signal number. + + or... TAAn...:r...;n...:r...;n...:r...; + AA = signal number + n... = register number (hex) + r... = register contents + n... = `thread' + r... = thread process ID. This is + a hex integer. + n... = other string not starting + with valid hex digit. + gdb should ignore this n,r pair + and go on to the next. This way + we can extend the protocol. + or... WAA The process exited, and AA is + the exit status. This is only + applicable for certains sorts of + targets. + or... XAA The process terminated with signal + AA. + or... OXX..XX XX..XX is hex encoding of ASCII data. This + can happen at any time while the program is + running and the debugger should + continue to wait for 'W', 'T', etc. + + thread alive TXX Find out if the thread XX is alive. + reply OK thread is still alive + ENN thread is dead + + remote restart RXX Restart the remote server + + extended ops ! Use the extended remote protocol. + Sticky -- only needs to be set once. + + kill request k + + toggle debug d toggle debug flag (see 386 & 68k stubs) + reset r reset -- see sparc stub. + reserved On other requests, the stub should + ignore the request and send an empty + response ($#). This way + we can extend the protocol and GDB + can tell whether the stub it is + talking to uses the old or the new. + search tAA:PP,MM Search backwards starting at address + AA for a match with pattern PP and + mask MM. PP and MM are 4 bytes. + Not supported by all stubs. + + general query qXXXX Request info about XXXX. + general set QXXXX=yyyy Set value of XXXX to yyyy. + query sect offs qOffsets Get section offsets. Reply is + Text=xxx;Data=yyy;Bss=zzz + + Responses can be run-length encoded to save space. A '*' means that + the next character is an ASCII encoding giving a repeat count which + stands for that many repititions of the character preceding the '*'. + The encoding is n+29, yielding a printable character where n >=3 + (which is where rle starts to win). Don't use an n > 126. + + So + "0* " means the same as "0000". */ + +#include "defs.h" +#include "gdb_string.h" +#include +#include "frame.h" +#include "inferior.h" +#include "bfd.h" +#include "symfile.h" +#include "target.h" +#include "wait.h" +/*#include "terminal.h"*/ +#include "gdbcmd.h" +#include "objfiles.h" +#include "gdb-stabs.h" +#include "gdbthread.h" + +#include "dcache.h" + +#ifdef USG +#include +#endif + +#include +#include "serial.h" + +/* Prototypes for local functions */ + +static int remote_write_bytes PARAMS ((CORE_ADDR memaddr, + char *myaddr, int len)); + +static int remote_read_bytes PARAMS ((CORE_ADDR memaddr, + char *myaddr, int len)); + +static void remote_files_info PARAMS ((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 void remote_prepare_to_store PARAMS ((void)); + +static void remote_fetch_registers PARAMS ((int regno)); + +static void remote_resume PARAMS ((int pid, int step, + enum target_signal siggnal)); + +static int remote_start_remote PARAMS ((char *dummy)); + +static void remote_open PARAMS ((char *name, int from_tty)); + +static void extended_remote_open PARAMS ((char *name, int from_tty)); + +static void remote_open_1 PARAMS ((char *, int, struct target_ops *, int extended_p)); + +static void remote_close PARAMS ((int quitting)); + +static void remote_store_registers PARAMS ((int regno)); + +static void remote_mourn PARAMS ((void)); + +static void extended_remote_restart PARAMS ((void)); + +static void extended_remote_mourn PARAMS ((void)); + +static void extended_remote_create_inferior PARAMS ((char *, char *, char **)); + +static void remote_mourn_1 PARAMS ((struct target_ops *)); + +static void remote_send PARAMS ((char *buf)); + +static int readchar PARAMS ((int timeout)); + +static int remote_wait PARAMS ((int pid, struct target_waitstatus *status)); + +static void remote_kill PARAMS ((void)); + +static int tohex PARAMS ((int nib)); + +static void remote_detach PARAMS ((char *args, int from_tty)); + +static void remote_interrupt PARAMS ((int signo)); + +static void remote_interrupt_twice PARAMS ((int signo)); + +static void interrupt_query PARAMS ((void)); + +static void set_thread PARAMS ((int, int)); + +static int remote_thread_alive PARAMS ((int)); + +static void get_offsets PARAMS ((void)); + +static int read_frame PARAMS ((char *)); + +static int remote_insert_breakpoint PARAMS ((CORE_ADDR, char *)); + +static int remote_remove_breakpoint PARAMS ((CORE_ADDR, char *)); + +static int hexnumlen PARAMS ((ULONGEST num)); + +/* exported functions */ + +extern int fromhex PARAMS ((int a)); +extern void getpkt PARAMS ((char *buf, int forever)); +extern int putpkt PARAMS ((char *buf)); + +/* Define the target subroutine names */ + +static struct target_ops remote_ops ; + +static void init_remote_ops(void) +{ + remote_ops.to_shortname = "remote"; + remote_ops.to_longname = "Remote serial target in gdb-specific protocol"; + remote_ops.to_doc = "Use a remote computer via a serial line; using a gdb-specific protocol.\n\ +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_attach = NULL; + remote_ops.to_detach = remote_detach; + remote_ops.to_resume = remote_resume; + 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; + remote_ops.to_xfer_memory = remote_xfer_memory; + remote_ops.to_files_info = remote_files_info; + remote_ops.to_insert_breakpoint = remote_insert_breakpoint; + remote_ops.to_remove_breakpoint = remote_remove_breakpoint; + remote_ops.to_terminal_init = NULL; + remote_ops.to_terminal_inferior = NULL; + remote_ops.to_terminal_ours_for_output = NULL; + remote_ops.to_terminal_ours = NULL; + remote_ops.to_terminal_info = NULL; + remote_ops.to_kill = remote_kill; + remote_ops.to_load = generic_load; + remote_ops.to_lookup_symbol = NULL; + remote_ops.to_create_inferior = NULL; + remote_ops.to_mourn_inferior = remote_mourn; + remote_ops.to_can_run = 0; + remote_ops.to_notice_signals = 0; + remote_ops.to_thread_alive = remote_thread_alive; + remote_ops.to_stop = 0; + remote_ops.to_stratum = process_stratum; + remote_ops.DONT_USE = NULL; + remote_ops.to_has_all_memory = 1; + remote_ops.to_has_memory = 1; + remote_ops.to_has_stack = 1; + remote_ops.to_has_registers = 1; + remote_ops.to_has_execution = 1; + remote_ops.to_sections = NULL; + remote_ops.to_sections_end = NULL; + remote_ops.to_magic = OPS_MAGIC ; +} /* init_remote_ops */ + +static struct target_ops extended_remote_ops ; + +static void init_extended_remote_ops(void) +{ + extended_remote_ops.to_shortname = "extended-remote"; + extended_remote_ops.to_longname = "Extended remote serial target in gdb-specific protocol"; + extended_remote_ops.to_doc = "Use a remote computer via a serial line; using a gdb-specific protocol.\n\ +Specify the serial device it is connected to (e.g. /dev/ttya).", + extended_remote_ops.to_open = extended_remote_open; + extended_remote_ops.to_close = remote_close; + extended_remote_ops.to_attach = NULL; + extended_remote_ops.to_detach = remote_detach; + extended_remote_ops.to_resume = remote_resume; + extended_remote_ops.to_wait = remote_wait; + extended_remote_ops.to_fetch_registers = remote_fetch_registers; + extended_remote_ops.to_store_registers = remote_store_registers; + extended_remote_ops.to_prepare_to_store = remote_prepare_to_store; + extended_remote_ops.to_xfer_memory = remote_xfer_memory; + extended_remote_ops.to_files_info = remote_files_info; + extended_remote_ops.to_insert_breakpoint = remote_insert_breakpoint; + extended_remote_ops.to_remove_breakpoint = remote_remove_breakpoint; + extended_remote_ops.to_terminal_init = NULL; + extended_remote_ops.to_terminal_inferior = NULL; + extended_remote_ops.to_terminal_ours_for_output = NULL; + extended_remote_ops.to_terminal_ours = NULL; + extended_remote_ops.to_terminal_info = NULL; + extended_remote_ops.to_kill = remote_kill; + extended_remote_ops.to_load = generic_load; + extended_remote_ops.to_lookup_symbol = NULL; + extended_remote_ops.to_create_inferior = extended_remote_create_inferior; + extended_remote_ops.to_mourn_inferior = extended_remote_mourn; + extended_remote_ops.to_can_run = 0; + extended_remote_ops.to_notice_signals = 0; + extended_remote_ops.to_thread_alive = remote_thread_alive; + extended_remote_ops.to_stop = 0; + extended_remote_ops.to_stratum = process_stratum; + extended_remote_ops.DONT_USE = NULL; + extended_remote_ops.to_has_all_memory = 1; + extended_remote_ops.to_has_memory = 1; + extended_remote_ops.to_has_stack = 1; + extended_remote_ops.to_has_registers = 1; + extended_remote_ops.to_has_execution = 1; + extended_remote_ops.to_sections = NULL; + extended_remote_ops.to_sections_end = NULL; + extended_remote_ops.to_magic = OPS_MAGIC ; +} + + +/* 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; + +/* This variable chooses whether to send a ^C or a break when the user + requests program interruption. Although ^C is usually what remote + systems expect, and that is the default here, sometimes a break is + preferable instead. */ + +static int remote_break; + +/* Descriptor for I/O to remote machine. Initialize it to NULL so that + remote_open knows that we don't have a file open when the program + starts. */ +static serial_t remote_desc = NULL; + +/* Having this larger than 400 causes us to be incompatible with m68k-stub.c + and i386-stub.c. Normally, no one would notice because it only matters + for writing large chunks of memory (e.g. in downloads). Also, this needs + to be more than 400 if required to hold the registers (see below, where + we round it up based on REGISTER_BYTES). */ +#define PBUFSIZ 400 + +/* Maximum number of bytes to read/write at once. The value here + is chosen to fill up a packet (the headers account for the 32). */ +#define MAXBUFBYTES ((PBUFSIZ-32)/2) + +/* Round up PBUFSIZ to hold all the registers, at least. */ +/* The blank line after the #if seems to be required to work around a + bug in HP's PA compiler. */ +#if REGISTER_BYTES > MAXBUFBYTES + +#undef PBUFSIZ +#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 + is slow). */ + +static int remote_write_size = PBUFSIZ; + +/* This is the size (in chars) of the first response to the `g' command. This + is used to limit the size of the memory read and write commands to prevent + stub buffers from overflowing. The size does not include headers and + trailers, it is only the payload size. */ + +static int remote_register_buf_size = 0; + +/* Should we try the 'P' request? If this is set to one when the stub + doesn't support 'P', the only consequence is some unnecessary traffic. */ +static int stub_supports_P = 1; + +/* 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)); + + +/* 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; + +static void +set_thread (th, gen) + int th; + int gen; +{ + char buf[PBUFSIZ]; + int state = gen ? general_thread : cont_thread; + if (state == th) + return; + buf[0] = 'H'; + buf[1] = gen ? 'g' : 'c'; + if (th == 42000) + { + buf[2] = '0'; + buf[3] = '\0'; + } + else if (th < 0) + sprintf (&buf[2], "-%x", -th); + else + sprintf (&buf[2], "%x", th); + putpkt (buf); + getpkt (buf, 0); + if (gen) + general_thread = th; + else + cont_thread = th; +} + +/* Return nonzero if the thread TH is still alive on the remote system. */ + +static int +remote_thread_alive (th) + int th; +{ + char buf[PBUFSIZ]; + + buf[0] = 'T'; + if (th < 0) + sprintf (&buf[1], "-%x", -th); + else + sprintf (&buf[1], "%x", th); + putpkt (buf); + getpkt (buf, 0); + return (buf[0] == 'O' && buf[1] == 'K'); +} + +/* Restart the remote side; this is an extended protocol operation. */ + +static void +extended_remote_restart () +{ + char buf[PBUFSIZ]; + + /* Send the restart command; for reasons I don't understand the + remote side really expects a number after the "R". */ + buf[0] = 'R'; + sprintf (&buf[1], "%x", 0); + putpkt (buf); + + /* Now query for status so this looks just like we restarted + gdbserver from scratch. */ + putpkt ("?"); + getpkt (buf, 0); +} + +/* Clean up connection to a remote debugger. */ + +/* ARGSUSED */ +static void +remote_close (quitting) + int quitting; +{ + if (remote_desc) + SERIAL_CLOSE (remote_desc); + remote_desc = NULL; +} + +/* Query the remote side for the text, data and bss offsets. */ + +static void +get_offsets () +{ + char buf[PBUFSIZ], *ptr; + int lose; + CORE_ADDR text_addr, data_addr, bss_addr; + struct section_offsets *offs; + + putpkt ("qOffsets"); + + getpkt (buf, 0); + + if (buf[0] == '\000') + return; /* Return silently. Stub doesn't support this + command. */ + if (buf[0] == 'E') + { + warning ("Remote failure reply: %s", buf); + return; + } + + /* Pick up each field in turn. This used to be done with scanf, but + scanf will make trouble if CORE_ADDR size doesn't match + conversion directives correctly. The following code will work + with any size of CORE_ADDR. */ + text_addr = data_addr = bss_addr = 0; + ptr = buf; + lose = 0; + + if (strncmp (ptr, "Text=", 5) == 0) + { + ptr += 5; + /* Don't use strtol, could lose on big values. */ + while (*ptr && *ptr != ';') + text_addr = (text_addr << 4) + fromhex (*ptr++); + } + else + lose = 1; + + if (!lose && strncmp (ptr, ";Data=", 6) == 0) + { + ptr += 6; + while (*ptr && *ptr != ';') + data_addr = (data_addr << 4) + fromhex (*ptr++); + } + else + lose = 1; + + if (!lose && strncmp (ptr, ";Bss=", 5) == 0) + { + ptr += 5; + while (*ptr && *ptr != ';') + bss_addr = (bss_addr << 4) + fromhex (*ptr++); + } + else + lose = 1; + + if (lose) + error ("Malformed response to offset query, %s", buf); + + if (symfile_objfile == NULL) + return; + + offs = (struct section_offsets *) alloca (sizeof (struct section_offsets) + + symfile_objfile->num_sections + * sizeof (offs->offsets)); + memcpy (offs, symfile_objfile->section_offsets, + sizeof (struct section_offsets) + + symfile_objfile->num_sections + * sizeof (offs->offsets)); + + ANOFFSET (offs, SECT_OFF_TEXT) = 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; + + objfile_relocate (symfile_objfile, offs); +} + +/* Stub for catch_errors. */ + +static int +remote_start_remote (dummy) + char *dummy; +{ + immediate_quit = 1; /* Allow user to interrupt it */ + + /* Ack any packet which the remote side has already sent. */ + SERIAL_WRITE (remote_desc, "+", 1); + + /* Let the stub know that we want it to return the thread. */ + set_thread (-1, 0); + + get_offsets (); /* Get text, data & bss offsets */ + + putpkt ("?"); /* initiate a query from remote machine */ + immediate_quit = 0; + + start_remote (); /* Initialize gdb process mechanisms */ + return 1; +} + +/* Open a connection to a remote debugger. + NAME is the filename used for communication. */ + +static void +remote_open (name, from_tty) + char *name; + int from_tty; +{ + remote_open_1 (name, from_tty, &remote_ops, 0); +} + +/* Open a connection to a remote debugger using the extended + remote gdb protocol. NAME is the filename used for communication. */ + +static void +extended_remote_open (name, from_tty) + char *name; + int from_tty; +{ + remote_open_1 (name, from_tty, &extended_remote_ops, 1/*extended_p*/); +} + +/* Generic code for opening a connection to a remote target. */ +static DCACHE *remote_dcache; + +static void +remote_open_1 (name, from_tty, target, extended_p) + 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 serial\n\ +device is attached to the remote system (e.g. /dev/ttya)."); + + target_preopen (from_tty); + + 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); + + if (baud_rate != -1) + { + if (SERIAL_SETBAUDRATE (remote_desc, baud_rate)) + { + SERIAL_CLOSE (remote_desc); + perror_with_name (name); + } + } + + + SERIAL_RAW (remote_desc); + + /* If there is something sitting in the buffer we might take it as a + response to a command, which would be bad. */ + SERIAL_FLUSH_INPUT (remote_desc); + + if (from_tty) + { + puts_filtered ("Remote debugging using "); + puts_filtered (name); + puts_filtered ("\n"); + } + push_target (target); /* Switch to using remote target now */ + + /* 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. */ + stub_supports_P = 1; + + general_thread = -2; + cont_thread = -2; + + /* 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 flag indicating that a + target is active. These functions should be split out into seperate + variables, especially since GDB will someday have a notion of debugging + several processes. */ + + inferior_pid = 42000; + /* Start the remote connection; if error (0), discard this target. + In particular, if the user quits, be sure to discard it + (we'd be in an inconsistent state otherwise). */ + if (!catch_errors (remote_start_remote, (char *)0, + "Couldn't establish connection to remote target\n", RETURN_MASK_ALL)) + { + pop_target(); + return; + } + + if (extended_p) + { + /* tell the remote that we're using the extended protocol. */ + char buf[PBUFSIZ]; + putpkt ("!"); + getpkt (buf, 0); + } +} + +/* This takes a program previously attached to and detaches it. After + this is done, GDB can be used to debug some other program. We + better not have left any breakpoints in the target program or it'll + die when it hits one. */ + +static void +remote_detach (args, from_tty) + char *args; + int from_tty; +{ + char buf[PBUFSIZ]; + + if (args) + error ("Argument given to \"detach\" when remotely debugging."); + + /* Tell the remote target to detach. */ + strcpy (buf, "D"); + remote_send (buf); + + pop_target (); + if (from_tty) + puts_filtered ("Ending remote debugging.\n"); +} + +/* Convert hex digit A to a number. */ + +int +fromhex (a) + int a; +{ + if (a >= '0' && a <= '9') + return a - '0'; + else if (a >= 'a' && a <= 'f') + return a - 'a' + 10; + else if (a >= 'A' && a <= 'F') + return a - 'A' + 10; + else + error ("Reply contains invalid hex digit %d", a); +} + +/* Convert number NIB to a hex digit. */ + +static int +tohex (nib) + int nib; +{ + if (nib < 10) + return '0'+nib; + else + return 'a'+nib-10; +} + +/* Tell the remote machine to resume. */ + +static enum target_signal last_sent_signal = TARGET_SIGNAL_0; +int last_sent_step; + +static void +remote_resume (pid, step, siggnal) + int pid, step; + enum target_signal siggnal; +{ + char buf[PBUFSIZ]; + + if (pid == -1) + set_thread (inferior_pid, 0); + else + set_thread (pid, 0); + + dcache_flush (remote_dcache); + + last_sent_signal = siggnal; + last_sent_step = step; + + /* A hook for when we need to do something at the last moment before + resumption. */ + if (target_resume_hook) + (*target_resume_hook) (); + + if (siggnal != TARGET_SIGNAL_0) + { + buf[0] = step ? 'S' : 'C'; + buf[1] = tohex (((int)siggnal >> 4) & 0xf); + buf[2] = tohex ((int)siggnal & 0xf); + buf[3] = '\0'; + } + else + strcpy (buf, step ? "s": "c"); + + putpkt (buf); +} + +/* Send ^C to target to halt it. Target will respond, and send us a + packet. */ + +static void +remote_interrupt (signo) + int signo; +{ + /* If this doesn't work, try more severe steps. */ + signal (signo, remote_interrupt_twice); + + if (remote_debug) + printf_unfiltered ("remote_interrupt called\n"); + + /* Send a break or a ^C, depending on user preference. */ + if (remote_break) + SERIAL_SEND_BREAK (remote_desc); + else + SERIAL_WRITE (remote_desc, "\003", 1); +} + +static void (*ofunc)(); + +/* The user typed ^C twice. */ +static void +remote_interrupt_twice (signo) + int signo; +{ + signal (signo, ofunc); + + interrupt_query (); + + signal (signo, remote_interrupt); +} + +/* Ask the user what to do when an interrupt is received. */ + +static void +interrupt_query () +{ + target_terminal_ours (); + + if (query ("Interrupted while waiting for the program.\n\ +Give up (and stop debugging it)? ")) + { + target_mourn_inferior (); + return_to_top_level (RETURN_QUIT); + } + + target_terminal_inferior (); +} + +/* If nonzero, ignore the next kill. */ +int kill_kludge; + +void +remote_console_output (msg) + char *msg; +{ + char *p; + + for (p = msg; *p; p +=2) + { + char tb[2]; + char c = fromhex (p[0]) * 16 + fromhex (p[1]); + tb[0] = c; + tb[1] = 0; + if (target_output_hook) + target_output_hook (tb); + else + fputs_filtered (tb, gdb_stdout); + } +} + +/* Wait until the remote machine stops, then return, + storing status in STATUS just as `wait' would. + Returns "pid" (though it's not clear what, if anything, that + means in the case of this target). */ + +static int +remote_wait (pid, status) + int pid; + struct target_waitstatus *status; +{ + unsigned char buf[PBUFSIZ]; + int thread_num = -1; + + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; + + while (1) + { + unsigned char *p; + + ofunc = (void (*)()) signal (SIGINT, remote_interrupt); + getpkt ((char *) buf, 1); + signal (SIGINT, ofunc); + + /* This is a hook for when we need to do something (perhaps the + collection of trace data) every time the target stops. */ + if (target_wait_loop_hook) + (*target_wait_loop_hook) (); + + switch (buf[0]) + { + case 'E': /* Error of some sort */ + warning ("Remote failure reply: %s", buf); + continue; + case 'T': /* Status with PC, SP, FP, ... */ + { + int i; + long regno; + char regs[MAX_REGISTER_RAW_SIZE]; + + /* Expedited reply, containing Signal, {regno, reg} repeat */ + /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where + ss = signal number + n... = register number + r... = register contents + */ + p = &buf[3]; /* after Txx */ + + while (*p) + { + unsigned char *p1; + char *p_temp; + + regno = strtol ((const char *) p, &p_temp, 16); /* Read the register number */ + p1 = (unsigned char *)p_temp; + + if (p1 == p) + { + p1 = (unsigned char *) strchr ((const char *) p, ':'); + if (p1 == NULL) + warning ("Malformed packet (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 = (unsigned char *)p_temp; + } + } + else + { + p = p1; + + if (*p++ != ':') + warning ("Malformed packet (missing colon): %s\n\ +Packet: '%s'\n", + p, buf); + + if (regno >= NUM_REGS) + warning ("Remote sent bad register number %ld: %s\n\ +Packet: '%s'\n", + regno, p, buf); + + for (i = 0; i < REGISTER_RAW_SIZE (regno); i++) + { + if (p[0] == 0 || p[1] == 0) + warning ("Remote reply is too short: %s", buf); + regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); + p += 2; + } + supply_register (regno, regs); + } + + if (*p++ != ';') + warning ("Remote register badly formatted: %s", buf); + } + } + /* fall through */ + case 'S': /* Old style status, just signal only */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = (enum target_signal) + (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))); + + goto got_status; + case 'W': /* Target exited */ + { + /* The remote process exited. */ + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]); + goto got_status; + } + case 'X': + status->kind = TARGET_WAITKIND_SIGNALLED; + status->value.sig = (enum target_signal) + (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))); + kill_kludge = 1; + + goto got_status; + case 'O': /* Console output */ + remote_console_output (buf + 1); + continue; + case '\0': + if (last_sent_signal != TARGET_SIGNAL_0) + { + /* Zero length reply means that we tried 'S' or 'C' and + the remote system doesn't support it. */ + target_terminal_ours_for_output (); + printf_filtered + ("Can't send signals to this remote system. %s not sent.\n", + target_signal_to_name (last_sent_signal)); + last_sent_signal = TARGET_SIGNAL_0; + target_terminal_inferior (); + + strcpy ((char *) buf, last_sent_step ? "s" : "c"); + putpkt ((char *) buf); + continue; + } + /* else fallthrough */ + default: + warning ("Invalid remote reply: %s", buf); + continue; + } + } + got_status: + if (thread_num != -1) + { + /* Initial thread value can only be acquired via wait, so deal with + this marker which is used before the first thread value is + acquired. */ + if (inferior_pid == 42000) + { + inferior_pid = thread_num; + add_thread (inferior_pid); + } + return thread_num; + } + return inferior_pid; +} + +/* Number of bytes of registers this stub implements. */ +static int register_bytes_found; + +/* Read the remote registers into the block REGS. */ +/* Currently we just read all the registers, so we don't use regno. */ +/* ARGSUSED */ +static void +remote_fetch_registers (regno) + int regno; +{ + char buf[PBUFSIZ]; + int i; + char *p; + char regs[REGISTER_BYTES]; + + set_thread (inferior_pid, 1); + + sprintf (buf, "g"); + remote_send (buf); + + if (remote_register_buf_size == 0) + remote_register_buf_size = strlen (buf); + + /* Unimplemented registers read as all bits zero. */ + memset (regs, 0, REGISTER_BYTES); + + /* We can get out of synch in various cases. If the first character + in the buffer is not a hex character, assume that has happened + and try to fetch another packet to read. */ + while ((buf[0] < '0' || buf[0] > '9') + && (buf[0] < 'a' || buf[0] > 'f')) + { + if (remote_debug) + printf_unfiltered ("Bad register packet; fetching a new packet\n"); + getpkt (buf, 0); + } + + /* Reply describes registers byte by byte, each byte encoded as two + hex characters. Suck them all up, then supply them to the + register cacheing/storage mechanism. */ + + p = buf; + for (i = 0; i < REGISTER_BYTES; i++) + { + if (p[0] == 0) + break; + if (p[1] == 0) + { + warning ("Remote reply is of odd length: %s", buf); + /* Don't change register_bytes_found in this case, and don't + print a second warning. */ + goto supply_them; + } + regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); + p += 2; + } + + if (i != register_bytes_found) + { + register_bytes_found = i; +#ifdef REGISTER_BYTES_OK + if (!REGISTER_BYTES_OK (i)) + warning ("Remote reply is too short: %s", buf); +#endif + } + + supply_them: + for (i = 0; i < NUM_REGS; i++) + supply_register (i, ®s[REGISTER_BYTE(i)]); +} + +/* Prepare to store registers. Since we may send them all (using a + 'G' request), we have to read out the ones we don't want to change + first. */ + +static void +remote_prepare_to_store () +{ + /* Make sure the entire registers array is valid. */ + read_register_bytes (0, (char *)NULL, REGISTER_BYTES); +} + +/* Store register REGNO, or all registers if REGNO == -1, from the contents + of REGISTERS. FIXME: ignores errors. */ + +static void +remote_store_registers (regno) + int regno; +{ + char buf[PBUFSIZ]; + int i; + char *p; + + set_thread (inferior_pid, 1); + + if (regno >= 0 && stub_supports_P) + { + /* Try storing a single register. */ + char *regp; + + sprintf (buf, "P%x=", regno); + p = buf + strlen (buf); + regp = ®isters[REGISTER_BYTE (regno)]; + for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i) + { + *p++ = tohex ((regp[i] >> 4) & 0xf); + *p++ = tohex (regp[i] & 0xf); + } + *p = '\0'; + remote_send (buf); + if (buf[0] != '\0') + { + /* The stub understands the 'P' request. We are done. */ + return; + } + + /* The stub does not support the 'P' request. Use 'G' instead, + and don't try using 'P' in the future (it will just waste our + time). */ + stub_supports_P = 0; + } + + buf[0] = 'G'; + + /* Command describes registers byte by byte, + each byte encoded as two hex characters. */ + + 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 = '\0'; + + remote_send (buf); +} + +/* + 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?) */ + + + +/* Return the number of hex digits in num. */ + +static int +hexnumlen (num) + ULONGEST num; +{ + int i; + + for (i = 0; num != 0; i++) + num >>= 4; + + return max (i, 1); +} + +/* Write memory data directly to the remote machine. + This does not inform the data cache; the data cache uses this. + MEMADDR is the address in the remote memory space. + MYADDR is the address of the buffer in our space. + LEN is the number of bytes. + + Returns number of bytes transferred, or 0 for error. */ + +static int +remote_write_bytes (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int max_buf_size; /* Max size of packet output buffer */ + int origlen; + + /* Chop the transfer down if necessary */ + + max_buf_size = min (remote_write_size, PBUFSIZ); + if (remote_register_buf_size != 0) + max_buf_size = min (max_buf_size, remote_register_buf_size); + + /* Subtract header overhead from max payload size - $M,:#nn */ + max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4; + + origlen = len; + while (len > 0) + { + char buf[PBUFSIZ]; + char *p; + int todo; + int i; + + todo = min (len, max_buf_size / 2); /* num bytes that will fit */ + + /* FIXME-32x64: Need a version of print_address_numeric which puts the + result in a buffer like sprintf. */ + sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); + + /* We send target system values byte by byte, in increasing byte addresses, + each byte encoded as two hex characters. */ + + p = buf + strlen (buf); + for (i = 0; i < todo; i++) + { + *p++ = tohex ((myaddr[i] >> 4) & 0xf); + *p++ = tohex (myaddr[i] & 0xf); + } + *p = '\0'; + + putpkt (buf); + getpkt (buf, 0); + + if (buf[0] == 'E') + { + /* There is no correspondance between what the remote protocol uses + for errors and errno codes. We would like a cleaner way of + representing errors (big enough to include errno codes, bfd_error + codes, and others). But for now just return EIO. */ + errno = EIO; + return 0; + } + myaddr += todo; + memaddr += todo; + len -= todo; + } + return origlen; +} + +/* Read memory data directly from the remote machine. + This does not use the data cache; the data cache uses this. + MEMADDR is the address in the remote memory space. + MYADDR is the address of the buffer in our space. + LEN is the number of bytes. + + Returns number of bytes transferred, or 0 for error. */ + +static int +remote_read_bytes (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int max_buf_size; /* Max size of packet output buffer */ + int origlen; + + /* Chop the transfer down if necessary */ + + max_buf_size = min (remote_write_size, PBUFSIZ); + if (remote_register_buf_size != 0) + max_buf_size = min (max_buf_size, remote_register_buf_size); + + origlen = len; + while (len > 0) + { + char buf[PBUFSIZ]; + char *p; + int todo; + int i; + + todo = min (len, max_buf_size / 2); /* num bytes that will fit */ + + /* FIXME-32x64: Need a version of print_address_numeric which puts the + result in a buffer like sprintf. */ + sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); + putpkt (buf); + getpkt (buf, 0); + + if (buf[0] == 'E') + { + /* There is no correspondance between what the remote protocol uses + for errors and errno codes. We would like a cleaner way of + representing errors (big enough to include errno codes, bfd_error + codes, and others). But for now just return EIO. */ + errno = EIO; + return 0; + } + + /* Reply describes memory byte by byte, + each byte encoded as two hex characters. */ + + p = buf; + for (i = 0; i < todo; i++) + { + if (p[0] == 0 || p[1] == 0) + /* Reply is short. This means that we were able to read only part + of what we wanted to. */ + return i + (origlen - len); + myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]); + p += 2; + } + myaddr += todo; + memaddr += todo; + len -= todo; + } + return origlen; +} + +/* Read or write LEN bytes from inferior memory at MEMADDR, transferring + to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is + nonzero. Returns length of data written or read; 0 for error. */ + +/* ARGSUSED */ +static int +remote_xfer_memory(memaddr, myaddr, len, should_write, target) + CORE_ADDR memaddr; + char *myaddr; + int len; + int should_write; + struct target_ops *target; /* ignored */ +{ +#ifdef REMOTE_TRANSLATE_XFER_ADDRESS + CORE_ADDR targaddr; + int targlen; + REMOTE_TRANSLATE_XFER_ADDRESS (memaddr, len, targaddr, targlen); + if (targlen == 0) + return 0; + memaddr = targaddr; + len = targlen; +#endif + + return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, should_write); +} + + +#if 0 +/* 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; +{ + if (increment == -4 && len == 4) + { + long mask_long, data_long; + long data_found_long; + CORE_ADDR addr_we_found; + char buf[PBUFSIZ]; + long returned_long[2]; + char *p; + + mask_long = extract_unsigned_integer (mask, len); + data_long = extract_unsigned_integer (data, len); + sprintf (buf, "t%x:%x,%x", startaddr, data_long, mask_long); + putpkt (buf); + getpkt (buf, 0); + if (buf[0] == '\0') + { + /* The stub doesn't support the 't' request. We might want to + remember this fact, but on the other hand the stub could be + switched on us. Maybe we should remember it only until + the next "target remote". */ + generic_search (len, data, mask, startaddr, increment, lorange, + hirange, addr_found, data_found); + return; + } + + if (buf[0] == 'E') + /* There is no correspondance between what the remote protocol uses + for errors and errno codes. We would like a cleaner way of + representing errors (big enough to include errno codes, bfd_error + codes, and others). But for now just use EIO. */ + memory_error (EIO, startaddr); + p = buf; + addr_we_found = 0; + while (*p != '\0' && *p != ',') + addr_we_found = (addr_we_found << 4) + fromhex (*p++); + if (*p == '\0') + error ("Protocol error: short return for search"); + + data_found_long = 0; + while (*p != '\0' && *p != ',') + data_found_long = (data_found_long << 4) + fromhex (*p++); + /* Ignore anything after this comma, for future extensions. */ + + if (addr_we_found < lorange || addr_we_found >= hirange) + { + *addr_found = 0; + return; + } + + *addr_found = addr_we_found; + *data_found = store_unsigned_integer (data_we_found, len); + return; + } + generic_search (len, data, mask, startaddr, increment, lorange, + hirange, addr_found, data_found); +} +#endif /* 0 */ + +static void +remote_files_info (ignore) + struct target_ops *ignore; +{ + puts_filtered ("Debugging a target over a serial line.\n"); +} + +/* Stuff for dealing with the packets which are part of this protocol. + See comment at top of file for details. */ + +/* Read a single character from the remote end, masking it down to 7 bits. */ + +static int +readchar (timeout) + int timeout; +{ + int ch; + + ch = SERIAL_READCHAR (remote_desc, timeout); + + switch (ch) + { + case SERIAL_EOF: + error ("Remote connection closed"); + case SERIAL_ERROR: + perror_with_name ("Remote communication error"); + case SERIAL_TIMEOUT: + return ch; + default: + return ch & 0x7f; + } +} + +/* Send the command in BUF to the remote machine, + and read the reply into BUF. + Report an error if we get an error reply. */ + +static void +remote_send (buf) + char *buf; +{ + putpkt (buf); + getpkt (buf, 0); + + if (buf[0] == 'E') + error ("Remote failure reply: %s", buf); +} + +/* Send a packet to the remote machine, with error checking. + The data of the packet is in BUF. */ + +int +putpkt (buf) + char *buf; +{ + int i; + unsigned char csum = 0; + char buf2[PBUFSIZ]; + int cnt = strlen (buf); + int ch; + int tcount = 0; + char *p; + + /* Copy the packet into buffer BUF2, encapsulating it + and giving it a checksum. */ + + if (cnt > (int) sizeof (buf2) - 5) /* Prosanity check */ + abort(); + + p = buf2; + *p++ = '$'; + + for (i = 0; i < cnt; i++) + { + csum += buf[i]; + *p++ = buf[i]; + } + *p++ = '#'; + *p++ = tohex ((csum >> 4) & 0xf); + *p++ = tohex (csum & 0xf); + + /* Send it over and over until we get a positive ack. */ + + while (1) + { + int started_error_output = 0; + + if (remote_debug) + { + *p = '\0'; + printf_unfiltered ("Sending packet: %s...", buf2); + gdb_flush(gdb_stdout); + } + if (SERIAL_WRITE (remote_desc, buf2, p - buf2)) + perror_with_name ("putpkt: write failed"); + + /* read until either a timeout occurs (-2) or '+' is read */ + while (1) + { + ch = readchar (remote_timeout); + + if (remote_debug) + { + switch (ch) + { + case '+': + case SERIAL_TIMEOUT: + case '$': + if (started_error_output) + { + putchar_unfiltered ('\n'); + started_error_output = 0; + } + } + } + + switch (ch) + { + case '+': + if (remote_debug) + printf_unfiltered("Ack\n"); + return 1; + case SERIAL_TIMEOUT: + tcount ++; + if (tcount > 3) + return 0; + break; /* Retransmit buffer */ + case '$': + { + char junkbuf[PBUFSIZ]; + + /* It's probably an old response, and we're out of sync. Just + gobble up the packet and ignore it. */ + getpkt (junkbuf, 0); + continue; /* Now, go look for + */ + } + default: + if (remote_debug) + { + if (!started_error_output) + { + started_error_output = 1; + printf_unfiltered ("putpkt: Junk: "); + } + putchar_unfiltered (ch & 0177); + } + continue; + } + break; /* Here to retransmit */ + } + +#if 0 + /* This is wrong. If doing a long backtrace, the user should be + able to get out next time we call QUIT, without anything as violent + as interrupt_query. If we want to provide a way out of here + without getting to the next QUIT, it should be based on hitting + ^C twice as in remote_wait. */ + if (quit_flag) + { + quit_flag = 0; + interrupt_query (); + } +#endif + } +} + +/* Come here after finding the start of the frame. Collect the rest into BUF, + verifying the checksum, length, and handling run-length compression. + Returns 0 on any error, 1 on success. */ + +static int +read_frame (buf) + char *buf; +{ + unsigned char csum; + char *bp; + int c; + + csum = 0; + bp = buf; + + while (1) + { + c = readchar (remote_timeout); + + switch (c) + { + case SERIAL_TIMEOUT: + if (remote_debug) + puts_filtered ("Timeout in mid-packet, retrying\n"); + return 0; + case '$': + if (remote_debug) + puts_filtered ("Saw new packet start in middle of old one\n"); + return 0; /* Start a new packet, count retries */ + case '#': + { + unsigned char pktcsum; + + *bp = '\000'; + + pktcsum = fromhex (readchar (remote_timeout)) << 4; + pktcsum |= fromhex (readchar (remote_timeout)); + + if (csum == pktcsum) + return 1; + + if (remote_debug) + { + printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=", + pktcsum, csum); + puts_filtered (buf); + puts_filtered ("\n"); + } + return 0; + } + case '*': /* Run length encoding */ + csum += c; + c = readchar (remote_timeout); + csum += c; + c = c - ' ' + 3; /* Compute repeat count */ + + + if (c > 0 && c < 255 && bp + c - 1 < buf + PBUFSIZ - 1) + { + memset (bp, *(bp - 1), c); + bp += c; + continue; + } + + *bp = '\0'; + printf_filtered ("Repeat count %d too large for buffer: ", c); + puts_filtered (buf); + puts_filtered ("\n"); + return 0; + + default: + if (bp < buf + PBUFSIZ - 1) + { + *bp++ = c; + csum += c; + continue; + } + + *bp = '\0'; + puts_filtered ("Remote packet too long: "); + puts_filtered (buf); + puts_filtered ("\n"); + + return 0; + } + } +} + +/* 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 + while the target is executing user code. */ + +void +getpkt (buf, forever) + char *buf; + int forever; +{ + int c; + int tries; + int timeout; + int val; + + strcpy (buf,"timeout"); + + if (forever) + { +#ifdef MAINTENANCE_CMDS + timeout = watchdog > 0 ? watchdog : -1; +#else + timeout = -1; +#endif + } + + else + timeout = remote_timeout; + +#define MAX_TRIES 3 + + for (tries = 1; tries <= MAX_TRIES; tries++) + { + /* This can loop forever if the remote side sends us characters + continuously, but if it pauses, we'll get a zero from readchar + because of timeout. Then we'll count that as a retry. */ + + /* Note that we will only wait forever prior to the start of a packet. + After that, we expect characters to arrive at a brisk pace. They + should show up within remote_timeout intervals. */ + + do + { + c = readchar (timeout); + + if (c == SERIAL_TIMEOUT) + { +#ifdef MAINTENANCE_CMDS + if (forever) /* Watchdog went off. Kill the target. */ + { + target_mourn_inferior (); + error ("Watchdog has expired. Target detached.\n"); + } +#endif + if (remote_debug) + puts_filtered ("Timed out.\n"); + goto retry; + } + } + while (c != '$'); + + /* We've found the start of a packet, now collect the data. */ + + val = read_frame (buf); + + if (val == 1) + { + if (remote_debug) + fprintf_unfiltered (gdb_stdout, "Packet received: %s\n", buf); + SERIAL_WRITE (remote_desc, "+", 1); + return; + } + + /* Try the whole thing again. */ + retry: + SERIAL_WRITE (remote_desc, "-", 1); + } + + /* We have tried hard enough, and just can't receive the packet. Give up. */ + + printf_unfiltered ("Ignoring packet error, continuing...\n"); + SERIAL_WRITE (remote_desc, "+", 1); +} + +static void +remote_kill () +{ + /* For some mysterious reason, wait_for_inferior calls kill instead of + mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */ + if (kill_kludge) + { + kill_kludge = 0; + target_mourn_inferior (); + return; + } + + /* Use catch_errors so the user can quit from gdb even when we aren't on + speaking terms with the remote system. */ + catch_errors (putpkt, "k", "", RETURN_MASK_ERROR); + + /* Don't wait for it to die. I'm not really sure it matters whether + we do or not. For the existing stubs, kill is a noop. */ + target_mourn_inferior (); +} + +static void +remote_mourn () +{ + remote_mourn_1 (&remote_ops); +} + +static void +extended_remote_mourn () +{ + /* We do _not_ want to mourn the target like this; this will + remove the extended remote target from the target stack, + and the next time the user says "run" it'll fail. + + FIXME: What is the right thing to do here? */ +#if 0 + remote_mourn_1 (&extended_remote_ops); +#endif +} + +/* Worker function for remote_mourn. */ +static void +remote_mourn_1 (target) + struct target_ops *target; +{ + unpush_target (target); + generic_mourn_inferior (); +} + +/* In the extended protocol we want to be able to do things like + "run" and have them basically work as expected. So we need + a special create_inferior function. + + FIXME: One day add support for changing the exec file + we're debugging, arguments and an environment. */ + +static void +extended_remote_create_inferior (exec_file, args, env) + char *exec_file; + char *args; + char **env; +{ + /* Rip out the breakpoints; we'll reinsert them after restarting + the remote server. */ + remove_breakpoints (); + + /* Now restart the remote server. */ + extended_remote_restart (); + + /* Now put the breakpoints back in. This way we're safe if the + restart function works via a unix fork on the remote side. */ + insert_breakpoints (); + + /* Clean up from the last time we were running. */ + clear_proceed_status (); + + /* Let the remote process run. */ + proceed (-1, TARGET_SIGNAL_0, 0); +} + + +/* On some machines, e.g. 68k, we may use a different breakpoint instruction + than other targets; in those use REMOTE_BREAKPOINT instead of just + BREAKPOINT. Also, bi-endian targets may define LITTLE_REMOTE_BREAKPOINT + and BIG_REMOTE_BREAKPOINT. If none of these are defined, we just call + the standard routines that are in mem-break.c. */ + +/* FIXME, these ought to be done in a more dynamic fashion. For instance, + the choice of breakpoint instruction affects target program design and + vice versa, and by making it user-tweakable, the special code here + goes away and we need fewer special GDB configurations. */ + +#if defined (LITTLE_REMOTE_BREAKPOINT) && defined (BIG_REMOTE_BREAKPOINT) && !defined(REMOTE_BREAKPOINT) +#define REMOTE_BREAKPOINT +#endif + +#ifdef REMOTE_BREAKPOINT + +/* If the target isn't bi-endian, just pretend it is. */ +#if !defined (LITTLE_REMOTE_BREAKPOINT) && !defined (BIG_REMOTE_BREAKPOINT) +#define LITTLE_REMOTE_BREAKPOINT REMOTE_BREAKPOINT +#define BIG_REMOTE_BREAKPOINT REMOTE_BREAKPOINT +#endif + +static unsigned char big_break_insn[] = BIG_REMOTE_BREAKPOINT; +static unsigned char little_break_insn[] = LITTLE_REMOTE_BREAKPOINT; + +#endif /* REMOTE_BREAKPOINT */ + +/* Insert a breakpoint on targets that don't have any better breakpoint + support. We read the contents of the target location and stash it, + then overwrite it with a breakpoint instruction. ADDR is the target + location in the target machine. CONTENTS_CACHE is a pointer to + memory allocated for saving the target contents. It is guaranteed + by the caller to be long enough to save sizeof BREAKPOINT bytes (this + is accomplished via BREAKPOINT_MAX). */ + +static int +remote_insert_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ +#ifdef REMOTE_BREAKPOINT + int val; + + val = target_read_memory (addr, contents_cache, sizeof big_break_insn); + + if (val == 0) + { + if (TARGET_BYTE_ORDER == BIG_ENDIAN) + val = target_write_memory (addr, (char *) big_break_insn, + sizeof big_break_insn); + else + val = target_write_memory (addr, (char *) little_break_insn, + sizeof little_break_insn); + } + + return val; +#else + return memory_insert_breakpoint (addr, contents_cache); +#endif /* REMOTE_BREAKPOINT */ +} + +static int +remote_remove_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ +#ifdef REMOTE_BREAKPOINT + return target_write_memory (addr, contents_cache, sizeof big_break_insn); +#else + return memory_remove_breakpoint (addr, contents_cache); +#endif /* REMOTE_BREAKPOINT */ +} + +/* Some targets are only capable of doing downloads, and afterwards they switch + to the remote serial protocol. This function provides a clean way to get + from the download target to the remote target. It's basically just a + wrapper so that we don't have to expose any of the internal workings of + remote.c. + + Prior to calling this routine, you should shutdown the current target code, + else you will get the "A program is being debugged already..." message. + Usually a call to pop_target() suffices. +*/ + +void +push_remote_target (name, from_tty) + char *name; + int from_tty; +{ + printf_filtered ("Switching to remote protocol\n"); + remote_open (name, from_tty); +} + +/* Other targets want to use the entire remote serial module but with + 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; +{ + printf_filtered ("Selecting the %sremote protocol\n", + (extended_p ? "extended-" : "")); + remote_open_1 (name, from_tty, target, extended_p); +} + +/* Table used by the crc32 function to calcuate the checksum. */ +static unsigned long crc32_table[256] = {0, 0}; + +static unsigned long +crc32 (buf, len, crc) + unsigned char *buf; + int len; + unsigned int crc; +{ + if (! crc32_table[1]) + { + /* Initialize the CRC table and the decoding table. */ + int i, j; + unsigned int c; + + for (i = 0; i < 256; i++) + { + for (c = i << 24, j = 8; j > 0; --j) + c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); + crc32_table[i] = c; + } + } + + while (len--) + { + crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255]; + buf++; + } + return crc; +} + +/* compare-sections command + + With no arguments, compares each loadable section in the exec bfd + with the same memory range on the target, and reports mismatches. + Useful for verifying the image on the target against the exec file. + Depends on the target understanding the new "qCRC:" request. */ + +static void +remote_compare_command (args, from_tty) + char *args; + int from_tty; +{ + asection *s; + unsigned long host_crc, target_crc; + extern bfd *exec_bfd; + struct cleanup *old_chain; + char *tmp, *sectdata, *sectname, buf[PBUFSIZ]; + bfd_size_type size; + bfd_vma lma; + int matched = 0; + + if (!exec_bfd) + error ("command cannot be used without an exec file"); + if (!current_target.to_shortname || + strcmp (current_target.to_shortname, "remote") != 0) + error ("command can only be used with remote target"); + + for (s = exec_bfd->sections; s; s = s->next) + { + if (!(s->flags & SEC_LOAD)) + continue; /* skip non-loadable section */ + + size = bfd_get_section_size_before_reloc (s); + if (size == 0) + continue; /* skip zero-length section */ + + sectname = (char *) bfd_get_section_name (exec_bfd, s); + if (args && strcmp (args, sectname) != 0) + continue; /* not the section selected by user */ + + matched = 1; /* do this section */ + lma = s->lma; + /* FIXME: assumes lma can fit into long */ + sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size); + putpkt (buf); + + /* be clever; compute the host_crc before waiting for target reply */ + sectdata = xmalloc (size); + old_chain = make_cleanup (free, sectdata); + bfd_get_section_contents (exec_bfd, s, sectdata, 0, size); + host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff); + + getpkt (buf, 0); + if (buf[0] == 'E') + error ("target memory fault, section %s, range 0x%08x -- 0x%08x", + sectname, lma, lma + size); + if (buf[0] != 'C') + error ("remote target does not support this operation"); + + for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++) + target_crc = target_crc * 16 + fromhex (*tmp); + + printf_filtered ("Section %s, range 0x%08x -- 0x%08x: ", + sectname, lma, lma + size); + if (host_crc == target_crc) + printf_filtered ("matched.\n"); + else + printf_filtered ("MIS-MATCHED!\n"); + + do_cleanups (old_chain); + } + if (args && !matched) + printf_filtered ("No loaded section named '%s'.\n", args); +} + + +void +_initialize_remote () +{ + init_remote_ops() ; + init_extended_remote_ops() ; + add_target (&remote_ops); + add_target (&extended_remote_ops); + +/* Remote target communications for serial-line targets in custom GDB protocol + Copyright 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* Remote communication protocol. + + A debug packet whose contents are + is encapsulated for transmission in the form: + + $ # CSUM1 CSUM2 + + must be ASCII alphanumeric and cannot include characters + '$' or '#'. If starts with two characters followed by + ':', then the existing stubs interpret this as a sequence number. + + CSUM1 and CSUM2 are ascii hex representation of an 8-bit + checksum of , the most significant nibble is sent first. + the hex digits 0-9,a-f are used. + + Receiver responds with: + + + - if CSUM is correct and ready for next packet + - - if CSUM is incorrect + + is as follows: + Most values are encoded in ascii hex digits. Signal numbers are according + to the numbering in target.h. + + Request Packet + + set thread Hct... Set thread for subsequent operations. + c = 'c' for thread used in step and + continue; t... can be -1 for all + threads. + c = 'g' for thread used in other + operations. If zero, pick a thread, + any thread. + reply OK for success + ENN for an error. + + read registers g + reply XX....X Each byte of register data + is described by two hex digits. + Registers are in the internal order + for GDB, and the bytes in a register + are in the same order the machine uses. + or ENN for an error. + + write regs GXX..XX Each byte of register data + is described by two hex digits. + reply OK for success + ENN for an error + + write reg Pn...=r... Write register n... with value r..., + which contains two hex digits for each + byte in the register (target byte + order). + reply OK for success + ENN for an error + (not supported by all stubs). + + read mem mAA..AA,LLLL AA..AA is address, LLLL is length. + reply XX..XX XX..XX is mem contents + Can be fewer bytes than requested + if able to read only part of the data. + or ENN NN is errno + + write mem MAA..AA,LLLL:XX..XX + AA..AA is address, + LLLL is number of bytes, + XX..XX is data + reply OK for success + ENN for an error (this includes the case + where only part of the data was + written). + + continue cAA..AA AA..AA is address to resume + If AA..AA is omitted, + resume at same address. + + step sAA..AA AA..AA is address to resume + If AA..AA is omitted, + resume at same address. + + continue with Csig;AA..AA Continue with signal sig (hex signal + signal number). If ;AA..AA is omitted, resume + at same address. + + step with Ssig;AA..AA Like 'C' but step not continue. + signal + + last signal ? Reply the current reason for stopping. + This is the same reply as is generated + for step or cont : SAA where AA is the + signal number. + + detach D Reply OK. + + There is no immediate reply to step or cont. + The reply comes when the machine stops. + It is SAA AA is the signal number. + + or... TAAn...:r...;n...:r...;n...:r...; + AA = signal number + n... = register number (hex) + r... = register contents + n... = `thread' + r... = thread process ID. This is + a hex integer. + n... = other string not starting + with valid hex digit. + gdb should ignore this n,r pair + and go on to the next. This way + we can extend the protocol. + or... WAA The process exited, and AA is + the exit status. This is only + applicable for certains sorts of + targets. + or... XAA The process terminated with signal + AA. + or... OXX..XX XX..XX is hex encoding of ASCII data. This + can happen at any time while the program is + running and the debugger should + continue to wait for 'W', 'T', etc. + + thread alive TXX Find out if the thread XX is alive. + reply OK thread is still alive + ENN thread is dead + + remote restart RXX Restart the remote server + + extended ops ! Use the extended remote protocol. + Sticky -- only needs to be set once. + + kill request k + + toggle debug d toggle debug flag (see 386 & 68k stubs) + reset r reset -- see sparc stub. + reserved On other requests, the stub should + ignore the request and send an empty + response ($#). This way + we can extend the protocol and GDB + can tell whether the stub it is + talking to uses the old or the new. + search tAA:PP,MM Search backwards starting at address + AA for a match with pattern PP and + mask MM. PP and MM are 4 bytes. + Not supported by all stubs. + + general query qXXXX Request info about XXXX. + general set QXXXX=yyyy Set value of XXXX to yyyy. + query sect offs qOffsets Get section offsets. Reply is + Text=xxx;Data=yyy;Bss=zzz + + Responses can be run-length encoded to save space. A '*' means that + the next character is an ASCII encoding giving a repeat count which + stands for that many repititions of the character preceding the '*'. + The encoding is n+29, yielding a printable character where n >=3 + (which is where rle starts to win). Don't use an n > 126. + + So + "0* " means the same as "0000". */ + +#include "defs.h" +#include "gdb_string.h" +#include +#include "frame.h" +#include "inferior.h" +#include "bfd.h" +#include "symfile.h" +#include "target.h" +#include "wait.h" +/*#include "terminal.h"*/ +#include "gdbcmd.h" +#include "objfiles.h" +#include "gdb-stabs.h" +#include "gdbthread.h" + +#include "dcache.h" + +#ifdef USG +#include +#endif + +#include +#include "serial.h" + +/* Prototypes for local functions */ + +static int remote_write_bytes PARAMS ((CORE_ADDR memaddr, + char *myaddr, int len)); + +static int remote_read_bytes PARAMS ((CORE_ADDR memaddr, + char *myaddr, int len)); + +static void remote_files_info PARAMS ((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 void remote_prepare_to_store PARAMS ((void)); + +static void remote_fetch_registers PARAMS ((int regno)); + +static void remote_resume PARAMS ((int pid, int step, + enum target_signal siggnal)); + +static int remote_start_remote PARAMS ((char *dummy)); + +static void remote_open PARAMS ((char *name, int from_tty)); + +static void extended_remote_open PARAMS ((char *name, int from_tty)); + +static void remote_open_1 PARAMS ((char *, int, struct target_ops *, int extended_p)); + +static void remote_close PARAMS ((int quitting)); + +static void remote_store_registers PARAMS ((int regno)); + +static void remote_mourn PARAMS ((void)); + +static void extended_remote_restart PARAMS ((void)); + +static void extended_remote_mourn PARAMS ((void)); + +static void extended_remote_create_inferior PARAMS ((char *, char *, char **)); + +static void remote_mourn_1 PARAMS ((struct target_ops *)); + +static void remote_send PARAMS ((char *buf)); + +static int readchar PARAMS ((int timeout)); + +static int remote_wait PARAMS ((int pid, struct target_waitstatus *status)); + +static void remote_kill PARAMS ((void)); + +static int tohex PARAMS ((int nib)); + +static void remote_detach PARAMS ((char *args, int from_tty)); + +static void remote_interrupt PARAMS ((int signo)); + +static void remote_interrupt_twice PARAMS ((int signo)); + +static void interrupt_query PARAMS ((void)); + +static void set_thread PARAMS ((int, int)); + +static int remote_thread_alive PARAMS ((int)); + +static void get_offsets PARAMS ((void)); + +static int read_frame PARAMS ((char *)); + +static int remote_insert_breakpoint PARAMS ((CORE_ADDR, char *)); + +static int remote_remove_breakpoint PARAMS ((CORE_ADDR, char *)); + +static int hexnumlen PARAMS ((ULONGEST num)); + +/* exported functions */ + +extern int fromhex PARAMS ((int a)); +extern void getpkt PARAMS ((char *buf, int forever)); +extern int putpkt PARAMS ((char *buf)); + +/* Define the target subroutine names */ + +static struct target_ops remote_ops ; + +static void init_remote_ops(void) +{ + remote_ops.to_shortname = "remote"; + remote_ops.to_longname = "Remote serial target in gdb-specific protocol"; + remote_ops.to_doc = "Use a remote computer via a serial line; using a gdb-specific protocol.\n\ +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_attach = NULL; + remote_ops.to_detach = remote_detach; + remote_ops.to_resume = remote_resume; + 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; + remote_ops.to_xfer_memory = remote_xfer_memory; + remote_ops.to_files_info = remote_files_info; + remote_ops.to_insert_breakpoint = remote_insert_breakpoint; + remote_ops.to_remove_breakpoint = remote_remove_breakpoint; + remote_ops.to_terminal_init = NULL; + remote_ops.to_terminal_inferior = NULL; + remote_ops.to_terminal_ours_for_output = NULL; + remote_ops.to_terminal_ours = NULL; + remote_ops.to_terminal_info = NULL; + remote_ops.to_kill = remote_kill; + remote_ops.to_load = generic_load; + remote_ops.to_lookup_symbol = NULL; + remote_ops.to_create_inferior = NULL; + remote_ops.to_mourn_inferior = remote_mourn; + remote_ops.to_can_run = 0; + remote_ops.to_notice_signals = 0; + remote_ops.to_thread_alive = remote_thread_alive; + remote_ops.to_stop = 0; + remote_ops.to_stratum = process_stratum; + remote_ops.DONT_USE = NULL; + remote_ops.to_has_all_memory = 1; + remote_ops.to_has_memory = 1; + remote_ops.to_has_stack = 1; + remote_ops.to_has_registers = 1; + remote_ops.to_has_execution = 1; + remote_ops.to_sections = NULL; + remote_ops.to_sections_end = NULL; + remote_ops.to_magic = OPS_MAGIC ; +} /* init_remote_ops */ + +static struct target_ops extended_remote_ops ; + +static void init_extended_remote_ops(void) +{ + extended_remote_ops.to_shortname = "extended-remote"; + extended_remote_ops.to_longname = "Extended remote serial target in gdb-specific protocol"; + extended_remote_ops.to_doc = "Use a remote computer via a serial line; using a gdb-specific protocol.\n\ +Specify the serial device it is connected to (e.g. /dev/ttya).", + extended_remote_ops.to_open = extended_remote_open; + extended_remote_ops.to_close = remote_close; + extended_remote_ops.to_attach = NULL; + extended_remote_ops.to_detach = remote_detach; + extended_remote_ops.to_resume = remote_resume; + extended_remote_ops.to_wait = remote_wait; + extended_remote_ops.to_fetch_registers = remote_fetch_registers; + extended_remote_ops.to_store_registers = remote_store_registers; + extended_remote_ops.to_prepare_to_store = remote_prepare_to_store; + extended_remote_ops.to_xfer_memory = remote_xfer_memory; + extended_remote_ops.to_files_info = remote_files_info; + extended_remote_ops.to_insert_breakpoint = remote_insert_breakpoint; + extended_remote_ops.to_remove_breakpoint = remote_remove_breakpoint; + extended_remote_ops.to_terminal_init = NULL; + extended_remote_ops.to_terminal_inferior = NULL; + extended_remote_ops.to_terminal_ours_for_output = NULL; + extended_remote_ops.to_terminal_ours = NULL; + extended_remote_ops.to_terminal_info = NULL; + extended_remote_ops.to_kill = remote_kill; + extended_remote_ops.to_load = generic_load; + extended_remote_ops.to_lookup_symbol = NULL; + extended_remote_ops.to_create_inferior = extended_remote_create_inferior; + extended_remote_ops.to_mourn_inferior = extended_remote_mourn; + extended_remote_ops.to_can_run = 0; + extended_remote_ops.to_notice_signals = 0; + extended_remote_ops.to_thread_alive = remote_thread_alive; + extended_remote_ops.to_stop = 0; + extended_remote_ops.to_stratum = process_stratum; + extended_remote_ops.DONT_USE = NULL; + extended_remote_ops.to_has_all_memory = 1; + extended_remote_ops.to_has_memory = 1; + extended_remote_ops.to_has_stack = 1; + extended_remote_ops.to_has_registers = 1; + extended_remote_ops.to_has_execution = 1; + extended_remote_ops.to_sections = NULL; + extended_remote_ops.to_sections_end = NULL; + extended_remote_ops.to_magic = OPS_MAGIC ; +} + + +/* 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; + +/* This variable chooses whether to send a ^C or a break when the user + requests program interruption. Although ^C is usually what remote + systems expect, and that is the default here, sometimes a break is + preferable instead. */ + +static int remote_break; + +/* Descriptor for I/O to remote machine. Initialize it to NULL so that + remote_open knows that we don't have a file open when the program + starts. */ +static serial_t remote_desc = NULL; + +/* Having this larger than 400 causes us to be incompatible with m68k-stub.c + and i386-stub.c. Normally, no one would notice because it only matters + for writing large chunks of memory (e.g. in downloads). Also, this needs + to be more than 400 if required to hold the registers (see below, where + we round it up based on REGISTER_BYTES). */ +#define PBUFSIZ 400 + +/* Maximum number of bytes to read/write at once. The value here + is chosen to fill up a packet (the headers account for the 32). */ +#define MAXBUFBYTES ((PBUFSIZ-32)/2) + +/* Round up PBUFSIZ to hold all the registers, at least. */ +/* The blank line after the #if seems to be required to work around a + bug in HP's PA compiler. */ +#if REGISTER_BYTES > MAXBUFBYTES + +#undef PBUFSIZ +#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 + is slow). */ + +static int remote_write_size = PBUFSIZ; + +/* This is the size (in chars) of the first response to the `g' command. This + is used to limit the size of the memory read and write commands to prevent + stub buffers from overflowing. The size does not include headers and + trailers, it is only the payload size. */ + +static int remote_register_buf_size = 0; + +/* Should we try the 'P' request? If this is set to one when the stub + doesn't support 'P', the only consequence is some unnecessary traffic. */ +static int stub_supports_P = 1; + +/* 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)); + + +/* 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; + +static void +set_thread (th, gen) + int th; + int gen; +{ + char buf[PBUFSIZ]; + int state = gen ? general_thread : cont_thread; + if (state == th) + return; + buf[0] = 'H'; + buf[1] = gen ? 'g' : 'c'; + if (th == 42000) + { + buf[2] = '0'; + buf[3] = '\0'; + } + else if (th < 0) + sprintf (&buf[2], "-%x", -th); + else + sprintf (&buf[2], "%x", th); + putpkt (buf); + getpkt (buf, 0); + if (gen) + general_thread = th; + else + cont_thread = th; +} + +/* Return nonzero if the thread TH is still alive on the remote system. */ + +static int +remote_thread_alive (th) + int th; +{ + char buf[PBUFSIZ]; + + buf[0] = 'T'; + if (th < 0) + sprintf (&buf[1], "-%x", -th); + else + sprintf (&buf[1], "%x", th); + putpkt (buf); + getpkt (buf, 0); + return (buf[0] == 'O' && buf[1] == 'K'); +} + +/* Restart the remote side; this is an extended protocol operation. */ + +static void +extended_remote_restart () +{ + char buf[PBUFSIZ]; + + /* Send the restart command; for reasons I don't understand the + remote side really expects a number after the "R". */ + buf[0] = 'R'; + sprintf (&buf[1], "%x", 0); + putpkt (buf); + + /* Now query for status so this looks just like we restarted + gdbserver from scratch. */ + putpkt ("?"); + getpkt (buf, 0); +} + +/* Clean up connection to a remote debugger. */ + +/* ARGSUSED */ +static void +remote_close (quitting) + int quitting; +{ + if (remote_desc) + SERIAL_CLOSE (remote_desc); + remote_desc = NULL; +} + +/* Query the remote side for the text, data and bss offsets. */ + +static void +get_offsets () +{ + char buf[PBUFSIZ], *ptr; + int lose; + CORE_ADDR text_addr, data_addr, bss_addr; + struct section_offsets *offs; + + putpkt ("qOffsets"); + + getpkt (buf, 0); + + if (buf[0] == '\000') + return; /* Return silently. Stub doesn't support this + command. */ + if (buf[0] == 'E') + { + warning ("Remote failure reply: %s", buf); + return; + } + + /* Pick up each field in turn. This used to be done with scanf, but + scanf will make trouble if CORE_ADDR size doesn't match + conversion directives correctly. The following code will work + with any size of CORE_ADDR. */ + text_addr = data_addr = bss_addr = 0; + ptr = buf; + lose = 0; + + if (strncmp (ptr, "Text=", 5) == 0) + { + ptr += 5; + /* Don't use strtol, could lose on big values. */ + while (*ptr && *ptr != ';') + text_addr = (text_addr << 4) + fromhex (*ptr++); + } + else + lose = 1; + + if (!lose && strncmp (ptr, ";Data=", 6) == 0) + { + ptr += 6; + while (*ptr && *ptr != ';') + data_addr = (data_addr << 4) + fromhex (*ptr++); + } + else + lose = 1; + + if (!lose && strncmp (ptr, ";Bss=", 5) == 0) + { + ptr += 5; + while (*ptr && *ptr != ';') + bss_addr = (bss_addr << 4) + fromhex (*ptr++); + } + else + lose = 1; + + if (lose) + error ("Malformed response to offset query, %s", buf); + + if (symfile_objfile == NULL) + return; + + offs = (struct section_offsets *) alloca (sizeof (struct section_offsets) + + symfile_objfile->num_sections + * sizeof (offs->offsets)); + memcpy (offs, symfile_objfile->section_offsets, + sizeof (struct section_offsets) + + symfile_objfile->num_sections + * sizeof (offs->offsets)); + + ANOFFSET (offs, SECT_OFF_TEXT) = 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; + + objfile_relocate (symfile_objfile, offs); +} + +/* Stub for catch_errors. */ + +static int +remote_start_remote (dummy) + char *dummy; +{ + immediate_quit = 1; /* Allow user to interrupt it */ + + /* Ack any packet which the remote side has already sent. */ + SERIAL_WRITE (remote_desc, "+", 1); + + /* Let the stub know that we want it to return the thread. */ + set_thread (-1, 0); + + get_offsets (); /* Get text, data & bss offsets */ + + putpkt ("?"); /* initiate a query from remote machine */ + immediate_quit = 0; + + start_remote (); /* Initialize gdb process mechanisms */ + return 1; +} + +/* Open a connection to a remote debugger. + NAME is the filename used for communication. */ + +static void +remote_open (name, from_tty) + char *name; + int from_tty; +{ + remote_open_1 (name, from_tty, &remote_ops, 0); +} + +/* Open a connection to a remote debugger using the extended + remote gdb protocol. NAME is the filename used for communication. */ + +static void +extended_remote_open (name, from_tty) + char *name; + int from_tty; +{ + remote_open_1 (name, from_tty, &extended_remote_ops, 1/*extended_p*/); +} + +/* Generic code for opening a connection to a remote target. */ +static DCACHE *remote_dcache; + +static void +remote_open_1 (name, from_tty, target, extended_p) + 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 serial\n\ +device is attached to the remote system (e.g. /dev/ttya)."); + + target_preopen (from_tty); + + 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); + + if (baud_rate != -1) + { + if (SERIAL_SETBAUDRATE (remote_desc, baud_rate)) + { + SERIAL_CLOSE (remote_desc); + perror_with_name (name); + } + } + + + SERIAL_RAW (remote_desc); + + /* If there is something sitting in the buffer we might take it as a + response to a command, which would be bad. */ + SERIAL_FLUSH_INPUT (remote_desc); + + if (from_tty) + { + puts_filtered ("Remote debugging using "); + puts_filtered (name); + puts_filtered ("\n"); + } + push_target (target); /* Switch to using remote target now */ + + /* 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. */ + stub_supports_P = 1; + + general_thread = -2; + cont_thread = -2; + + /* 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 flag indicating that a + target is active. These functions should be split out into seperate + variables, especially since GDB will someday have a notion of debugging + several processes. */ + inferior_pid = 42000; + /* Start the remote connection; if error (0), discard this target. + In particular, if the user quits, be sure to discard it + (we'd be in an inconsistent state otherwise). */ + if (!catch_errors (remote_start_remote, (char *)0, + "Couldn't establish connection to remote target\n", RETURN_MASK_ALL)) + { + pop_target(); + return; + } if (extended_p) { @@ -2020,6 +6185,217 @@ open_remote_target (name, from_tty, target, extended_p) remote_open_1 (name, from_tty, target, extended_p); } +/* Table used by the crc32 function to calcuate the checksum. */ +static unsigned long crc32_table[256] = {0, 0}; + +static unsigned long +crc32 (buf, len, crc) + unsigned char *buf; + int len; + unsigned int crc; +{ + if (! crc32_table[1]) + { + /* Initialize the CRC table and the decoding table. */ + int i, j; + unsigned int c; + + for (i = 0; i < 256; i++) + { + for (c = i << 24, j = 8; j > 0; --j) + c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); + crc32_table[i] = c; + } + } + + while (len--) + { + crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255]; + buf++; + } + return crc; +} + +/* compare-sections command + + With no arguments, compares each loadable section in the exec bfd + with the same memory range on the target, and reports mismatches. + Useful for verifying the image on the target against the exec file. + Depends on the target understanding the new "qCRC:" request. */ + +static void +remote_compare_command (args, from_tty) + char *args; + int from_tty; +{ + asection *s; + unsigned long host_crc, target_crc; + extern bfd *exec_bfd; + struct cleanup *old_chain; + char *tmp, *sectdata, *sectname, buf[PBUFSIZ]; + bfd_size_type size; + bfd_vma lma; + int matched = 0; + + if (!exec_bfd) + error ("command cannot be used without an exec file"); + if (!current_target.to_shortname || + strcmp (current_target.to_shortname, "remote") != 0) + error ("command can only be used with remote target"); + + for (s = exec_bfd->sections; s; s = s->next) + { + if (!(s->flags & SEC_LOAD)) + continue; /* skip non-loadable section */ + + size = bfd_get_section_size_before_reloc (s); + if (size == 0) + continue; /* skip zero-length section */ + + sectname = (char *) bfd_get_section_name (exec_bfd, s); + if (args && strcmp (args, sectname) != 0) + continue; /* not the section selected by user */ + + matched = 1; /* do this section */ + lma = s->lma; + /* FIXME: assumes lma can fit into long */ + sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size); + putpkt (buf); + + /* be clever; compute the host_crc before waiting for target reply */ + sectdata = xmalloc (size); + old_chain = make_cleanup (free, sectdata); + bfd_get_section_contents (exec_bfd, s, sectdata, 0, size); + host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff); + + getpkt (buf, 0); + if (buf[0] == 'E') + error ("target memory fault, section %s, range 0x%08x -- 0x%08x", + sectname, lma, lma + size); + if (buf[0] != 'C') + error ("remote target does not support this operation"); + + for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++) + target_crc = target_crc * 16 + fromhex (*tmp); + + printf_filtered ("Section %s, range 0x%08x -- 0x%08x: ", + sectname, lma, lma + size); + if (host_crc == target_crc) + printf_filtered ("matched.\n"); + else + printf_filtered ("MIS-MATCHED!\n"); + + do_cleanups (old_chain); + } + if (args && !matched) + printf_filtered ("No loaded section named '%s'.\n", args); +} + +/* reload command + + With no arguments, compares each loadable section on the target + with the binary image in the current exec bfd. Sections that + are not identical are downloaded to the target. Depends on the + target understanding the "qCRC:" request. + + Optionally accepts the name of a section as an argument, and + downloads that section; in this case no comparison is done -- + the section is downloaded unconditionally. */ + +static void +remote_reload_command (args, from_tty) + char *args; + int from_tty; +{ + asection *s; + unsigned long host_crc, target_crc; + extern bfd *exec_bfd; + struct cleanup *old_chain; + char *tmp, *sectdata, *sectname, buf[PBUFSIZ]; + bfd_size_type size; + bfd_vma lma; + unsigned long sent, len, l; + int matched = 0; + int err; + + if (!exec_bfd) + error ("command cannot be used without an exec file"); + + for (s = exec_bfd->sections; s; s = s->next) + { + if (!(s->flags & SEC_LOAD)) + continue; /* skip non-loadable section */ + + size = bfd_get_section_size_before_reloc (s); + if (size == 0) + continue; /* skip zero-length section */ + + sectname = (char *) bfd_get_section_name (exec_bfd, s); + if (args && strcmp (args, sectname) != 0) + continue; /* not the section selected by user */ + + matched = 1; /* do this section */ + lma = s->lma; + sectdata = xmalloc (size); + old_chain = make_cleanup (free, sectdata); + bfd_get_section_contents (exec_bfd, s, sectdata, 0, size); + + if (args == 0) + { + /* + * Compare all sections, and reload those that don't match. + */ + + if (!current_target.to_shortname || + strcmp (current_target.to_shortname, "remote") != 0) + error ("command can only be used with remote target"); + + /* FIXME: assumes lma can fit into long */ + sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size); + putpkt (buf); + + /* be clever; compute the host_crc before waiting for target reply */ + host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff); + + getpkt (buf, 0); + if (buf[0] == 'E') + error ("target memory fault, section %s, range 0x%08x -- 0x%08x", + sectname, lma, lma + size); + if (buf[0] != 'C') + error ("remote target does not support this operation"); + + for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++) + target_crc = target_crc * 16 + fromhex (*tmp); + } + + printf_filtered ("Section %s, range 0x%08x -- 0x%08x: ", + sectname, lma, lma + size); + + if (args != 0 || /* section specified -- reload unconditionally */ + host_crc != target_crc) /* section changed on target */ + { + printf_filtered ("being reloaded now.\n"); + l = size / 100; + l = l > 100 ? l : 100; /* chunk size; at least 100 */ + sent = 0; + do + { + len = (size - sent) < l ? (size - sent) : l; + sent += len; + err = target_write_memory (lma, sectdata, len); + lma += len; + sectdata += len; + } + while (err == 0 && sent < size); + } + else + printf_filtered ("unchanged.\n"); + + do_cleanups (old_chain); + } + if (args && !matched) + printf_filtered ("No loaded section named '%s'.\n", args); +} void _initialize_remote () @@ -2029,6 +6405,11 @@ _initialize_remote () add_target (&remote_ops); add_target (&extended_remote_ops); + add_cmd ("compare-sections", class_obscure, remote_compare_command, + "Compare section data on remote target to the exec file.\n\ +Optional argument is a single section name (default: all loadable sections).", + &cmdlist); + add_show_from_set (add_set_cmd ("remotetimeout", no_class, var_integer, (char *)&remote_timeout, "Set timeout value for remote read.\n", &setlist),