101 #define _DEBUG_GDB_IO_
114 const char *
function,
const char *
string);
162 LOG_USER(
"undefined debug reason %d - target needs reset",
169 int timeout_s,
int *got_data)
210 #ifdef _DEBUG_GDB_IO_
228 LOG_DEBUG(
"GDB connection closed by the remote client");
234 errno = WSAGetLastError();
240 case WSAECONNABORTED:
269 #ifdef _DEBUG_GDB_IO_
271 LOG_DEBUG(
"received '%s'", debug_buffer);
277 *next_char = *(gdb_con->
buf_p++);
282 #ifdef _DEBUG_GDB_IO_
283 LOG_DEBUG(
"returned char '%c' (0x%2.2x)", *next_char, *next_char);
301 *next_char = **
buf_p;
308 #ifdef _DEBUG_GDB_IO_
309 LOG_DEBUG(
"returned char '%c' (0x%2.2x)", *next_char, *next_char);
336 *(--gdb_con->
buf_p) = last_char;
339 LOG_ERROR(
"BUG: couldn't put character back");
351 LOG_DEBUG(
"GDB socket marked as closed, cannot write to it.");
358 LOG_WARNING(
"Error writing to GDB socket. Dropping the connection.");
371 const unsigned packet_len = strlen(packet);
376 const char *colon = memchr(packet,
':',
MIN(50, packet_len));
377 const bool packet_has_prefix = (colon);
378 const bool packet_prefix_printable = (packet_has_prefix && nonprint > colon);
380 if (packet_prefix_printable) {
381 const unsigned int prefix_len = colon - packet + 1;
382 const unsigned int payload_len = packet_len - prefix_len;
384 packet, payload_len);
395 unsigned int packet_len,
unsigned char checksum)
404 packet_len, checksum);
414 unsigned char my_checksum = 0;
419 for (i = 0; i < len; i++)
422 #ifdef _DEBUG_GDB_IO_
441 LOG_DEBUG(
"Unexpected start of new packet");
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 == 0x3) {
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");
805 stop_reason[0] =
'\0';
812 switch (hit_wp_type) {
814 snprintf(stop_reason,
sizeof(stop_reason),
818 snprintf(stop_reason,
sizeof(stop_reason),
822 snprintf(stop_reason,
sizeof(stop_reason),
836 sig_reply_len = snprintf(sig_reply,
sizeof(sig_reply),
"T%2.2x%s%s",
849 char fileio_command[256];
851 bool program_exited =
false;
910 program_exited =
true;
921 command_len = strlen(fileio_command);
924 if (program_exited) {
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'.");
1070 __FILE__, __LINE__, __func__,
1071 "New GDB Connection: %d, Target %s, state: %s",
1077 LOG_ERROR(
"Target %s not examined yet, refuse gdb connection %d!",
1084 LOG_WARNING(
"GDB connection %d on target %s not halted",
1112 LOG_DEBUG(
"GDB Close, Target: %s, state: %s, gdb_actual_connections=%d",
1142 snprintf(err, 4,
"E%2.2X", the_error);
1147 char const *packet,
int packet_size)
1163 snprintf(sig_reply, 4,
"S%2.2x", signal_var);
1174 return len - 1 - pos;
1187 char *tstr,
struct reg *
reg)
1196 for (i = 0; i < buf_len; i++) {
1198 tstr += sprintf(tstr,
"%02x", buf[j]);
1204 char const *tstr,
int str_len, uint8_t *bin)
1207 LOG_ERROR(
"BUG: gdb value with uneven number of characters encountered");
1212 for (i = 0; i < str_len; i += 2) {
1214 if (sscanf(tstr + i,
"%02x", &t) != 1) {
1215 LOG_ERROR(
"BUG: unable to convert register value");
1225 char const *packet,
int packet_size)
1228 struct reg **reg_list;
1231 int reg_packet_size = 0;
1236 #ifdef _DEBUG_GDB_IO_
1248 for (i = 0; i < reg_list_size; i++) {
1249 if (!reg_list[i] || reg_list[i]->
exist ==
false || reg_list[i]->
hidden)
1254 assert(reg_packet_size > 0);
1256 reg_packet = malloc(reg_packet_size + 1);
1260 reg_packet_p = reg_packet;
1262 for (i = 0; i < reg_list_size; i++) {
1263 if (!reg_list[i] || reg_list[i]->
exist ==
false || reg_list[i]->
hidden)
1265 if (!reg_list[i]->
valid) {
1266 retval = reg_list[i]->
type->
get(reg_list[i]);
1278 #ifdef _DEBUG_GDB_IO_
1280 char *reg_packet_p_debug;
1281 reg_packet_p_debug =
strndup(reg_packet, reg_packet_size);
1282 LOG_DEBUG(
"reg_packet: %s", reg_packet_p_debug);
1283 free(reg_packet_p_debug);
1296 char const *packet,
int packet_size)
1300 struct reg **reg_list;
1303 char const *packet_p;
1305 #ifdef _DEBUG_GDB_IO_
1313 if (packet_size % 2) {
1314 LOG_WARNING(
"GDB set_registers packet with uneven characters received, dropping connection");
1324 for (i = 0; i < reg_list_size; i++) {
1326 if (!reg_list[i] || !reg_list[i]->
exist || reg_list[i]->
hidden)
1330 if (packet_p + chars > packet + packet_size)
1331 LOG_ERROR(
"BUG: register packet is too small for registers");
1336 retval = reg_list[i]->
type->
set(reg_list[i], bin_buf);
1359 char const *packet,
int packet_size)
1363 int reg_num = strtoul(packet + 1,
NULL, 16);
1364 struct reg **reg_list;
1368 #ifdef _DEBUG_GDB_IO_
1380 if ((reg_list_size <= reg_num) || !reg_list[reg_num] ||
1381 !reg_list[reg_num]->
exist || reg_list[reg_num]->
hidden) {
1382 LOG_ERROR(
"gdb requested a non-existing register (reg_num=%d)", reg_num);
1386 if (!reg_list[reg_num]->
valid) {
1387 retval = reg_list[reg_num]->
type->
get(reg_list[reg_num]);
1389 LOG_DEBUG(
"Couldn't get register %s.", reg_list[reg_num]->
name);
1408 char const *packet,
int packet_size)
1412 int reg_num = strtoul(packet + 1, &separator, 16);
1413 struct reg **reg_list;
1417 #ifdef _DEBUG_GDB_IO_
1421 if (*separator !=
'=') {
1422 LOG_ERROR(
"GDB 'set register packet', but no '=' following the register number");
1425 size_t chars = strlen(separator + 1);
1426 uint8_t *bin_buf = malloc(chars / 2);
1443 if ((reg_list_size <= reg_num) || !reg_list[reg_num] ||
1444 !reg_list[reg_num]->
exist || reg_list[reg_num]->
hidden) {
1445 LOG_ERROR(
"gdb requested a non-existing register (reg_num=%d)", reg_num);
1452 LOG_ERROR(
"gdb sent %zu bits for a %" PRIu32
"-bit register (%s)",
1453 chars * 4, reg_list[reg_num]->
size, reg_list[reg_num]->
name);
1461 retval = reg_list[reg_num]->
type->
set(reg_list[reg_num], bin_buf);
1463 LOG_DEBUG(
"Couldn't set register %s.", reg_list[reg_num]->
name);
1483 LOG_DEBUG(
"Reporting %i to GDB as generic error", retval);
1492 char const *packet,
int packet_size)
1507 addr = strtoull(packet, &separator, 16);
1509 if (*separator !=
',') {
1510 LOG_ERROR(
"incomplete read memory packet received, dropping connection");
1514 len = strtoul(separator + 1,
NULL, 16);
1517 LOG_WARNING(
"invalid read memory packet received (len == 0)");
1524 LOG_DEBUG(
"addr: 0x%16.16" PRIx64
", len: 0x%8.8" PRIx32
"",
addr, len);
1551 hex_buffer = malloc(len * 2 + 1);
1553 size_t pkt_len =
hexify(hex_buffer,
buffer, len, len * 2 + 1);
1567 char const *packet,
int packet_size)
1580 addr = strtoull(packet, &separator, 16);
1582 if (*separator !=
',') {
1583 LOG_ERROR(
"incomplete write memory packet received, dropping connection");
1587 len = strtoul(separator + 1, &separator, 16);
1589 if (*(separator++) !=
':') {
1590 LOG_ERROR(
"incomplete write memory packet received, dropping connection");
1596 LOG_DEBUG(
"addr: 0x%" PRIx64
", len: 0x%8.8" PRIx32
"",
addr, len);
1599 LOG_ERROR(
"unable to decode memory packet");
1618 char const *packet,
int packet_size)
1629 uint32_t fast_limit = 8;
1634 addr = strtoull(packet, &separator, 16);
1636 if (*separator !=
',') {
1637 LOG_ERROR(
"incomplete write memory binary packet received, dropping connection");
1641 len = strtoul(separator + 1, &separator, 16);
1643 if (*(separator++) !=
':') {
1644 LOG_ERROR(
"incomplete write memory binary packet received, dropping connection");
1654 if (len >= fast_limit) {
1672 LOG_DEBUG(
"addr: 0x%" PRIx64
", len: 0x%8.8" PRIx32
"",
addr, len);
1684 if (len < fast_limit) {
1697 char const *packet,
int packet_size)
1701 uint64_t address = 0x0;
1706 if (packet_size > 1)
1707 address = strtoull(packet + 1,
NULL, 16);
1712 if (packet[0] ==
'c') {
1716 }
else if (packet[0] ==
's') {
1725 char const *packet,
int packet_size)
1738 type = strtoul(packet + 1, &separator, 16);
1751 LOG_ERROR(
"invalid gdb watch/breakpoint type(%d), dropping connection",
type);
1758 if (*separator !=
',') {
1759 LOG_ERROR(
"incomplete breakpoint/watchpoint packet received, dropping connection");
1763 address = strtoull(separator + 1, &separator, 16);
1765 if (*separator !=
',') {
1766 LOG_ERROR(
"incomplete breakpoint/watchpoint packet received, dropping connection");
1770 size = strtoul(separator + 1, &separator, 16);
1775 if (packet[0] ==
'Z') {
1795 if (packet[0] ==
'Z') {
1823 char **xml,
int *pos,
int *
size, const
char *fmt, ...)
1830 if ((!*xml) || (!first)) {
1836 *xml = realloc(*xml, *
size);
1847 ret = vsnprintf(*xml + *pos, *
size - *pos, fmt, ap);
1849 if ((ret > 0) && ((ret + 1) < *
size - *pos)) {
1861 const char *annex_end = strchr(buf,
':');
1868 *ofs = strtoul(annex_end + 1, &separator, 16);
1870 if (*separator !=
',')
1873 *len = strtoul(separator + 1,
NULL, 16);
1877 *annex =
strndup(buf, annex_end - buf);
1900 char const *packet,
int packet_size)
1920 unsigned int target_flash_banks = 0;
1925 offset = strtoul(packet, &separator, 16);
1926 length = strtoul(separator + 1, &separator, 16);
1928 xml_printf(&retval, &xml, &pos, &
size,
"<memory-map>\n");
1946 banks[target_flash_banks++] = p;
1949 qsort(banks, target_flash_banks,
sizeof(
struct flash_bank *),
1952 for (
unsigned int i = 0; i < target_flash_banks; i++) {
1954 unsigned group_len = 0;
1958 if (ram_start < p->
base)
1959 xml_printf(&retval, &xml, &pos, &
size,
1962 ram_start, p->
base - ram_start);
1970 for (
unsigned int j = 0; j < p->
num_sectors; j++) {
1975 LOG_WARNING(
"The flash sector at offset 0x%08" PRIx32
1976 " overflows the end of %s bank.",
1978 LOG_WARNING(
"The rest of bank will not show in gdb memory map.");
1983 xml_printf(&retval, &xml, &pos, &
size,
1984 "<memory type=\"flash\" "
2002 xml_printf(&retval, &xml, &pos, &
size,
2003 "length=\"0x%x\">\n"
2004 "<property name=\"blocksize\">"
2016 xml_printf(&retval, &xml, &pos, &
size,
2025 xml_printf(&retval, &xml, &pos, &
size,
"</memory-map>\n");
2036 char *t = malloc(
length + 1);
2082 return "ieee_single";
2084 return "ieee_double";
2093 int *num_arch_defined_types)
2095 int tbl_sz = *num_arch_defined_types;
2097 if (type_id && (strcmp(type_id,
""))) {
2098 for (
int j = 0; j < (tbl_sz + 1); j++) {
2099 if (!((*arch_defined_types_list)[j])) {
2100 (*arch_defined_types_list)[tbl_sz++] = type_id;
2101 *arch_defined_types_list = realloc(*arch_defined_types_list,
2102 sizeof(
char *) * (tbl_sz + 1));
2103 (*arch_defined_types_list)[tbl_sz] =
NULL;
2104 *num_arch_defined_types = tbl_sz;
2107 if (!strcmp((*arch_defined_types_list)[j], type_id))
2118 char const **arch_defined_types_list[],
int *num_arch_defined_types)
2126 num_arch_defined_types))
2128 arch_defined_types_list,
2129 num_arch_defined_types);
2132 xml_printf(&retval, tdesc, pos,
size,
2133 "<vector id=\"%s\" type=\"%s\" count=\"%" PRIu32
"\"/>\n",
2134 type->id,
type->reg_type_vector->type->id,
2135 type->reg_type_vector->count);
2139 field =
type->reg_type_union->fields;
2144 num_arch_defined_types))
2146 arch_defined_types_list,
2147 num_arch_defined_types);
2150 field = field->
next;
2155 xml_printf(&retval, tdesc, pos,
size,
2156 "<union id=\"%s\">\n",
2159 field =
type->reg_type_union->fields;
2161 xml_printf(&retval, tdesc, pos,
size,
2162 "<field name=\"%s\" type=\"%s\"/>\n",
2165 field = field->
next;
2168 xml_printf(&retval, tdesc, pos,
size,
2173 field =
type->reg_type_struct->fields;
2179 xml_printf(&retval, tdesc, pos,
size,
2180 "<struct id=\"%s\" size=\"%" PRIu32
"\">\n",
2181 type->id,
type->reg_type_struct->size);
2183 xml_printf(&retval, tdesc, pos,
size,
2184 "<field name=\"%s\" start=\"%" PRIu32
"\" end=\"%" PRIu32
"\" type=\"%s\" />\n",
2188 field = field->
next;
2195 num_arch_defined_types))
2197 arch_defined_types_list,
2198 num_arch_defined_types);
2205 xml_printf(&retval, tdesc, pos,
size,
2206 "<struct id=\"%s\">\n",
2209 xml_printf(&retval, tdesc, pos,
size,
2210 "<field name=\"%s\" type=\"%s\"/>\n",
2213 field = field->
next;
2217 xml_printf(&retval, tdesc, pos,
size,
2224 xml_printf(&retval, tdesc, pos,
size,
2225 "<flags id=\"%s\" size=\"%" PRIu32
"\">\n",
2226 type->id,
type->reg_type_flags->size);
2229 field =
type->reg_type_flags->fields;
2231 xml_printf(&retval, tdesc, pos,
size,
2232 "<field name=\"%s\" start=\"%" PRIu32
"\" end=\"%" PRIu32
"\" type=\"%s\" />\n",
2236 field = field->
next;
2239 xml_printf(&retval, tdesc, pos,
size,
2251 struct reg **reg_list,
int reg_list_size)
2256 *feature_list = calloc(1,
sizeof(
char *));
2258 for (
int i = 0; i < reg_list_size; i++) {
2259 if (reg_list[i]->exist ==
false || reg_list[i]->hidden)
2264 && (strcmp(reg_list[i]->
feature->name,
""))) {
2269 for (
int j = 0; j < (tbl_sz + 1); j++) {
2270 if (!((*feature_list)[j])) {
2271 (*feature_list)[tbl_sz++] = reg_list[i]->
feature->
name;
2272 *feature_list = realloc(*feature_list,
sizeof(
char *) * (tbl_sz + 1));
2273 (*feature_list)[tbl_sz] =
NULL;
2276 if (!strcmp((*feature_list)[j], reg_list[i]->
feature->name))
2283 if (feature_list_size)
2284 *feature_list_size = tbl_sz;
2294 struct reg **combined_list[],
int *combined_list_size,
2301 unsigned int combined_allocated = 256;
2302 struct reg **local_list = malloc(combined_allocated *
sizeof(
struct reg *));
2304 LOG_ERROR(
"malloc(%zu) failed", combined_allocated *
sizeof(
struct reg *));
2307 unsigned int local_list_size = 0;
2317 ®_list_size, reg_class);
2322 for (
int i = 0; i < reg_list_size; i++) {
2324 struct reg *a = reg_list[i];
2329 for (
unsigned int j = 0; j < local_list_size; j++) {
2330 struct reg *b = local_list[j];
2334 LOG_ERROR(
"SMP register %s is %d bits on one "
2335 "target, but %d bits on another target.",
2346 if (local_list_size >= combined_allocated) {
2347 combined_allocated *= 2;
2348 local_list = realloc(local_list, combined_allocated *
sizeof(
struct reg *));
2350 LOG_ERROR(
"realloc(%zu) failed", combined_allocated *
sizeof(
struct reg *));
2354 local_list[local_list_size] = a;
2362 if (local_list_size == 0) {
2363 LOG_ERROR(
"Unable to get register list");
2376 ®_list_size, reg_class);
2381 for (
unsigned int i = 0; i < local_list_size; i++) {
2383 struct reg *a = local_list[i];
2384 for (
int j = 0; j < reg_list_size; j++) {
2385 struct reg *b = reg_list[j];
2392 LOG_WARNING(
"Register %s does not exist in %s, which is part of an SMP group where "
2393 "this register does exist.",
2400 *combined_list = local_list;
2401 *combined_list_size = local_list_size;
2410 char const *architecture;
2411 char const **features =
NULL;
2412 int feature_list_size = 0;
2427 if (reg_list_size <= 0) {
2436 LOG_ERROR(
"Can't get the registers feature list");
2442 int current_feature = 0;
2444 xml_printf(&retval, &tdesc, &pos, &
size,
2445 "<?xml version=\"1.0\"?>\n"
2446 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">\n"
2447 "<target version=\"1.0\">\n");
2452 xml_printf(&retval, &tdesc, &pos, &
size,
2453 "<architecture>%s</architecture>\n", architecture);
2457 while (features[current_feature]) {
2458 char const **arch_defined_types =
NULL;
2459 int num_arch_defined_types = 0;
2461 arch_defined_types = calloc(1,
sizeof(
char *));
2462 xml_printf(&retval, &tdesc, &pos, &
size,
2463 "<feature name=\"%s\">\n",
2464 features[current_feature]);
2467 for (i = 0; i < reg_list_size; i++) {
2469 if (reg_list[i]->
exist ==
false || reg_list[i]->
hidden)
2472 if (strcmp(reg_list[i]->
feature->name, features[current_feature]))
2475 const char *type_str;
2481 &num_arch_defined_types))
2484 &arch_defined_types,
2485 &num_arch_defined_types);
2498 xml_printf(&retval, &tdesc, &pos, &
size,
2499 "<reg name=\"%s\"", reg_list[i]->
name);
2500 xml_printf(&retval, &tdesc, &pos, &
size,
2501 " bitsize=\"%" PRIu32
"\"", reg_list[i]->
size);
2502 xml_printf(&retval, &tdesc, &pos, &
size,
2503 " regnum=\"%" PRIu32
"\"", reg_list[i]->
number);
2505 xml_printf(&retval, &tdesc, &pos, &
size,
2506 " save-restore=\"yes\"");
2508 xml_printf(&retval, &tdesc, &pos, &
size,
2509 " save-restore=\"no\"");
2511 xml_printf(&retval, &tdesc, &pos, &
size,
2512 " type=\"%s\"", type_str);
2514 if (reg_list[i]->
group)
2515 xml_printf(&retval, &tdesc, &pos, &
size,
2516 " group=\"%s\"", reg_list[i]->
group);
2518 xml_printf(&retval, &tdesc, &pos, &
size,
2522 xml_printf(&retval, &tdesc, &pos, &
size,
2526 free(arch_defined_types);
2530 xml_printf(&retval, &tdesc, &pos, &
size,
2549 LOG_ERROR(
"Unable to Generate Target Description");
2553 char *tdesc = target_desc->
tdesc;
2559 LOG_ERROR(
"Unable to Generate Target Description");
2563 tdesc_length = strlen(tdesc);
2569 transfer_type =
'm';
2571 transfer_type =
'l';
2573 *chunk = malloc(
length + 2);
2579 (*chunk)[0] = transfer_type;
2580 if (transfer_type ==
'm') {
2582 (*chunk)[1 +
length] =
'\0';
2584 strncpy((*chunk) + 1, tdesc +
offset, tdesc_length -
offset);
2585 (*chunk)[1 + (tdesc_length -
offset)] =
'\0';
2593 target_desc->
tdesc = tdesc;
2603 int reg_list_size = 0;
2604 char const **features =
NULL;
2605 int feature_list_size = 0;
2616 if (reg_list_size <= 0) {
2625 LOG_ERROR(
"Can't get the registers feature list");
2630 if (architecture || feature_list_size)
2648 char *thread_list =
NULL;
2652 xml_printf(&retval, &thread_list, &pos, &
size,
2653 "<?xml version=\"1.0\"?>\n"
2664 xml_printf(&retval, &thread_list, &pos, &
size,
2665 "<thread id=\"%" PRIx64
"\" name=\"%s\">",
2669 xml_printf(&retval, &thread_list, &pos, &
size,
2673 xml_printf(&retval, &thread_list, &pos, &
size,
2678 xml_printf(&retval, &thread_list, &pos, &
size,
2680 xml_printf(&retval, &thread_list, &pos, &
size,
2684 xml_printf(&retval, &thread_list, &pos, &
size,
2689 xml_printf(&retval, &thread_list, &pos, &
size,
2693 *thread_list_out = thread_list;
2703 if (!*thread_list) {
2706 LOG_ERROR(
"Unable to Generate Thread List");
2711 size_t thread_list_length = strlen(*thread_list);
2716 transfer_type =
'm';
2718 transfer_type =
'l';
2720 *chunk = malloc(
length + 2 + 3);
2730 (*chunk)[0] = transfer_type;
2731 strncpy((*chunk) + 1, (*thread_list) +
offset,
length);
2732 (*chunk)[1 +
length] =
'\0';
2735 if (transfer_type ==
'l') {
2737 *thread_list =
NULL;
2744 char const *packet,
int packet_size)
2750 if (strncmp(packet,
"qRcmd,", 6) == 0) {
2751 if (packet_size > 6) {
2752 Jim_Interp *interp = cmd_ctx->
interp;
2754 cmd = malloc((packet_size - 6) / 2 + 1);
2755 size_t len =
unhexify((uint8_t *)
cmd, packet + 6, (packet_size - 6) / 2);
2769 Jim_DeleteAssocData(
interp,
"context");
2770 int retval = Jim_SetAssocData(
interp,
"context",
NULL, cmd_ctx);
2771 if (retval == JIM_OK) {
2773 Jim_DeleteAssocData(
interp,
"context");
2775 int inner_retval = Jim_SetAssocData(
interp,
"context",
NULL, old_context);
2776 if (retval == JIM_OK)
2777 retval = inner_retval;
2785 if (retval == JIM_RETURN)
2786 retval =
interp->returnCode;
2788 const char *cretmsg = Jim_GetString(Jim_GetResult(
interp), &lenmsg);
2790 if (lenmsg && cretmsg[lenmsg - 1] !=
'\n') {
2794 retmsg = strdup(cretmsg);
2799 if (retval == JIM_OK) {
2801 char *hex_buffer = malloc(lenmsg * 2 + 1);
2807 size_t pkt_len =
hexify(hex_buffer, (
const uint8_t *)retmsg, lenmsg,
2824 }
else if (strncmp(packet,
"qCRC:", 5) == 0) {
2825 if (packet_size > 5) {
2836 addr = strtoull(packet, &separator, 16);
2838 if (*separator !=
',') {
2839 LOG_ERROR(
"incomplete read memory packet received, dropping connection");
2843 len = strtoul(separator + 1,
NULL, 16);
2848 snprintf(gdb_reply, 10,
"C%8.8" PRIx32
"", checksum);
2858 }
else if (strncmp(packet,
"qSupported", 10) == 0) {
2865 int gdb_target_desc_supported = 0;
2870 LOG_INFO(
"Failed detecting Target Description Support, disabling");
2871 gdb_target_desc_supported = 0;
2876 if (gdb_target_desc_supported)
2877 LOG_WARNING(
"Target Descriptions Supported, but disabled");
2878 gdb_target_desc_supported = 0;
2885 "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read%c;qXfer:threads:read+;QStartNoAckMode+;vContSupported+",
2888 (gdb_target_desc_supported == 1) ?
'+' :
'-');
2899 }
else if ((strncmp(packet,
"qXfer:memory-map:read::", 23) == 0)
2902 else if (strncmp(packet,
"qXfer:features:read:", 20) == 0) {
2933 }
else if (strncmp(packet,
"qXfer:threads:read:", 19) == 0) {
2964 }
else if (strncmp(packet,
"QStartNoAckMode", 15) == 0) {
2983 const char *parse = packet;
2987 if (parse[0] ==
'?') {
2996 if (parse[0] ==
';') {
3002 if (parse[0] ==
'c') {
3029 if (parse[0] ==
's') {
3031 bool fake_step =
false;
3038 if (parse[0] ==
':') {
3042 thread_id = strtoll(parse, &endp, 16);
3044 packet_size -= endp - parse;
3065 if (parse[0] ==
';') {
3069 if (parse[0] ==
'c') {
3073 if (parse[0] ==
':') {
3077 tid = strtoll(parse,
NULL, 16);
3078 if (tid == thread_id) {
3088 LOG_DEBUG(
"request to step current core only");
3110 char sig_reply[128];
3112 LOG_DEBUG(
"fake step thread %"PRIx64, thread_id);
3114 sig_reply_len = snprintf(sig_reply,
sizeof(sig_reply),
3115 "T05thread:%016"PRIx64
";", thread_id);
3127 LOG_DEBUG(
"stepi ignored. GDB will now fetch the register state "
3128 "from the target.");
3160 const char *hex = *str;
3164 const char *end = strchr(hex, sep);
3166 hexlen = strlen(hex);
3169 *str = hex + hexlen + 1;
3171 if (hexlen % 2 != 0) {
3176 size_t count = hexlen / 2;
3177 char *decoded = malloc(
count + 1);
3182 if (converted !=
count) {
3187 decoded[
count] =
'\0';
3210 const char *parse = packet;
3215 if (parse[0] !=
';')
3227 char *new_cmdline =
alloc_printf(
"%s %s", cmdline, arg);
3230 cmdline = new_cmdline;
3235 LOG_INFO(
"GDB set inferior command line to '%s'", cmdline);
3239 LOG_INFO(
"GDB set inferior command line to '%s' but semihosting is unavailable", cmdline);
3250 char const *packet,
int packet_size)
3257 if (strncmp(packet,
"vCont", 5) == 0) {
3270 if (strncmp(packet,
"vRun", 4) == 0) {
3287 if (strncmp(packet,
"vFlashErase:", 12) == 0) {
3291 char const *parse = packet + 12;
3292 if (*parse ==
'\0') {
3293 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3297 addr = strtoul(parse, (
char **)&parse, 16);
3299 if (*(parse++) !=
',' || *parse ==
'\0') {
3300 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3304 length = strtoul(parse, (
char **)&parse, 16);
3306 if (*parse !=
'\0') {
3307 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3336 LOG_ERROR(
"flash_erase returned %i", result);
3343 if (strncmp(packet,
"vFlashWrite:", 12) == 0) {
3347 char const *parse = packet + 12;
3349 if (*parse ==
'\0') {
3350 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3353 addr = strtoul(parse, (
char **)&parse, 16);
3354 if (*(parse++) !=
':') {
3355 LOG_ERROR(
"incomplete vFlashErase packet received, dropping connection");
3358 length = packet_size - (parse - packet);
3377 if (strncmp(packet,
"vFlashDone", 10) == 0) {
3394 LOG_DEBUG(
"wrote %u bytes from vFlash image to flash", (
unsigned)written);
3424 char const *packet,
int packet_size)
3428 char *parsing_point;
3429 int fileio_retcode = strtoul(packet + 1, &separator, 16);
3430 int fileio_errno = 0;
3431 bool fileio_ctrl_c =
false;
3436 if (*separator ==
',') {
3437 parsing_point = separator + 1;
3438 fileio_errno = strtoul(parsing_point, &separator, 16);
3439 if (*separator ==
',') {
3440 if (*(separator + 1) ==
'C') {
3442 fileio_ctrl_c =
true;
3447 LOG_DEBUG(
"File-I/O response, retcode: 0x%x, errno: 0x%x, ctrl-c: %s",
3448 fileio_retcode, fileio_errno, fileio_ctrl_c ?
"true" :
"false");
3469 const char *
function,
const char *
string)
3478 if (gdb_con->
busy) {
3489 snprintf(sig_reply, 4,
"T%2.2x", 2);
3499 char const *packet = gdb_packet_buffer;
3503 static bool warn_use_ext;
3525 gdb_packet_buffer[packet_size] =
'\0';
3527 if (packet_size > 0) {
3532 switch (packet[0]) {
3572 warn_use_ext =
true;
3573 LOG_WARNING(
"Prefer GDB command \"target extended-remote :%s\" instead of \"target remote :%s\"",
3591 bool nostep =
false;
3592 bool already_running =
false;
3594 LOG_WARNING(
"WARNING! The target is already running. "
3595 "All changes GDB did to registers will be discarded! "
3596 "Waiting for target to halt.");
3597 already_running =
true;
3599 LOG_WARNING(
"The target is not in the halted nor running stated, "
3600 "stepi/continue ignored.");
3602 }
else if ((packet[0] ==
's') && gdb_con->
sync) {
3608 LOG_DEBUG(
"stepi ignored. GDB will now fetch the register state "
3609 "from the target.");
3611 gdb_con->
sync =
false;
3613 if (!already_running && nostep) {
3632 if (!already_running) {
3704 LOG_DEBUG(
"ignoring 0x%2.2x packet", packet[0]);
3726 LOG_INFO(
"The target is not running when halt was requested, stopping GDB.");
3731 }
while (gdb_con->
buf_cnt > 0);
3755 if (gdb_con->
busy) {
3775 .new_connection_during_keep_alive_handler =
NULL,
3831 if (strcmp(
gdb_port,
"disabled") == 0) {
3868 LOG_WARNING(
"gdb services need one or more targets defined");
3890 "gdb_sync command can only be run from within gdb using \"monitor gdb_sync\"");
3953 if (strcmp(
CMD_ARGV[0],
"hard") == 0)
3955 else if (strcmp(
CMD_ARGV[0],
"soft") == 0)
3957 else if (strcmp(
CMD_ARGV[0],
"disable") == 0)
3965 LOG_USER(
"breakpoint type is not overridden");
3982 uint32_t tdesc_length;
3987 LOG_ERROR(
"Unable to Generate Target Description");
3991 tdesc_length = strlen(tdesc);
3994 size_t size_written;
3997 if (!tdesc_filename) {
4005 LOG_ERROR(
"Can't open %s for writing", tdesc_filename);
4014 LOG_ERROR(
"Error while writing the tdesc file");
4017 free(tdesc_filename);
4026 .handler = handle_gdb_sync_command,
4028 .help =
"next stepi will return immediately allowing "
4029 "GDB to fetch register state without affecting "
4035 .handler = handle_gdb_port_command,
4037 .help =
"Normally gdb listens to a TCP/IP port. Each subsequent GDB "
4038 "server listens for the next port number after the "
4039 "base port number specified. "
4040 "No arguments reports GDB port. \"pipe\" means listen to stdin "
4041 "output to stdout, an integer is base port number, \"disabled\" disables "
4042 "port. Any other string is are interpreted as named pipe to listen to. "
4043 "Output pipe is the same name as input pipe, but with 'o' appended.",
4044 .usage =
"[port_num]",
4047 .name =
"gdb_memory_map",
4048 .handler = handle_gdb_memory_map_command,
4050 .help =
"enable or disable memory map",
4051 .usage =
"('enable'|'disable')"
4054 .name =
"gdb_flash_program",
4055 .handler = handle_gdb_flash_program_command,
4057 .help =
"enable or disable flash program",
4058 .usage =
"('enable'|'disable')"
4061 .name =
"gdb_report_data_abort",
4062 .handler = handle_gdb_report_data_abort_command,
4064 .help =
"enable or disable reporting data aborts",
4065 .usage =
"('enable'|'disable')"
4068 .name =
"gdb_report_register_access_error",
4069 .handler = handle_gdb_report_register_access_error,
4071 .help =
"enable or disable reporting register access errors",
4072 .usage =
"('enable'|'disable')"
4075 .name =
"gdb_breakpoint_override",
4076 .handler = handle_gdb_breakpoint_override_command,
4078 .help =
"Display or specify type of breakpoint "
4079 "to be used by gdb 'break' commands.",
4080 .usage =
"('hard'|'soft'|'disable')"
4083 .name =
"gdb_target_description",
4084 .handler = handle_gdb_target_description_command,
4086 .help =
"enable or disable target description",
4087 .usage =
"('enable'|'disable')"
4090 .name =
"gdb_save_tdesc",
4091 .handler = handle_gdb_save_tdesc_command,
4093 .help =
"Save the target description file",
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.
void watchpoint_clear_target(struct target *target)
void breakpoint_clear_target(struct target *target)
int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, target_addr_t *address)
void watchpoint_remove(struct target *target, target_addr_t address)
void breakpoint_remove(struct target *target, target_addr_t address)
int breakpoint_add(struct target *target, target_addr_t address, uint32_t length, enum breakpoint_type type)
int watchpoint_add(struct target *target, target_addr_t address, uint32_t length, enum watchpoint_rw rw, uint32_t value, uint32_t 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,...
enum esirisc_reg_num number
static struct esp_usb_jtag * priv
static const int sector_size
#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_target_description_supported(struct target *target, int *supported)
static int gdb_output_con(struct connection *connection, const char *line)
static int gdb_v_packet(struct connection *connection, char const *packet, int packet_size)
static const struct service_driver gdb_service_driver
static int gdb_input_inner(struct connection *connection)
static int gdb_put_packet_inner(struct connection *connection, char *buffer, int len)
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 void gdb_log_incoming_packet(struct connection *connection, char *packet)
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 void gdb_log_outgoing_packet(struct connection *connection, char *packet_buf, unsigned int packet_len, unsigned char checksum)
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_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 bool gdb_handle_vcont_packet(struct connection *connection, const char *packet, int packet_size)
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)
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)
static int gdb_flash_program
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 void gdb_log_callback(void *priv, const char *file, unsigned line, const char *function, const char *string)
static int gdb_putback_char(struct connection *connection, int last_char)
static enum breakpoint_type gdb_breakpoint_override_type
static int gdb_write(struct connection *connection, void *data, int len)
static int gdb_write_memory_binary_packet(struct connection *connection, char const *packet, int packet_size)
static int gdb_use_memory_map
static int gdb_breakpoint_override
static int gdb_use_target_description
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_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 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 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 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)
int gdb_put_packet(struct connection *connection, char *buffer, int len)
static int gdb_set_register_packet(struct connection *connection, char const *packet, int packet_size)
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 line, const char *function, const char *format,...)
int log_add_callback(log_callback_fn fn, void *priv)
char * find_nonprint_char(char *buf, unsigned 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_USER(expr ...)
#define ERROR_NOT_IMPLEMENTED
#define LOG_WARNING(expr ...)
#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
size_t size
Size of the control block search area.
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
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
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, int current, target_addr_t address, int 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)
const char * target_state_name(struct target *t)
Return the name of this targets current state.
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.
const char * target_get_gdb_arch(struct target *target)
Obtain the architecture for GDB.
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_call_timer_callbacks_now()
Invoke this to ensure that e.g.
bool target_supports_gdb_connection(struct target *target)
Check if target allows GDB connections.
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.
int target_step(struct target *target, int current, target_addr_t address, int handle_breakpoints)
Step the target.
int target_poll(struct target *target)
struct target * get_current_target(struct command_context *cmd_ctx)
const char * target_type_name(struct target *target)
Get the target type name.
int target_resume(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
Make the target (re)start executing using its saved execution context (possibly with some modificatio...
#define ERROR_TARGET_NOT_HALTED
@ 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
#define ERROR_TARGET_NOT_EXAMINED
static const char * target_name(struct target *target)
Returns the instance-specific name of the specified target.
static bool target_was_examined(struct target *target)
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.