3 Copyright (C) 2012-2018 Free Software Foundation, Inc.
4 Contributed by Hui Zhu <hui_zhu@mentor.com>
5 Contributed by Yao Qi <yao@codesourcery.com>
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "tracepoint.h"
28 #include "completer.h"
30 #include "gdbthread.h"
31 #include "tracefile.h"
37 class ctf_target final : public tracefile_target
40 const char *shortname () override
43 const char *longname () override
44 { return _("CTF file"); }
46 const char *doc () override
49 Use a CTF directory as a target.\n\
50 Specify the filename of the CTF directory.");
53 void open (const char *, int) override;
54 void close () override;
55 void fetch_registers (struct regcache *, int) override;
56 enum target_xfer_status xfer_partial (enum target_object object,
59 const gdb_byte *writebuf,
60 ULONGEST offset, ULONGEST len,
61 ULONGEST *xfered_len) override;
62 void files_info () override;
63 int trace_find (enum trace_find_type type, int num,
64 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override;
65 int get_trace_state_variable_value (int tsv, LONGEST *val) override;
66 traceframe_info_up traceframe_info () override;
69 /* GDB saves trace buffers and other information (such as trace
70 status) got from the remote target into Common Trace Format (CTF).
71 The following types of information are expected to save in CTF:
73 1. The length (in bytes) of register cache. Event "register" will
74 be defined in metadata, which includes the length.
76 2. Trace status. Event "status" is defined in metadata, which
77 includes all aspects of trace status.
79 3. Uploaded trace variables. Event "tsv_def" is defined in
80 metadata, which is about all aspects of a uploaded trace variable.
81 Uploaded tracepoints. Event "tp_def" is defined in meta, which
82 is about all aspects of an uploaded tracepoint. Note that the
83 "sequence" (a CTF type, which is a dynamically-sized array.) is
84 used for "actions" "step_actions" and "cmd_strings".
86 4. Trace frames. Each trace frame is composed by several blocks
87 of different types ('R', 'M', 'V'). One trace frame is saved in
88 one CTF packet and the blocks of this frame are saved as events.
89 4.1: The trace frame related information (such as the number of
90 tracepoint associated with this frame) is saved in the packet
92 4.2: The block 'M', 'R' and 'V' are saved in event "memory",
93 "register" and "tsv" respectively.
94 4.3: When iterating over events, babeltrace can't tell iterator
95 goes to a new packet, so we need a marker or anchor to tell GDB
96 that iterator goes into a new packet or frame. We define event
99 #define CTF_MAGIC 0xC1FC1FC1
100 #define CTF_SAVE_MAJOR 1
101 #define CTF_SAVE_MINOR 8
103 #define CTF_METADATA_NAME "metadata"
104 #define CTF_DATASTREAM_NAME "datastream"
106 /* Reserved event id. */
108 #define CTF_EVENT_ID_REGISTER 0
109 #define CTF_EVENT_ID_TSV 1
110 #define CTF_EVENT_ID_MEMORY 2
111 #define CTF_EVENT_ID_FRAME 3
112 #define CTF_EVENT_ID_STATUS 4
113 #define CTF_EVENT_ID_TSV_DEF 5
114 #define CTF_EVENT_ID_TP_DEF 6
118 /* The state kept while writing the CTF datastream file. */
120 struct trace_write_handler
122 /* File descriptor of metadata. */
124 /* File descriptor of traceframes. */
127 /* This is the content size of the current packet. */
130 /* This is the start offset of current packet. */
134 /* Write metadata in FORMAT. */
137 ctf_save_write_metadata (struct trace_write_handler *handler,
138 const char *format, ...)
139 ATTRIBUTE_PRINTF (2, 3);
142 ctf_save_write_metadata (struct trace_write_handler *handler,
143 const char *format, ...)
147 va_start (args, format);
148 if (vfprintf (handler->metadata_fd, format, args) < 0)
149 error (_("Unable to write metadata file (%s)"),
150 safe_strerror (errno));
154 /* Write BUF of length SIZE to datastream file represented by
158 ctf_save_write (struct trace_write_handler *handler,
159 const gdb_byte *buf, size_t size)
161 if (fwrite (buf, size, 1, handler->datastream_fd) != 1)
162 error (_("Unable to write file for saving trace data (%s)"),
163 safe_strerror (errno));
165 handler->content_size += size;
170 /* Write a unsigned 32-bit integer to datastream file represented by
173 #define ctf_save_write_uint32(HANDLER, U32) \
174 ctf_save_write (HANDLER, (gdb_byte *) &U32, 4)
176 /* Write a signed 32-bit integer to datastream file represented by
179 #define ctf_save_write_int32(HANDLER, INT32) \
180 ctf_save_write ((HANDLER), (gdb_byte *) &(INT32), 4)
182 /* Set datastream file position. Update HANDLER->content_size
183 if WHENCE is SEEK_CUR. */
186 ctf_save_fseek (struct trace_write_handler *handler, long offset,
189 gdb_assert (whence != SEEK_END);
190 gdb_assert (whence != SEEK_SET
191 || offset <= handler->content_size + handler->packet_start);
193 if (fseek (handler->datastream_fd, offset, whence))
194 error (_("Unable to seek file for saving trace data (%s)"),
195 safe_strerror (errno));
197 if (whence == SEEK_CUR)
198 handler->content_size += offset;
203 /* Change the datastream file position to align on ALIGN_SIZE,
204 and write BUF to datastream file. The size of BUF is SIZE. */
207 ctf_save_align_write (struct trace_write_handler *handler,
209 size_t size, size_t align_size)
212 = (align_up (handler->content_size, align_size)
213 - handler->content_size);
215 if (ctf_save_fseek (handler, offset, SEEK_CUR))
218 if (ctf_save_write (handler, buf, size))
224 /* Write events to next new packet. */
227 ctf_save_next_packet (struct trace_write_handler *handler)
229 handler->packet_start += (handler->content_size + 4);
230 ctf_save_fseek (handler, handler->packet_start, SEEK_SET);
231 handler->content_size = 0;
234 /* Write the CTF metadata header. */
237 ctf_save_metadata_header (struct trace_write_handler *handler)
239 ctf_save_write_metadata (handler, "/* CTF %d.%d */\n",
240 CTF_SAVE_MAJOR, CTF_SAVE_MINOR);
241 ctf_save_write_metadata (handler,
242 "typealias integer { size = 8; align = 8; "
243 "signed = false; encoding = ascii;}"
245 ctf_save_write_metadata (handler,
246 "typealias integer { size = 8; align = 8; "
249 ctf_save_write_metadata (handler,
250 "typealias integer { size = 16; align = 16;"
251 "signed = false; } := uint16_t;\n");
252 ctf_save_write_metadata (handler,
253 "typealias integer { size = 32; align = 32;"
254 "signed = false; } := uint32_t;\n");
255 ctf_save_write_metadata (handler,
256 "typealias integer { size = 64; align = 64;"
257 "signed = false; base = hex;}"
259 ctf_save_write_metadata (handler,
260 "typealias integer { size = 32; align = 32;"
261 "signed = true; } := int32_t;\n");
262 ctf_save_write_metadata (handler,
263 "typealias integer { size = 64; align = 64;"
264 "signed = true; } := int64_t;\n");
265 ctf_save_write_metadata (handler,
266 "typealias string { encoding = ascii;"
268 ctf_save_write_metadata (handler, "\n");
270 /* Get the byte order of the host and write CTF data in this byte
273 #define HOST_ENDIANNESS "be"
275 #define HOST_ENDIANNESS "le"
278 ctf_save_write_metadata (handler,
282 " byte_order = %s;\n"
283 " packet.header := struct {\n"
289 " packet.context := struct {\n"
290 " uint32_t content_size;\n"
291 " uint32_t packet_size;\n"
294 " event.header := struct {\n"
298 CTF_SAVE_MAJOR, CTF_SAVE_MINOR,
300 ctf_save_write_metadata (handler, "\n");
303 /* CTF trace writer. */
305 struct ctf_trace_file_writer
307 struct trace_file_writer base;
309 /* States related to writing CTF trace file. */
310 struct trace_write_handler tcs;
313 /* This is the implementation of trace_file_write_ops method
317 ctf_dtor (struct trace_file_writer *self)
319 struct ctf_trace_file_writer *writer
320 = (struct ctf_trace_file_writer *) self;
322 if (writer->tcs.metadata_fd != NULL)
323 fclose (writer->tcs.metadata_fd);
325 if (writer->tcs.datastream_fd != NULL)
326 fclose (writer->tcs.datastream_fd);
330 /* This is the implementation of trace_file_write_ops method
334 ctf_target_save (struct trace_file_writer *self,
337 /* Don't support save trace file to CTF format in the target. */
341 /* This is the implementation of trace_file_write_ops method
342 start. It creates the directory DIRNAME, metadata and datastream
346 ctf_start (struct trace_file_writer *self, const char *dirname)
348 struct ctf_trace_file_writer *writer
349 = (struct ctf_trace_file_writer *) self;
350 mode_t hmode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH;
352 /* Create DIRNAME. */
353 if (mkdir (dirname, hmode) && errno != EEXIST)
354 error (_("Unable to open directory '%s' for saving trace data (%s)"),
355 dirname, safe_strerror (errno));
357 memset (&writer->tcs, '\0', sizeof (writer->tcs));
359 std::string file_name = string_printf ("%s/%s", dirname, CTF_METADATA_NAME);
361 writer->tcs.metadata_fd = fopen (file_name.c_str (), "w");
362 if (writer->tcs.metadata_fd == NULL)
363 error (_("Unable to open file '%s' for saving trace data (%s)"),
364 file_name.c_str (), safe_strerror (errno));
366 ctf_save_metadata_header (&writer->tcs);
368 file_name = string_printf ("%s/%s", dirname, CTF_DATASTREAM_NAME);
369 writer->tcs.datastream_fd = fopen (file_name.c_str (), "w");
370 if (writer->tcs.datastream_fd == NULL)
371 error (_("Unable to open file '%s' for saving trace data (%s)"),
372 file_name.c_str (), safe_strerror (errno));
375 /* This is the implementation of trace_file_write_ops method
376 write_header. Write the types of events on trace variable and
380 ctf_write_header (struct trace_file_writer *self)
382 struct ctf_trace_file_writer *writer
383 = (struct ctf_trace_file_writer *) self;
386 ctf_save_write_metadata (&writer->tcs, "\n");
387 ctf_save_write_metadata (&writer->tcs,
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"
394 "};\n", CTF_EVENT_ID_MEMORY);
396 ctf_save_write_metadata (&writer->tcs, "\n");
397 ctf_save_write_metadata (&writer->tcs,
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"
403 "};\n", CTF_EVENT_ID_TSV);
405 ctf_save_write_metadata (&writer->tcs, "\n");
406 ctf_save_write_metadata (&writer->tcs,
407 "event {\n\tname = \"frame\";\n\tid = %u;\n"
408 "\tfields := struct { \n"
410 "};\n", CTF_EVENT_ID_FRAME);
412 ctf_save_write_metadata (&writer->tcs, "\n");
413 ctf_save_write_metadata (&writer->tcs,
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"
421 "};\n", CTF_EVENT_ID_TSV_DEF);
423 ctf_save_write_metadata (&writer->tcs, "\n");
424 ctf_save_write_metadata (&writer->tcs,
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"
449 "};\n", CTF_EVENT_ID_TP_DEF);
451 gdb_assert (writer->tcs.content_size == 0);
452 gdb_assert (writer->tcs.packet_start == 0);
454 /* Create a new packet to contain this event. */
455 self->ops->frame_ops->start (self, 0);
458 /* This is the implementation of trace_file_write_ops method
459 write_regblock_type. Write the type of register event in
463 ctf_write_regblock_type (struct trace_file_writer *self, int size)
465 struct ctf_trace_file_writer *writer
466 = (struct ctf_trace_file_writer *) self;
468 ctf_save_write_metadata (&writer->tcs, "\n");
470 ctf_save_write_metadata (&writer->tcs,
471 "event {\n\tname = \"register\";\n\tid = %u;\n"
472 "\tfields := struct { \n"
473 "\t\tascii contents[%d];\n"
476 CTF_EVENT_ID_REGISTER, size);
479 /* This is the implementation of trace_file_write_ops method
483 ctf_write_status (struct trace_file_writer *self,
484 struct trace_status *ts)
486 struct ctf_trace_file_writer *writer
487 = (struct ctf_trace_file_writer *) self;
490 ctf_save_write_metadata (&writer->tcs, "\n");
491 ctf_save_write_metadata (&writer->tcs,
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"
504 CTF_EVENT_ID_STATUS);
506 id = CTF_EVENT_ID_STATUS;
508 ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
510 ctf_save_write_int32 (&writer->tcs, ts->stop_reason);
511 ctf_save_write_int32 (&writer->tcs, ts->stopping_tracepoint);
512 ctf_save_write_int32 (&writer->tcs, ts->traceframe_count);
513 ctf_save_write_int32 (&writer->tcs, ts->traceframes_created);
514 ctf_save_write_int32 (&writer->tcs, ts->buffer_free);
515 ctf_save_write_int32 (&writer->tcs, ts->buffer_size);
516 ctf_save_write_int32 (&writer->tcs, ts->disconnected_tracing);
517 ctf_save_write_int32 (&writer->tcs, ts->circular_buffer);
520 /* This is the implementation of trace_file_write_ops method
521 write_uploaded_tsv. */
524 ctf_write_uploaded_tsv (struct trace_file_writer *self,
525 struct uploaded_tsv *tsv)
527 struct ctf_trace_file_writer *writer
528 = (struct ctf_trace_file_writer *) self;
531 const gdb_byte zero = 0;
534 int32 = CTF_EVENT_ID_TSV_DEF;
535 ctf_save_align_write (&writer->tcs, (gdb_byte *) &int32, 4, 4);
538 int64 = tsv->initial_value;
539 ctf_save_align_write (&writer->tcs, (gdb_byte *) &int64, 8, 8);
542 ctf_save_write_int32 (&writer->tcs, tsv->number);
545 ctf_save_write_int32 (&writer->tcs, tsv->builtin);
548 if (tsv->name != NULL)
549 ctf_save_write (&writer->tcs, (gdb_byte *) tsv->name,
551 ctf_save_write (&writer->tcs, &zero, 1);
554 /* This is the implementation of trace_file_write_ops method
555 write_uploaded_tp. */
558 ctf_write_uploaded_tp (struct trace_file_writer *self,
559 struct uploaded_tp *tp)
561 struct ctf_trace_file_writer *writer
562 = (struct ctf_trace_file_writer *) self;
566 const gdb_byte zero = 0;
569 int32 = CTF_EVENT_ID_TP_DEF;
570 ctf_save_align_write (&writer->tcs, (gdb_byte *) &int32, 4, 4);
574 ctf_save_align_write (&writer->tcs, (gdb_byte *) &int64, 8, 8);
576 /* traceframe_usage */
577 int64 = tp->traceframe_usage;
578 ctf_save_align_write (&writer->tcs, (gdb_byte *) &int64, 8, 8);
581 ctf_save_write_int32 (&writer->tcs, tp->number);
584 ctf_save_write_int32 (&writer->tcs, tp->enabled);
587 ctf_save_write_int32 (&writer->tcs, tp->step);
590 ctf_save_write_int32 (&writer->tcs, tp->pass);
593 ctf_save_write_int32 (&writer->tcs, tp->hit_count);
596 ctf_save_write_int32 (&writer->tcs, tp->type);
599 if (tp->cond != NULL)
600 ctf_save_write (&writer->tcs, (gdb_byte *) tp->cond, strlen (tp->cond));
601 ctf_save_write (&writer->tcs, &zero, 1);
604 u32 = tp->actions.size ();
605 ctf_save_align_write (&writer->tcs, (gdb_byte *) &u32, 4, 4);
606 for (char *act : tp->actions)
607 ctf_save_write (&writer->tcs, (gdb_byte *) act, strlen (act) + 1);
610 u32 = tp->step_actions.size ();
611 ctf_save_align_write (&writer->tcs, (gdb_byte *) &u32, 4, 4);
612 for (char *act : tp->step_actions)
613 ctf_save_write (&writer->tcs, (gdb_byte *) act, strlen (act) + 1);
616 if (tp->at_string != NULL)
617 ctf_save_write (&writer->tcs, (gdb_byte *) tp->at_string,
618 strlen (tp->at_string));
619 ctf_save_write (&writer->tcs, &zero, 1);
622 if (tp->cond_string != NULL)
623 ctf_save_write (&writer->tcs, (gdb_byte *) tp->cond_string,
624 strlen (tp->cond_string));
625 ctf_save_write (&writer->tcs, &zero, 1);
628 u32 = tp->cmd_strings.size ();
629 ctf_save_align_write (&writer->tcs, (gdb_byte *) &u32, 4, 4);
630 for (char *act : tp->cmd_strings)
631 ctf_save_write (&writer->tcs, (gdb_byte *) act, strlen (act) + 1);
635 /* This is the implementation of trace_file_write_ops method
639 ctf_write_tdesc (struct trace_file_writer *self)
641 /* Nothing so far. */
644 /* This is the implementation of trace_file_write_ops method
645 write_definition_end. */
648 ctf_write_definition_end (struct trace_file_writer *self)
650 self->ops->frame_ops->end (self);
653 /* This is the implementation of trace_file_write_ops method
657 ctf_end (struct trace_file_writer *self)
659 struct ctf_trace_file_writer *writer = (struct ctf_trace_file_writer *) self;
661 gdb_assert (writer->tcs.content_size == 0);
664 /* This is the implementation of trace_frame_write_ops method
668 ctf_write_frame_start (struct trace_file_writer *self, uint16_t tpnum)
670 struct ctf_trace_file_writer *writer
671 = (struct ctf_trace_file_writer *) self;
672 uint32_t id = CTF_EVENT_ID_FRAME;
675 /* Step 1: Write packet context. */
678 ctf_save_write_uint32 (&writer->tcs, u32);
679 /* content_size and packet_size.. We still don't know the value,
681 ctf_save_fseek (&writer->tcs, 4, SEEK_CUR);
682 ctf_save_fseek (&writer->tcs, 4, SEEK_CUR);
683 /* Tracepoint number. */
684 ctf_save_write (&writer->tcs, (gdb_byte *) &tpnum, 2);
686 /* Step 2: Write event "frame". */
688 ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
691 /* This is the implementation of trace_frame_write_ops method
695 ctf_write_frame_r_block (struct trace_file_writer *self,
696 gdb_byte *buf, int32_t size)
698 struct ctf_trace_file_writer *writer
699 = (struct ctf_trace_file_writer *) self;
700 uint32_t id = CTF_EVENT_ID_REGISTER;
703 ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
705 /* array contents. */
706 ctf_save_align_write (&writer->tcs, buf, size, 1);
709 /* This is the implementation of trace_frame_write_ops method
710 write_m_block_header. */
713 ctf_write_frame_m_block_header (struct trace_file_writer *self,
714 uint64_t addr, uint16_t length)
716 struct ctf_trace_file_writer *writer
717 = (struct ctf_trace_file_writer *) self;
718 uint32_t event_id = CTF_EVENT_ID_MEMORY;
721 ctf_save_align_write (&writer->tcs, (gdb_byte *) &event_id, 4, 4);
724 ctf_save_align_write (&writer->tcs, (gdb_byte *) &addr, 8, 8);
727 ctf_save_align_write (&writer->tcs, (gdb_byte *) &length, 2, 2);
730 /* This is the implementation of trace_frame_write_ops method
731 write_m_block_memory. */
734 ctf_write_frame_m_block_memory (struct trace_file_writer *self,
735 gdb_byte *buf, uint16_t length)
737 struct ctf_trace_file_writer *writer
738 = (struct ctf_trace_file_writer *) self;
741 ctf_save_align_write (&writer->tcs, (gdb_byte *) buf, length, 1);
744 /* This is the implementation of trace_frame_write_ops method
748 ctf_write_frame_v_block (struct trace_file_writer *self,
749 int32_t num, uint64_t val)
751 struct ctf_trace_file_writer *writer
752 = (struct ctf_trace_file_writer *) self;
753 uint32_t id = CTF_EVENT_ID_TSV;
756 ctf_save_align_write (&writer->tcs, (gdb_byte *) &id, 4, 4);
759 ctf_save_align_write (&writer->tcs, (gdb_byte *) &val, 8, 8);
761 ctf_save_align_write (&writer->tcs, (gdb_byte *) &num, 4, 4);
764 /* This is the implementation of trace_frame_write_ops method
768 ctf_write_frame_end (struct trace_file_writer *self)
770 struct ctf_trace_file_writer *writer
771 = (struct ctf_trace_file_writer *) self;
775 /* Write the content size to packet header. */
776 ctf_save_fseek (&writer->tcs, writer->tcs.packet_start + 4,
778 u32 = writer->tcs.content_size * TARGET_CHAR_BIT;
780 t = writer->tcs.content_size;
781 ctf_save_write_uint32 (&writer->tcs, u32);
783 /* Write the packet size. */
784 u32 += 4 * TARGET_CHAR_BIT;
785 ctf_save_write_uint32 (&writer->tcs, u32);
787 writer->tcs.content_size = t;
789 /* Write zero at the end of the packet. */
790 ctf_save_fseek (&writer->tcs, writer->tcs.packet_start + t,
793 ctf_save_write_uint32 (&writer->tcs, u32);
794 writer->tcs.content_size = t;
796 ctf_save_next_packet (&writer->tcs);
799 /* Operations to write various types of trace frames into CTF
802 static const struct trace_frame_write_ops ctf_write_frame_ops =
804 ctf_write_frame_start,
805 ctf_write_frame_r_block,
806 ctf_write_frame_m_block_header,
807 ctf_write_frame_m_block_memory,
808 ctf_write_frame_v_block,
812 /* Operations to write trace buffers into CTF format. */
814 static const struct trace_file_write_ops ctf_write_ops =
820 ctf_write_regblock_type,
822 ctf_write_uploaded_tsv,
823 ctf_write_uploaded_tp,
825 ctf_write_definition_end,
827 &ctf_write_frame_ops,
831 /* Return a trace writer for CTF format. */
833 struct trace_file_writer *
834 ctf_trace_file_writer_new (void)
836 struct ctf_trace_file_writer *writer = XNEW (struct ctf_trace_file_writer);
838 writer->base.ops = &ctf_write_ops;
840 return (struct trace_file_writer *) writer;
843 #if HAVE_LIBBABELTRACE
844 /* Use libbabeltrace to read CTF data. The libbabeltrace provides
845 iterator to iterate over each event in CTF data and APIs to get
846 details of event and packet, so it is very convenient to use
847 libbabeltrace to access events in CTF. */
849 #include <babeltrace/babeltrace.h>
850 #include <babeltrace/ctf/events.h>
851 #include <babeltrace/ctf/iterator.h>
853 /* The struct pointer for current CTF directory. */
854 static int handle_id = -1;
855 static struct bt_context *ctx = NULL;
856 static struct bt_ctf_iter *ctf_iter = NULL;
857 /* The position of the first packet containing trace frame. */
858 static struct bt_iter_pos *start_pos;
860 /* The name of CTF directory. */
861 static char *trace_dirname;
863 static ctf_target ctf_ops;
865 /* Destroy ctf iterator and context. */
870 if (ctf_iter != NULL)
872 bt_ctf_iter_destroy (ctf_iter);
877 bt_context_put (ctx);
882 /* Open CTF trace data in DIRNAME. */
885 ctf_open_dir (const char *dirname)
887 struct bt_iter_pos begin_pos;
888 unsigned int count, i;
889 struct bt_ctf_event_decl * const *list;
891 ctx = bt_context_create ();
893 error (_("Unable to create bt_context"));
894 handle_id = bt_context_add_trace (ctx, dirname, "ctf", NULL, NULL, NULL);
898 error (_("Unable to use libbabeltrace on directory \"%s\""),
902 begin_pos.type = BT_SEEK_BEGIN;
903 ctf_iter = bt_ctf_iter_create (ctx, &begin_pos, NULL);
904 if (ctf_iter == NULL)
907 error (_("Unable to create bt_iterator"));
910 /* Look for the declaration of register block. Get the length of
911 array "contents" to set trace_regblock_size. */
913 bt_ctf_get_event_decl_list (handle_id, ctx, &list, &count);
914 for (i = 0; i < count; i++)
915 if (strcmp ("register", bt_ctf_get_decl_event_name (list[i])) == 0)
917 const struct bt_ctf_field_decl * const *field_list;
918 const struct bt_declaration *decl;
920 bt_ctf_get_decl_fields (list[i], BT_EVENT_FIELDS, &field_list,
923 gdb_assert (count == 1);
924 gdb_assert (0 == strcmp ("contents",
925 bt_ctf_get_decl_field_name (field_list[0])));
926 decl = bt_ctf_get_decl_from_field_decl (field_list[0]);
927 trace_regblock_size = bt_ctf_get_array_len (decl);
933 #define SET_INT32_FIELD(EVENT, SCOPE, VAR, FIELD) \
934 (VAR)->FIELD = (int) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
938 #define SET_ENUM_FIELD(EVENT, SCOPE, VAR, TYPE, FIELD) \
939 (VAR)->FIELD = (TYPE) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
944 /* EVENT is the "status" event and TS is filled in. */
947 ctf_read_status (struct bt_ctf_event *event, struct trace_status *ts)
949 const struct bt_definition *scope
950 = bt_ctf_get_top_level_scope (event, BT_EVENT_FIELDS);
952 SET_ENUM_FIELD (event, scope, ts, enum trace_stop_reason, stop_reason);
953 SET_INT32_FIELD (event, scope, ts, stopping_tracepoint);
954 SET_INT32_FIELD (event, scope, ts, traceframe_count);
955 SET_INT32_FIELD (event, scope, ts, traceframes_created);
956 SET_INT32_FIELD (event, scope, ts, buffer_free);
957 SET_INT32_FIELD (event, scope, ts, buffer_size);
958 SET_INT32_FIELD (event, scope, ts, disconnected_tracing);
959 SET_INT32_FIELD (event, scope, ts, circular_buffer);
961 bt_iter_next (bt_ctf_get_iter (ctf_iter));
964 /* Read the events "tsv_def" one by one, extract its contents and fill
965 in the list UPLOADED_TSVS. */
968 ctf_read_tsv (struct uploaded_tsv **uploaded_tsvs)
970 gdb_assert (ctf_iter != NULL);
974 struct bt_ctf_event *event;
975 const struct bt_definition *scope;
976 const struct bt_definition *def;
978 struct uploaded_tsv *utsv = NULL;
980 event = bt_ctf_iter_read_event (ctf_iter);
981 scope = bt_ctf_get_top_level_scope (event,
982 BT_STREAM_EVENT_HEADER);
983 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
985 if (event_id != CTF_EVENT_ID_TSV_DEF)
988 scope = bt_ctf_get_top_level_scope (event,
991 def = bt_ctf_get_field (event, scope, "number");
992 utsv = get_uploaded_tsv ((int32_t) bt_ctf_get_int64 (def),
995 def = bt_ctf_get_field (event, scope, "builtin");
996 utsv->builtin = (int32_t) bt_ctf_get_int64 (def);
997 def = bt_ctf_get_field (event, scope, "initial_value");
998 utsv->initial_value = bt_ctf_get_int64 (def);
1000 def = bt_ctf_get_field (event, scope, "name");
1001 utsv->name = xstrdup (bt_ctf_get_string (def));
1003 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1009 /* Read the value of element whose index is NUM from CTF and write it
1010 to the corresponding VAR->ARRAY. */
1012 #define SET_ARRAY_FIELD(EVENT, SCOPE, VAR, NUM, ARRAY) \
1016 const struct bt_definition *def; \
1018 u32 = (uint32_t) bt_ctf_get_uint64 (bt_ctf_get_field ((EVENT), \
1021 def = bt_ctf_get_field ((EVENT), (SCOPE), #ARRAY); \
1022 for (i = 0; i < u32; i++) \
1024 const struct bt_definition *element \
1025 = bt_ctf_get_index ((EVENT), def, i); \
1027 (VAR)->ARRAY.push_back \
1028 (xstrdup (bt_ctf_get_string (element))); \
1033 /* Read a string from CTF and set VAR->FIELD. If the length of string
1034 is zero, set VAR->FIELD to NULL. */
1036 #define SET_STRING_FIELD(EVENT, SCOPE, VAR, FIELD) \
1039 const char *p = bt_ctf_get_string (bt_ctf_get_field ((EVENT), \
1043 if (strlen (p) > 0) \
1044 (VAR)->FIELD = xstrdup (p); \
1046 (VAR)->FIELD = NULL; \
1050 /* Read the events "tp_def" one by one, extract its contents and fill
1051 in the list UPLOADED_TPS. */
1054 ctf_read_tp (struct uploaded_tp **uploaded_tps)
1056 gdb_assert (ctf_iter != NULL);
1060 struct bt_ctf_event *event;
1061 const struct bt_definition *scope;
1065 struct uploaded_tp *utp = NULL;
1067 event = bt_ctf_iter_read_event (ctf_iter);
1068 scope = bt_ctf_get_top_level_scope (event,
1069 BT_STREAM_EVENT_HEADER);
1070 u32 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1072 if (u32 != CTF_EVENT_ID_TP_DEF)
1075 scope = bt_ctf_get_top_level_scope (event,
1077 int32 = (int32_t) bt_ctf_get_int64 (bt_ctf_get_field (event,
1080 u64 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope,
1082 utp = get_uploaded_tp (int32, u64, uploaded_tps);
1084 SET_INT32_FIELD (event, scope, utp, enabled);
1085 SET_INT32_FIELD (event, scope, utp, step);
1086 SET_INT32_FIELD (event, scope, utp, pass);
1087 SET_INT32_FIELD (event, scope, utp, hit_count);
1088 SET_ENUM_FIELD (event, scope, utp, enum bptype, type);
1090 /* Read 'cmd_strings'. */
1091 SET_ARRAY_FIELD (event, scope, utp, cmd_num, cmd_strings);
1092 /* Read 'actions'. */
1093 SET_ARRAY_FIELD (event, scope, utp, action_num, actions);
1094 /* Read 'step_actions'. */
1095 SET_ARRAY_FIELD (event, scope, utp, step_action_num,
1098 SET_STRING_FIELD(event, scope, utp, at_string);
1099 SET_STRING_FIELD(event, scope, utp, cond_string);
1101 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1106 /* This is the implementation of target_ops method to_open. Open CTF
1107 trace data, read trace status, trace state variables and tracepoint
1108 definitions from the first packet. Set the start position at the
1109 second packet which contains events on trace blocks. */
1112 ctf_target::open (const char *dirname, int from_tty)
1114 struct bt_ctf_event *event;
1116 const struct bt_definition *scope;
1117 struct uploaded_tsv *uploaded_tsvs = NULL;
1118 struct uploaded_tp *uploaded_tps = NULL;
1121 error (_("No CTF directory specified."));
1123 ctf_open_dir (dirname);
1125 target_preopen (from_tty);
1127 /* Skip the first packet which about the trace status. The first
1128 event is "frame". */
1129 event = bt_ctf_iter_read_event (ctf_iter);
1130 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1131 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
1132 if (event_id != CTF_EVENT_ID_FRAME)
1133 error (_("Wrong event id of the first event"));
1134 /* The second event is "status". */
1135 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1136 event = bt_ctf_iter_read_event (ctf_iter);
1137 scope = bt_ctf_get_top_level_scope (event, BT_STREAM_EVENT_HEADER);
1138 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
1139 if (event_id != CTF_EVENT_ID_STATUS)
1140 error (_("Wrong event id of the second event"));
1141 ctf_read_status (event, current_trace_status ());
1143 ctf_read_tsv (&uploaded_tsvs);
1145 ctf_read_tp (&uploaded_tps);
1147 event = bt_ctf_iter_read_event (ctf_iter);
1148 /* EVENT can be NULL if we've already gone to the end of stream of
1152 scope = bt_ctf_get_top_level_scope (event,
1153 BT_STREAM_EVENT_HEADER);
1154 event_id = bt_ctf_get_uint64 (bt_ctf_get_field (event,
1156 if (event_id != CTF_EVENT_ID_FRAME)
1157 error (_("Wrong event id of the first event of the second packet"));
1160 start_pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1161 gdb_assert (start_pos->type == BT_SEEK_RESTORE);
1163 trace_dirname = xstrdup (dirname);
1164 push_target (&ctf_ops);
1166 inferior_appeared (current_inferior (), CTF_PID);
1167 inferior_ptid = pid_to_ptid (CTF_PID);
1168 add_thread_silent (inferior_ptid);
1170 merge_uploaded_trace_state_variables (&uploaded_tsvs);
1171 merge_uploaded_tracepoints (&uploaded_tps);
1173 post_create_inferior (&ctf_ops, from_tty);
1176 /* This is the implementation of target_ops method to_close. Destroy
1177 CTF iterator and context. */
1180 ctf_target::close ()
1185 xfree (trace_dirname);
1186 trace_dirname = NULL;
1188 pid = ptid_get_pid (inferior_ptid);
1189 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
1190 exit_inferior_silent (pid);
1192 trace_reset_local_state ();
1195 /* This is the implementation of target_ops method to_files_info.
1196 Print the directory name of CTF trace data. */
1199 ctf_target::files_info ()
1201 printf_filtered ("\t`%s'\n", trace_dirname);
1204 /* This is the implementation of target_ops method to_fetch_registers.
1205 Iterate over events whose name is "register" in current frame,
1206 extract contents from events, and set REGCACHE with the contents.
1207 If no matched events are found, mark registers unavailable. */
1210 ctf_target::fetch_registers (struct regcache *regcache, int regno)
1212 struct gdbarch *gdbarch = regcache->arch ();
1213 struct bt_ctf_event *event = NULL;
1214 struct bt_iter_pos *pos;
1216 /* An uninitialized reg size says we're not going to be
1217 successful at getting register blocks. */
1218 if (trace_regblock_size == 0)
1221 gdb_assert (ctf_iter != NULL);
1222 /* Save the current position. */
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)
1247 /* Restore the position. */
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);
1260 /* Assume the block is laid out in GDB register number order,
1261 each register with the size that it has in GDB. */
1263 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
1265 regsize = register_size (gdbarch, regn);
1266 /* Make sure we stay within block bounds. */
1267 if (offset + regsize >= trace_regblock_size)
1269 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
1273 regcache_raw_supply (regcache, regno, regs + offset);
1276 else if (regno == -1)
1278 regcache_raw_supply (regcache, regn, regs + offset);
1285 tracefile_fetch_registers (regcache, regno);
1288 /* This is the implementation of target_ops method to_xfer_partial.
1289 Iterate over events whose name is "memory" in
1290 current frame, extract the address and length from events. If
1291 OFFSET is within the range, read the contents from events to
1294 enum target_xfer_status
1295 ctf_target::xfer_partial (enum target_object object,
1296 const char *annex, gdb_byte *readbuf,
1297 const gdb_byte *writebuf, ULONGEST offset,
1298 ULONGEST len, ULONGEST *xfered_len)
1300 /* We're only doing regular memory for now. */
1301 if (object != TARGET_OBJECT_MEMORY)
1302 return TARGET_XFER_E_IO;
1304 if (readbuf == NULL)
1305 error (_("ctf_xfer_partial: trace file is read-only"));
1307 if (get_traceframe_number () != -1)
1309 struct bt_iter_pos *pos;
1310 enum target_xfer_status res;
1311 /* Records the lowest available address of all blocks that
1312 intersects the requested range. */
1313 ULONGEST low_addr_available = 0;
1315 gdb_assert (ctf_iter != NULL);
1316 /* Save the current position. */
1317 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1318 gdb_assert (pos->type == BT_SEEK_RESTORE);
1320 /* Iterate through the traceframe's blocks, looking for
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);
1351 /* If the block includes the first part of the desired
1352 range, return as much it has; GDB will re-request the
1353 remainder, which might be in a different block of this
1355 if (maddr <= offset && offset < (maddr + mlen))
1357 const struct bt_definition *array
1358 = bt_ctf_get_field (event, scope, "contents");
1362 contents = (gdb_byte *) xmalloc (mlen);
1364 for (k = 0; k < mlen; k++)
1366 const struct bt_definition *element
1367 = bt_ctf_get_index (event, array, k);
1369 contents[k] = (gdb_byte) bt_ctf_get_uint64 (element);
1372 amt = (maddr + mlen) - offset;
1376 memcpy (readbuf, &contents[offset - maddr], amt);
1380 /* Restore the position. */
1381 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1384 return TARGET_XFER_EOF;
1388 return TARGET_XFER_OK;
1392 if (offset < maddr && maddr < (offset + len))
1393 if (low_addr_available == 0 || low_addr_available > maddr)
1394 low_addr_available = maddr;
1396 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1400 /* Restore the position. */
1401 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1403 /* Requested memory is unavailable in the context of traceframes,
1404 and this address falls within a read-only section, fallback
1405 to reading from executable, up to LOW_ADDR_AVAILABLE */
1406 if (offset < low_addr_available)
1407 len = std::min (len, low_addr_available - offset);
1408 res = exec_read_partial_read_only (readbuf, offset, len, xfered_len);
1410 if (res == TARGET_XFER_OK)
1411 return TARGET_XFER_OK;
1414 /* No use trying further, we know some memory starting
1415 at MEMADDR isn't available. */
1417 return TARGET_XFER_UNAVAILABLE;
1422 /* Fallback to reading from read-only sections. */
1423 return section_table_read_available_memory (readbuf, offset, len, xfered_len);
1427 /* This is the implementation of target_ops method
1428 to_get_trace_state_variable_value.
1429 Iterate over events whose name is "tsv" in current frame. When the
1430 trace variable is found, set the value of it to *VAL and return
1431 true, otherwise return false. */
1434 ctf_target::get_trace_state_variable_value (int tsvnum, LONGEST *val)
1436 struct bt_iter_pos *pos;
1439 gdb_assert (ctf_iter != NULL);
1440 /* Save the current position. */
1441 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1442 gdb_assert (pos->type == BT_SEEK_RESTORE);
1444 /* Iterate through the traceframe's blocks, looking for 'V'
1448 struct bt_ctf_event *event
1449 = bt_ctf_iter_read_event (ctf_iter);
1450 const char *name = bt_ctf_event_name (event);
1452 if (name == NULL || strcmp (name, "frame") == 0)
1454 else if (strcmp (name, "tsv") == 0)
1456 const struct bt_definition *scope;
1457 const struct bt_definition *def;
1459 scope = bt_ctf_get_top_level_scope (event,
1462 def = bt_ctf_get_field (event, scope, "num");
1463 if (tsvnum == (int32_t) bt_ctf_get_uint64 (def))
1465 def = bt_ctf_get_field (event, scope, "val");
1466 *val = bt_ctf_get_uint64 (def);
1472 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1476 /* Restore the position. */
1477 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1482 /* Return the tracepoint number in "frame" event. */
1485 ctf_get_tpnum_from_frame_event (struct bt_ctf_event *event)
1487 /* The packet context of events has a field "tpnum". */
1488 const struct bt_definition *scope
1489 = bt_ctf_get_top_level_scope (event, BT_STREAM_PACKET_CONTEXT);
1491 = bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "tpnum"));
1496 /* Return the address at which the current frame was collected. */
1499 ctf_get_traceframe_address (void)
1501 struct bt_ctf_event *event = NULL;
1502 struct bt_iter_pos *pos;
1505 gdb_assert (ctf_iter != NULL);
1506 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1507 gdb_assert (pos->type == BT_SEEK_RESTORE);
1512 struct bt_ctf_event *event1;
1514 event1 = bt_ctf_iter_read_event (ctf_iter);
1516 name = bt_ctf_event_name (event1);
1520 else if (strcmp (name, "frame") == 0)
1526 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1532 int tpnum = ctf_get_tpnum_from_frame_event (event);
1533 struct tracepoint *tp
1534 = get_tracepoint_by_number_on_target (tpnum);
1537 addr = tp->loc->address;
1540 /* Restore the position. */
1541 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1546 /* This is the implementation of target_ops method to_trace_find.
1547 Iterate the events whose name is "frame", extract the tracepoint
1548 number in it. Return traceframe number when matched. */
1551 ctf_target::trace_find (enum trace_find_type type, int num,
1552 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
1564 gdb_assert (ctf_iter != NULL);
1565 /* Set iterator back to the start. */
1566 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), start_pos);
1570 struct bt_ctf_event *event;
1573 event = bt_ctf_iter_read_event (ctf_iter);
1575 name = bt_ctf_event_name (event);
1577 if (event == NULL || name == NULL)
1580 if (strcmp (name, "frame") == 0)
1584 if (type == tfind_number)
1586 /* Looking for a specific trace frame. */
1592 /* Start from the _next_ trace frame. */
1593 if (tfnum > get_traceframe_number ())
1599 struct tracepoint *tp = get_tracepoint (num);
1602 && (tp->number_on_target
1603 == ctf_get_tpnum_from_frame_event (event)))
1608 tfaddr = ctf_get_traceframe_address ();
1609 if (tfaddr == addr1)
1613 tfaddr = ctf_get_traceframe_address ();
1614 if (addr1 <= tfaddr && tfaddr <= addr2)
1618 tfaddr = ctf_get_traceframe_address ();
1619 if (!(addr1 <= tfaddr && tfaddr <= addr2))
1623 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
1630 *tpp = ctf_get_tpnum_from_frame_event (event);
1632 /* Skip the event "frame". */
1633 bt_iter_next (bt_ctf_get_iter (ctf_iter));
1640 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1647 /* This is the implementation of target_ops method to_traceframe_info.
1648 Iterate the events whose name is "memory", in current
1649 frame, extract memory range information, and return them in
1653 ctf_target::traceframe_info ()
1655 traceframe_info_up info (new struct traceframe_info);
1657 struct bt_iter_pos *pos;
1659 gdb_assert (ctf_iter != NULL);
1660 /* Save the current position. */
1661 pos = bt_iter_get_pos (bt_ctf_get_iter (ctf_iter));
1662 gdb_assert (pos->type == BT_SEEK_RESTORE);
1666 struct bt_ctf_event *event
1667 = bt_ctf_iter_read_event (ctf_iter);
1669 name = bt_ctf_event_name (event);
1671 if (name == NULL || strcmp (name, "register") == 0
1672 || strcmp (name, "frame") == 0)
1674 else if (strcmp (name, "memory") == 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, "address");
1682 CORE_ADDR start = bt_ctf_get_uint64 (def);
1684 def = bt_ctf_get_field (event, scope, "length");
1685 int length = (uint16_t) bt_ctf_get_uint64 (def);
1687 info->memory.emplace_back (start, length);
1689 else if (strcmp (name, "tsv") == 0)
1692 const struct bt_definition *scope
1693 = bt_ctf_get_top_level_scope (event,
1695 const struct bt_definition *def;
1697 def = bt_ctf_get_field (event, scope, "num");
1698 vnum = (int) bt_ctf_get_uint64 (def);
1699 info->tvars.push_back (vnum);
1703 warning (_("Unhandled trace block type (%s) "
1704 "while building trace frame info."),
1708 if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
1711 while (name != NULL && strcmp (name, "frame") != 0);
1713 /* Restore the position. */
1714 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), pos);
1721 /* module initialization */
1724 _initialize_ctf (void)
1726 #if HAVE_LIBBABELTRACE
1727 add_target_with_completer (&ctf_ops, filename_completer);