2010-03-22 06:12:51 +00:00
|
|
|
/* MSPDebug - debugging tool for MSP430 MCUs
|
|
|
|
* Copyright (C) 2009, 2010 Daniel Beer
|
|
|
|
*
|
|
|
|
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <stdarg.h>
|
2010-05-13 00:57:21 +00:00
|
|
|
#include <stdint.h>
|
2010-03-22 06:12:51 +00:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include "device.h"
|
2010-03-31 06:33:28 +00:00
|
|
|
#include "util.h"
|
2010-08-13 03:14:15 +00:00
|
|
|
#include "opdb.h"
|
2010-03-22 06:12:51 +00:00
|
|
|
#include "gdb.h"
|
|
|
|
|
2010-07-01 21:56:16 +00:00
|
|
|
#define MAX_MEM_XFER 1024
|
|
|
|
|
2010-03-22 06:12:51 +00:00
|
|
|
/************************************************************************
|
|
|
|
* GDB IO routines
|
|
|
|
*/
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
struct gdb_data {
|
|
|
|
int sock;
|
|
|
|
int error;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
char xbuf[1024];
|
|
|
|
int head;
|
|
|
|
int tail;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-07-01 21:56:16 +00:00
|
|
|
char outbuf[MAX_MEM_XFER * 2 + 64];
|
2010-04-30 04:01:03 +00:00
|
|
|
int outlen;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void gdb_printf(struct gdb_data *data, const char *fmt, ...)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2010-04-30 04:01:03 +00:00
|
|
|
len = vsnprintf(data->outbuf + data->outlen,
|
|
|
|
sizeof(data->outbuf) - data->outlen,
|
2010-03-22 06:12:51 +00:00
|
|
|
fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
data->outlen += len;
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int gdb_read(struct gdb_data *data, int blocking)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
fd_set r;
|
|
|
|
int len;
|
|
|
|
struct timeval to = {
|
|
|
|
.tv_sec = 0,
|
|
|
|
.tv_usec = 0
|
|
|
|
};
|
|
|
|
|
|
|
|
FD_ZERO(&r);
|
2010-04-30 04:01:03 +00:00
|
|
|
FD_SET(data->sock, &r);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
if (select(data->sock + 1, &r, NULL, NULL,
|
2010-03-22 06:12:51 +00:00
|
|
|
blocking ? NULL : &to) < 0) {
|
|
|
|
perror("gdb: select");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
if (!FD_ISSET(data->sock, &r))
|
2010-03-22 06:12:51 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
len = recv(data->sock, data->xbuf, sizeof(data->xbuf), 0);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
if (len < 0) {
|
2010-04-30 04:01:03 +00:00
|
|
|
data->error = errno;
|
2010-03-22 06:12:51 +00:00
|
|
|
perror("gdb: recv");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!len) {
|
|
|
|
printf("Connection closed\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
data->head = 0;
|
|
|
|
data->tail = len;
|
2010-03-22 06:12:51 +00:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int gdb_peek(struct gdb_data *data)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
2010-04-30 04:01:03 +00:00
|
|
|
if (data->head == data->tail && gdb_read(data, 0) < 0)
|
2010-03-22 06:12:51 +00:00
|
|
|
return -1;
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return data->head != data->tail;
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int gdb_getc(struct gdb_data *data)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
int c;
|
|
|
|
|
|
|
|
/* If the buffer is empty, receive some more data */
|
2010-04-30 04:01:03 +00:00
|
|
|
if (data->head == data->tail && gdb_read(data, 1) < 0)
|
2010-03-22 06:12:51 +00:00
|
|
|
return -1;
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
c = data->xbuf[data->head];
|
|
|
|
data->head++;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2010-05-12 05:43:30 +00:00
|
|
|
static int gdb_flush(struct gdb_data *data)
|
|
|
|
{
|
|
|
|
if (send(data->sock, data->outbuf, data->outlen, 0) < 0) {
|
|
|
|
data->error = errno;
|
|
|
|
perror("gdb: flush");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->outlen = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int gdb_flush_ack(struct gdb_data *data)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
int c;
|
|
|
|
|
|
|
|
do {
|
2010-04-30 04:01:03 +00:00
|
|
|
data->outbuf[data->outlen] = 0;
|
2010-03-22 06:12:51 +00:00
|
|
|
#ifdef DEBUG_GDB
|
2010-04-30 04:01:03 +00:00
|
|
|
printf("-> %s\n", data->outbuf);
|
2010-03-22 06:12:51 +00:00
|
|
|
#endif
|
2010-05-12 05:43:30 +00:00
|
|
|
if (send(data->sock, data->outbuf, data->outlen, 0) < 0) {
|
|
|
|
data->error = errno;
|
|
|
|
perror("gdb: flush_ack");
|
2010-03-22 06:12:51 +00:00
|
|
|
return -1;
|
2010-05-12 05:43:30 +00:00
|
|
|
}
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
c = gdb_getc(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
if (c < 0)
|
|
|
|
return -1;
|
|
|
|
} while (c != '+');
|
|
|
|
|
2010-05-12 05:43:30 +00:00
|
|
|
data->outlen = 0;
|
2010-03-22 06:12:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static void gdb_packet_start(struct gdb_data *data)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_printf(data, "$");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static void gdb_packet_end(struct gdb_data *data)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int c = 0;
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
for (i = 1; i < data->outlen; i++)
|
|
|
|
c = (c + data->outbuf[i]) & 0xff;
|
|
|
|
gdb_printf(data, "#%02x", c);
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int gdb_send_hex(struct gdb_data *data, const char *text)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_packet_start(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
while (*text)
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_printf(data, "%02x", *(text++));
|
|
|
|
gdb_packet_end(data);
|
2010-03-23 00:38:14 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_flush_ack(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hexval(int c)
|
|
|
|
{
|
|
|
|
if (isdigit(c))
|
|
|
|
return c - '0';
|
|
|
|
if (isupper(c))
|
|
|
|
return c - 'A' + 10;
|
|
|
|
if (islower(c))
|
|
|
|
return c - 'a' + 10;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int gdb_send(struct gdb_data *data, const char *msg)
|
2010-03-23 00:38:14 +00:00
|
|
|
{
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_packet_start(data);
|
|
|
|
gdb_printf(data, "%s", msg);
|
|
|
|
gdb_packet_end(data);
|
|
|
|
return gdb_flush_ack(data);
|
2010-03-23 00:38:14 +00:00
|
|
|
}
|
|
|
|
|
2010-03-22 06:12:51 +00:00
|
|
|
/************************************************************************
|
|
|
|
* GDB server
|
|
|
|
*/
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int read_registers(struct gdb_data *data)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
2010-08-05 02:43:07 +00:00
|
|
|
address_t regs[DEVICE_NUM_REGS];
|
2010-03-23 00:38:14 +00:00
|
|
|
int i;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
printf("Reading registers\n");
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->getregs(device_default, regs) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_packet_start(data);
|
2010-03-23 00:38:14 +00:00
|
|
|
for (i = 0; i < DEVICE_NUM_REGS; i++)
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_printf(data, "%02x%02x", regs[i] & 0xff, regs[i] >> 8);
|
|
|
|
gdb_packet_end(data);
|
|
|
|
return gdb_flush_ack(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int monitor_command(struct gdb_data *data, char *buf)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
char cmd[128];
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
while (len + 1 < sizeof(cmd) && *buf && buf[1]) {
|
2010-05-12 05:28:59 +00:00
|
|
|
if (len + 1 >= sizeof(cmd))
|
|
|
|
break;
|
|
|
|
|
2010-03-22 06:12:51 +00:00
|
|
|
cmd[len++] = (hexval(buf[0]) << 4) | hexval(buf[1]);
|
|
|
|
buf += 2;
|
|
|
|
}
|
2010-05-12 05:28:59 +00:00
|
|
|
cmd[len] = 0;
|
|
|
|
|
|
|
|
printf("Monitor command received: %s\n", cmd);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
if (!strcasecmp(cmd, "reset")) {
|
|
|
|
printf("Resetting device\n");
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->ctl(device_default, DEVICE_CTL_RESET) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send_hex(data, "Reset failed\n");
|
2010-03-22 06:12:51 +00:00
|
|
|
} else if (!strcasecmp(cmd, "erase")) {
|
|
|
|
printf("Erasing device\n");
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->ctl(device_default, DEVICE_CTL_ERASE) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send_hex(data, "Erase failed\n");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
2010-03-23 00:38:14 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "OK");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int write_registers(struct gdb_data *data, char *buf)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
2010-08-05 02:43:07 +00:00
|
|
|
address_t regs[DEVICE_NUM_REGS];
|
2010-03-22 06:12:51 +00:00
|
|
|
int i;
|
|
|
|
|
2010-03-23 00:38:14 +00:00
|
|
|
if (strlen(buf) < DEVICE_NUM_REGS * 4)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-23 00:38:14 +00:00
|
|
|
|
2010-03-22 06:12:51 +00:00
|
|
|
printf("Writing registers\n");
|
|
|
|
for (i = 0; i < DEVICE_NUM_REGS; i++) {
|
|
|
|
regs[i] = (hexval(buf[2]) << 12) |
|
|
|
|
(hexval(buf[3]) << 8) |
|
|
|
|
(hexval(buf[0]) << 4) |
|
|
|
|
hexval(buf[1]);
|
|
|
|
buf += 4;
|
|
|
|
}
|
|
|
|
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->setregs(device_default, regs) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-23 00:38:14 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "OK");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int read_memory(struct gdb_data *data, char *text)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
char *length_text = strchr(text, ',');
|
2010-08-05 04:44:41 +00:00
|
|
|
address_t length, addr;
|
2010-07-01 21:56:16 +00:00
|
|
|
uint8_t buf[MAX_MEM_XFER];
|
2010-03-23 00:38:14 +00:00
|
|
|
int i;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
if (!length_text) {
|
|
|
|
fprintf(stderr, "gdb: malformed memory read request\n");
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*(length_text++) = 0;
|
|
|
|
|
|
|
|
length = strtoul(length_text, NULL, 16);
|
|
|
|
addr = strtoul(text, NULL, 16);
|
|
|
|
|
|
|
|
if (length > sizeof(buf))
|
|
|
|
length = sizeof(buf);
|
|
|
|
|
|
|
|
printf("Reading %d bytes from 0x%04x\n", length, addr);
|
|
|
|
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->readmem(device_default, addr, buf, length) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_packet_start(data);
|
2010-03-23 00:38:14 +00:00
|
|
|
for (i = 0; i < length; i++)
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_printf(data, "%02x", buf[i]);
|
|
|
|
gdb_packet_end(data);
|
2010-03-23 00:38:14 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_flush_ack(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int write_memory(struct gdb_data *data, char *text)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
char *data_text = strchr(text, ':');
|
|
|
|
char *length_text = strchr(text, ',');
|
2010-08-05 04:44:41 +00:00
|
|
|
address_t length, addr;
|
2010-07-01 21:56:16 +00:00
|
|
|
uint8_t buf[MAX_MEM_XFER];
|
2010-03-22 06:12:51 +00:00
|
|
|
int buflen = 0;
|
|
|
|
|
|
|
|
if (!(data_text && length_text)) {
|
|
|
|
fprintf(stderr, "gdb: malformed memory write request\n");
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*(data_text++) = 0;
|
|
|
|
*(length_text++) = 0;
|
|
|
|
|
|
|
|
length = strtoul(length_text, NULL, 16);
|
|
|
|
addr = strtoul(text, NULL, 16);
|
|
|
|
|
|
|
|
while (buflen < sizeof(buf) && *data_text && data_text[1]) {
|
|
|
|
buf[buflen++] = (hexval(data_text[0]) << 4) |
|
|
|
|
hexval(data_text[1]);
|
|
|
|
data_text += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (buflen != length) {
|
|
|
|
fprintf(stderr, "gdb: length mismatch\n");
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
printf("Writing %d bytes to 0x%04x\n", buflen, addr);
|
|
|
|
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->writemem(device_default, addr, buf, buflen) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-23 00:38:14 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "OK");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int run_set_pc(struct gdb_data *data, char *buf)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
2010-08-05 02:43:07 +00:00
|
|
|
address_t regs[DEVICE_NUM_REGS];
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-03-23 00:38:14 +00:00
|
|
|
if (!*buf)
|
|
|
|
return 0;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->getregs(device_default, regs) < 0)
|
2010-03-23 00:38:14 +00:00
|
|
|
return -1;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-03-23 00:38:14 +00:00
|
|
|
regs[0] = strtoul(buf, NULL, 16);
|
2010-08-13 00:25:28 +00:00
|
|
|
return device_default->setregs(device_default, regs);
|
2010-03-23 00:38:14 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int run_final_status(struct gdb_data *data)
|
2010-03-23 00:38:14 +00:00
|
|
|
{
|
2010-08-05 02:43:07 +00:00
|
|
|
address_t regs[DEVICE_NUM_REGS];
|
2010-03-23 00:38:14 +00:00
|
|
|
int i;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->getregs(device_default, regs) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_packet_start(data);
|
2010-07-27 04:54:08 +00:00
|
|
|
gdb_printf(data, "T05");
|
2010-08-05 04:44:41 +00:00
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
address_t value = regs[i];
|
|
|
|
int j;
|
|
|
|
|
|
|
|
/* NOTE: this only gives GDB the lower 16 bits of each
|
|
|
|
* register. It complains if we give the full data.
|
|
|
|
*/
|
|
|
|
gdb_printf(data, "%02x:", i);
|
|
|
|
for (j = 0; j < 2; j++) {
|
|
|
|
gdb_printf(data, "%02x", value & 0xff);
|
|
|
|
value >>= 8;
|
|
|
|
}
|
|
|
|
gdb_printf(data, ";");
|
|
|
|
}
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_packet_end(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_flush_ack(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int single_step(struct gdb_data *data, char *buf)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
2010-03-23 00:38:14 +00:00
|
|
|
printf("Single stepping\n");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
if (run_set_pc(data, buf) < 0 ||
|
2010-08-13 00:25:28 +00:00
|
|
|
device_default->ctl(device_default, DEVICE_CTL_STEP) < 0)
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return run_final_status(data);
|
2010-03-23 00:38:14 +00:00
|
|
|
}
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int run(struct gdb_data *data, char *buf)
|
2010-03-23 00:38:14 +00:00
|
|
|
{
|
|
|
|
printf("Running\n");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
if (run_set_pc(data, buf) < 0 ||
|
2010-08-13 00:25:28 +00:00
|
|
|
device_default->ctl(device_default, DEVICE_CTL_RUN) < 0)
|
2010-05-12 05:43:30 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
for (;;) {
|
2010-08-13 00:25:28 +00:00
|
|
|
device_status_t status = device_default->poll(device_default);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-05-12 05:43:30 +00:00
|
|
|
if (status == DEVICE_STATUS_ERROR)
|
|
|
|
return gdb_send(data, "E00");
|
2010-03-23 00:38:14 +00:00
|
|
|
|
2010-03-23 01:37:53 +00:00
|
|
|
if (status == DEVICE_STATUS_HALTED) {
|
2010-03-22 06:12:51 +00:00
|
|
|
printf("Target halted\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-03-23 01:37:53 +00:00
|
|
|
if (status == DEVICE_STATUS_INTR)
|
|
|
|
goto out;
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
while (gdb_peek(data)) {
|
|
|
|
int c = gdb_getc(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
if (c < 0)
|
2010-03-23 00:38:14 +00:00
|
|
|
return -1;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
if (c == 3) {
|
|
|
|
printf("Interrupted by gdb\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_default->ctl(device_default, DEVICE_CTL_HALT) < 0)
|
2010-05-12 05:43:30 +00:00
|
|
|
return gdb_send(data, "E00");
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return run_final_status(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-05-12 06:17:12 +00:00
|
|
|
static int set_breakpoint(struct gdb_data *data, int enable, char *buf)
|
|
|
|
{
|
|
|
|
char *parts[2];
|
|
|
|
int type;
|
2010-08-05 04:44:41 +00:00
|
|
|
address_t addr;
|
2010-05-12 06:17:12 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Break up the arguments */
|
|
|
|
for (i = 0; i < 2; i++)
|
|
|
|
parts[i] = strsep(&buf, ",");
|
|
|
|
|
|
|
|
/* Make sure there's a type argument */
|
|
|
|
if (!parts[0]) {
|
|
|
|
fprintf(stderr, "gdb: breakpoint requested with no type\n");
|
|
|
|
return gdb_send(data, "E00");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We only support breakpoints */
|
|
|
|
type = atoi(parts[0]);
|
|
|
|
if (type < 0 || type > 1) {
|
|
|
|
fprintf(stderr, "gdb: unsupported breakpoint type: %s\n",
|
|
|
|
parts[0]);
|
|
|
|
return gdb_send(data, "");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* There needs to be an address specified */
|
|
|
|
if (!parts[1]) {
|
|
|
|
fprintf(stderr, "gdb: breakpoint address missing\n");
|
|
|
|
return gdb_send(data, "E00");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse the breakpoint address */
|
|
|
|
addr = strtoul(parts[1], NULL, 16);
|
|
|
|
|
2010-07-02 02:22:52 +00:00
|
|
|
if (enable) {
|
2010-08-13 00:25:28 +00:00
|
|
|
if (device_setbrk(device_default, -1, 1, addr) < 0) {
|
2010-07-02 02:22:52 +00:00
|
|
|
fprintf(stderr, "gdb: can't add breakpoint at "
|
|
|
|
"0x%04x\n", addr);
|
|
|
|
return gdb_send(data, "E00");
|
|
|
|
}
|
2010-05-12 06:17:12 +00:00
|
|
|
|
|
|
|
printf("Breakpoint set at 0x%04x\n", addr);
|
2010-07-02 02:22:52 +00:00
|
|
|
} else {
|
2010-08-13 00:25:28 +00:00
|
|
|
device_setbrk(device_default, -1, 0, addr);
|
2010-07-02 02:22:52 +00:00
|
|
|
printf("Breakpoint cleared at 0x%04x\n", addr);
|
|
|
|
}
|
2010-05-12 06:17:12 +00:00
|
|
|
|
|
|
|
return gdb_send(data, "OK");
|
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static int process_gdb_command(struct gdb_data *data, char *buf, int len)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
switch (buf[0]) {
|
|
|
|
case '?': /* Return target halt reason */
|
2010-07-27 04:54:08 +00:00
|
|
|
return run_final_status(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-05-12 06:17:12 +00:00
|
|
|
case 'z':
|
|
|
|
case 'Z':
|
|
|
|
return set_breakpoint(data, buf[0] == 'Z', buf + 1);
|
|
|
|
|
2010-03-22 06:12:51 +00:00
|
|
|
case 'g': /* Read registers */
|
2010-04-30 04:01:03 +00:00
|
|
|
return read_registers(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
case 'G': /* Write registers */
|
2010-04-30 04:01:03 +00:00
|
|
|
return write_registers(data, buf + 1);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
case 'q': /* Query */
|
|
|
|
if (!strncmp(buf, "qRcmd,", 6))
|
2010-04-30 04:01:03 +00:00
|
|
|
return monitor_command(data, buf + 6);
|
2010-03-22 06:12:51 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'm': /* Read memory */
|
2010-04-30 04:01:03 +00:00
|
|
|
return read_memory(data, buf + 1);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
case 'M': /* Write memory */
|
2010-04-30 04:01:03 +00:00
|
|
|
return write_memory(data, buf + 1);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
case 'c': /* Continue */
|
2010-04-30 04:01:03 +00:00
|
|
|
return run(data, buf + 1);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
case 's': /* Single step */
|
2010-04-30 04:01:03 +00:00
|
|
|
return single_step(data, buf + 1);
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* For unknown/unsupported packets, return an empty reply */
|
2010-04-30 04:01:03 +00:00
|
|
|
return gdb_send(data, "");
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
static void gdb_reader_loop(struct gdb_data *data)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
for (;;) {
|
2010-07-01 21:56:16 +00:00
|
|
|
char buf[MAX_MEM_XFER * 2 + 64];
|
2010-03-22 06:12:51 +00:00
|
|
|
int len = 0;
|
|
|
|
int cksum_calc = 0;
|
|
|
|
int cksum_recv = 0;
|
|
|
|
int c;
|
|
|
|
|
|
|
|
/* Wait for packet start */
|
|
|
|
do {
|
2010-04-30 04:01:03 +00:00
|
|
|
c = gdb_getc(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
if (c < 0)
|
|
|
|
return;
|
|
|
|
} while (c != '$');
|
|
|
|
|
|
|
|
/* Read packet payload */
|
|
|
|
while (len + 1 < sizeof(buf)) {
|
2010-04-30 04:01:03 +00:00
|
|
|
c = gdb_getc(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
if (c < 0)
|
|
|
|
return;
|
|
|
|
if (c == '#')
|
|
|
|
break;
|
|
|
|
|
|
|
|
buf[len++] = c;
|
|
|
|
cksum_calc = (cksum_calc + c) & 0xff;
|
|
|
|
}
|
|
|
|
buf[len] = 0;
|
|
|
|
|
|
|
|
/* Read packet checksum */
|
2010-04-30 04:01:03 +00:00
|
|
|
c = gdb_getc(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
if (c < 0)
|
|
|
|
return;
|
|
|
|
cksum_recv = hexval(c);
|
2010-04-30 04:01:03 +00:00
|
|
|
c = gdb_getc(data);
|
2010-03-22 06:12:51 +00:00
|
|
|
if (c < 0)
|
|
|
|
return;
|
|
|
|
cksum_recv = (cksum_recv << 4) | hexval(c);
|
|
|
|
|
|
|
|
#ifdef DEBUG_GDB
|
2010-03-23 00:38:14 +00:00
|
|
|
printf("<- $%s#%02x\n", buf, cksum_recv);
|
2010-03-22 06:12:51 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (cksum_recv != cksum_calc) {
|
|
|
|
fprintf(stderr, "gdb: bad checksum (calc = 0x%02x, "
|
|
|
|
"recv = 0x%02x)\n", cksum_calc, cksum_recv);
|
|
|
|
fprintf(stderr, "gdb: packet data was: %s\n", buf);
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_printf(data, "-");
|
|
|
|
if (gdb_flush(data) < 0)
|
2010-03-22 06:12:51 +00:00
|
|
|
return;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send acknowledgement */
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_printf(data, "+");
|
|
|
|
if (gdb_flush(data) < 0)
|
2010-03-22 06:12:51 +00:00
|
|
|
return;
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
if (len && process_gdb_command(data, buf, len) < 0)
|
2010-03-22 06:12:51 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-13 00:25:28 +00:00
|
|
|
static int gdb_server(int port)
|
2010-03-22 06:12:51 +00:00
|
|
|
{
|
|
|
|
int sock;
|
|
|
|
int client;
|
|
|
|
struct sockaddr_in addr;
|
|
|
|
socklen_t len;
|
2010-03-23 00:42:44 +00:00
|
|
|
int arg;
|
2010-04-30 04:01:03 +00:00
|
|
|
struct gdb_data data;
|
2010-07-02 02:22:52 +00:00
|
|
|
int i;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
|
|
|
sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
|
|
|
if (sock < 0) {
|
|
|
|
perror("gdb: can't create socket");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-03-23 00:42:44 +00:00
|
|
|
arg = 1;
|
|
|
|
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &arg, sizeof(arg)) < 0)
|
|
|
|
perror("gdb: warning: can't reuse socket address");
|
|
|
|
|
2010-03-22 06:12:51 +00:00
|
|
|
addr.sin_family = AF_INET;
|
|
|
|
addr.sin_port = htons(port);
|
|
|
|
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
|
if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
|
|
|
|
fprintf(stderr, "gdb: can't bind to port %d: %s\n",
|
|
|
|
port, strerror(errno));
|
|
|
|
close(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (listen(sock, 1) < 0) {
|
|
|
|
perror("gdb: can't listen on socket");
|
|
|
|
close(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Bound to port %d. Now waiting for connection...\n", port);
|
|
|
|
|
|
|
|
len = sizeof(addr);
|
|
|
|
client = accept(sock, (struct sockaddr *)&addr, &len);
|
|
|
|
if (client < 0) {
|
|
|
|
perror("gdb: failed to accept connection");
|
|
|
|
close(sock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
close(sock);
|
|
|
|
printf("Client connected from %s:%d\n",
|
|
|
|
inet_ntoa(addr.sin_addr), htons(addr.sin_port));
|
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
data.sock = client;
|
|
|
|
data.error = 0;
|
|
|
|
data.head = 0;
|
|
|
|
data.tail = 0;
|
|
|
|
data.outlen = 0;
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-05-12 06:17:12 +00:00
|
|
|
/* Put the hardware breakpoint setting into a known state. */
|
2010-07-02 02:22:52 +00:00
|
|
|
printf("Clearing all breakpoints...\n");
|
2010-08-13 00:25:28 +00:00
|
|
|
for (i = 0; i < device_default->max_breakpoints; i++)
|
|
|
|
device_setbrk(device_default, i, 0, 0);
|
2010-05-12 06:17:12 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
gdb_reader_loop(&data);
|
2010-03-22 06:12:51 +00:00
|
|
|
|
2010-04-30 04:01:03 +00:00
|
|
|
return data.error ? -1 : 0;
|
2010-03-22 06:12:51 +00:00
|
|
|
}
|
2010-03-31 06:33:28 +00:00
|
|
|
|
2010-08-13 04:40:58 +00:00
|
|
|
int cmd_gdb(char **arg)
|
2010-03-31 06:33:28 +00:00
|
|
|
{
|
|
|
|
char *port_text = get_arg(arg);
|
|
|
|
int port = 2000;
|
|
|
|
|
|
|
|
if (port_text)
|
|
|
|
port = atoi(port_text);
|
|
|
|
|
|
|
|
if (port <= 0 || port > 65535) {
|
|
|
|
fprintf(stderr, "gdb: invalid port: %d\n", port);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-06-15 02:51:12 +00:00
|
|
|
do {
|
2010-08-13 00:25:28 +00:00
|
|
|
if (gdb_server(port) < 0)
|
2010-06-15 02:51:12 +00:00
|
|
|
return -1;
|
2010-08-13 03:14:15 +00:00
|
|
|
} while (opdb_get_boolean("gdb_loop"));
|
2010-06-15 02:51:12 +00:00
|
|
|
|
|
|
|
return 0;
|
2010-03-31 06:33:28 +00:00
|
|
|
}
|