65 #define CTF_MAGIC 0xC1FC1FC1
66 #define CTF_SAVE_MAJOR 1
67 #define CTF_SAVE_MINOR 8
69 #define CTF_METADATA_NAME "metadata"
70 #define CTF_DATASTREAM_NAME "datastream"
74 #define CTF_EVENT_ID_REGISTER 0
75 #define CTF_EVENT_ID_TSV 1
76 #define CTF_EVENT_ID_MEMORY 2
77 #define CTF_EVENT_ID_FRAME 3
78 #define CTF_EVENT_ID_STATUS 4
79 #define CTF_EVENT_ID_TSV_DEF 5
80 #define CTF_EVENT_ID_TP_DEF 6
104 const char *format, ...)
109 const char *format, ...)
113 va_start (args, format);
114 if (vfprintf (handler->metadata_fd, format, args) < 0)
115 error (
_(
"Unable to write metadata file (%s)"),
128 error (
_(
"Unable to write file for saving trace data (%s)"),
139 #define ctf_save_write_uint32(HANDLER, U32) \
140 ctf_save_write (HANDLER, (gdb_byte *) &U32, 4)
145 #define ctf_save_write_int32(HANDLER, INT32) \
146 ctf_save_write ((HANDLER), (gdb_byte *) &(INT32), 4)
157 || offset <= handler->content_size + handler->
packet_start);
160 error (
_(
"Unable to seek file for saving trace data (%s)"),
175 size_t size,
size_t align_size)
205 const char metadata_fmt[] =
209 " byte_order = %s;\n"
210 " packet.header := struct {\n"
216 " packet.context := struct {\n"
217 " uint32_t content_size;\n"
218 " uint32_t packet_size;\n"
221 " event.header := struct {\n"
229 "typealias integer { size = 8; align = 8; "
230 "signed = false; encoding = ascii;}"
233 "typealias integer { size = 8; align = 8; "
237 "typealias integer { size = 16; align = 16;"
238 "signed = false; } := uint16_t;\n");
240 "typealias integer { size = 32; align = 32;"
241 "signed = false; } := uint32_t;\n");
243 "typealias integer { size = 64; align = 64;"
244 "signed = false; base = hex;}"
247 "typealias integer { size = 32; align = 32;"
248 "signed = true; } := int32_t;\n");
250 "typealias integer { size = 64; align = 64;"
251 "signed = true; } := int64_t;\n");
253 "typealias string { encoding = ascii;"
260 #define HOST_ENDIANNESS "be"
262 #define HOST_ENDIANNESS "le"
311 #define mkdir(pathname, mode) mkdir (pathname)
326 mode_t hmode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH;
329 if (mkdir (dirname, hmode) && errno != EEXIST)
330 error (
_(
"Unable to open directory '%s' for saving trace data (%s)"),
333 memset (&writer->
tcs,
'\0', sizeof (writer->
tcs));
340 error (
_(
"Unable to open file '%s' for saving trace data (%s)"),
350 error (
_(
"Unable to open file '%s' for saving trace data (%s)"),
368 "event {\n\tname = \"memory\";\n\tid = %u;\n"
369 "\tfields := struct { \n"
370 "\t\tuint64_t address;\n"
371 "\t\tuint16_t length;\n"
372 "\t\tuint8_t contents[length];\n"
378 "event {\n\tname = \"tsv\";\n\tid = %u;\n"
379 "\tfields := struct { \n"
380 "\t\tuint64_t val;\n"
381 "\t\tuint32_t num;\n"
387 "event {\n\tname = \"frame\";\n\tid = %u;\n"
388 "\tfields := struct { \n"
394 "event {\n\tname = \"tsv_def\";\n"
395 "\tid = %u;\n\tfields := struct { \n"
396 "\t\tint64_t initial_value;\n"
397 "\t\tint32_t number;\n"
398 "\t\tint32_t builtin;\n"
405 "event {\n\tname = \"tp_def\";\n"
406 "\tid = %u;\n\tfields := struct { \n"
407 "\t\tuint64_t addr;\n"
408 "\t\tuint64_t traceframe_usage;\n"
409 "\t\tint32_t number;\n"
410 "\t\tint32_t enabled;\n"
411 "\t\tint32_t step;\n"
412 "\t\tint32_t pass;\n"
413 "\t\tint32_t hit_count;\n"
414 "\t\tint32_t type;\n"
417 "\t\tuint32_t action_num;\n"
418 "\t\tchars actions[action_num];\n"
420 "\t\tuint32_t step_action_num;\n"
421 "\t\tchars step_actions[step_action_num];\n"
423 "\t\tchars at_string;\n"
424 "\t\tchars cond_string;\n"
426 "\t\tuint32_t cmd_num;\n"
427 "\t\tchars cmd_strings[cmd_num];\n"
435 self->ops->frame_ops->start (
self, 0);
451 "event {\n\tname = \"register\";\n\tid = %u;\n"
452 "\tfields := struct { \n"
453 "\t\tascii contents[%d];\n"
473 "event {\n\tname = \"status\";\n\tid = %u;\n"
474 "\tfields := struct { \n"
475 "\t\tint32_t stop_reason;\n"
476 "\t\tint32_t stopping_tracepoint;\n"
477 "\t\tint32_t traceframe_count;\n"
478 "\t\tint32_t traceframes_created;\n"
479 "\t\tint32_t buffer_free;\n"
480 "\t\tint32_t buffer_size;\n"
481 "\t\tint32_t disconnected_tracing;\n"
482 "\t\tint32_t circular_buffer;\n"
530 if (tsv->
name != NULL)
583 if (tp->
cond != NULL)
628 self->ops->frame_ops->end (
self);
692 uint64_t addr, uint16_t length)
727 int32_t num, uint64_t val)
821 #if HAVE_LIBBABELTRACE
827 #include <babeltrace/babeltrace.h>
828 #include <babeltrace/ctf/events.h>
829 #include <babeltrace/ctf/iterator.h>
832 static int handle_id = -1;
833 static struct bt_context *ctx = NULL;
834 static struct bt_ctf_iter *ctf_iter = NULL;
836 static struct bt_iter_pos *start_pos;
839 static char *trace_dirname;
848 if (ctf_iter != NULL)
850 bt_ctf_iter_destroy (ctf_iter);
855 bt_context_put (ctx);
863 ctf_open_dir (
const char *dirname)
865 struct bt_iter_pos begin_pos;
866 struct bt_iter_pos *pos;
867 unsigned int count, i;
868 struct bt_ctf_event_decl *
const *list;
870 ctx = bt_context_create ();
872 error (
_(
"Unable to create bt_context"));
873 handle_id = bt_context_add_trace (ctx, dirname,
"ctf", NULL, NULL, NULL);
877 error (
_(
"Unable to use libbabeltrace on directory \"%s\""),
881 begin_pos.type = BT_SEEK_BEGIN;
882 ctf_iter = bt_ctf_iter_create (ctx, &begin_pos, NULL);
883 if (ctf_iter == NULL)
886 error (
_(
"Unable to create bt_iterator"));
892 bt_ctf_get_event_decl_list (handle_id, ctx, &list, &count);
893 for (i = 0; i < count; i++)
894 if (strcmp (
"register", bt_ctf_get_decl_event_name (list[i])) == 0)
897 const struct bt_ctf_field_decl *
const *field_list;
898 const struct bt_declaration *decl;
900 bt_ctf_get_decl_fields (list[i], BT_EVENT_FIELDS, &field_list,
905 bt_ctf_get_decl_field_name (field_list[0])));
906 decl = bt_ctf_get_decl_from_field_decl (field_list[0]);
913 #define SET_INT32_FIELD(EVENT, SCOPE, VAR, FIELD) \
914 (VAR)->FIELD = (int) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
921 ctf_read_status (
struct bt_ctf_event *event,
struct trace_status *ts)
923 const struct bt_definition *scope
924 = bt_ctf_get_top_level_scope (event, BT_EVENT_FIELDS);
926 SET_INT32_FIELD (event, scope, ts, stop_reason);
927 SET_INT32_FIELD (event, scope, ts, stopping_tracepoint);
928 SET_INT32_FIELD (event, scope, ts, traceframe_count);
929 SET_INT32_FIELD (event, scope, ts, traceframes_created);
931 SET_INT32_FIELD (event, scope, ts, buffer_size);
932 SET_INT32_FIELD (event, scope, ts, disconnected_tracing);
933 SET_INT32_FIELD (event, scope, ts, circular_buffer);
935 bt_iter_next (bt_ctf_get_iter (ctf_iter));
948 struct bt_ctf_event *event;
949 const struct bt_definition *scope;
950 const struct bt_definition *def;
954 event = bt_ctf_iter_read_event (ctf_iter);
955 scope = bt_ctf_get_top_level_scope (event,
956 BT_STREAM_EVENT_HEADER);
957 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
962 scope = bt_ctf_get_top_level_scope (event,
965 def = bt_ctf_get_field (event, scope,
"number");
969 def = bt_ctf_get_field (event, scope,
"builtin");
970 utsv->
builtin = (int32_t) bt_ctf_get_int64 (def);
971 def = bt_ctf_get_field (event, scope,
"initial_value");
974 def = bt_ctf_get_field (event, scope,
"name");
975 utsv->
name = xstrdup (bt_ctf_get_string (def));
977 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
986 #define SET_ARRAY_FIELD(EVENT, SCOPE, VAR, NUM, ARRAY) \
990 const struct bt_definition *def; \
992 u32 = (uint32_t) bt_ctf_get_uint64 (bt_ctf_get_field ((EVENT), \
995 def = bt_ctf_get_field ((EVENT), (SCOPE), #ARRAY); \
996 for (i = 0; i < u32; i++) \
998 const struct bt_definition *element \
999 = bt_ctf_get_index ((EVENT), def, i); \
1001 VEC_safe_push (char_ptr, (VAR)->ARRAY, \
1002 xstrdup (bt_ctf_get_string (element))); \
1010 #define SET_STRING_FIELD(EVENT, SCOPE, VAR, FIELD) \
1013 const char *p = bt_ctf_get_string (bt_ctf_get_field ((EVENT), \
1017 if (strlen (p) > 0) \
1018 (VAR)->FIELD = xstrdup (p); \
1020 (VAR)->FIELD = NULL; \
1034 struct bt_ctf_event *event;
1035 const struct bt_definition *scope;
1041 event = bt_ctf_iter_read_event (ctf_iter);
1042 scope = bt_ctf_get_top_level_scope (event,
1043 BT_STREAM_EVENT_HEADER);
1044 u32 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1049 scope = bt_ctf_get_top_level_scope (event,
1051 int32 = (int32_t) bt_ctf_get_int64 (bt_ctf_get_field (event,
1054 u64 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1058 SET_INT32_FIELD (event, scope, utp,
enabled);
1059 SET_INT32_FIELD (event, scope, utp,
step);
1060 SET_INT32_FIELD (event, scope, utp,
pass);
1061 SET_INT32_FIELD (event, scope, utp,
hit_count);
1062 SET_INT32_FIELD (event, scope, utp, type);
1065 SET_ARRAY_FIELD (event, scope, utp, cmd_num, cmd_strings);
1067 SET_ARRAY_FIELD (event, scope, utp, action_num, actions);
1069 SET_ARRAY_FIELD (event, scope, utp, step_action_num,
1072 SET_STRING_FIELD(event, scope, utp,
at_string);
1075 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1086 ctf_open (
const char *dirname,
int from_tty)
1088 struct bt_ctf_event *event;
1090 const struct bt_definition *scope;
1095 error (
_(
"No CTF directory specified."));
1097 ctf_open_dir (dirname);
1103 event = bt_ctf_iter_read_event (ctf_iter);
1104 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1105 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"id"));
1107 error (
_(
"Wrong event id of the first event"));
1109 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1110 event = bt_ctf_iter_read_event (ctf_iter);
1111 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1112 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"id"));
1114 error (
_(
"Wrong event id of the second event"));
1117 ctf_read_tsv (&uploaded_tsvs);
1119 ctf_read_tp (&uploaded_tps);
1121 event = bt_ctf_iter_read_event (ctf_iter);
1126 scope = bt_ctf_get_top_level_scope (event,
1127 BT_STREAM_EVENT_HEADER);
1128 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event,
1131 error (
_(
"Wrong event id of the first event of the second packet"));
1134 start_pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1135 gdb_assert (start_pos->type == BT_SEEK_RESTORE);
1137 trace_dirname = xstrdup (dirname);
1159 xfree (trace_dirname);
1160 trace_dirname = NULL;
1185 struct regcache *regcache,
int regno)
1188 struct bt_ctf_event *
event = NULL;
1189 struct bt_iter_pos *pos;
1198 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1204 struct bt_ctf_event *event1;
1206 event1 = bt_ctf_iter_read_event (ctf_iter);
1208 name = bt_ctf_event_name (event1);
1210 if (name == NULL || strcmp (name,
"frame") == 0)
1212 else if (strcmp (name,
"register") == 0)
1218 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1223 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1227 int offset, regsize, regn;
1228 const struct bt_definition *scope
1229 = bt_ctf_get_top_level_scope (event,
1231 const struct bt_definition *array
1232 = bt_ctf_get_field (event, scope,
"contents");
1251 else if (regno == -1)
1271 const char *annex,
gdb_byte *readbuf,
1279 if (readbuf == NULL)
1280 error (
_(
"ctf_xfer_partial: trace file is read-only"));
1284 struct bt_iter_pos *pos;
1293 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1303 enum bfd_endian byte_order
1305 const struct bt_definition *scope;
1306 const struct bt_definition *def;
1307 struct bt_ctf_event *
event
1308 = bt_ctf_iter_read_event (ctf_iter);
1309 const char *name = bt_ctf_event_name (event);
1311 if (name == NULL || strcmp (name,
"frame") == 0)
1313 else if (strcmp (name,
"memory") != 0)
1315 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1321 scope = bt_ctf_get_top_level_scope (event,
1324 def = bt_ctf_get_field (event, scope,
"address");
1325 maddr = bt_ctf_get_uint64 (def);
1326 def = bt_ctf_get_field (event, scope,
"length");
1327 mlen = (uint16_t) bt_ctf_get_uint64 (def);
1333 if (maddr <= offset && offset < (maddr + mlen))
1335 const struct bt_definition *array
1336 = bt_ctf_get_field (event, scope,
"contents");
1337 const struct bt_declaration *decl
1338 = bt_ctf_get_decl_from_def (array);
1344 for (k = 0; k < mlen; k++)
1346 const struct bt_definition *element
1347 = bt_ctf_get_index (event, array, k);
1349 contents[k] = (
gdb_byte) bt_ctf_get_uint64 (element);
1352 amt = (maddr + mlen) - offset;
1356 memcpy (readbuf, &contents[offset - maddr], amt);
1361 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1372 if (offset < maddr && maddr < (offset + len))
1373 if (low_addr_available == 0 || low_addr_available > maddr)
1374 low_addr_available = maddr;
1376 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1381 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1386 if (offset < low_addr_available)
1387 len =
min (len, low_addr_available - offset);
1414 ctf_get_trace_state_variable_value (
struct target_ops *
self,
1417 struct bt_iter_pos *pos;
1422 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1429 struct bt_ctf_event *
event
1430 = bt_ctf_iter_read_event (ctf_iter);
1431 const char *name = bt_ctf_event_name (event);
1433 if (name == NULL || strcmp (name,
"frame") == 0)
1435 else if (strcmp (name,
"tsv") == 0)
1437 const struct bt_definition *scope;
1438 const struct bt_definition *def;
1440 scope = bt_ctf_get_top_level_scope (event,
1443 def = bt_ctf_get_field (event, scope,
"num");
1444 if (tsvnum == (int32_t) bt_ctf_get_uint64 (def))
1446 def = bt_ctf_get_field (event, scope,
"val");
1447 *val = bt_ctf_get_uint64 (def);
1453 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1458 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1466 ctf_get_tpnum_from_frame_event (
struct bt_ctf_event *event)
1469 const struct bt_definition *scope
1470 = bt_ctf_get_top_level_scope (event, BT_STREAM_PACKET_CONTEXT);
1472 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
"tpnum"));
1480 ctf_get_traceframe_address (
void)
1482 struct bt_ctf_event *
event = NULL;
1483 struct bt_iter_pos *pos;
1487 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1493 struct bt_ctf_event *event1;
1495 event1 = bt_ctf_iter_read_event (ctf_iter);
1497 name = bt_ctf_event_name (event1);
1501 else if (strcmp (name,
"frame") == 0)
1507 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1513 int tpnum = ctf_get_tpnum_from_frame_event (event);
1522 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1538 struct bt_iter_pos pos;
1549 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), start_pos);
1554 struct bt_ctf_event *event;
1557 event = bt_ctf_iter_read_event (ctf_iter);
1559 name = bt_ctf_event_name (event);
1561 if (event == NULL || name == NULL)
1564 if (strcmp (name,
"frame") == 0)
1587 == ctf_get_tpnum_from_frame_event (event)))
1592 tfaddr = ctf_get_traceframe_address ();
1593 if (tfaddr == addr1)
1597 tfaddr = ctf_get_traceframe_address ();
1598 if (addr1 <= tfaddr && tfaddr <= addr2)
1602 tfaddr = ctf_get_traceframe_address ();
1603 if (!(addr1 <= tfaddr && tfaddr <= addr2))
1614 *tpp = ctf_get_tpnum_from_frame_event (event);
1617 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1624 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1637 ctf_traceframe_info (
struct target_ops *
self)
1641 struct bt_iter_pos *pos;
1645 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1650 struct bt_ctf_event *
event
1651 = bt_ctf_iter_read_event (ctf_iter);
1653 name = bt_ctf_event_name (event);
1655 if (name == NULL || strcmp (name,
"register") == 0
1656 || strcmp (name,
"frame") == 0)
1658 else if (strcmp (name,
"memory") == 0)
1660 const struct bt_definition *scope
1661 = bt_ctf_get_top_level_scope (event,
1663 const struct bt_definition *def;
1667 def = bt_ctf_get_field (event, scope,
"address");
1668 r->
start = bt_ctf_get_uint64 (def);
1670 def = bt_ctf_get_field (event, scope,
"length");
1671 r->
length = (uint16_t) bt_ctf_get_uint64 (def);
1673 else if (strcmp (name,
"tsv") == 0)
1676 const struct bt_definition *scope
1677 = bt_ctf_get_top_level_scope (event,
1679 const struct bt_definition *def;
1681 def = bt_ctf_get_field (event, scope,
"num");
1682 vnum = (
int) bt_ctf_get_int64 (def);
1687 warning (
_(
"Unhandled trace block type (%s) "
1688 "while building trace frame info."),
1692 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1695 while (name != NULL && strcmp (name,
"frame") != 0);
1698 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1706 memset (&ctf_ops, 0,
sizeof (ctf_ops));
1709 ctf_ops.to_shortname =
"ctf";
1710 ctf_ops.to_longname =
"CTF file";
1711 ctf_ops.to_doc =
"Use a CTF directory as a target.\n\
1712 Specify the filename of the CTF directory.";
1713 ctf_ops.to_open = ctf_open;
1714 ctf_ops.to_close = ctf_close;
1715 ctf_ops.to_fetch_registers = ctf_fetch_registers;
1716 ctf_ops.to_xfer_partial = ctf_xfer_partial;
1717 ctf_ops.to_files_info = ctf_files_info;
1718 ctf_ops.to_trace_find = ctf_trace_find;
1719 ctf_ops.to_get_trace_state_variable_value
1720 = ctf_get_trace_state_variable_value;
1721 ctf_ops.to_traceframe_info = ctf_traceframe_info;
1735 #if HAVE_LIBBABELTRACE
struct gdbarch * target_gdbarch(void)
static void ctf_dtor(struct trace_file_writer *self)
#define CTF_EVENT_ID_MEMORY
void post_create_inferior(struct target_ops *target, int from_tty)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
const struct trace_file_write_ops * ops
void warning(const char *fmt,...)
struct type ** const(pascal_builtin_types[])
void push_target(struct target_ops *t)
initialize_file_ftype _initialize_ctf
void buffer_free(struct buffer *buffer)
void internal_error(const char *file, int line, const char *fmt,...)
#define CTF_EVENT_ID_FRAME
static void ctf_write_uploaded_tp(struct trace_file_writer *self, struct uploaded_tp *tp)
static void ctf_write_frame_m_block_header(struct trace_file_writer *self, uint64_t addr, uint16_t length)
#define VEC_safe_push(T, V, O)
int gdbarch_num_regs(struct gdbarch *gdbarch)
struct tracepoint * get_tracepoint(int num)
#define CTF_EVENT_ID_TSV_DEF
static void ctf_write_uploaded_tsv(struct trace_file_writer *self, struct uploaded_tsv *tsv)
ULONGEST traceframe_usage
static int ctf_save_write(struct trace_write_handler *handler, const gdb_byte *buf, size_t size)
void printf_filtered(const char *format,...)
static const struct trace_file_write_ops ctf_write_ops
static void ctf_save_next_packet(struct trace_write_handler *handler)
struct trace_status * current_trace_status(void)
static void ctf_end(struct trace_file_writer *self)
struct uploaded_tp * get_uploaded_tp(int num, ULONGEST addr, struct uploaded_tp **utpp)
struct trace_write_handler tcs
#define VEC_iterate(T, V, I, P)
struct tracepoint * get_tracepoint_by_number_on_target(int num)
#define CTF_EVENT_ID_REGISTER
static void ctf_write_status(struct trace_file_writer *self, struct trace_status *ts)
void merge_uploaded_tracepoints(struct uploaded_tp **uploaded_tps)
struct uploaded_tsv * get_uploaded_tsv(int num, struct uploaded_tsv **utsvp)
void initialize_file_ftype(void)
void merge_uploaded_trace_state_variables(struct uploaded_tsv **uploaded_tsvs)
static void ctf_save_metadata_header(struct trace_write_handler *handler)
void trace_reset_local_state(void)
static int ctf_save_fseek(struct trace_write_handler *handler, long offset, int whence)
enum trace_stop_reason stop_reason
ptid_t pid_to_ptid(int pid)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void init_tracefile_ops(struct target_ops *ops)
int get_traceframe_number(void)
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
#define CTF_EVENT_ID_STATUS
static void ctf_write_frame_end(struct trace_file_writer *self)
void add_target_with_completer(struct target_ops *t, completer_ftype *completer)
enum target_xfer_status exec_read_partial_read_only(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
static void ctf_write_frame_r_block(struct trace_file_writer *self, gdb_byte *buf, int32_t size)
struct thread_info * add_thread_silent(ptid_t ptid)
char * xstrprintf(const char *format,...)
struct trace_file_writer base
enum target_xfer_status section_table_read_available_memory(gdb_byte *readbuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
#define ctf_save_write_int32(HANDLER, INT32)
#define ctf_save_write_uint32(HANDLER, U32)
#define CTF_EVENT_ID_TP_DEF
int ptid_get_pid(ptid_t ptid)
const char const char int
ULONGEST align_up(ULONGEST v, int n)
void tracefile_fetch_registers(struct regcache *regcache, int regno)
enum register_status regcache_register_status(const struct regcache *regcache, int regnum)
#define CTF_METADATA_NAME
char * safe_strerror(int)
struct trace_file_writer * ctf_trace_file_writer_new(void)
static void ctf_write_frame_v_block(struct trace_file_writer *self, int32_t num, uint64_t val)
static void ctf_write_definition_end(struct trace_file_writer *self)
struct inferior * current_inferior(void)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
#define CTF_DATASTREAM_NAME
unsigned long long ULONGEST
static void ATTRIBUTE_PRINTF(6, 0)
void exit_inferior_silent(int pid)
int register_size(struct gdbarch *gdbarch, int regnum)
static void ctf_write_regblock_type(struct trace_file_writer *self, int size)
static const struct trace_frame_write_ops ctf_write_frame_ops
static int ctf_target_save(struct trace_file_writer *self, const char *dirname)
static void ctf_write_frame_m_block_memory(struct trace_file_writer *self, gdb_byte *buf, uint16_t length)
static void ctf_save_write_metadata(struct trace_write_handler *handler, const char *format,...) ATTRIBUTE_PRINTF(2
void target_preopen(int from_tty)
static void ctf_write_header(struct trace_file_writer *self)
static int ctf_save_align_write(struct trace_write_handler *handler, const gdb_byte *buf, size_t size, size_t align_size)
void error(const char *fmt,...)
static void ctf_start(struct trace_file_writer *self, const char *dirname)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
void inferior_appeared(struct inferior *inf, int pid)
static void ctf_write_frame_start(struct trace_file_writer *self, uint16_t tpnum)
void do_cleanups(struct cleanup *old_chain)
const ULONGEST const LONGEST len