34#include "gdbsupport/filestuff.h"
42 N_(
"(Use a CTF directory as a target.\n\
43Specify the filename of the CTF directory.")
57 const gdb_byte *writebuf,
58 ULONGEST offset, ULONGEST len,
59 ULONGEST *xfered_len)
override;
62 CORE_ADDR addr1, CORE_ADDR addr2,
int *tpp)
override;
97#define CTF_MAGIC 0xC1FC1FC1
98#define CTF_SAVE_MAJOR 1
99#define CTF_SAVE_MINOR 8
101#define CTF_METADATA_NAME "metadata"
102#define CTF_DATASTREAM_NAME "datastream"
106#define CTF_EVENT_ID_REGISTER 0
107#define CTF_EVENT_ID_TSV 1
108#define CTF_EVENT_ID_MEMORY 2
109#define CTF_EVENT_ID_FRAME 3
110#define CTF_EVENT_ID_STATUS 4
111#define CTF_EVENT_ID_TSV_DEF 5
112#define CTF_EVENT_ID_TP_DEF 6
136 const char *format, ...)
141 const
char *format, ...)
145 va_start (args, format);
146 if (vfprintf (handler->
metadata_fd, format, args) < 0)
147 error (_(
"Unable to write metadata file (%s)"),
148 safe_strerror (errno));
157 const gdb_byte *buf,
size_t size)
160 error (_(
"Unable to write file for saving trace data (%s)"),
161 safe_strerror (errno));
171#define ctf_save_write_uint32(HANDLER, U32) \
172 ctf_save_write (HANDLER, (gdb_byte *) &U32, 4)
177#define ctf_save_write_int32(HANDLER, INT32) \
178 ctf_save_write ((HANDLER), (gdb_byte *) &(INT32), 4)
187 gdb_assert (whence != SEEK_END);
189 || offset <= handler->content_size + handler->
packet_start);
192 error (_(
"Unable to seek file for saving trace data (%s)"),
193 safe_strerror (errno));
207 size_t size,
size_t align_size)
240 "typealias integer { size = 8; align = 8; "
241 "signed = false; encoding = ascii;}"
244 "typealias integer { size = 8; align = 8; "
248 "typealias integer { size = 16; align = 16;"
249 "signed = false; } := uint16_t;\n");
251 "typealias integer { size = 32; align = 32;"
252 "signed = false; } := uint32_t;\n");
254 "typealias integer { size = 64; align = 64;"
255 "signed = false; base = hex;}"
258 "typealias integer { size = 32; align = 32;"
259 "signed = true; } := int32_t;\n");
261 "typealias integer { size = 64; align = 64;"
262 "signed = true; } := int64_t;\n");
264 "typealias string { encoding = ascii;"
271#define HOST_ENDIANNESS "be"
273#define HOST_ENDIANNESS "le"
280 " byte_order = %s;\n"
281 " packet.header := struct {\n"
287 " packet.context := struct {\n"
288 " uint32_t content_size;\n"
289 " uint32_t packet_size;\n"
292 " event.header := struct {\n"
348 mode_t hmode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH;
351 if (mkdir (dirname, hmode) && errno != EEXIST)
352 error (_(
"Unable to open directory '%s' for saving trace data (%s)"),
353 dirname, safe_strerror (errno));
355 memset (&writer->
tcs,
'\0', sizeof (writer->
tcs));
360 = gdb_fopen_cloexec (file_name.c_str (),
"w").release ();
362 error (_(
"Unable to open file '%s' for saving trace data (%s)"),
363 file_name.c_str (), safe_strerror (errno));
369 = gdb_fopen_cloexec (file_name.c_str (),
"w").release ();
371 error (_(
"Unable to open file '%s' for saving trace data (%s)"),
372 file_name.c_str (), safe_strerror (errno));
388 "event {\n\tname = \"memory\";\n\tid = %u;\n"
389 "\tfields := struct { \n"
390 "\t\tuint64_t address;\n"
391 "\t\tuint16_t length;\n"
392 "\t\tuint8_t contents[length];\n"
398 "event {\n\tname = \"tsv\";\n\tid = %u;\n"
399 "\tfields := struct { \n"
400 "\t\tuint64_t val;\n"
401 "\t\tuint32_t num;\n"
407 "event {\n\tname = \"frame\";\n\tid = %u;\n"
408 "\tfields := struct { \n"
414 "event {\n\tname = \"tsv_def\";\n"
415 "\tid = %u;\n\tfields := struct { \n"
416 "\t\tint64_t initial_value;\n"
417 "\t\tint32_t number;\n"
418 "\t\tint32_t builtin;\n"
425 "event {\n\tname = \"tp_def\";\n"
426 "\tid = %u;\n\tfields := struct { \n"
427 "\t\tuint64_t addr;\n"
428 "\t\tuint64_t traceframe_usage;\n"
429 "\t\tint32_t number;\n"
430 "\t\tint32_t enabled;\n"
431 "\t\tint32_t step;\n"
432 "\t\tint32_t pass;\n"
433 "\t\tint32_t hit_count;\n"
434 "\t\tint32_t type;\n"
437 "\t\tuint32_t action_num;\n"
438 "\t\tchars actions[action_num];\n"
440 "\t\tuint32_t step_action_num;\n"
441 "\t\tchars step_actions[step_action_num];\n"
443 "\t\tchars at_string;\n"
444 "\t\tchars cond_string;\n"
446 "\t\tuint32_t cmd_num;\n"
447 "\t\tchars cmd_strings[cmd_num];\n"
471 "event {\n\tname = \"register\";\n\tid = %u;\n"
472 "\tfields := struct { \n"
473 "\t\tascii contents[%d];\n"
492 "event {\n\tname = \"status\";\n\tid = %u;\n"
493 "\tfields := struct { \n"
494 "\t\tint32_t stop_reason;\n"
495 "\t\tint32_t stopping_tracepoint;\n"
496 "\t\tint32_t traceframe_count;\n"
497 "\t\tint32_t traceframes_created;\n"
498 "\t\tint32_t buffer_free;\n"
499 "\t\tint32_t buffer_size;\n"
500 "\t\tint32_t disconnected_tracing;\n"
501 "\t\tint32_t circular_buffer;\n"
531 const gdb_byte zero = 0;
548 if (tsv->
name != NULL)
566 const gdb_byte zero = 0;
599 if (tp->
cond != NULL)
601 strlen (tp->
cond.get ()));
607 for (
const auto &act : tp->
actions)
609 strlen (act.get ()) + 1);
616 strlen (act.get ()) + 1);
635 strlen (act.get ()) + 1);
700 gdb_byte *buf, int32_t
size)
718 uint64_t addr, uint16_t length)
739 gdb_byte *buf, uint16_t length)
753 int32_t num, uint64_t val)
788 u32 += 4 * TARGET_CHAR_BIT;
847#if HAVE_LIBBABELTRACE
853#include <babeltrace/babeltrace.h>
854#include <babeltrace/ctf/events.h>
855#include <babeltrace/ctf/iterator.h>
858static int handle_id = -1;
859static struct bt_context *ctx = NULL;
860static struct bt_ctf_iter *ctf_iter = NULL;
862static struct bt_iter_pos *start_pos;
865static char *trace_dirname;
874 if (ctf_iter != NULL)
876 bt_ctf_iter_destroy (ctf_iter);
881 bt_context_put (ctx);
889ctf_open_dir (
const char *dirname)
891 struct bt_iter_pos begin_pos;
892 unsigned int count, i;
893 struct bt_ctf_event_decl *
const *list;
895 ctx = bt_context_create ();
897 error (_(
"Unable to create bt_context"));
898 handle_id = bt_context_add_trace (ctx, dirname,
"ctf", NULL, NULL, NULL);
902 error (_(
"Unable to use libbabeltrace on directory \"%s\""),
906 begin_pos.type = BT_SEEK_BEGIN;
907 ctf_iter = bt_ctf_iter_create (ctx, &begin_pos, NULL);
908 if (ctf_iter == NULL)
911 error (_(
"Unable to create bt_iterator"));
917 bt_ctf_get_event_decl_list (handle_id, ctx, &list, &count);
918 for (i = 0; i < count; i++)
919 if (strcmp (
"register", bt_ctf_get_decl_event_name (list[i])) == 0)
921 const struct bt_ctf_field_decl *
const *field_list;
922 const struct bt_declaration *decl;
924 bt_ctf_get_decl_fields (list[i], BT_EVENT_FIELDS, &field_list,
927 gdb_assert (count == 1);
928 gdb_assert (0 == strcmp (
"contents",
929 bt_ctf_get_decl_field_name (field_list[0])));
930 decl = bt_ctf_get_decl_from_field_decl (field_list[0]);
937#define SET_INT32_FIELD(EVENT, SCOPE, VAR, FIELD) \
938 (VAR)->FIELD = (int) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
942#define SET_ENUM_FIELD(EVENT, SCOPE, VAR, TYPE, FIELD) \
943 (VAR)->FIELD = (TYPE) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
951ctf_read_status (
struct bt_ctf_event *event,
struct trace_status *ts)
953 const struct bt_definition *scope
954 = bt_ctf_get_top_level_scope (event, BT_EVENT_FIELDS);
957 SET_INT32_FIELD (event, scope, ts, stopping_tracepoint);
958 SET_INT32_FIELD (event, scope, ts, traceframe_count);
959 SET_INT32_FIELD (event, scope, ts, traceframes_created);
960 SET_INT32_FIELD (event, scope, ts, buffer_free);
961 SET_INT32_FIELD (event, scope, ts, buffer_size);
963 SET_INT32_FIELD (event, scope, ts, circular_buffer);
965 bt_iter_next (bt_ctf_get_iter (ctf_iter));
974 gdb_assert (ctf_iter != NULL);
978 struct bt_ctf_event *event;
979 const struct bt_definition *scope;
980 const struct bt_definition *def;
984 event = bt_ctf_iter_read_event (ctf_iter);
985 scope = bt_ctf_get_top_level_scope (event,
986 BT_STREAM_EVENT_HEADER);
987 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
992 scope = bt_ctf_get_top_level_scope (event,
995 def = bt_ctf_get_field (event, scope,
"number");
999 def = bt_ctf_get_field (event, scope,
"builtin");
1000 utsv->
builtin = (int32_t) bt_ctf_get_int64 (def);
1001 def = bt_ctf_get_field (event, scope,
"initial_value");
1004 def = bt_ctf_get_field (event, scope,
"name");
1005 utsv->
name = xstrdup (bt_ctf_get_string (def));
1007 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1016#define SET_ARRAY_FIELD(EVENT, SCOPE, VAR, NUM, ARRAY) \
1020 const struct bt_definition *def; \
1022 lu32 = (uint32_t) bt_ctf_get_uint64 (bt_ctf_get_field ((EVENT), \
1025 def = bt_ctf_get_field ((EVENT), (SCOPE), #ARRAY); \
1026 for (i = 0; i < lu32; i++) \
1028 const struct bt_definition *element \
1029 = bt_ctf_get_index ((EVENT), def, i); \
1031 (VAR)->ARRAY.emplace_back \
1032 (xstrdup (bt_ctf_get_string (element))); \
1040#define SET_STRING_FIELD(EVENT, SCOPE, VAR, FIELD) \
1043 const char *p = bt_ctf_get_string (bt_ctf_get_field ((EVENT), \
1047 if (strlen (p) > 0) \
1048 (VAR)->FIELD.reset (xstrdup (p)); \
1050 (VAR)->FIELD = NULL; \
1060 gdb_assert (ctf_iter != NULL);
1064 struct bt_ctf_event *event;
1065 const struct bt_definition *scope;
1071 event = bt_ctf_iter_read_event (ctf_iter);
1072 scope = bt_ctf_get_top_level_scope (event,
1073 BT_STREAM_EVENT_HEADER);
1074 u32 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1079 scope = bt_ctf_get_top_level_scope (event,
1081 int32 = (int32_t) bt_ctf_get_int64 (bt_ctf_get_field (event,
1084 u64 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1088 SET_INT32_FIELD (event, scope, utp,
enabled);
1089 SET_INT32_FIELD (event, scope, utp,
step);
1090 SET_INT32_FIELD (event, scope, utp,
pass);
1091 SET_INT32_FIELD (event, scope, utp,
hit_count);
1092 SET_ENUM_FIELD (event, scope, utp,
enum bptype,
type);
1095 SET_ARRAY_FIELD (event, scope, utp, cmd_num,
cmd_strings);
1097 SET_ARRAY_FIELD (event, scope, utp, action_num,
actions);
1099 SET_ARRAY_FIELD (event, scope, utp, step_action_num,
1102 SET_STRING_FIELD(event, scope, utp,
at_string);
1105 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1116ctf_target_open (
const char *dirname,
int from_tty)
1118 struct bt_ctf_event *event;
1120 const struct bt_definition *scope;
1125 error (_(
"No CTF directory specified."));
1127 ctf_open_dir (dirname);
1133 event = bt_ctf_iter_read_event (ctf_iter);
1134 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1135 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"id"));
1137 error (_(
"Wrong event id of the first event"));
1139 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1140 event = bt_ctf_iter_read_event (ctf_iter);
1141 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1142 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"id"));
1144 error (_(
"Wrong event id of the second event"));
1147 ctf_read_tsv (&uploaded_tsvs);
1149 ctf_read_tp (&uploaded_tps);
1151 event = bt_ctf_iter_read_event (ctf_iter);
1156 scope = bt_ctf_get_top_level_scope (event,
1157 BT_STREAM_EVENT_HEADER);
1158 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event,
1161 error (_(
"Wrong event id of the first event of the second packet"));
1164 start_pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1165 gdb_assert (start_pos->type == BT_SEEK_RESTORE);
1167 trace_dirname = xstrdup (dirname);
1188 xfree (trace_dirname);
1189 trace_dirname = NULL;
1215 struct bt_ctf_event *
event = NULL;
1216 struct bt_iter_pos *pos;
1223 gdb_assert (ctf_iter != NULL);
1225 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1226 gdb_assert (pos->type == BT_SEEK_RESTORE);
1231 struct bt_ctf_event *event1;
1233 event1 = bt_ctf_iter_read_event (ctf_iter);
1235 name = bt_ctf_event_name (event1);
1237 if (
name == NULL || strcmp (
name,
"frame") == 0)
1239 else if (strcmp (
name,
"register") == 0)
1245 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1250 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1254 int offset, regsize, regn;
1255 const struct bt_definition *scope
1256 = bt_ctf_get_top_level_scope (event,
1258 const struct bt_definition *array
1259 = bt_ctf_get_field (event, scope,
"contents");
1260 gdb_byte *regs = (gdb_byte *) bt_ctf_get_char_array (array);
1278 else if (regno == -1)
1298 const char *annex, gdb_byte *readbuf,
1299 const gdb_byte *writebuf, ULONGEST offset,
1300 ULONGEST len, ULONGEST *xfered_len)
1306 if (readbuf == NULL)
1307 error (_(
"ctf_xfer_partial: trace file is read-only"));
1311 struct bt_iter_pos *pos;
1315 ULONGEST low_addr_available = 0;
1317 gdb_assert (ctf_iter != NULL);
1319 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1320 gdb_assert (pos->type == BT_SEEK_RESTORE);
1329 const struct bt_definition *scope;
1330 const struct bt_definition *def;
1331 struct bt_ctf_event *
event
1332 = bt_ctf_iter_read_event (ctf_iter);
1333 const char *
name = bt_ctf_event_name (event);
1335 if (
name == NULL || strcmp (
name,
"frame") == 0)
1337 else if (strcmp (
name,
"memory") != 0)
1339 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1345 scope = bt_ctf_get_top_level_scope (event,
1348 def = bt_ctf_get_field (event, scope,
"address");
1349 maddr = bt_ctf_get_uint64 (def);
1350 def = bt_ctf_get_field (event, scope,
"length");
1351 mlen = (uint16_t) bt_ctf_get_uint64 (def);
1357 if (maddr <= offset && offset < (maddr + mlen))
1359 const struct bt_definition *array
1360 = bt_ctf_get_field (event, scope,
"contents");
1364 contents = (gdb_byte *)
xmalloc (mlen);
1366 for (k = 0; k < mlen; k++)
1368 const struct bt_definition *element
1369 = bt_ctf_get_index (event, array, k);
1371 contents[k] = (gdb_byte) bt_ctf_get_uint64 (element);
1374 amt = (maddr + mlen) - offset;
1378 memcpy (readbuf, &contents[offset - maddr], amt);
1383 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1394 if (offset < maddr && maddr < (offset + len))
1395 if (low_addr_available == 0 || low_addr_available > maddr)
1396 low_addr_available = maddr;
1398 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1403 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1408 if (offset < low_addr_available)
1409 len = std::min (len, low_addr_available - offset);
1438 struct bt_iter_pos *pos;
1441 gdb_assert (ctf_iter != NULL);
1443 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1444 gdb_assert (pos->type == BT_SEEK_RESTORE);
1450 struct bt_ctf_event *
event
1451 = bt_ctf_iter_read_event (ctf_iter);
1452 const char *
name = bt_ctf_event_name (event);
1454 if (
name == NULL || strcmp (
name,
"frame") == 0)
1456 else if (strcmp (
name,
"tsv") == 0)
1458 const struct bt_definition *scope;
1459 const struct bt_definition *def;
1461 scope = bt_ctf_get_top_level_scope (event,
1464 def = bt_ctf_get_field (event, scope,
"num");
1465 if (tsvnum == (int32_t) bt_ctf_get_uint64 (def))
1467 def = bt_ctf_get_field (event, scope,
"val");
1468 *val = bt_ctf_get_uint64 (def);
1474 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1479 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1487ctf_get_tpnum_from_frame_event (
struct bt_ctf_event *event)
1490 const struct bt_definition *scope
1491 = bt_ctf_get_top_level_scope (event, BT_STREAM_PACKET_CONTEXT);
1493 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"tpnum"));
1501ctf_get_traceframe_address (
void)
1503 struct bt_ctf_event *
event = NULL;
1504 struct bt_iter_pos *pos;
1507 gdb_assert (ctf_iter != NULL);
1508 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1509 gdb_assert (pos->type == BT_SEEK_RESTORE);
1514 struct bt_ctf_event *event1;
1516 event1 = bt_ctf_iter_read_event (ctf_iter);
1518 name = bt_ctf_event_name (event1);
1522 else if (strcmp (
name,
"frame") == 0)
1528 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1534 int tpnum = ctf_get_tpnum_from_frame_event (event);
1543 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1554 CORE_ADDR addr1, CORE_ADDR addr2,
int *tpp)
1566 gdb_assert (ctf_iter != NULL);
1568 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), start_pos);
1572 struct bt_ctf_event *event;
1575 event = bt_ctf_iter_read_event (ctf_iter);
1577 name = bt_ctf_event_name (event);
1579 if (event == NULL ||
name == NULL)
1582 if (strcmp (
name,
"frame") == 0)
1605 == ctf_get_tpnum_from_frame_event (event)))
1610 tfaddr = ctf_get_traceframe_address ();
1611 if (tfaddr == addr1)
1615 tfaddr = ctf_get_traceframe_address ();
1616 if (addr1 <= tfaddr && tfaddr <= addr2)
1620 tfaddr = ctf_get_traceframe_address ();
1621 if (!(addr1 <= tfaddr && tfaddr <= addr2))
1625 internal_error (_(
"unknown tfind type"));
1632 *tpp = ctf_get_tpnum_from_frame_event (event);
1635 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1642 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1659 struct bt_iter_pos *pos;
1661 gdb_assert (ctf_iter != NULL);
1663 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1664 gdb_assert (pos->type == BT_SEEK_RESTORE);
1668 struct bt_ctf_event *
event
1669 = bt_ctf_iter_read_event (ctf_iter);
1671 name = bt_ctf_event_name (event);
1673 if (
name == NULL || strcmp (
name,
"register") == 0
1674 || strcmp (
name,
"frame") == 0)
1676 else if (strcmp (
name,
"memory") == 0)
1678 const struct bt_definition *scope
1679 = bt_ctf_get_top_level_scope (event,
1681 const struct bt_definition *def;
1683 def = bt_ctf_get_field (event, scope,
"address");
1684 CORE_ADDR start = bt_ctf_get_uint64 (def);
1686 def = bt_ctf_get_field (event, scope,
"length");
1687 int length = (uint16_t) bt_ctf_get_uint64 (def);
1689 info->memory.emplace_back (start, length);
1691 else if (strcmp (
name,
"tsv") == 0)
1694 const struct bt_definition *scope
1695 = bt_ctf_get_top_level_scope (event,
1697 const struct bt_definition *def;
1699 def = bt_ctf_get_field (event, scope,
"num");
1700 vnum = (int) bt_ctf_get_uint64 (def);
1701 info->tvars.push_back (vnum);
1705 warning (_(
"Unhandled trace block type (%s) "
1706 "while building trace frame info."),
1710 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1713 while (
name != NULL && strcmp (
name,
"frame") != 0);
1716 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1729#if HAVE_LIBBABELTRACE
struct tracepoint * get_tracepoint_by_number_on_target(int num)
struct tracepoint * get_tracepoint(int num)
const target_info & info() const override
traceframe_info_up traceframe_info() override
bool get_trace_state_variable_value(int tsv, LONGEST *val) override
void fetch_registers(struct regcache *, int) override
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) override
int trace_find(enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override
void files_info() override
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_silent(inferior *inf)
int register_size(struct gdbarch *gdbarch, int regnum)
struct trace_write_handler tcs
struct trace_file_writer base
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)
static const target_info ctf_target_info
#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,...)