34#include "gdbsupport/filestuff.h"
67#define CTF_MAGIC 0xC1FC1FC1
68#define CTF_SAVE_MAJOR 1
69#define CTF_SAVE_MINOR 8
71#define CTF_METADATA_NAME "metadata"
72#define CTF_DATASTREAM_NAME "datastream"
76#define CTF_EVENT_ID_REGISTER 0
77#define CTF_EVENT_ID_TSV 1
78#define CTF_EVENT_ID_MEMORY 2
79#define CTF_EVENT_ID_FRAME 3
80#define CTF_EVENT_ID_STATUS 4
81#define CTF_EVENT_ID_TSV_DEF 5
82#define CTF_EVENT_ID_TP_DEF 6
106 const char *format, ...)
111 const
char *format, ...)
115 va_start (args, format);
116 if (vfprintf (handler->
metadata_fd, format, args) < 0)
117 error (_(
"Unable to write metadata file (%s)"),
118 safe_strerror (errno));
127 const gdb_byte *buf,
size_t size)
130 error (_(
"Unable to write file for saving trace data (%s)"),
131 safe_strerror (errno));
141#define ctf_save_write_uint32(HANDLER, U32) \
142 ctf_save_write (HANDLER, (gdb_byte *) &U32, 4)
147#define ctf_save_write_int32(HANDLER, INT32) \
148 ctf_save_write ((HANDLER), (gdb_byte *) &(INT32), 4)
157 gdb_assert (whence != SEEK_END);
159 || offset <= handler->content_size + handler->
packet_start);
162 error (_(
"Unable to seek file for saving trace data (%s)"),
163 safe_strerror (errno));
177 size_t size,
size_t align_size)
210 "typealias integer { size = 8; align = 8; "
211 "signed = false; encoding = ascii;}"
214 "typealias integer { size = 8; align = 8; "
218 "typealias integer { size = 16; align = 16;"
219 "signed = false; } := uint16_t;\n");
221 "typealias integer { size = 32; align = 32;"
222 "signed = false; } := uint32_t;\n");
224 "typealias integer { size = 64; align = 64;"
225 "signed = false; base = hex;}"
228 "typealias integer { size = 32; align = 32;"
229 "signed = true; } := int32_t;\n");
231 "typealias integer { size = 64; align = 64;"
232 "signed = true; } := int64_t;\n");
234 "typealias string { encoding = ascii;"
241#define HOST_ENDIANNESS "be"
243#define HOST_ENDIANNESS "le"
250 " byte_order = %s;\n"
251 " packet.header := struct {\n"
257 " packet.context := struct {\n"
258 " uint32_t content_size;\n"
259 " uint32_t packet_size;\n"
262 " event.header := struct {\n"
318 mode_t hmode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH;
321 if (mkdir (dirname, hmode) && errno != EEXIST)
322 error (_(
"Unable to open directory '%s' for saving trace data (%s)"),
323 dirname, safe_strerror (errno));
325 memset (&writer->
tcs,
'\0', sizeof (writer->
tcs));
330 = gdb_fopen_cloexec (file_name.c_str (),
"w").release ();
332 error (_(
"Unable to open file '%s' for saving trace data (%s)"),
333 file_name.c_str (), safe_strerror (errno));
339 = gdb_fopen_cloexec (file_name.c_str (),
"w").release ();
341 error (_(
"Unable to open file '%s' for saving trace data (%s)"),
342 file_name.c_str (), safe_strerror (errno));
358 "event {\n\tname = \"memory\";\n\tid = %u;\n"
359 "\tfields := struct { \n"
360 "\t\tuint64_t address;\n"
361 "\t\tuint16_t length;\n"
362 "\t\tuint8_t contents[length];\n"
368 "event {\n\tname = \"tsv\";\n\tid = %u;\n"
369 "\tfields := struct { \n"
370 "\t\tuint64_t val;\n"
371 "\t\tuint32_t num;\n"
377 "event {\n\tname = \"frame\";\n\tid = %u;\n"
378 "\tfields := struct { \n"
384 "event {\n\tname = \"tsv_def\";\n"
385 "\tid = %u;\n\tfields := struct { \n"
386 "\t\tint64_t initial_value;\n"
387 "\t\tint32_t number;\n"
388 "\t\tint32_t builtin;\n"
395 "event {\n\tname = \"tp_def\";\n"
396 "\tid = %u;\n\tfields := struct { \n"
397 "\t\tuint64_t addr;\n"
398 "\t\tuint64_t traceframe_usage;\n"
399 "\t\tint32_t number;\n"
400 "\t\tint32_t enabled;\n"
401 "\t\tint32_t step;\n"
402 "\t\tint32_t pass;\n"
403 "\t\tint32_t hit_count;\n"
404 "\t\tint32_t type;\n"
407 "\t\tuint32_t action_num;\n"
408 "\t\tchars actions[action_num];\n"
410 "\t\tuint32_t step_action_num;\n"
411 "\t\tchars step_actions[step_action_num];\n"
413 "\t\tchars at_string;\n"
414 "\t\tchars cond_string;\n"
416 "\t\tuint32_t cmd_num;\n"
417 "\t\tchars cmd_strings[cmd_num];\n"
441 "event {\n\tname = \"register\";\n\tid = %u;\n"
442 "\tfields := struct { \n"
443 "\t\tascii contents[%d];\n"
462 "event {\n\tname = \"status\";\n\tid = %u;\n"
463 "\tfields := struct { \n"
464 "\t\tint32_t stop_reason;\n"
465 "\t\tint32_t stopping_tracepoint;\n"
466 "\t\tint32_t traceframe_count;\n"
467 "\t\tint32_t traceframes_created;\n"
468 "\t\tint32_t buffer_free;\n"
469 "\t\tint32_t buffer_size;\n"
470 "\t\tint32_t disconnected_tracing;\n"
471 "\t\tint32_t circular_buffer;\n"
501 const gdb_byte zero = 0;
518 if (tsv->
name != NULL)
536 const gdb_byte zero = 0;
569 if (tp->
cond != NULL)
571 strlen (tp->
cond.get ()));
577 for (
const auto &act : tp->
actions)
579 strlen (act.get ()) + 1);
586 strlen (act.get ()) + 1);
605 strlen (act.get ()) + 1);
670 gdb_byte *buf, int32_t
size)
688 uint64_t addr, uint16_t length)
709 gdb_byte *buf, uint16_t length)
723 int32_t num, uint64_t val)
758 u32 += 4 * TARGET_CHAR_BIT;
817#if HAVE_LIBBABELTRACE
823#include <babeltrace/babeltrace.h>
824#include <babeltrace/ctf/events.h>
825#include <babeltrace/ctf/iterator.h>
832 N_(
"(Use a CTF directory as a target.\n\
833Specify the filename of the CTF directory.")
840 {
return ctf_target_info; }
842 void close ()
override;
843 void fetch_registers (
struct regcache *,
int)
override;
847 const gdb_byte *writebuf,
848 ULONGEST offset, ULONGEST len,
849 ULONGEST *xfered_len)
override;
850 void files_info ()
override;
852 CORE_ADDR addr1, CORE_ADDR addr2,
int *tpp)
override;
853 bool get_trace_state_variable_value (
int tsv, LONGEST *val)
override;
858static struct bt_context *ctx = NULL;
859static struct bt_ctf_iter *ctf_iter = NULL;
861static struct bt_iter_pos *start_pos;
864static gdb::unique_xmalloc_ptr<char> trace_dirname;
866static ctf_target ctf_ops;
873 if (ctf_iter != NULL)
875 bt_ctf_iter_destroy (ctf_iter);
880 bt_context_put (ctx);
888ctf_open_dir (
const char *dirname)
890 struct bt_iter_pos begin_pos;
891 unsigned int count, i;
892 struct bt_ctf_event_decl *
const *list;
894 ctx = bt_context_create ();
896 error (_(
"Unable to create bt_context"));
897 int handle_id = bt_context_add_trace (ctx, dirname,
"ctf", NULL, NULL, NULL);
901 error (_(
"Unable to use libbabeltrace on directory \"%s\""),
905 begin_pos.type = BT_SEEK_BEGIN;
906 ctf_iter = bt_ctf_iter_create (ctx, &begin_pos, NULL);
907 if (ctf_iter == NULL)
910 error (_(
"Unable to create bt_iterator"));
916 bt_ctf_get_event_decl_list (handle_id, ctx, &list, &count);
917 for (i = 0; i < count; i++)
918 if (strcmp (
"register", bt_ctf_get_decl_event_name (list[i])) == 0)
920 const struct bt_ctf_field_decl *
const *field_list;
921 const struct bt_declaration *decl;
923 bt_ctf_get_decl_fields (list[i], BT_EVENT_FIELDS, &field_list,
926 gdb_assert (count == 1);
927 gdb_assert (0 == strcmp (
"contents",
928 bt_ctf_get_decl_field_name (field_list[0])));
929 decl = bt_ctf_get_decl_from_field_decl (field_list[0]);
936#define SET_INT32_FIELD(EVENT, SCOPE, VAR, FIELD) \
937 (VAR)->FIELD = (int) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
941#define SET_ENUM_FIELD(EVENT, SCOPE, VAR, TYPE, FIELD) \
942 (VAR)->FIELD = (TYPE) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
950ctf_read_status (
struct bt_ctf_event *event,
struct trace_status *ts)
952 const struct bt_definition *scope
953 = bt_ctf_get_top_level_scope (event, BT_EVENT_FIELDS);
956 SET_INT32_FIELD (event, scope, ts, stopping_tracepoint);
957 SET_INT32_FIELD (event, scope, ts, traceframe_count);
958 SET_INT32_FIELD (event, scope, ts, traceframes_created);
959 SET_INT32_FIELD (event, scope, ts, buffer_free);
960 SET_INT32_FIELD (event, scope, ts, buffer_size);
962 SET_INT32_FIELD (event, scope, ts, circular_buffer);
964 bt_iter_next (bt_ctf_get_iter (ctf_iter));
973 gdb_assert (ctf_iter != NULL);
977 struct bt_ctf_event *event;
978 const struct bt_definition *scope;
979 const struct bt_definition *def;
983 event = bt_ctf_iter_read_event (ctf_iter);
984 scope = bt_ctf_get_top_level_scope (event,
985 BT_STREAM_EVENT_HEADER);
986 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
991 scope = bt_ctf_get_top_level_scope (event,
994 def = bt_ctf_get_field (event, scope,
"number");
998 def = bt_ctf_get_field (event, scope,
"builtin");
999 utsv->
builtin = (int32_t) bt_ctf_get_int64 (def);
1000 def = bt_ctf_get_field (event, scope,
"initial_value");
1003 def = bt_ctf_get_field (event, scope,
"name");
1004 utsv->
name = xstrdup (bt_ctf_get_string (def));
1006 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1015#define SET_ARRAY_FIELD(EVENT, SCOPE, VAR, NUM, ARRAY) \
1019 const struct bt_definition *def; \
1021 lu32 = (uint32_t) bt_ctf_get_uint64 (bt_ctf_get_field ((EVENT), \
1024 def = bt_ctf_get_field ((EVENT), (SCOPE), #ARRAY); \
1025 for (i = 0; i < lu32; i++) \
1027 const struct bt_definition *element \
1028 = bt_ctf_get_index ((EVENT), def, i); \
1030 (VAR)->ARRAY.emplace_back \
1031 (xstrdup (bt_ctf_get_string (element))); \
1039#define SET_STRING_FIELD(EVENT, SCOPE, VAR, FIELD) \
1042 const char *p = bt_ctf_get_string (bt_ctf_get_field ((EVENT), \
1046 if (strlen (p) > 0) \
1047 (VAR)->FIELD.reset (xstrdup (p)); \
1049 (VAR)->FIELD = NULL; \
1059 gdb_assert (ctf_iter != NULL);
1063 struct bt_ctf_event *event;
1064 const struct bt_definition *scope;
1070 event = bt_ctf_iter_read_event (ctf_iter);
1071 scope = bt_ctf_get_top_level_scope (event,
1072 BT_STREAM_EVENT_HEADER);
1073 u32 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1078 scope = bt_ctf_get_top_level_scope (event,
1080 int32 = (int32_t) bt_ctf_get_int64 (bt_ctf_get_field (event,
1083 u64 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1087 SET_INT32_FIELD (event, scope, utp,
enabled);
1088 SET_INT32_FIELD (event, scope, utp,
step);
1089 SET_INT32_FIELD (event, scope, utp,
pass);
1090 SET_INT32_FIELD (event, scope, utp,
hit_count);
1091 SET_ENUM_FIELD (event, scope, utp,
enum bptype,
type);
1094 SET_ARRAY_FIELD (event, scope, utp, cmd_num,
cmd_strings);
1096 SET_ARRAY_FIELD (event, scope, utp, action_num,
actions);
1098 SET_ARRAY_FIELD (event, scope, utp, step_action_num,
1101 SET_STRING_FIELD(event, scope, utp,
at_string);
1104 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1115ctf_target_open (
const char *dirname,
int from_tty)
1117 struct bt_ctf_event *event;
1119 const struct bt_definition *scope;
1124 error (_(
"No CTF directory specified."));
1126 ctf_open_dir (dirname);
1132 event = bt_ctf_iter_read_event (ctf_iter);
1133 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1134 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"id"));
1136 error (_(
"Wrong event id of the first event"));
1138 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1139 event = bt_ctf_iter_read_event (ctf_iter);
1140 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1141 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"id"));
1143 error (_(
"Wrong event id of the second event"));
1146 ctf_read_tsv (&uploaded_tsvs);
1148 ctf_read_tp (&uploaded_tps);
1150 event = bt_ctf_iter_read_event (ctf_iter);
1155 scope = bt_ctf_get_top_level_scope (event,
1156 BT_STREAM_EVENT_HEADER);
1157 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event,
1160 error (_(
"Wrong event id of the first event of the second packet"));
1163 start_pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1164 gdb_assert (start_pos->type == BT_SEEK_RESTORE);
1166 trace_dirname = make_unique_xstrdup (dirname);
1187 trace_dirname.reset ();
1199ctf_target::files_info ()
1201 gdb_printf (
"\t`%s'\n", trace_dirname.get ());
1213 struct bt_ctf_event *
event = NULL;
1214 struct bt_iter_pos *pos;
1221 gdb_assert (ctf_iter != NULL);
1223 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1224 gdb_assert (pos->type == BT_SEEK_RESTORE);
1229 struct bt_ctf_event *event1;
1231 event1 = bt_ctf_iter_read_event (ctf_iter);
1233 name = bt_ctf_event_name (event1);
1235 if (
name == NULL || strcmp (
name,
"frame") == 0)
1237 else if (strcmp (
name,
"register") == 0)
1243 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1248 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1252 int offset, regsize, regn;
1253 const struct bt_definition *scope
1254 = bt_ctf_get_top_level_scope (event,
1256 const struct bt_definition *array
1257 = bt_ctf_get_field (event, scope,
"contents");
1258 gdb_byte *regs = (gdb_byte *) bt_ctf_get_char_array (array);
1276 else if (regno == -1)
1296 const char *annex, gdb_byte *readbuf,
1297 const gdb_byte *writebuf, ULONGEST offset,
1298 ULONGEST len, ULONGEST *xfered_len)
1304 if (readbuf == NULL)
1305 error (_(
"ctf_xfer_partial: trace file is read-only"));
1309 struct bt_iter_pos *pos;
1313 ULONGEST low_addr_available = 0;
1315 gdb_assert (ctf_iter != NULL);
1317 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1318 gdb_assert (pos->type == BT_SEEK_RESTORE);
1327 const struct bt_definition *scope;
1328 const struct bt_definition *def;
1329 struct bt_ctf_event *
event
1330 = bt_ctf_iter_read_event (ctf_iter);
1331 const char *
name = bt_ctf_event_name (event);
1333 if (
name == NULL || strcmp (
name,
"frame") == 0)
1335 else if (strcmp (
name,
"memory") != 0)
1337 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1343 scope = bt_ctf_get_top_level_scope (event,
1346 def = bt_ctf_get_field (event, scope,
"address");
1347 maddr = bt_ctf_get_uint64 (def);
1348 def = bt_ctf_get_field (event, scope,
"length");
1349 mlen = (uint16_t) bt_ctf_get_uint64 (def);
1355 if (maddr <= offset && offset < (maddr + mlen))
1357 const struct bt_definition *array
1358 = bt_ctf_get_field (event, scope,
"contents");
1361 gdb::byte_vector contents (mlen);
1363 for (k = 0; k < mlen; k++)
1365 const struct bt_definition *element
1366 = bt_ctf_get_index (event, array, k);
1368 contents[k] = (gdb_byte) bt_ctf_get_uint64 (element);
1371 amt = (maddr + mlen) - offset;
1375 memcpy (readbuf, &contents[offset - maddr], amt);
1378 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1389 if (offset < maddr && maddr < (offset + len))
1390 if (low_addr_available == 0 || low_addr_available > maddr)
1391 low_addr_available = maddr;
1393 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1398 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1403 if (offset < low_addr_available)
1404 len = std::min (len, low_addr_available - offset);
1431ctf_target::get_trace_state_variable_value (
int tsvnum, LONGEST *val)
1433 struct bt_iter_pos *pos;
1436 gdb_assert (ctf_iter != NULL);
1438 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1439 gdb_assert (pos->type == BT_SEEK_RESTORE);
1445 struct bt_ctf_event *
event
1446 = bt_ctf_iter_read_event (ctf_iter);
1447 const char *
name = bt_ctf_event_name (event);
1449 if (
name == NULL || strcmp (
name,
"frame") == 0)
1451 else if (strcmp (
name,
"tsv") == 0)
1453 const struct bt_definition *scope;
1454 const struct bt_definition *def;
1456 scope = bt_ctf_get_top_level_scope (event,
1459 def = bt_ctf_get_field (event, scope,
"num");
1460 if (tsvnum == (int32_t) bt_ctf_get_uint64 (def))
1462 def = bt_ctf_get_field (event, scope,
"val");
1463 *val = bt_ctf_get_uint64 (def);
1469 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1474 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1482ctf_get_tpnum_from_frame_event (
struct bt_ctf_event *event)
1485 const struct bt_definition *scope
1486 = bt_ctf_get_top_level_scope (event, BT_STREAM_PACKET_CONTEXT);
1488 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"tpnum"));
1496ctf_get_traceframe_address (
void)
1498 struct bt_ctf_event *
event = NULL;
1499 struct bt_iter_pos *pos;
1502 gdb_assert (ctf_iter != NULL);
1503 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1504 gdb_assert (pos->type == BT_SEEK_RESTORE);
1509 struct bt_ctf_event *event1;
1511 event1 = bt_ctf_iter_read_event (ctf_iter);
1513 name = bt_ctf_event_name (event1);
1517 else if (strcmp (
name,
"frame") == 0)
1523 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1529 int tpnum = ctf_get_tpnum_from_frame_event (event);
1538 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1549 CORE_ADDR addr1, CORE_ADDR addr2,
int *tpp)
1561 gdb_assert (ctf_iter != NULL);
1563 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), start_pos);
1567 struct bt_ctf_event *event;
1570 event = bt_ctf_iter_read_event (ctf_iter);
1572 name = bt_ctf_event_name (event);
1574 if (event == NULL ||
name == NULL)
1577 if (strcmp (
name,
"frame") == 0)
1600 == ctf_get_tpnum_from_frame_event (event)))
1605 tfaddr = ctf_get_traceframe_address ();
1606 if (tfaddr == addr1)
1610 tfaddr = ctf_get_traceframe_address ();
1611 if (addr1 <= tfaddr && tfaddr <= addr2)
1615 tfaddr = ctf_get_traceframe_address ();
1616 if (!(addr1 <= tfaddr && tfaddr <= addr2))
1620 internal_error (_(
"unknown tfind type"));
1627 *tpp = ctf_get_tpnum_from_frame_event (event);
1630 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1637 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1650ctf_target::traceframe_info ()
1654 struct bt_iter_pos *pos;
1656 gdb_assert (ctf_iter != NULL);
1658 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1659 gdb_assert (pos->type == BT_SEEK_RESTORE);
1663 struct bt_ctf_event *
event
1664 = bt_ctf_iter_read_event (ctf_iter);
1666 name = bt_ctf_event_name (event);
1668 if (
name == NULL || strcmp (
name,
"register") == 0
1669 || strcmp (
name,
"frame") == 0)
1671 else if (strcmp (
name,
"memory") == 0)
1673 const struct bt_definition *scope
1674 = bt_ctf_get_top_level_scope (event,
1676 const struct bt_definition *def;
1678 def = bt_ctf_get_field (event, scope,
"address");
1679 CORE_ADDR start = bt_ctf_get_uint64 (def);
1681 def = bt_ctf_get_field (event, scope,
"length");
1682 int length = (uint16_t) bt_ctf_get_uint64 (def);
1684 info->memory.emplace_back (start, length);
1686 else if (strcmp (
name,
"tsv") == 0)
1689 const struct bt_definition *scope
1690 = bt_ctf_get_top_level_scope (event,
1692 const struct bt_definition *def;
1694 def = bt_ctf_get_field (event, scope,
"num");
1695 vnum = (int) bt_ctf_get_uint64 (def);
1696 info->tvars.push_back (vnum);
1700 warning (_(
"Unhandled trace block type (%s) "
1701 "while building trace frame info."),
1705 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1708 while (
name != NULL && strcmp (
name,
"frame") != 0);
1711 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1724#if HAVE_LIBBABELTRACE
struct tracepoint * get_tracepoint_by_number_on_target(int num)
struct tracepoint * get_tracepoint(int num)
void push_target(struct target_ops *t)
void raw_supply(int regnum, const void *buf) override
enum register_status get_register_status(int regnum) const override
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
enum target_xfer_status section_table_read_available_memory(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
enum target_xfer_status exec_read_partial_read_only(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
static void ATTRIBUTE_PRINTF(1, 0)
int gdbarch_num_regs(struct gdbarch *gdbarch)
struct thread_info * add_thread_silent(process_stratum_target *targ, ptid_t ptid)
void switch_to_thread(struct thread_info *thr)
void switch_to_no_thread()
void post_create_inferior(int from_tty)
void inferior_appeared(struct inferior *inf, int pid)
struct inferior * current_inferior(void)
void exit_inferior(struct inferior *inf)
int register_size(struct gdbarch *gdbarch, int regnum)
bool has_locations() const
bp_location & first_loc()
struct trace_write_handler tcs
struct trace_file_writer base
virtual void fetch_registers(struct regcache *, int) TARGET_DEFAULT_IGNORE()
virtual bool get_trace_state_variable_value(int tsv, LONGEST *val) TARGET_DEFAULT_RETURN(false)
virtual traceframe_info_up traceframe_info() TARGET_DEFAULT_NORETURN(tcomplain())
virtual enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
virtual const target_info & info() const =0
virtual int trace_find(enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) TARGET_DEFAULT_RETURN(-1)
virtual void files_info() TARGET_DEFAULT_IGNORE()
const struct trace_frame_write_ops * frame_ops
const struct trace_file_write_ops * ops
void(* end)(struct trace_file_writer *self)
void(* start)(struct trace_file_writer *self, uint16_t tpnum)
enum trace_stop_reason stop_reason
std::vector< gdb::unique_xmalloc_ptr< char[]> > cmd_strings
gdb::unique_xmalloc_ptr< char[]> cond_string
std::vector< gdb::unique_xmalloc_ptr< char[]> > step_actions
ULONGEST traceframe_usage
std::vector< gdb::unique_xmalloc_ptr< char[]> > actions
gdb::unique_xmalloc_ptr< char[]> at_string
gdb::unique_xmalloc_ptr< char[]> cond
void add_target(const target_info &t, target_open_ftype *func, completer_ftype *completer)
void target_preopen(int from_tty)
@ TARGET_XFER_UNAVAILABLE
#define CTF_METADATA_NAME
#define ctf_save_write_int32(HANDLER, INT32)
static int ctf_save_write(struct trace_write_handler *handler, const gdb_byte *buf, size_t size)
#define CTF_EVENT_ID_MEMORY
static void ctf_save_write_metadata(struct trace_write_handler *handler, const char *format,...) ATTRIBUTE_PRINTF(2
static void ctf_write_tdesc(struct trace_file_writer *self)
static void ctf_write_uploaded_tsv(struct trace_file_writer *self, struct uploaded_tsv *tsv)
static void ctf_start(struct trace_file_writer *self, const char *dirname)
static void ctf_write_frame_end(struct trace_file_writer *self)
static void ctf_write_header(struct trace_file_writer *self)
static void ctf_write_frame_m_block_header(struct trace_file_writer *self, uint64_t addr, uint16_t length)
static int ctf_save_fseek(struct trace_write_handler *handler, long offset, int whence)
static void ctf_write_frame_v_block(struct trace_file_writer *self, int32_t num, uint64_t val)
static void ctf_write_uploaded_tp(struct trace_file_writer *self, struct uploaded_tp *tp)
#define CTF_DATASTREAM_NAME
static void ctf_save_next_packet(struct trace_write_handler *handler)
static void ctf_end(struct trace_file_writer *self)
#define ctf_save_write_uint32(HANDLER, U32)
static const struct trace_frame_write_ops ctf_write_frame_ops
static void ctf_write_status(struct trace_file_writer *self, struct trace_status *ts)
static void ctf_write_frame_r_block(struct trace_file_writer *self, gdb_byte *buf, int32_t size)
static void ctf_write_regblock_type(struct trace_file_writer *self, int size)
#define CTF_EVENT_ID_FRAME
static int ctf_target_save(struct trace_file_writer *self, const char *dirname)
struct trace_file_writer * ctf_trace_file_writer_new(void)
#define CTF_EVENT_ID_STATUS
static int ctf_save_align_write(struct trace_write_handler *handler, const gdb_byte *buf, size_t size, size_t align_size)
#define CTF_EVENT_ID_REGISTER
#define CTF_EVENT_ID_TP_DEF
static void ctf_dtor(struct trace_file_writer *self)
static void ctf_write_frame_start(struct trace_file_writer *self, uint16_t tpnum)
static const struct trace_file_write_ops ctf_write_ops
static void ctf_write_definition_end(struct trace_file_writer *self)
#define CTF_EVENT_ID_TSV_DEF
static void ctf_save_metadata_header(struct trace_write_handler *handler)
static void ctf_write_frame_m_block_memory(struct trace_file_writer *self, gdb_byte *buf, uint16_t length)
void tracefile_fetch_registers(struct regcache *regcache, int regno)
struct trace_status * current_trace_status(void)
int get_traceframe_number(void)
struct uploaded_tp * get_uploaded_tp(int num, ULONGEST addr, struct uploaded_tp **utpp)
struct uploaded_tsv * get_uploaded_tsv(int num, struct uploaded_tsv **utsvp)
static bool disconnected_tracing
void trace_reset_local_state(void)
void merge_uploaded_tracepoints(struct uploaded_tp **uploaded_tps)
void merge_uploaded_trace_state_variables(struct uploaded_tsv **uploaded_tsvs)
std::unique_ptr< traceframe_info > traceframe_info_up
void gdb_printf(struct ui_file *stream, const char *format,...)