53 #define CTRL(c) ((c) - '@')
109 #define _DEBUG_GDB_IO_
122 const char *
function,
const char *
string);
173 LOG_USER(
"undefined debug reason %d (%s) - target needs reset",
181 int timeout_s,
int *got_data)
222 #ifdef _DEBUG_GDB_IO_
240 LOG_DEBUG(
"GDB connection closed by the remote client");
246 bool retry = (WSAGetLastError() == WSAEWOULDBLOCK);
248 bool retry = (errno == EAGAIN);
262 #ifdef _DEBUG_GDB_IO_
264 LOG_DEBUG(
"received '%s'", debug_buffer);
270 *next_char = *(gdb_con->
buf_p++);
275 #ifdef _DEBUG_GDB_IO_
276 LOG_DEBUG(
"returned char '%c' (0x%2.2x)", *next_char, *next_char);
294 *next_char = **
buf_p;
301 #ifdef _DEBUG_GDB_IO_
302 LOG_DEBUG(
"returned char '%c' (0x%2.2x)", *next_char, *next_char);
329 *(--gdb_con->
buf_p) = last_char;
332 LOG_ERROR(
"BUG: couldn't put character back");
344 LOG_DEBUG(
"GDB socket marked as closed, cannot write to it.");
351 LOG_WARNING(
"Error writing to GDB socket. Dropping the connection.");
365 const unsigned int packet_len = strlen(packet);
370 const char *colon = memchr(packet,
':',
MIN(50, packet_len));
371 const bool packet_has_prefix = (colon);
372 const bool packet_prefix_printable = (packet_has_prefix && nonprint > colon);
374 if (packet_prefix_printable) {
375 const unsigned int prefix_len = colon - packet + 1;
376 const unsigned int payload_len = packet_len - prefix_len;
390 unsigned int packet_len,
unsigned char checksum)
407 const char *
buffer,
int len)
410 unsigned char my_checksum = 0;
415 for (i = 0; i < len; i++)
418 #ifdef _DEBUG_GDB_IO_
437 LOG_DEBUG(
"Unexpected start of new packet");
439 }
else if (reply ==
CTRL(
'C')) {
452 char local_buffer[1024];
453 local_buffer[0] =
'$';
454 if ((
size_t)len + 4 <=
sizeof(local_buffer)) {
456 memcpy(local_buffer + 1,
buffer, len++);
457 len += snprintf(local_buffer + len,
sizeof(local_buffer) - len,
"#%02x", my_checksum);
464 snprintf(local_buffer + 1,
sizeof(local_buffer) - 1,
"#%02x", my_checksum);
486 }
else if (reply ==
'-') {
491 }
else if (reply ==
CTRL(
'C')) {
500 }
else if (reply ==
'-') {
505 }
else if (reply ==
'$') {
506 LOG_ERROR(
"GDB missing ack(1) - assumed good");
510 LOG_ERROR(
"unknown character(1) 0x%2.2x in reply, dropping connection", reply);
514 }
else if (reply ==
'$') {
515 LOG_ERROR(
"GDB missing ack(2) - assumed good");
519 LOG_ERROR(
"unknown character(2) 0x%2.2x in reply, dropping connection",
534 gdb_con->
busy =
true;
536 gdb_con->
busy =
false;
545 int *checksum_ok,
int noack,
int *len,
char *
buffer)
547 unsigned char my_checksum = 0;
580 if (character ==
'#') {
587 if (character ==
'}') {
590 my_checksum += character & 0xff;
593 my_checksum += character & 0xff;
596 my_checksum += character & 0xff;
615 if (character ==
'#')
618 if (character ==
'}') {
621 my_checksum += character & 0xff;
627 my_checksum += character & 0xff;
630 my_checksum += character & 0xff;
646 checksum[0] = character;
650 checksum[1] = character;
654 *checksum_ok = (my_checksum == strtoul(checksum,
NULL, 16));
672 #ifdef _DEBUG_GDB_IO_
691 LOG_WARNING(
"acknowledgment received, but no packet pending");
693 LOG_DEBUG(
"Received first acknowledgment after entering noack mode. Ignoring it.");
699 LOG_WARNING(
"negative acknowledgment, but no packet pending");
710 }
while (character !=
'$');
745 gdb_con->
busy =
true;
747 gdb_con->
busy =
false;
756 bin_size = strlen(line);
758 hex_buffer = malloc(bin_size * 2 + 2);
763 size_t pkt_len =
hexify(hex_buffer + 1, (
const uint8_t *)line, bin_size,
782 char stop_reason[32];
790 sig_reply_len = snprintf(sig_reply,
sizeof(sig_reply),
"W00");
806 stop_reason[0] =
'\0';
813 switch (hit_wp_type) {
815 snprintf(stop_reason,
sizeof(stop_reason),
819 snprintf(stop_reason,
sizeof(stop_reason),
823 snprintf(stop_reason,
sizeof(stop_reason),
837 sig_reply_len = snprintf(sig_reply,
sizeof(sig_reply),
"T%2.2x%s%s",
850 char fileio_command[256];
852 bool program_exited =
false;
911 program_exited =
true;
922 command_len = strlen(fileio_command);
925 if (program_exited) {
989 static unsigned int next_unique_id = 1;
1034 if (initial_ack !=
'+')
1061 LOG_ERROR(
"Connect failed. Consider setting up a gdb-attach event for the target "
1062 "to prepare target for GDB connect, or use 'gdb_memory_map disable'.");
1069 __FILE__, __LINE__, __func__,
1070 "New GDB Connection: %d, Target %s, state: %s",
1141 snprintf(err, 4,
"E%2.2X", the_error);
1146 char const *packet,
int packet_size)
1162 snprintf(sig_reply, 4,
"S%2.2x", signal_var);
1173 return len - 1 - pos;
1186 char *tstr,
struct reg *
reg)
1195 for (i = 0; i < buf_len; i++) {
1197 tstr += sprintf(tstr,
"%02x", buf[j]);
1203 char const *tstr,
int str_len, uint8_t *bin)
1206 LOG_ERROR(
"BUG: gdb value with uneven number of characters encountered");
1211 for (i = 0; i < str_len; i += 2) {
1213 if (sscanf(tstr + i,
"%02x", &t) != 1) {
1214 LOG_ERROR(
"BUG: unable to convert register value");
1237 memset(tstr,
'x', len);
1241 memset(tstr,
'0', len);
1247 char const *packet,
int packet_size)
1250 struct reg **reg_list;
1253 int reg_packet_size = 0;
1258 #ifdef _DEBUG_GDB_IO_
1270 for (i = 0; i < reg_list_size; i++) {
1271 if (!reg_list[i] || !reg_list[i]->
exist || reg_list[i]->
hidden)
1276 assert(reg_packet_size > 0);
1278 reg_packet = malloc(reg_packet_size + 1);
1282 reg_packet_p = reg_packet;
1284 for (i = 0; i < reg_list_size; i++) {
1285 if (!reg_list[i] || !reg_list[i]->
exist || reg_list[i]->
hidden)
1297 #ifdef _DEBUG_GDB_IO_
1299 char *reg_packet_p_debug;
1300 reg_packet_p_debug =
strndup(reg_packet, reg_packet_size);
1301 LOG_DEBUG(
"reg_packet: %s", reg_packet_p_debug);
1302 free(reg_packet_p_debug);
1315 char const *packet,
int packet_size)
1319 struct reg **reg_list;
1322 char const *packet_p;
1324 #ifdef _DEBUG_GDB_IO_
1332 if (packet_size % 2) {
1333 LOG_WARNING(
"GDB set_registers packet with uneven characters received, dropping connection");
1343 for (i = 0; i < reg_list_size; i++) {
1345 if (!reg_list[i] || !reg_list[i]->
exist || reg_list[i]->
hidden)
1349 if (packet_p + chars > packet + packet_size)
1350 LOG_ERROR(
"BUG: register packet is too small for registers");
1355 retval = reg_list[i]->
type->
set(reg_list[i], bin_buf);
1378 char const *packet,
int packet_size)
1382 int reg_num = strtoul(packet + 1,
NULL, 16);
1383 struct reg **reg_list;
1387 #ifdef _DEBUG_GDB_IO_
1399 if ((reg_list_size <= reg_num) || !reg_list[reg_num] ||
1400 !reg_list[reg_num]->
exist || reg_list[reg_num]->
hidden) {
1401 LOG_ERROR(
"gdb requested a non-existing register (reg_num=%d)", reg_num);
1409 LOG_DEBUG(
"Couldn't get register %s.", reg_list[reg_num]->
name);
1424 char const *packet,
int packet_size)
1428 int reg_num = strtoul(packet + 1, &separator, 16);
1429 struct reg **reg_list;
1433 #ifdef _DEBUG_GDB_IO_
1437 if (*separator !=
'=') {
1438 LOG_ERROR(
"GDB 'set register packet', but no '=' following the register number");
1441 size_t chars = strlen(separator + 1);
1442 uint8_t *bin_buf = malloc(chars / 2);
1459 if ((reg_list_size <= reg_num) || !reg_list[reg_num] ||
1460 !reg_list[reg_num]->
exist || reg_list[reg_num]->
hidden) {
1461 LOG_ERROR(
"gdb requested a non-existing register (reg_num=%d)", reg_num);
1468 LOG_ERROR(
"gdb sent %zu bits for a %" PRIu32
"-bit register (%s)",
1469 chars * 4, reg_list[reg_num]->
size, reg_list[reg_num]->
name);
1477 retval = reg_list[reg_num]->
type->
set(reg_list[reg_num], bin_buf);
1479 LOG_DEBUG(
"Couldn't set register %s.", reg_list[reg_num]->
name);
1499 LOG_DEBUG(
"Reporting %i to GDB as generic error", retval);
1505 char const *packet,
int packet_size)
1520 addr = strtoull(packet, &separator, 16);
1522 if (*separator !=
',') {
1523 LOG_ERROR(
"incomplete read memory packet received, dropping connection");
1527 len = strtoul(separator + 1,
NULL, 16);
1530 LOG_WARNING(
"invalid read memory packet received (len == 0)");
1537 LOG_DEBUG(
"addr: 0x%16.16" PRIx64
", len: 0x%8.8" PRIx32
"",
addr, len);
1564 hex_buffer = malloc(len * 2 + 1);
1566 size_t pkt_len =
hexify(hex_buffer,
buffer, len, len * 2 + 1);
1580 char const *packet,
int packet_size)
1593 addr = strtoull(packet, &separator, 16);
1595 if (*separator !=
',') {
1596 LOG_ERROR(
"incomplete write memory packet received, dropping connection");
1600 len = strtoul(separator + 1, &separator, 16);
1602 if (*(separator++) !=
':') {
1603 LOG_ERROR(
"incomplete write memory packet received, dropping connection");
1609 LOG_DEBUG(
"addr: 0x%" PRIx64
", len: 0x%8.8" PRIx32
"",
addr, len);
1612 LOG_ERROR(
"unable to decode memory packet");
1631 char const *packet,
int packet_size)
1642 uint32_t fast_limit = 8;
1647 addr = strtoull(packet, &separator, 16);
1649 if (*separator !=
',') {
1650 LOG_ERROR(
"incomplete write memory binary packet received, dropping connection");
1654 len = strtoul(separator + 1, &separator, 16);
1656 if (*(separator++) !=
':') {
1657 LOG_ERROR(
"incomplete write memory binary packet received, dropping connection");
1667 if (len >= fast_limit) {
1685 LOG_DEBUG(
"addr: 0x%" PRIx64
", len: 0x%8.8" PRIx32
"",
addr, len);
1697 if (len < fast_limit) {
1710 char const *packet,
int packet_size)
1713 bool current =
false;
1719 if (packet_size > 1)
1725 if (packet[0] ==
'c') {
1729 }
else if (packet[0] ==
's') {
1738 char const *packet,
int packet_size)
1751 type = strtoul(packet + 1, &separator, 16);
1764 LOG_ERROR(
"invalid gdb watch/breakpoint type(%d), dropping connection",
type);
1771 if (*separator !=
',') {
1772 LOG_ERROR(
"incomplete breakpoint/watchpoint packet received, dropping connection");
1776 address = strtoull(separator + 1, &separator, 16);
1778 if (*separator !=
',') {
1779 LOG_ERROR(
"incomplete breakpoint/watchpoint packet received, dropping connection");
1783 size = strtoul(separator + 1, &separator, 16);
1788 if (packet[0] ==
'Z') {
1791 assert(packet[0] ==
'z');
1799 if (packet[0] ==
'Z') {
1802 assert(packet[0] ==
'z');
1827 char **xml,
int *pos,
int *
size, const
char *fmt, ...)
1834 if ((!*xml) || (!first)) {
1840 *xml = realloc(*xml, *
size);
1851 ret = vsnprintf(*xml + *pos, *
size - *pos, fmt, ap);
1853 if ((ret > 0) && ((ret + 1) < *
size - *pos)) {
1865 const char *annex_end = strchr(buf,
':');
1872 *ofs = strtoul(annex_end + 1, &separator, 16);
1874 if (*separator !=
',')
1877 *len = strtoul(separator + 1,
NULL, 16);
1881 *annex =
strndup(buf, annex_end - buf);
1904 char const *packet,
int packet_size)
1924 unsigned int target_flash_banks = 0;
1929 offset = strtoul(packet, &separator, 16);
1930 length = strtoul(separator + 1, &separator, 16);
1932 xml_printf(&retval, &xml, &pos, &
size,
"<memory-map>\n");
1950 banks[target_flash_banks++] = p;
1953 qsort(banks, target_flash_banks,
sizeof(
struct flash_bank *),
1956 for (
unsigned int i = 0; i < target_flash_banks; i++) {
1958 unsigned int group_len = 0;
1962 if (ram_start < p->
base)
1963 xml_printf(&retval, &xml, &pos, &
size,
1966 ram_start, p->
base - ram_start);
1974 for (
unsigned int j = 0; j < p->
num_sectors; j++) {
1979 LOG_WARNING(
"The flash sector at offset 0x%08" PRIx32
1980 " overflows the end of %s bank.",
1982 LOG_WARNING(
"The rest of bank will not show in gdb memory map.");
1987 xml_printf(&retval, &xml, &pos, &
size,
1988 "<memory type=\"flash\" "
2006 xml_printf(&retval, &xml, &pos, &
size,
2007 "length=\"0x%x\">\n"
2008 "<property name=\"blocksize\">"
2020 xml_printf(&retval, &xml, &pos, &
size,
2029 xml_printf(&retval, &xml, &pos, &
size,
"</memory-map>\n");
2040 char *t = malloc(
length + 1);
2086 return "ieee_single";
2088 return "ieee_double";
2097 int *num_arch_defined_types)
2099 int tbl_sz = *num_arch_defined_types;
2101 if (type_id && (strcmp(type_id,
""))) {
2102 for (
int j = 0; j < (tbl_sz + 1); j++) {
2103 if (!((*arch_defined_types_list)[j])) {
2104 (*arch_defined_types_list)[tbl_sz++] = type_id;
2105 *arch_defined_types_list = realloc(*arch_defined_types_list,
2106 sizeof(
char *) * (tbl_sz + 1));
2107 (*arch_defined_types_list)[tbl_sz] =
NULL;
2108 *num_arch_defined_types = tbl_sz;
2111 if (!strcmp((*arch_defined_types_list)[j], type_id))
2122 char const **arch_defined_types_list[],
int *num_arch_defined_types)
2130 num_arch_defined_types))
2132 arch_defined_types_list,
2133 num_arch_defined_types);
2136 xml_printf(&retval, tdesc, pos,
size,
2137 "<vector id=\"%s\" type=\"%s\" count=\"%" PRIu32
"\"/>\n",
2138 type->id,
type->reg_type_vector->type->id,
2139 type->reg_type_vector->count);
2143 field =
type->reg_type_union->fields;
2148 num_arch_defined_types))
2150 arch_defined_types_list,
2151 num_arch_defined_types);
2154 field = field->
next;
2159 xml_printf(&retval, tdesc, pos,
size,
2160 "<union id=\"%s\">\n",
2163 field =
type->reg_type_union->fields;
2165 xml_printf(&retval, tdesc, pos,
size,
2166 "<field name=\"%s\" type=\"%s\"/>\n",
2169 field = field->
next;
2172 xml_printf(&retval, tdesc, pos,
size,
2177 field =
type->reg_type_struct->fields;
2183 xml_printf(&retval, tdesc, pos,
size,
2184 "<struct id=\"%s\" size=\"%" PRIu32
"\">\n",
2185 type->id,
type->reg_type_struct->size);
2187 xml_printf(&retval, tdesc, pos,
size,
2188 "<field name=\"%s\" start=\"%" PRIu32
"\" end=\"%" PRIu32
"\" type=\"%s\" />\n",
2192 field = field->
next;
2199 num_arch_defined_types))
2201 arch_defined_types_list,
2202 num_arch_defined_types);
2209 xml_printf(&retval, tdesc, pos,
size,
2210 "<struct id=\"%s\">\n",
2213 xml_printf(&retval, tdesc, pos,
size,
2214 "<field name=\"%s\" type=\"%s\"/>\n",
2217 field = field->
next;
2221 xml_printf(&retval, tdesc, pos,
size,
2228 xml_printf(&retval, tdesc, pos,
size,
2229 "<flags id=\"%s\" size=\"%" PRIu32
"\">\n",
2230 type->id,
type->reg_type_flags->size);
2233 field =
type->reg_type_flags->fields;
2235 xml_printf(&retval, tdesc, pos,
size,
2236 "<field name=\"%s\" start=\"%" PRIu32
"\" end=\"%" PRIu32
"\" type=\"%s\" />\n",
2240 field = field->
next;
2243 xml_printf(&retval, tdesc, pos,
size,
2255 struct reg **reg_list,
int reg_list_size)
2260 *feature_list = calloc(1,
sizeof(
char *));
2262 for (
int i = 0; i < reg_list_size; i++) {
2263 if (!reg_list[i]->exist || reg_list[i]->hidden)
2268 && (strcmp(reg_list[i]->
feature->name,
""))) {
2273 for (
int j = 0; j < (tbl_sz + 1); j++) {
2274 if (!((*feature_list)[j])) {
2275 (*feature_list)[tbl_sz++] = reg_list[i]->
feature->
name;
2276 *feature_list = realloc(*feature_list,
sizeof(
char *) * (tbl_sz + 1));
2277 (*feature_list)[tbl_sz] =
NULL;
2280 if (!strcmp((*feature_list)[j], reg_list[i]->
feature->name))
2287 if (feature_list_size)
2288 *feature_list_size = tbl_sz;
2298 struct reg **combined_list[],
int *combined_list_size,
2305 unsigned int combined_allocated = 256;
2306 struct reg **local_list = malloc(combined_allocated *
sizeof(
struct reg *));
2308 LOG_ERROR(
"malloc(%zu) failed", combined_allocated *
sizeof(
struct reg *));
2311 unsigned int local_list_size = 0;
2321 ®_list_size, reg_class);
2326 for (
int i = 0; i < reg_list_size; i++) {
2328 struct reg *a = reg_list[i];
2333 for (
unsigned int j = 0; j < local_list_size; j++) {
2334 struct reg *b = local_list[j];
2338 LOG_ERROR(
"SMP register %s is %d bits on one "
2339 "target, but %d bits on another target.",
2350 if (local_list_size >= combined_allocated) {
2351 combined_allocated *= 2;
2352 local_list = realloc(local_list, combined_allocated *
sizeof(
struct reg *));
2354 LOG_ERROR(
"realloc(%zu) failed", combined_allocated *
sizeof(
struct reg *));
2359 local_list[local_list_size] = a;
2367 if (local_list_size == 0) {
2368 LOG_ERROR(
"Unable to get register list");
2381 ®_list_size, reg_class);
2386 for (
unsigned int i = 0; i < local_list_size; i++) {
2388 struct reg *a = local_list[i];
2389 for (
int j = 0; j < reg_list_size; j++) {
2390 struct reg *b = reg_list[j];
2398 "this register does exist.", a->
name);
2404 *combined_list = local_list;
2405 *combined_list_size = local_list_size;
2414 char const *architecture;
2415 char const **features =
NULL;
2416 int feature_list_size = 0;
2431 if (reg_list_size <= 0) {
2440 LOG_ERROR(
"Can't get the registers feature list");
2446 int current_feature = 0;
2448 xml_printf(&retval, &tdesc, &pos, &
size,
2449 "<?xml version=\"1.0\"?>\n"
2450 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">\n"
2451 "<target version=\"1.0\">\n");
2456 xml_printf(&retval, &tdesc, &pos, &
size,
2457 "<architecture>%s</architecture>\n", architecture);
2461 while (features[current_feature]) {
2462 char const **arch_defined_types =
NULL;
2463 int num_arch_defined_types = 0;
2465 arch_defined_types = calloc(1,
sizeof(
char *));
2466 xml_printf(&retval, &tdesc, &pos, &
size,
2467 "<feature name=\"%s\">\n",
2468 features[current_feature]);
2471 for (i = 0; i < reg_list_size; i++) {
2476 if (strcmp(reg_list[i]->
feature->name, features[current_feature]))
2479 const char *type_str;
2485 &num_arch_defined_types))
2488 &arch_defined_types,
2489 &num_arch_defined_types);
2502 xml_printf(&retval, &tdesc, &pos, &
size,
2503 "<reg name=\"%s\"", reg_list[i]->
name);
2504 xml_printf(&retval, &tdesc, &pos, &
size,
2505 " bitsize=\"%" PRIu32
"\"", reg_list[i]->
size);
2506 xml_printf(&retval, &tdesc, &pos, &
size,
2507 " regnum=\"%" PRIu32
"\"", reg_list[i]->
number);
2509 xml_printf(&retval, &tdesc, &pos, &
size,
2510 " save-restore=\"yes\"");
2512 xml_printf(&retval, &tdesc, &pos, &
size,
2513 " save-restore=\"no\"");
2515 xml_printf(&retval, &tdesc, &pos, &
size,
2516 " type=\"%s\"", type_str);
2518 if (reg_list[i]->
group)
2519 xml_printf(&retval, &tdesc, &pos, &
size,
2520 " group=\"%s\"", reg_list[i]->
group);
2522 xml_printf(&retval, &tdesc, &pos, &
size,
2526 xml_printf(&retval, &tdesc, &pos, &
size,
2530 free(arch_defined_types);
2534 xml_printf(&retval, &tdesc, &pos, &
size,
2553 LOG_ERROR(
"Unable to Generate Target Description");
2557 char *tdesc = target_desc->
tdesc;
2563 LOG_ERROR(
"Unable to Generate Target Description");
2567 tdesc_length = strlen(tdesc);
2573 transfer_type =
'm';
2575 transfer_type =
'l';
2577 *chunk = malloc(
length + 2);
2583 (*chunk)[0] = transfer_type;
2584 if (transfer_type ==
'm') {
2586 (*chunk)[1 +
length] =
'\0';
2588 strncpy((*chunk) + 1, tdesc +
offset, tdesc_length -
offset);
2589 (*chunk)[1 + (tdesc_length -
offset)] =
'\0';
2597 target_desc->
tdesc = tdesc;
2607 int reg_list_size = 0;
2608 char const **features =
NULL;
2609 int feature_list_size = 0;
2620 if (reg_list_size <= 0) {
2629 LOG_ERROR(
"Can't get the registers feature list");
2634 if (architecture || feature_list_size)
2652 char *thread_list =
NULL;
2656 xml_printf(&retval, &thread_list, &pos, &
size,
2657 "<?xml version=\"1.0\"?>\n"
2668 xml_printf(&retval, &thread_list, &pos, &
size,
2669 "<thread id=\"%" PRIx64
"\" name=\"%s\">",
2673 xml_printf(&retval, &thread_list, &pos, &
size,
2677 xml_printf(&retval, &thread_list, &pos, &
size,
2682 xml_printf(&retval, &thread_list, &pos, &
size,
2684 xml_printf(&retval, &thread_list, &pos, &
size,
2688 xml_printf(&retval, &thread_list, &pos, &
size,
2693 xml_printf(&retval, &thread_list, &pos, &
size,
2697 *thread_list_out = thread_list;
2707 if (!*thread_list) {
2710 LOG_ERROR(
"Unable to Generate Thread List");
2715 size_t thread_list_length = strlen(*thread_list);
2720 transfer_type =
'm';
2722 transfer_type =
'l';
2724 *chunk = malloc(
length + 2 + 3);
2734 (*chunk)[0] = transfer_type;
2735 strncpy((*chunk) + 1, (*thread_list) +
offset,
length);
2736 (*chunk)[1 +
length] =
'\0';
2739 if (transfer_type ==
'l') {
2741 *thread_list =
NULL;
2748 char const *packet,
int packet_size)
2754 if (strncmp(packet,
"qRcmd,", 6) == 0) {
2755 if (packet_size > 6) {
2756 Jim_Interp *interp = cmd_ctx->
interp;
2758 cmd = malloc((packet_size - 6) / 2 + 1);
2759 size_t len =
unhexify((uint8_t *)
cmd, packet + 6, (packet_size - 6) / 2);
2773 Jim_DeleteAssocData(
interp,
"context");
2774 int retval = Jim_SetAssocData(
interp,
"context",
NULL, cmd_ctx);
2775 if (retval == JIM_OK) {
2777 Jim_DeleteAssocData(
interp,
"context");
2779 int inner_retval = Jim_SetAssocData(
interp,
"context",
NULL, old_context);
2780 if (retval == JIM_OK)
2781 retval = inner_retval;
2789 if (retval == JIM_RETURN)
2790 retval =
interp->returnCode;
2792 const char *cretmsg = Jim_GetString(Jim_GetResult(
interp), &lenmsg);
2794 if (lenmsg && cretmsg[lenmsg - 1] !=
'\n') {
2798 retmsg = strdup(cretmsg);
2803 if (retval == JIM_OK) {
2805 char *hex_buffer = malloc(lenmsg * 2 + 1);
2811 size_t pkt_len =
hexify(hex_buffer, (
const uint8_t *)retmsg, lenmsg,
2828 }
else if (strncmp(packet,
"qCRC:", 5) == 0) {
2829 if (packet_size > 5) {
2840 addr = strtoull(packet, &separator, 16);
2842 if (*separator !=
',') {
2843 LOG_ERROR(
"incomplete read memory packet received, dropping connection");
2847 len = strtoul(separator + 1,
NULL, 16);
2854 snprintf(gdb_reply, 10,
"C%8.8" PRIx32
"", checksum);
2864 }
else if (strncmp(packet,
"qSupported", 10) == 0) {
2871 bool gdb_target_desc_supported =
false;
2876 LOG_INFO(
"Failed detecting Target Description Support, disabling");
2877 gdb_target_desc_supported =
false;
2882 if (gdb_target_desc_supported)
2883 LOG_WARNING(
"Target Descriptions Supported, but disabled");
2884 gdb_target_desc_supported =
false;
2891 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read%c;qXfer:threads:read+;QStartNoAckMode+;vContSupported+",
2894 gdb_target_desc_supported ?
'+' :
'-');
2905 }
else if ((strncmp(packet,
"qXfer:memory-map:read::", 23) == 0)
2908 else if (strncmp(packet,
"qXfer:features:read:", 20) == 0) {
2939 }
else if (strncmp(packet,
"qXfer:threads:read:", 19) == 0) {
2970 }
else if (strncmp(packet,
"QStartNoAckMode", 15) == 0) {
2990 const char *parse = packet;
2994 if (parse[0] ==
'?') {
3003 if (parse[0] ==
';') {
3008 if (parse[0] ==
'c') {
3035 if (parse[0] ==
's') {
3037 bool fake_step =
false;
3040 bool current_pc =
true;
3043 if (parse[0] ==
':') {
3046 thread_id = strtoll(parse, &endp, 16);
3068 if (parse[0] ==
';') {
3071 if (parse[0] ==
'c') {
3075 if (parse[0] ==
':') {
3079 tid = strtoll(parse,
NULL, 16);
3080 if (tid == thread_id) {
3090 LOG_DEBUG(
"request to step current core only");
3112 char sig_reply[128];
3114 LOG_DEBUG(
"fake step thread %"PRIx64, thread_id);
3116 sig_reply_len = snprintf(sig_reply,
sizeof(sig_reply),
3117 "T05thread:%016"PRIx64
";", thread_id);
3129 LOG_DEBUG(
"stepi ignored. GDB will now fetch the register state "
3130 "from the target.");
3162 const char *hex = *str;
3166 const char *end = strchr(hex, sep);
3168 hexlen = strlen(hex);
3171 *str = hex + hexlen + 1;
3173 if (hexlen % 2 != 0) {
3178 size_t count = hexlen / 2;
3179 char *decoded = malloc(
count + 1);
3184 if (converted !=
count) {
3189 decoded[
count] =
'\0';
3212 const char *parse = packet;
3217 if (parse[0] !=
';')
3229 char *new_cmdline =
alloc_printf(
"%s %s", cmdline, arg);
3232 cmdline = new_cmdline;
3237 LOG_INFO(
"GDB set inferior command line to '%s'", cmdline);
3241 LOG_INFO(
"GDB set inferior command line to '%s' but semihosting is unavailable", cmdline);
3252 char const *packet,
int packet_size)
3259 if (strncmp(packet,
"vCont", 5) == 0) {
3272 if (strncmp(packet,
"vRun", 4) == 0) {
3289 if (strncmp(packet,
"vFlashErase:", 12) == 0) {
3293 char const *parse = packet + 12;
3294 if (*parse ==
'\0') {
3295 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3299 addr = strtoull(parse, (
char **)&parse, 16);
3301 if (*(parse++) !=
',' || *parse ==
'\0') {
3302 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3306 length = strtoul(parse, (
char **)&parse, 16);
3308 if (*parse !=
'\0') {
3309 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3338 LOG_ERROR(
"flash_erase returned %i", result);
3345 if (strncmp(packet,
"vFlashWrite:", 12) == 0) {
3349 char const *parse = packet + 12;
3351 if (*parse ==
'\0') {
3352 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3356 addr = strtoull(parse, (
char **)&parse, 16);
3357 if (*(parse++) !=
':') {
3358 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3361 length = packet_size - (parse - packet);
3380 if (strncmp(packet,
"vFlashDone", 10) == 0) {
3404 LOG_DEBUG(
"wrote %u bytes from vFlash image to flash", (
unsigned)written);
3434 char const *packet,
int packet_size)
3438 char *parsing_point;
3439 int fileio_retcode = strtoul(packet + 1, &separator, 16);
3440 int fileio_errno = 0;
3441 bool fileio_ctrl_c =
false;
3446 if (*separator ==
',') {
3447 parsing_point = separator + 1;
3448 fileio_errno = strtoul(parsing_point, &separator, 16);
3449 if (*separator ==
',') {
3450 if (*(separator + 1) ==
'C') {
3452 fileio_ctrl_c =
true;
3457 LOG_DEBUG(
"File-I/O response, retcode: 0x%x, errno: 0x%x, ctrl-c: %s",
3458 fileio_retcode, fileio_errno, fileio_ctrl_c ?
"true" :
"false");
3479 const char *
function,
const char *
string)
3488 if (gdb_con->
busy) {
3499 snprintf(sig_reply, 4,
"T%2.2x", 2);
3509 char const *packet = gdb_packet_buffer;
3513 static bool warn_use_ext;
3535 gdb_packet_buffer[packet_size] =
'\0';
3537 if (packet_size > 0) {
3542 switch (packet[0]) {
3586 warn_use_ext =
true;
3587 LOG_WARNING(
"Prefer GDB command \"target extended-remote :%s\" instead of \"target remote :%s\"",
3605 bool nostep =
false;
3606 bool already_running =
false;
3608 LOG_WARNING(
"WARNING! The target is already running. "
3609 "All changes GDB did to registers will be discarded! "
3610 "Waiting for target to halt.");
3611 already_running =
true;
3613 LOG_WARNING(
"The target is not in the halted nor running stated, "
3614 "stepi/continue ignored.");
3616 }
else if ((packet[0] ==
's') && gdb_con->
sync) {
3622 LOG_DEBUG(
"stepi ignored. GDB will now fetch the register state "
3623 "from the target.");
3625 gdb_con->
sync =
false;
3627 if (!already_running && nostep) {
3646 if (!already_running) {
3718 LOG_DEBUG(
"ignoring 0x%2.2x packet", packet[0]);
3740 LOG_INFO(
"The target is not running when halt was requested, stopping GDB.");
3745 }
while (gdb_con->
buf_cnt > 0);
3782 static unsigned char count;
3783 unsigned char checksum = 0;
3786 int len = sprintf(buf,
"%%oocd_keepalive:%2.2x",
count++);
3787 for (
int i = 1; i < len; i++)
3789 len += sprintf(buf + len,
"#%2.2x", checksum);
3791 #ifdef _DEBUG_GDB_IO_
3821 .new_connection_during_keep_alive_handler =
NULL,
3917 LOG_WARNING(
"gdb services need one or more targets defined");
3939 "gdb sync command can only be run from within gdb using \"monitor gdb sync\"");
4000 if (strcmp(
CMD_ARGV[0],
"hard") == 0)
4002 else if (strcmp(
CMD_ARGV[0],
"soft") == 0)
4004 else if (strcmp(
CMD_ARGV[0],
"disable") == 0)
4012 LOG_USER(
"breakpoint type is not overridden");
4029 uint32_t tdesc_length;
4034 LOG_ERROR(
"Unable to Generate Target Description");
4038 tdesc_length = strlen(tdesc);
4041 size_t size_written;
4044 if (!tdesc_filename) {
4052 LOG_ERROR(
"Can't open %s for writing", tdesc_filename);
4061 LOG_ERROR(
"Error while writing the tdesc file");
4064 free(tdesc_filename);
4073 .handler = handle_gdb_sync_command,
4075 .help =
"next stepi will return immediately allowing "
4076 "GDB to fetch register state without affecting "
4082 .handler = handle_gdb_port_command,
4084 .help =
"Normally gdb listens to a TCP/IP port. Each subsequent GDB "
4085 "server listens for the next port number after the "
4086 "base port number specified. "
4087 "No arguments reports GDB port. \"pipe\" means listen to stdin "
4088 "output to stdout, an integer is base port number, \"disabled\" disables "
4089 "port. Any other string is are interpreted as named pipe to listen to. "
4090 "Output pipe is the same name as input pipe, but with 'o' appended.",
4091 .usage =
"[port_num]",
4094 .name =
"memory_map",
4095 .handler = handle_gdb_memory_map_command,
4097 .help =
"enable or disable memory map",
4098 .usage =
"('enable'|'disable')"
4101 .name =
"flash_program",
4102 .handler = handle_gdb_flash_program_command,
4104 .help =
"enable or disable flash program",
4105 .usage =
"('enable'|'disable')"
4108 .name =
"report_data_abort",
4109 .handler = handle_gdb_report_data_abort_command,
4111 .help =
"enable or disable reporting data aborts",
4112 .usage =
"('enable'|'disable')"
4115 .name =
"report_register_access_error",
4116 .handler = handle_gdb_report_register_access_error,
4118 .help =
"enable or disable reporting register access errors",
4119 .usage =
"('enable'|'disable')"
4122 .name =
"breakpoint_override",
4123 .handler = handle_gdb_breakpoint_override_command,
4125 .help =
"Display or specify type of breakpoint "
4126 "to be used by gdb 'break' commands.",
4127 .usage =
"('hard'|'soft'|'disable')"
4130 .name =
"target_description",
4131 .handler = handle_gdb_target_description_command,
4133 .help =
"enable or disable target description",
4134 .usage =
"('enable'|'disable')"
4137 .name =
"save_tdesc",
4138 .handler = handle_gdb_save_tdesc_command,
4140 .help =
"Save the target description file",
4150 .help =
"GDB commands",
struct reg_data_type * data_type
size_t hexify(char *hex, const uint8_t *bin, size_t count, size_t length)
Convert binary data into a string of hexadecimal pairs.
size_t unhexify(uint8_t *bin, const char *hex, size_t count)
Convert a string of hexadecimal pairs into its binary representation.
int watchpoint_add(struct target *target, target_addr_t address, unsigned int length, enum watchpoint_rw rw, uint64_t value, uint64_t mask)
int breakpoint_remove(struct target *target, target_addr_t address)
int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, target_addr_t *address)
int watchpoint_remove(struct target *target, target_addr_t address)
int breakpoint_add(struct target *target, target_addr_t address, unsigned int length, enum breakpoint_type type)
int watchpoint_clear_target(struct target *target)
int breakpoint_clear_target(struct target *target)
#define WATCHPOINT_IGNORE_DATA_VALUE_MASK
void command_print(struct command_invocation *cmd, const char *format,...)
int command_run_linef(struct command_context *context, const char *format,...)
void command_set_output_handler(struct command_context *context, command_output_handler_t output_handler, void *priv)
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
#define CALL_COMMAND_HANDLER(name, extra ...)
Use this to macro to call a command helper (or a nested handler).
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
#define PRINTF_ATTRIBUTE_FORMAT
#define ERROR_COMMAND_SYNTAX_ERROR
int parse_long(const char *str, long *ul)
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
#define COMMAND_PARSE_ENABLE(in, out)
parses an enable/disable command argument
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
static int register_commands(struct command_context *cmd_ctx, const char *cmd_prefix, const struct command_registration *cmds)
Register one or more commands in the specified context, as children of parent (or top-level commends,...
uint32_t sector_size
Sector size.
uint64_t buffer
Pointer to data buffer to send over SPI.
uint32_t size
Size of dw_spi_transaction::buffer.
uint32_t address
Starting address. Sector aligned.
enum esirisc_reg_num number
static struct esp_usb_jtag * priv
#define ERROR_FLASH_DST_OUT_OF_BANK
struct flash_bank * get_flash_bank_by_num_noprobe(unsigned int num)
Returns the flash bank like get_flash_bank_by_num(), without probing.
unsigned int flash_get_bank_count(void)
int flash_erase_address_range(struct target *target, bool pad, target_addr_t addr, uint32_t length)
Erases length bytes in the target flash, starting at addr.
int flash_write(struct target *target, struct image *image, uint32_t *written, bool erase)
Writes image into the target flash.
int get_flash_bank_by_num(unsigned int num, struct flash_bank **bank)
Returns the flash bank like get_flash_bank_by_name(), without probing.
static int gdb_read_memory_packet(struct connection *connection, char const *packet, int packet_size)
static void gdb_fileio_reply(struct target *target, struct connection *connection)
static void gdb_signal_reply(struct target *target, struct connection *connection)
static int gdb_get_char_inner(struct connection *connection, int *next_char)
static int gdb_target_start(struct target *target, const char *port)
static int gdb_output_con(struct connection *connection, const char *line)
static void gdb_async_notif(struct connection *connection)
static int gdb_v_packet(struct connection *connection, char const *packet, int packet_size)
static void gdb_log_incoming_packet(struct connection *connection, const char *packet)
static const struct service_driver gdb_service_driver
int gdb_put_packet(struct connection *connection, const char *buffer, int len)
static int gdb_input_inner(struct connection *connection)
static int gdb_get_registers_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_target_add_one(struct target *target)
static void gdb_sig_halted(struct connection *connection)
static bool gdb_handle_vrun_packet(struct connection *connection, const char *packet, int packet_size)
static int gdb_reg_pos(struct target *target, int pos, int len)
static int gdb_generate_thread_list(struct target *target, char **thread_list_out)
static struct gdb_connection * current_gdb_connection
COMMAND_HANDLER(handle_gdb_sync_command)
static int gdb_detach(struct connection *connection)
static int compare_bank(const void *a, const void *b)
int gdb_register_commands(struct command_context *cmd_ctx)
static void gdb_keep_client_alive(struct connection *connection)
static int gdb_target_callback_event_handler(struct target *target, enum target_event event, void *priv)
static char gdb_running_type
static int gdb_get_reg_value_as_str(struct target *target, char *tstr, struct reg *reg)
static int gdb_query_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_get_thread_list_chunk(struct target *target, char **thread_list, char **chunk, int32_t offset, uint32_t length)
static char * next_hex_encoded_field(const char **str, char sep)
static void gdb_restart_inferior(struct connection *connection, const char *packet, int packet_size)
int gdb_target_add_all(struct target *target)
static int gdb_set_registers_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_generate_reg_type_description(struct target *target, char **tdesc, int *pos, int *size, struct reg_data_type *type, char const **arch_defined_types_list[], int *num_arch_defined_types)
static void gdb_log_outgoing_packet(struct connection *connection, const char *packet_buf, unsigned int packet_len, unsigned char checksum)
static int decode_xfer_read(char const *buf, char **annex, int *ofs, unsigned int *len)
static int gdb_fileio_response_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_memory_map(struct connection *connection, char const *packet, int packet_size)
static int gdb_get_packet(struct connection *connection, char *buffer, int *len)
static int check_pending(struct connection *connection, int timeout_s, int *got_data)
static int gdb_error(struct connection *connection, int retval)
static int gdb_put_packet_inner(struct connection *connection, const char *buffer, int len)
static int gdb_actual_connections
static void gdb_frontend_halted(struct target *target, struct connection *connection)
static int gdb_connection_closed(struct connection *connection)
static const struct command_registration gdb_command_handlers[]
static int gdb_input(struct connection *connection)
static int gdb_new_connection(struct connection *connection)
static int gdb_get_char_fast(struct connection *connection, int *next_char, char **buf_p, int *buf_cnt)
The cool thing about this fn is that it allows buf_p and buf_cnt to be held in registers in the inner...
static int get_reg_features_list(struct target *target, char const **feature_list[], int *feature_list_size, struct reg **reg_list, int reg_list_size)
static int gdb_get_target_description_chunk(struct target *target, struct target_desc_format *target_desc, char **chunk, int32_t offset, uint32_t length)
static int gdb_get_register_packet(struct connection *connection, char const *packet, int packet_size)
int gdb_get_actual_connections(void)
static char * gdb_port_next
static int gdb_write_memory_packet(struct connection *connection, char const *packet, int packet_size)
static __attribute__((format(PRINTF_ATTRIBUTE_FORMAT, 5, 6)))
static int gdb_get_char(struct connection *connection, int *next_char)
void gdb_service_free(void)
static bool gdb_use_target_description
static int gdb_write(struct connection *connection, const void *data, int len)
static bool gdb_handle_vcont_packet(struct connection *connection, const char *packet, __attribute__((unused)) int packet_size)
static int gdb_putback_char(struct connection *connection, int last_char)
static enum breakpoint_type gdb_breakpoint_override_type
static int gdb_write_memory_binary_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_breakpoint_override
static int smp_reg_list_noread(struct target *target, struct reg **combined_list[], int *combined_list_size, enum target_register_class reg_class)
static int gdb_report_data_abort
static int gdb_target_description_supported(struct target *target, bool *supported)
static int gdb_report_register_access_error
static int gdb_generate_target_description(struct target *target, char **tdesc_out)
static void gdb_str_to_target(struct target *target, char *tstr, struct reg *reg)
static int gdb_last_signal(struct target *target)
static bool gdb_flash_program
static void gdb_send_error(struct connection *connection, uint8_t the_error)
static int gdb_get_packet_inner(struct connection *connection, char *buffer, int *len)
static bool gdb_use_memory_map
static int gdb_last_signal_packet(struct connection *connection, char const *packet, int packet_size)
static int fetch_packet(struct connection *connection, int *checksum_ok, int noack, int *len, char *buffer)
static const char * gdb_get_reg_type_name(enum reg_type type)
static int gdb_output(struct command_context *context, const char *line)
static void gdb_log_callback(void *priv, const char *file, unsigned int line, const char *function, const char *string)
static int lookup_add_arch_defined_types(char const **arch_defined_types_list[], const char *type_id, int *num_arch_defined_types)
static int gdb_step_continue_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_breakpoint_watchpoint_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_set_register_packet(struct connection *connection, char const *packet, int packet_size)
static const struct command_registration gdb_subcommand_handlers[]
static void gdb_target_to_reg(struct target *target, char const *tstr, int str_len, uint8_t *bin)
#define ERROR_GDB_BUFFER_TOO_SMALL
#define ERROR_GDB_TIMEOUT
static struct target * get_target_from_connection(struct connection *connection)
int fileio_write(struct fileio *fileio, size_t size, const void *buffer, size_t *size_written)
int fileio_close(struct fileio *fileio)
int fileio_open(struct fileio **fileio, const char *url, enum fileio_access access_type, enum fileio_type type)
void image_close(struct image *image)
int image_add_section(struct image *image, target_addr_t base, uint32_t size, uint64_t flags, uint8_t const *data)
int image_open(struct image *image, const char *url, const char *type_string)
The JTAG interface can be implemented with a software or hardware fifo.
int log_remove_callback(log_callback_fn fn, void *priv)
void log_printf_lf(enum log_levels level, const char *file, unsigned int line, const char *function, const char *format,...)
int log_add_callback(log_callback_fn fn, void *priv)
void log_socket_error(const char *socket_desc)
const char * find_nonprint_char(const char *buf, unsigned int buf_len)
Find the first non-printable character in the char buffer, return a pointer to it.
char * alloc_printf(const char *format,...)
#define LOG_TARGET_INFO(target, fmt_str,...)
#define LOG_USER(expr ...)
#define LOG_TARGET_WARNING(target, fmt_str,...)
#define ERROR_NOT_IMPLEMENTED
#define LOG_WARNING(expr ...)
#define LOG_TARGET_ERROR(target, fmt_str,...)
#define LOG_TARGET_DEBUG(target, fmt_str,...)
#define LOG_USER_N(expr ...)
#define LOG_ERROR(expr ...)
#define LOG_LEVEL_IS(FOO)
#define LOG_INFO(expr ...)
#define LOG_DEBUG(expr ...)
Upper level NOR flash interfaces.
void flash_set_dirty(void)
Forces targets to re-examine their erase/protection state.
char * strndup(const char *s, size_t n)
static int socket_select(int max_fd, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv)
static int read_socket(int handle, void *buffer, unsigned int count)
int gdb_thread_packet(struct connection *connection, char const *packet, int packet_size)
int rtos_set_reg(struct connection *connection, int reg_num, uint8_t *reg_value)
int rtos_get_gdb_reg_list(struct connection *connection)
Return a list of general registers.
int rtos_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
int rtos_update_threads(struct target *target)
int rtos_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
int rtos_get_gdb_reg(struct connection *connection, int reg_num)
Look through all registers to find this register.
#define GDB_THREAD_PACKET_NOT_CONSUMED
target_addr_t addr
Start address to search for the control block.
int connection_write(struct connection *connection, const void *data, int len)
int add_service(const struct service_driver *driver, const char *port, int max_connections, void *priv)
#define ERROR_SERVER_REMOTE_CLOSED
int gdb_read_smp_packet(struct connection *connection, char const *packet, int packet_size)
int gdb_write_smp_packet(struct connection *connection, char const *packet, int packet_size)
#define foreach_smp_target(pos, head)
struct target * current_target_override
struct target * current_target
const char * usage
a string listing the options and arguments, required or optional
struct command_context * cmd_ctx
Provides details of a flash bank, available either on-chip or through a major interface.
struct flash_sector * sectors
Array of sectors, allocated and initialized by the flash driver.
target_addr_t base
The base address of this bank.
uint32_t size
The size of this chip bank, in bytes.
unsigned int num_sectors
The number of sectors on this chip.
struct target * target
Target to which this bank belongs.
uint32_t offset
Bus offset from start of the flash chip (in bytes).
uint32_t size
Number of bytes in this flash sector.
enum gdb_output_flag output_flag
enum target_state frontend_state
unsigned int unique_index
struct target_desc_format target_desc
struct image * vflash_image
char buffer[GDB_BUFFER_SIZE+1]
int(* get)(struct reg *reg)
int(* set)(struct reg *reg, uint8_t *buf)
struct reg_data_type_flags_field * next
struct reg_data_type_bitfield * bitfield
struct reg_data_type * type
struct reg_data_type_bitfield * bitfield
struct reg_data_type_struct_field * next
struct reg_data_type * type
struct reg_data_type_union_field * next
struct reg_feature * feature
struct reg_data_type * reg_data_type
const struct reg_arch_type * type
int(* clean)(struct target *target)
const struct rtos_type * type
struct thread_detail * thread_details
int(* gdb_target_for_threadid)(struct connection *connection, int64_t thread_id, struct target **p_target)
threadid_t current_thread
char * cmdline
The semihosting command line to be passed to the target.
const char * name
the name of the server
enum connection_type type
int(* step)(struct target *target, bool current, target_addr_t address, bool handle_breakpoints)
int(* gdb_query_custom)(struct target *target, const char *packet, char **response_p)
struct semihosting * semihosting
struct gdb_service * gdb_service
enum target_debug_reason debug_reason
enum target_endianness endianness
struct list_head * smp_targets
struct gdb_fileio_info * fileio_info
struct target_type * type
int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info)
Obtain file-I/O information from target for GDB to do syscall.
struct target * all_targets
int target_call_event_callbacks(struct target *target, enum target_event event)
int target_unregister_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
int target_register_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
int target_halt(struct target *target)
int target_get_gdb_reg_list_noread(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Obtain the registers for GDB, but don't read register values from the target.
bool target_supports_gdb_connection(const struct target *target)
Check if target allows GDB connections.
int target_call_timer_callbacks_now(void)
Invoke this to ensure that e.g.
int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t *crc)
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
target_addr_t target_address_max(struct target *target)
Return the highest accessible address for this target.
int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
Pass GDB file-I/O response to target after finishing host syscall.
int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
int target_get_gdb_reg_list(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Obtain the registers for GDB.
const char * target_debug_reason_str(enum target_debug_reason reason)
const char * target_state_name(const struct target *t)
Return the name of this targets current state.
int target_poll(struct target *target)
int target_resume(struct target *target, bool current, target_addr_t address, bool handle_breakpoints, bool debug_execution)
Make the target (re)start executing using its saved execution context (possibly with some modificatio...
const char * target_get_gdb_arch(const struct target *target)
Obtain the architecture for GDB.
int target_step(struct target *target, bool current, target_addr_t address, bool handle_breakpoints)
Step the target.
struct target * get_current_target(struct command_context *cmd_ctx)
const char * target_type_name(const struct target *target)
Get the target type name.
#define ERROR_TARGET_NOT_HALTED
static bool target_was_examined(const struct target *target)
@ TARGET_EVENT_GDB_FLASH_WRITE_END
@ TARGET_EVENT_GDB_FLASH_ERASE_START
@ TARGET_EVENT_GDB_FLASH_WRITE_START
@ TARGET_EVENT_GDB_ATTACH
@ TARGET_EVENT_GDB_FLASH_ERASE_END
@ TARGET_EVENT_GDB_DETACH
static const char * target_name(const struct target *target)
Returns the instance-specific name of the specified target.
#define ERROR_TARGET_NOT_EXAMINED
#define ERROR_TARGET_RESOURCE_NOT_AVAILABLE
int delete_debug_msg_receiver(struct command_context *cmd_ctx, struct target *target)
#define DIV_ROUND_UP(m, n)
Rounds m up to the nearest multiple of n using division.