3 Copyright (C) 2012-2019 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 /* Standard C includes. */
28 /* Standard C++ includes. */
31 /* Local non-gdb includes. */
32 #include "common/filestuff.h"
33 #include "completer.h"
36 #include "gdbthread.h"
39 #include "tracefile.h"
40 #include "tracepoint.h"
44 static const target_info ctf_target_info
= {
47 N_("(Use a CTF directory as a target.\n\
48 Specify the filename of the CTF directory.")
51 class ctf_target final
: public tracefile_target
54 const target_info
&info () const override
55 { return ctf_target_info
; }
57 void close () override
;
58 void fetch_registers (struct regcache
*, int) override
;
59 enum target_xfer_status
xfer_partial (enum target_object object
,
62 const gdb_byte
*writebuf
,
63 ULONGEST offset
, ULONGEST len
,
64 ULONGEST
*xfered_len
) override
;
65 void files_info () override
;
66 int trace_find (enum trace_find_type type
, int num
,
67 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
68 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
69 traceframe_info_up
traceframe_info () override
;
72 /* GDB saves trace buffers and other information (such as trace
73 status) got from the remote target into Common Trace Format (CTF).
74 The following types of information are expected to save in CTF:
76 1. The length (in bytes) of register cache. Event "register" will
77 be defined in metadata, which includes the length.
79 2. Trace status. Event "status" is defined in metadata, which
80 includes all aspects of trace status.
82 3. Uploaded trace variables. Event "tsv_def" is defined in
83 metadata, which is about all aspects of a uploaded trace variable.
84 Uploaded tracepoints. Event "tp_def" is defined in meta, which
85 is about all aspects of an uploaded tracepoint. Note that the
86 "sequence" (a CTF type, which is a dynamically-sized array.) is
87 used for "actions" "step_actions" and "cmd_strings".
89 4. Trace frames. Each trace frame is composed by several blocks
90 of different types ('R', 'M', 'V'). One trace frame is saved in
91 one CTF packet and the blocks of this frame are saved as events.
92 4.1: The trace frame related information (such as the number of
93 tracepoint associated with this frame) is saved in the packet
95 4.2: The block 'M', 'R' and 'V' are saved in event "memory",
96 "register" and "tsv" respectively.
97 4.3: When iterating over events, babeltrace can't tell iterator
98 goes to a new packet, so we need a marker or anchor to tell GDB
99 that iterator goes into a new packet or frame. We define event
102 #define CTF_MAGIC 0xC1FC1FC1
103 #define CTF_SAVE_MAJOR 1
104 #define CTF_SAVE_MINOR 8
106 #define CTF_METADATA_NAME "metadata"
107 #define CTF_DATASTREAM_NAME "datastream"
109 /* Reserved event id. */
111 #define CTF_EVENT_ID_REGISTER 0
112 #define CTF_EVENT_ID_TSV 1
113 #define CTF_EVENT_ID_MEMORY 2
114 #define CTF_EVENT_ID_FRAME 3
115 #define CTF_EVENT_ID_STATUS 4
116 #define CTF_EVENT_ID_TSV_DEF 5
117 #define CTF_EVENT_ID_TP_DEF 6
121 /* The state kept while writing the CTF datastream file. */
123 struct trace_write_handler
125 /* File descriptor of metadata. */
127 /* File descriptor of traceframes. */
130 /* This is the content size of the current packet. */
133 /* This is the start offset of current packet. */
137 /* Write metadata in FORMAT. */
140 ctf_save_write_metadata (struct trace_write_handler
*handler
,
141 const char *format
, ...)
142 ATTRIBUTE_PRINTF (2, 3);
145 ctf_save_write_metadata (struct trace_write_handler
*handler
,
146 const char *format
, ...)
150 va_start (args
, format
);
151 if (vfprintf (handler
->metadata_fd
, format
, args
) < 0)
152 error (_("Unable to write metadata file (%s)"),
153 safe_strerror (errno
));
157 /* Write BUF of length SIZE to datastream file represented by
161 ctf_save_write (struct trace_write_handler
*handler
,
162 const gdb_byte
*buf
, size_t size
)
164 if (fwrite (buf
, size
, 1, handler
->datastream_fd
) != 1)
165 error (_("Unable to write file for saving trace data (%s)"),
166 safe_strerror (errno
));
168 handler
->content_size
+= size
;
173 /* Write a unsigned 32-bit integer to datastream file represented by
176 #define ctf_save_write_uint32(HANDLER, U32) \
177 ctf_save_write (HANDLER, (gdb_byte *) &U32, 4)
179 /* Write a signed 32-bit integer to datastream file represented by
182 #define ctf_save_write_int32(HANDLER, INT32) \
183 ctf_save_write ((HANDLER), (gdb_byte *) &(INT32), 4)
185 /* Set datastream file position. Update HANDLER->content_size
186 if WHENCE is SEEK_CUR. */
189 ctf_save_fseek (struct trace_write_handler
*handler
, long offset
,
192 gdb_assert (whence
!= SEEK_END
);
193 gdb_assert (whence
!= SEEK_SET
194 || offset
<= handler
->content_size
+ handler
->packet_start
);
196 if (fseek (handler
->datastream_fd
, offset
, whence
))
197 error (_("Unable to seek file for saving trace data (%s)"),
198 safe_strerror (errno
));
200 if (whence
== SEEK_CUR
)
201 handler
->content_size
+= offset
;
206 /* Change the datastream file position to align on ALIGN_SIZE,
207 and write BUF to datastream file. The size of BUF is SIZE. */
210 ctf_save_align_write (struct trace_write_handler
*handler
,
212 size_t size
, size_t align_size
)
215 = (align_up (handler
->content_size
, align_size
)
216 - handler
->content_size
);
218 if (ctf_save_fseek (handler
, offset
, SEEK_CUR
))
221 if (ctf_save_write (handler
, buf
, size
))
227 /* Write events to next new packet. */
230 ctf_save_next_packet (struct trace_write_handler
*handler
)
232 handler
->packet_start
+= (handler
->content_size
+ 4);
233 ctf_save_fseek (handler
, handler
->packet_start
, SEEK_SET
);
234 handler
->content_size
= 0;
237 /* Write the CTF metadata header. */
240 ctf_save_metadata_header (struct trace_write_handler
*handler
)
242 ctf_save_write_metadata (handler
, "/* CTF %d.%d */\n",
243 CTF_SAVE_MAJOR
, CTF_SAVE_MINOR
);
244 ctf_save_write_metadata (handler
,
245 "typealias integer { size = 8; align = 8; "
246 "signed = false; encoding = ascii;}"
248 ctf_save_write_metadata (handler
,
249 "typealias integer { size = 8; align = 8; "
252 ctf_save_write_metadata (handler
,
253 "typealias integer { size = 16; align = 16;"
254 "signed = false; } := uint16_t;\n");
255 ctf_save_write_metadata (handler
,
256 "typealias integer { size = 32; align = 32;"
257 "signed = false; } := uint32_t;\n");
258 ctf_save_write_metadata (handler
,
259 "typealias integer { size = 64; align = 64;"
260 "signed = false; base = hex;}"
262 ctf_save_write_metadata (handler
,
263 "typealias integer { size = 32; align = 32;"
264 "signed = true; } := int32_t;\n");
265 ctf_save_write_metadata (handler
,
266 "typealias integer { size = 64; align = 64;"
267 "signed = true; } := int64_t;\n");
268 ctf_save_write_metadata (handler
,
269 "typealias string { encoding = ascii;"
271 ctf_save_write_metadata (handler
, "\n");
273 /* Get the byte order of the host and write CTF data in this byte
276 #define HOST_ENDIANNESS "be"
278 #define HOST_ENDIANNESS "le"
281 ctf_save_write_metadata (handler
,
285 " byte_order = %s;\n"
286 " packet.header := struct {\n"
292 " packet.context := struct {\n"
293 " uint32_t content_size;\n"
294 " uint32_t packet_size;\n"
297 " event.header := struct {\n"
301 CTF_SAVE_MAJOR
, CTF_SAVE_MINOR
,
303 ctf_save_write_metadata (handler
, "\n");
306 /* CTF trace writer. */
308 struct ctf_trace_file_writer
310 struct trace_file_writer base
;
312 /* States related to writing CTF trace file. */
313 struct trace_write_handler tcs
;
316 /* This is the implementation of trace_file_write_ops method
320 ctf_dtor (struct trace_file_writer
*self
)
322 struct ctf_trace_file_writer
*writer
323 = (struct ctf_trace_file_writer
*) self
;
325 if (writer
->tcs
.metadata_fd
!= NULL
)
326 fclose (writer
->tcs
.metadata_fd
);
328 if (writer
->tcs
.datastream_fd
!= NULL
)
329 fclose (writer
->tcs
.datastream_fd
);
333 /* This is the implementation of trace_file_write_ops method
337 ctf_target_save (struct trace_file_writer
*self
,
340 /* Don't support save trace file to CTF format in the target. */
344 /* This is the implementation of trace_file_write_ops method
345 start. It creates the directory DIRNAME, metadata and datastream
349 ctf_start (struct trace_file_writer
*self
, const char *dirname
)
351 struct ctf_trace_file_writer
*writer
352 = (struct ctf_trace_file_writer
*) self
;
353 mode_t hmode
= S_IRUSR
| S_IWUSR
| S_IXUSR
| S_IRGRP
| S_IXGRP
| S_IROTH
;
355 /* Create DIRNAME. */
356 if (mkdir (dirname
, hmode
) && errno
!= EEXIST
)
357 error (_("Unable to open directory '%s' for saving trace data (%s)"),
358 dirname
, safe_strerror (errno
));
360 memset (&writer
->tcs
, '\0', sizeof (writer
->tcs
));
362 std::string file_name
= string_printf ("%s/%s", dirname
, CTF_METADATA_NAME
);
364 writer
->tcs
.metadata_fd
365 = gdb_fopen_cloexec (file_name
.c_str (), "w").release ();
366 if (writer
->tcs
.metadata_fd
== NULL
)
367 error (_("Unable to open file '%s' for saving trace data (%s)"),
368 file_name
.c_str (), safe_strerror (errno
));
370 ctf_save_metadata_header (&writer
->tcs
);
372 file_name
= string_printf ("%s/%s", dirname
, CTF_DATASTREAM_NAME
);
373 writer
->tcs
.datastream_fd
374 = gdb_fopen_cloexec (file_name
.c_str (), "w").release ();
375 if (writer
->tcs
.datastream_fd
== NULL
)
376 error (_("Unable to open file '%s' for saving trace data (%s)"),
377 file_name
.c_str (), safe_strerror (errno
));
380 /* This is the implementation of trace_file_write_ops method
381 write_header. Write the types of events on trace variable and
385 ctf_write_header (struct trace_file_writer
*self
)
387 struct ctf_trace_file_writer
*writer
388 = (struct ctf_trace_file_writer
*) self
;
391 ctf_save_write_metadata (&writer
->tcs
, "\n");
392 ctf_save_write_metadata (&writer
->tcs
,
393 "event {\n\tname = \"memory\";\n\tid = %u;\n"
394 "\tfields := struct { \n"
395 "\t\tuint64_t address;\n"
396 "\t\tuint16_t length;\n"
397 "\t\tuint8_t contents[length];\n"
399 "};\n", CTF_EVENT_ID_MEMORY
);
401 ctf_save_write_metadata (&writer
->tcs
, "\n");
402 ctf_save_write_metadata (&writer
->tcs
,
403 "event {\n\tname = \"tsv\";\n\tid = %u;\n"
404 "\tfields := struct { \n"
405 "\t\tuint64_t val;\n"
406 "\t\tuint32_t num;\n"
408 "};\n", CTF_EVENT_ID_TSV
);
410 ctf_save_write_metadata (&writer
->tcs
, "\n");
411 ctf_save_write_metadata (&writer
->tcs
,
412 "event {\n\tname = \"frame\";\n\tid = %u;\n"
413 "\tfields := struct { \n"
415 "};\n", CTF_EVENT_ID_FRAME
);
417 ctf_save_write_metadata (&writer
->tcs
, "\n");
418 ctf_save_write_metadata (&writer
->tcs
,
419 "event {\n\tname = \"tsv_def\";\n"
420 "\tid = %u;\n\tfields := struct { \n"
421 "\t\tint64_t initial_value;\n"
422 "\t\tint32_t number;\n"
423 "\t\tint32_t builtin;\n"
426 "};\n", CTF_EVENT_ID_TSV_DEF
);
428 ctf_save_write_metadata (&writer
->tcs
, "\n");
429 ctf_save_write_metadata (&writer
->tcs
,
430 "event {\n\tname = \"tp_def\";\n"
431 "\tid = %u;\n\tfields := struct { \n"
432 "\t\tuint64_t addr;\n"
433 "\t\tuint64_t traceframe_usage;\n"
434 "\t\tint32_t number;\n"
435 "\t\tint32_t enabled;\n"
436 "\t\tint32_t step;\n"
437 "\t\tint32_t pass;\n"
438 "\t\tint32_t hit_count;\n"
439 "\t\tint32_t type;\n"
442 "\t\tuint32_t action_num;\n"
443 "\t\tchars actions[action_num];\n"
445 "\t\tuint32_t step_action_num;\n"
446 "\t\tchars step_actions[step_action_num];\n"
448 "\t\tchars at_string;\n"
449 "\t\tchars cond_string;\n"
451 "\t\tuint32_t cmd_num;\n"
452 "\t\tchars cmd_strings[cmd_num];\n"
454 "};\n", CTF_EVENT_ID_TP_DEF
);
456 gdb_assert (writer
->tcs
.content_size
== 0);
457 gdb_assert (writer
->tcs
.packet_start
== 0);
459 /* Create a new packet to contain this event. */
460 self
->ops
->frame_ops
->start (self
, 0);
463 /* This is the implementation of trace_file_write_ops method
464 write_regblock_type. Write the type of register event in
468 ctf_write_regblock_type (struct trace_file_writer
*self
, int size
)
470 struct ctf_trace_file_writer
*writer
471 = (struct ctf_trace_file_writer
*) self
;
473 ctf_save_write_metadata (&writer
->tcs
, "\n");
475 ctf_save_write_metadata (&writer
->tcs
,
476 "event {\n\tname = \"register\";\n\tid = %u;\n"
477 "\tfields := struct { \n"
478 "\t\tascii contents[%d];\n"
481 CTF_EVENT_ID_REGISTER
, size
);
484 /* This is the implementation of trace_file_write_ops method
488 ctf_write_status (struct trace_file_writer
*self
,
489 struct trace_status
*ts
)
491 struct ctf_trace_file_writer
*writer
492 = (struct ctf_trace_file_writer
*) self
;
495 ctf_save_write_metadata (&writer
->tcs
, "\n");
496 ctf_save_write_metadata (&writer
->tcs
,
497 "event {\n\tname = \"status\";\n\tid = %u;\n"
498 "\tfields := struct { \n"
499 "\t\tint32_t stop_reason;\n"
500 "\t\tint32_t stopping_tracepoint;\n"
501 "\t\tint32_t traceframe_count;\n"
502 "\t\tint32_t traceframes_created;\n"
503 "\t\tint32_t buffer_free;\n"
504 "\t\tint32_t buffer_size;\n"
505 "\t\tint32_t disconnected_tracing;\n"
506 "\t\tint32_t circular_buffer;\n"
509 CTF_EVENT_ID_STATUS
);
511 id
= CTF_EVENT_ID_STATUS
;
513 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
515 ctf_save_write_int32 (&writer
->tcs
, ts
->stop_reason
);
516 ctf_save_write_int32 (&writer
->tcs
, ts
->stopping_tracepoint
);
517 ctf_save_write_int32 (&writer
->tcs
, ts
->traceframe_count
);
518 ctf_save_write_int32 (&writer
->tcs
, ts
->traceframes_created
);
519 ctf_save_write_int32 (&writer
->tcs
, ts
->buffer_free
);
520 ctf_save_write_int32 (&writer
->tcs
, ts
->buffer_size
);
521 ctf_save_write_int32 (&writer
->tcs
, ts
->disconnected_tracing
);
522 ctf_save_write_int32 (&writer
->tcs
, ts
->circular_buffer
);
525 /* This is the implementation of trace_file_write_ops method
526 write_uploaded_tsv. */
529 ctf_write_uploaded_tsv (struct trace_file_writer
*self
,
530 struct uploaded_tsv
*tsv
)
532 struct ctf_trace_file_writer
*writer
533 = (struct ctf_trace_file_writer
*) self
;
536 const gdb_byte zero
= 0;
539 int32
= CTF_EVENT_ID_TSV_DEF
;
540 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int32
, 4, 4);
543 int64
= tsv
->initial_value
;
544 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int64
, 8, 8);
547 ctf_save_write_int32 (&writer
->tcs
, tsv
->number
);
550 ctf_save_write_int32 (&writer
->tcs
, tsv
->builtin
);
553 if (tsv
->name
!= NULL
)
554 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tsv
->name
,
556 ctf_save_write (&writer
->tcs
, &zero
, 1);
559 /* This is the implementation of trace_file_write_ops method
560 write_uploaded_tp. */
563 ctf_write_uploaded_tp (struct trace_file_writer
*self
,
564 struct uploaded_tp
*tp
)
566 struct ctf_trace_file_writer
*writer
567 = (struct ctf_trace_file_writer
*) self
;
571 const gdb_byte zero
= 0;
574 int32
= CTF_EVENT_ID_TP_DEF
;
575 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int32
, 4, 4);
579 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int64
, 8, 8);
581 /* traceframe_usage */
582 int64
= tp
->traceframe_usage
;
583 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int64
, 8, 8);
586 ctf_save_write_int32 (&writer
->tcs
, tp
->number
);
589 ctf_save_write_int32 (&writer
->tcs
, tp
->enabled
);
592 ctf_save_write_int32 (&writer
->tcs
, tp
->step
);
595 ctf_save_write_int32 (&writer
->tcs
, tp
->pass
);
598 ctf_save_write_int32 (&writer
->tcs
, tp
->hit_count
);
601 ctf_save_write_int32 (&writer
->tcs
, tp
->type
);
604 if (tp
->cond
!= NULL
)
605 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tp
->cond
.get (),
606 strlen (tp
->cond
.get ()));
607 ctf_save_write (&writer
->tcs
, &zero
, 1);
610 u32
= tp
->actions
.size ();
611 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &u32
, 4, 4);
612 for (const auto &act
: tp
->actions
)
613 ctf_save_write (&writer
->tcs
, (gdb_byte
*) act
.get (),
614 strlen (act
.get ()) + 1);
617 u32
= tp
->step_actions
.size ();
618 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &u32
, 4, 4);
619 for (const auto &act
: tp
->step_actions
)
620 ctf_save_write (&writer
->tcs
, (gdb_byte
*) act
.get (),
621 strlen (act
.get ()) + 1);
624 if (tp
->at_string
!= NULL
)
625 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tp
->at_string
.get (),
626 strlen (tp
->at_string
.get ()));
627 ctf_save_write (&writer
->tcs
, &zero
, 1);
630 if (tp
->cond_string
!= NULL
)
631 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tp
->cond_string
.get (),
632 strlen (tp
->cond_string
.get ()));
633 ctf_save_write (&writer
->tcs
, &zero
, 1);
636 u32
= tp
->cmd_strings
.size ();
637 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &u32
, 4, 4);
638 for (const auto &act
: tp
->cmd_strings
)
639 ctf_save_write (&writer
->tcs
, (gdb_byte
*) act
.get (),
640 strlen (act
.get ()) + 1);
644 /* This is the implementation of trace_file_write_ops method
648 ctf_write_tdesc (struct trace_file_writer
*self
)
650 /* Nothing so far. */
653 /* This is the implementation of trace_file_write_ops method
654 write_definition_end. */
657 ctf_write_definition_end (struct trace_file_writer
*self
)
659 self
->ops
->frame_ops
->end (self
);
662 /* This is the implementation of trace_file_write_ops method
666 ctf_end (struct trace_file_writer
*self
)
668 struct ctf_trace_file_writer
*writer
= (struct ctf_trace_file_writer
*) self
;
670 gdb_assert (writer
->tcs
.content_size
== 0);
673 /* This is the implementation of trace_frame_write_ops method
677 ctf_write_frame_start (struct trace_file_writer
*self
, uint16_t tpnum
)
679 struct ctf_trace_file_writer
*writer
680 = (struct ctf_trace_file_writer
*) self
;
681 uint32_t id
= CTF_EVENT_ID_FRAME
;
684 /* Step 1: Write packet context. */
687 ctf_save_write_uint32 (&writer
->tcs
, u32
);
688 /* content_size and packet_size.. We still don't know the value,
690 ctf_save_fseek (&writer
->tcs
, 4, SEEK_CUR
);
691 ctf_save_fseek (&writer
->tcs
, 4, SEEK_CUR
);
692 /* Tracepoint number. */
693 ctf_save_write (&writer
->tcs
, (gdb_byte
*) &tpnum
, 2);
695 /* Step 2: Write event "frame". */
697 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
700 /* This is the implementation of trace_frame_write_ops method
704 ctf_write_frame_r_block (struct trace_file_writer
*self
,
705 gdb_byte
*buf
, int32_t size
)
707 struct ctf_trace_file_writer
*writer
708 = (struct ctf_trace_file_writer
*) self
;
709 uint32_t id
= CTF_EVENT_ID_REGISTER
;
712 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
714 /* array contents. */
715 ctf_save_align_write (&writer
->tcs
, buf
, size
, 1);
718 /* This is the implementation of trace_frame_write_ops method
719 write_m_block_header. */
722 ctf_write_frame_m_block_header (struct trace_file_writer
*self
,
723 uint64_t addr
, uint16_t length
)
725 struct ctf_trace_file_writer
*writer
726 = (struct ctf_trace_file_writer
*) self
;
727 uint32_t event_id
= CTF_EVENT_ID_MEMORY
;
730 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &event_id
, 4, 4);
733 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &addr
, 8, 8);
736 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &length
, 2, 2);
739 /* This is the implementation of trace_frame_write_ops method
740 write_m_block_memory. */
743 ctf_write_frame_m_block_memory (struct trace_file_writer
*self
,
744 gdb_byte
*buf
, uint16_t length
)
746 struct ctf_trace_file_writer
*writer
747 = (struct ctf_trace_file_writer
*) self
;
750 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) buf
, length
, 1);
753 /* This is the implementation of trace_frame_write_ops method
757 ctf_write_frame_v_block (struct trace_file_writer
*self
,
758 int32_t num
, uint64_t val
)
760 struct ctf_trace_file_writer
*writer
761 = (struct ctf_trace_file_writer
*) self
;
762 uint32_t id
= CTF_EVENT_ID_TSV
;
765 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
768 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &val
, 8, 8);
770 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &num
, 4, 4);
773 /* This is the implementation of trace_frame_write_ops method
777 ctf_write_frame_end (struct trace_file_writer
*self
)
779 struct ctf_trace_file_writer
*writer
780 = (struct ctf_trace_file_writer
*) self
;
784 /* Write the content size to packet header. */
785 ctf_save_fseek (&writer
->tcs
, writer
->tcs
.packet_start
+ 4,
787 u32
= writer
->tcs
.content_size
* TARGET_CHAR_BIT
;
789 t
= writer
->tcs
.content_size
;
790 ctf_save_write_uint32 (&writer
->tcs
, u32
);
792 /* Write the packet size. */
793 u32
+= 4 * TARGET_CHAR_BIT
;
794 ctf_save_write_uint32 (&writer
->tcs
, u32
);
796 writer
->tcs
.content_size
= t
;
798 /* Write zero at the end of the packet. */
799 ctf_save_fseek (&writer
->tcs
, writer
->tcs
.packet_start
+ t
,
802 ctf_save_write_uint32 (&writer
->tcs
, u32
);
803 writer
->tcs
.content_size
= t
;
805 ctf_save_next_packet (&writer
->tcs
);
808 /* Operations to write various types of trace frames into CTF
811 static const struct trace_frame_write_ops ctf_write_frame_ops
=
813 ctf_write_frame_start
,
814 ctf_write_frame_r_block
,
815 ctf_write_frame_m_block_header
,
816 ctf_write_frame_m_block_memory
,
817 ctf_write_frame_v_block
,
821 /* Operations to write trace buffers into CTF format. */
823 static const struct trace_file_write_ops ctf_write_ops
=
829 ctf_write_regblock_type
,
831 ctf_write_uploaded_tsv
,
832 ctf_write_uploaded_tp
,
834 ctf_write_definition_end
,
836 &ctf_write_frame_ops
,
840 /* Return a trace writer for CTF format. */
842 struct trace_file_writer
*
843 ctf_trace_file_writer_new (void)
845 struct ctf_trace_file_writer
*writer
= XNEW (struct ctf_trace_file_writer
);
847 writer
->base
.ops
= &ctf_write_ops
;
849 return (struct trace_file_writer
*) writer
;
852 #if HAVE_LIBBABELTRACE
853 /* Use libbabeltrace to read CTF data. The libbabeltrace provides
854 iterator to iterate over each event in CTF data and APIs to get
855 details of event and packet, so it is very convenient to use
856 libbabeltrace to access events in CTF. */
858 #include <babeltrace/babeltrace.h>
859 #include <babeltrace/ctf/events.h>
860 #include <babeltrace/ctf/iterator.h>
862 /* The struct pointer for current CTF directory. */
863 static int handle_id
= -1;
864 static struct bt_context
*ctx
= NULL
;
865 static struct bt_ctf_iter
*ctf_iter
= NULL
;
866 /* The position of the first packet containing trace frame. */
867 static struct bt_iter_pos
*start_pos
;
869 /* The name of CTF directory. */
870 static char *trace_dirname
;
872 static ctf_target ctf_ops
;
874 /* Destroy ctf iterator and context. */
879 if (ctf_iter
!= NULL
)
881 bt_ctf_iter_destroy (ctf_iter
);
886 bt_context_put (ctx
);
891 /* Open CTF trace data in DIRNAME. */
894 ctf_open_dir (const char *dirname
)
896 struct bt_iter_pos begin_pos
;
897 unsigned int count
, i
;
898 struct bt_ctf_event_decl
* const *list
;
900 ctx
= bt_context_create ();
902 error (_("Unable to create bt_context"));
903 handle_id
= bt_context_add_trace (ctx
, dirname
, "ctf", NULL
, NULL
, NULL
);
907 error (_("Unable to use libbabeltrace on directory \"%s\""),
911 begin_pos
.type
= BT_SEEK_BEGIN
;
912 ctf_iter
= bt_ctf_iter_create (ctx
, &begin_pos
, NULL
);
913 if (ctf_iter
== NULL
)
916 error (_("Unable to create bt_iterator"));
919 /* Look for the declaration of register block. Get the length of
920 array "contents" to set trace_regblock_size. */
922 bt_ctf_get_event_decl_list (handle_id
, ctx
, &list
, &count
);
923 for (i
= 0; i
< count
; i
++)
924 if (strcmp ("register", bt_ctf_get_decl_event_name (list
[i
])) == 0)
926 const struct bt_ctf_field_decl
* const *field_list
;
927 const struct bt_declaration
*decl
;
929 bt_ctf_get_decl_fields (list
[i
], BT_EVENT_FIELDS
, &field_list
,
932 gdb_assert (count
== 1);
933 gdb_assert (0 == strcmp ("contents",
934 bt_ctf_get_decl_field_name (field_list
[0])));
935 decl
= bt_ctf_get_decl_from_field_decl (field_list
[0]);
936 trace_regblock_size
= bt_ctf_get_array_len (decl
);
942 #define SET_INT32_FIELD(EVENT, SCOPE, VAR, FIELD) \
943 (VAR)->FIELD = (int) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
947 #define SET_ENUM_FIELD(EVENT, SCOPE, VAR, TYPE, FIELD) \
948 (VAR)->FIELD = (TYPE) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
953 /* EVENT is the "status" event and TS is filled in. */
956 ctf_read_status (struct bt_ctf_event
*event
, struct trace_status
*ts
)
958 const struct bt_definition
*scope
959 = bt_ctf_get_top_level_scope (event
, BT_EVENT_FIELDS
);
961 SET_ENUM_FIELD (event
, scope
, ts
, enum trace_stop_reason
, stop_reason
);
962 SET_INT32_FIELD (event
, scope
, ts
, stopping_tracepoint
);
963 SET_INT32_FIELD (event
, scope
, ts
, traceframe_count
);
964 SET_INT32_FIELD (event
, scope
, ts
, traceframes_created
);
965 SET_INT32_FIELD (event
, scope
, ts
, buffer_free
);
966 SET_INT32_FIELD (event
, scope
, ts
, buffer_size
);
967 SET_INT32_FIELD (event
, scope
, ts
, disconnected_tracing
);
968 SET_INT32_FIELD (event
, scope
, ts
, circular_buffer
);
970 bt_iter_next (bt_ctf_get_iter (ctf_iter
));
973 /* Read the events "tsv_def" one by one, extract its contents and fill
974 in the list UPLOADED_TSVS. */
977 ctf_read_tsv (struct uploaded_tsv
**uploaded_tsvs
)
979 gdb_assert (ctf_iter
!= NULL
);
983 struct bt_ctf_event
*event
;
984 const struct bt_definition
*scope
;
985 const struct bt_definition
*def
;
987 struct uploaded_tsv
*utsv
= NULL
;
989 event
= bt_ctf_iter_read_event (ctf_iter
);
990 scope
= bt_ctf_get_top_level_scope (event
,
991 BT_STREAM_EVENT_HEADER
);
992 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
,
994 if (event_id
!= CTF_EVENT_ID_TSV_DEF
)
997 scope
= bt_ctf_get_top_level_scope (event
,
1000 def
= bt_ctf_get_field (event
, scope
, "number");
1001 utsv
= get_uploaded_tsv ((int32_t) bt_ctf_get_int64 (def
),
1004 def
= bt_ctf_get_field (event
, scope
, "builtin");
1005 utsv
->builtin
= (int32_t) bt_ctf_get_int64 (def
);
1006 def
= bt_ctf_get_field (event
, scope
, "initial_value");
1007 utsv
->initial_value
= bt_ctf_get_int64 (def
);
1009 def
= bt_ctf_get_field (event
, scope
, "name");
1010 utsv
->name
= xstrdup (bt_ctf_get_string (def
));
1012 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1018 /* Read the value of element whose index is NUM from CTF and write it
1019 to the corresponding VAR->ARRAY. */
1021 #define SET_ARRAY_FIELD(EVENT, SCOPE, VAR, NUM, ARRAY) \
1025 const struct bt_definition *def; \
1027 lu32 = (uint32_t) bt_ctf_get_uint64 (bt_ctf_get_field ((EVENT), \
1030 def = bt_ctf_get_field ((EVENT), (SCOPE), #ARRAY); \
1031 for (i = 0; i < lu32; i++) \
1033 const struct bt_definition *element \
1034 = bt_ctf_get_index ((EVENT), def, i); \
1036 (VAR)->ARRAY.emplace_back \
1037 (xstrdup (bt_ctf_get_string (element))); \
1042 /* Read a string from CTF and set VAR->FIELD. If the length of string
1043 is zero, set VAR->FIELD to NULL. */
1045 #define SET_STRING_FIELD(EVENT, SCOPE, VAR, FIELD) \
1048 const char *p = bt_ctf_get_string (bt_ctf_get_field ((EVENT), \
1052 if (strlen (p) > 0) \
1053 (VAR)->FIELD.reset (xstrdup (p)); \
1055 (VAR)->FIELD = NULL; \
1059 /* Read the events "tp_def" one by one, extract its contents and fill
1060 in the list UPLOADED_TPS. */
1063 ctf_read_tp (struct uploaded_tp
**uploaded_tps
)
1065 gdb_assert (ctf_iter
!= NULL
);
1069 struct bt_ctf_event
*event
;
1070 const struct bt_definition
*scope
;
1074 struct uploaded_tp
*utp
= NULL
;
1076 event
= bt_ctf_iter_read_event (ctf_iter
);
1077 scope
= bt_ctf_get_top_level_scope (event
,
1078 BT_STREAM_EVENT_HEADER
);
1079 u32
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
,
1081 if (u32
!= CTF_EVENT_ID_TP_DEF
)
1084 scope
= bt_ctf_get_top_level_scope (event
,
1086 int32
= (int32_t) bt_ctf_get_int64 (bt_ctf_get_field (event
,
1089 u64
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
,
1091 utp
= get_uploaded_tp (int32
, u64
, uploaded_tps
);
1093 SET_INT32_FIELD (event
, scope
, utp
, enabled
);
1094 SET_INT32_FIELD (event
, scope
, utp
, step
);
1095 SET_INT32_FIELD (event
, scope
, utp
, pass
);
1096 SET_INT32_FIELD (event
, scope
, utp
, hit_count
);
1097 SET_ENUM_FIELD (event
, scope
, utp
, enum bptype
, type
);
1099 /* Read 'cmd_strings'. */
1100 SET_ARRAY_FIELD (event
, scope
, utp
, cmd_num
, cmd_strings
);
1101 /* Read 'actions'. */
1102 SET_ARRAY_FIELD (event
, scope
, utp
, action_num
, actions
);
1103 /* Read 'step_actions'. */
1104 SET_ARRAY_FIELD (event
, scope
, utp
, step_action_num
,
1107 SET_STRING_FIELD(event
, scope
, utp
, at_string
);
1108 SET_STRING_FIELD(event
, scope
, utp
, cond_string
);
1110 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1115 /* This is the implementation of target_ops method to_open. Open CTF
1116 trace data, read trace status, trace state variables and tracepoint
1117 definitions from the first packet. Set the start position at the
1118 second packet which contains events on trace blocks. */
1121 ctf_target_open (const char *dirname
, int from_tty
)
1123 struct bt_ctf_event
*event
;
1125 const struct bt_definition
*scope
;
1126 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
1127 struct uploaded_tp
*uploaded_tps
= NULL
;
1130 error (_("No CTF directory specified."));
1132 ctf_open_dir (dirname
);
1134 target_preopen (from_tty
);
1136 /* Skip the first packet which about the trace status. The first
1137 event is "frame". */
1138 event
= bt_ctf_iter_read_event (ctf_iter
);
1139 scope
= bt_ctf_get_top_level_scope (event
, BT_STREAM_EVENT_HEADER
);
1140 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
, "id"));
1141 if (event_id
!= CTF_EVENT_ID_FRAME
)
1142 error (_("Wrong event id of the first event"));
1143 /* The second event is "status". */
1144 bt_iter_next (bt_ctf_get_iter (ctf_iter
));
1145 event
= bt_ctf_iter_read_event (ctf_iter
);
1146 scope
= bt_ctf_get_top_level_scope (event
, BT_STREAM_EVENT_HEADER
);
1147 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
, "id"));
1148 if (event_id
!= CTF_EVENT_ID_STATUS
)
1149 error (_("Wrong event id of the second event"));
1150 ctf_read_status (event
, current_trace_status ());
1152 ctf_read_tsv (&uploaded_tsvs
);
1154 ctf_read_tp (&uploaded_tps
);
1156 event
= bt_ctf_iter_read_event (ctf_iter
);
1157 /* EVENT can be NULL if we've already gone to the end of stream of
1161 scope
= bt_ctf_get_top_level_scope (event
,
1162 BT_STREAM_EVENT_HEADER
);
1163 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
,
1165 if (event_id
!= CTF_EVENT_ID_FRAME
)
1166 error (_("Wrong event id of the first event of the second packet"));
1169 start_pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1170 gdb_assert (start_pos
->type
== BT_SEEK_RESTORE
);
1172 trace_dirname
= xstrdup (dirname
);
1173 push_target (&ctf_ops
);
1175 inferior_appeared (current_inferior (), CTF_PID
);
1176 inferior_ptid
= ptid_t (CTF_PID
);
1177 add_thread_silent (inferior_ptid
);
1179 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
1180 merge_uploaded_tracepoints (&uploaded_tps
);
1182 post_create_inferior (&ctf_ops
, from_tty
);
1185 /* This is the implementation of target_ops method to_close. Destroy
1186 CTF iterator and context. */
1189 ctf_target::close ()
1192 xfree (trace_dirname
);
1193 trace_dirname
= NULL
;
1195 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
1196 exit_inferior_silent (current_inferior ());
1198 trace_reset_local_state ();
1201 /* This is the implementation of target_ops method to_files_info.
1202 Print the directory name of CTF trace data. */
1205 ctf_target::files_info ()
1207 printf_filtered ("\t`%s'\n", trace_dirname
);
1210 /* This is the implementation of target_ops method to_fetch_registers.
1211 Iterate over events whose name is "register" in current frame,
1212 extract contents from events, and set REGCACHE with the contents.
1213 If no matched events are found, mark registers unavailable. */
1216 ctf_target::fetch_registers (struct regcache
*regcache
, int regno
)
1218 struct gdbarch
*gdbarch
= regcache
->arch ();
1219 struct bt_ctf_event
*event
= NULL
;
1220 struct bt_iter_pos
*pos
;
1222 /* An uninitialized reg size says we're not going to be
1223 successful at getting register blocks. */
1224 if (trace_regblock_size
== 0)
1227 gdb_assert (ctf_iter
!= NULL
);
1228 /* Save the current position. */
1229 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1230 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1235 struct bt_ctf_event
*event1
;
1237 event1
= bt_ctf_iter_read_event (ctf_iter
);
1239 name
= bt_ctf_event_name (event1
);
1241 if (name
== NULL
|| strcmp (name
, "frame") == 0)
1243 else if (strcmp (name
, "register") == 0)
1249 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1253 /* Restore the position. */
1254 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1258 int offset
, regsize
, regn
;
1259 const struct bt_definition
*scope
1260 = bt_ctf_get_top_level_scope (event
,
1262 const struct bt_definition
*array
1263 = bt_ctf_get_field (event
, scope
, "contents");
1264 gdb_byte
*regs
= (gdb_byte
*) bt_ctf_get_char_array (array
);
1266 /* Assume the block is laid out in GDB register number order,
1267 each register with the size that it has in GDB. */
1269 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
1271 regsize
= register_size (gdbarch
, regn
);
1272 /* Make sure we stay within block bounds. */
1273 if (offset
+ regsize
>= trace_regblock_size
)
1275 if (regcache
->get_register_status (regn
) == REG_UNKNOWN
)
1279 regcache
->raw_supply (regno
, regs
+ offset
);
1282 else if (regno
== -1)
1284 regcache
->raw_supply (regn
, regs
+ offset
);
1291 tracefile_fetch_registers (regcache
, regno
);
1294 /* This is the implementation of target_ops method to_xfer_partial.
1295 Iterate over events whose name is "memory" in
1296 current frame, extract the address and length from events. If
1297 OFFSET is within the range, read the contents from events to
1300 enum target_xfer_status
1301 ctf_target::xfer_partial (enum target_object object
,
1302 const char *annex
, gdb_byte
*readbuf
,
1303 const gdb_byte
*writebuf
, ULONGEST offset
,
1304 ULONGEST len
, ULONGEST
*xfered_len
)
1306 /* We're only doing regular memory for now. */
1307 if (object
!= TARGET_OBJECT_MEMORY
)
1308 return TARGET_XFER_E_IO
;
1310 if (readbuf
== NULL
)
1311 error (_("ctf_xfer_partial: trace file is read-only"));
1313 if (get_traceframe_number () != -1)
1315 struct bt_iter_pos
*pos
;
1316 enum target_xfer_status res
;
1317 /* Records the lowest available address of all blocks that
1318 intersects the requested range. */
1319 ULONGEST low_addr_available
= 0;
1321 gdb_assert (ctf_iter
!= NULL
);
1322 /* Save the current position. */
1323 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1324 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1326 /* Iterate through the traceframe's blocks, looking for
1333 const struct bt_definition
*scope
;
1334 const struct bt_definition
*def
;
1335 struct bt_ctf_event
*event
1336 = bt_ctf_iter_read_event (ctf_iter
);
1337 const char *name
= bt_ctf_event_name (event
);
1339 if (name
== NULL
|| strcmp (name
, "frame") == 0)
1341 else if (strcmp (name
, "memory") != 0)
1343 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1349 scope
= bt_ctf_get_top_level_scope (event
,
1352 def
= bt_ctf_get_field (event
, scope
, "address");
1353 maddr
= bt_ctf_get_uint64 (def
);
1354 def
= bt_ctf_get_field (event
, scope
, "length");
1355 mlen
= (uint16_t) bt_ctf_get_uint64 (def
);
1357 /* If the block includes the first part of the desired
1358 range, return as much it has; GDB will re-request the
1359 remainder, which might be in a different block of this
1361 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
1363 const struct bt_definition
*array
1364 = bt_ctf_get_field (event
, scope
, "contents");
1368 contents
= (gdb_byte
*) xmalloc (mlen
);
1370 for (k
= 0; k
< mlen
; k
++)
1372 const struct bt_definition
*element
1373 = bt_ctf_get_index (event
, array
, k
);
1375 contents
[k
] = (gdb_byte
) bt_ctf_get_uint64 (element
);
1378 amt
= (maddr
+ mlen
) - offset
;
1382 memcpy (readbuf
, &contents
[offset
- maddr
], amt
);
1386 /* Restore the position. */
1387 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1390 return TARGET_XFER_EOF
;
1394 return TARGET_XFER_OK
;
1398 if (offset
< maddr
&& maddr
< (offset
+ len
))
1399 if (low_addr_available
== 0 || low_addr_available
> maddr
)
1400 low_addr_available
= maddr
;
1402 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1406 /* Restore the position. */
1407 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1409 /* Requested memory is unavailable in the context of traceframes,
1410 and this address falls within a read-only section, fallback
1411 to reading from executable, up to LOW_ADDR_AVAILABLE */
1412 if (offset
< low_addr_available
)
1413 len
= std::min (len
, low_addr_available
- offset
);
1414 res
= exec_read_partial_read_only (readbuf
, offset
, len
, xfered_len
);
1416 if (res
== TARGET_XFER_OK
)
1417 return TARGET_XFER_OK
;
1420 /* No use trying further, we know some memory starting
1421 at MEMADDR isn't available. */
1423 return TARGET_XFER_UNAVAILABLE
;
1428 /* Fallback to reading from read-only sections. */
1429 return section_table_read_available_memory (readbuf
, offset
, len
, xfered_len
);
1433 /* This is the implementation of target_ops method
1434 to_get_trace_state_variable_value.
1435 Iterate over events whose name is "tsv" in current frame. When the
1436 trace variable is found, set the value of it to *VAL and return
1437 true, otherwise return false. */
1440 ctf_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
1442 struct bt_iter_pos
*pos
;
1445 gdb_assert (ctf_iter
!= NULL
);
1446 /* Save the current position. */
1447 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1448 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1450 /* Iterate through the traceframe's blocks, looking for 'V'
1454 struct bt_ctf_event
*event
1455 = bt_ctf_iter_read_event (ctf_iter
);
1456 const char *name
= bt_ctf_event_name (event
);
1458 if (name
== NULL
|| strcmp (name
, "frame") == 0)
1460 else if (strcmp (name
, "tsv") == 0)
1462 const struct bt_definition
*scope
;
1463 const struct bt_definition
*def
;
1465 scope
= bt_ctf_get_top_level_scope (event
,
1468 def
= bt_ctf_get_field (event
, scope
, "num");
1469 if (tsvnum
== (int32_t) bt_ctf_get_uint64 (def
))
1471 def
= bt_ctf_get_field (event
, scope
, "val");
1472 *val
= bt_ctf_get_uint64 (def
);
1478 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1482 /* Restore the position. */
1483 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1488 /* Return the tracepoint number in "frame" event. */
1491 ctf_get_tpnum_from_frame_event (struct bt_ctf_event
*event
)
1493 /* The packet context of events has a field "tpnum". */
1494 const struct bt_definition
*scope
1495 = bt_ctf_get_top_level_scope (event
, BT_STREAM_PACKET_CONTEXT
);
1497 = bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
, "tpnum"));
1502 /* Return the address at which the current frame was collected. */
1505 ctf_get_traceframe_address (void)
1507 struct bt_ctf_event
*event
= NULL
;
1508 struct bt_iter_pos
*pos
;
1511 gdb_assert (ctf_iter
!= NULL
);
1512 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1513 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1518 struct bt_ctf_event
*event1
;
1520 event1
= bt_ctf_iter_read_event (ctf_iter
);
1522 name
= bt_ctf_event_name (event1
);
1526 else if (strcmp (name
, "frame") == 0)
1532 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1538 int tpnum
= ctf_get_tpnum_from_frame_event (event
);
1539 struct tracepoint
*tp
1540 = get_tracepoint_by_number_on_target (tpnum
);
1543 addr
= tp
->loc
->address
;
1546 /* Restore the position. */
1547 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1552 /* This is the implementation of target_ops method to_trace_find.
1553 Iterate the events whose name is "frame", extract the tracepoint
1554 number in it. Return traceframe number when matched. */
1557 ctf_target::trace_find (enum trace_find_type type
, int num
,
1558 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
1570 gdb_assert (ctf_iter
!= NULL
);
1571 /* Set iterator back to the start. */
1572 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), start_pos
);
1576 struct bt_ctf_event
*event
;
1579 event
= bt_ctf_iter_read_event (ctf_iter
);
1581 name
= bt_ctf_event_name (event
);
1583 if (event
== NULL
|| name
== NULL
)
1586 if (strcmp (name
, "frame") == 0)
1590 if (type
== tfind_number
)
1592 /* Looking for a specific trace frame. */
1598 /* Start from the _next_ trace frame. */
1599 if (tfnum
> get_traceframe_number ())
1605 struct tracepoint
*tp
= get_tracepoint (num
);
1608 && (tp
->number_on_target
1609 == ctf_get_tpnum_from_frame_event (event
)))
1614 tfaddr
= ctf_get_traceframe_address ();
1615 if (tfaddr
== addr1
)
1619 tfaddr
= ctf_get_traceframe_address ();
1620 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
1624 tfaddr
= ctf_get_traceframe_address ();
1625 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
1629 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
1636 *tpp
= ctf_get_tpnum_from_frame_event (event
);
1638 /* Skip the event "frame". */
1639 bt_iter_next (bt_ctf_get_iter (ctf_iter
));
1646 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1653 /* This is the implementation of target_ops method to_traceframe_info.
1654 Iterate the events whose name is "memory", in current
1655 frame, extract memory range information, and return them in
1659 ctf_target::traceframe_info ()
1661 traceframe_info_up
info (new struct traceframe_info
);
1663 struct bt_iter_pos
*pos
;
1665 gdb_assert (ctf_iter
!= NULL
);
1666 /* Save the current position. */
1667 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1668 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1672 struct bt_ctf_event
*event
1673 = bt_ctf_iter_read_event (ctf_iter
);
1675 name
= bt_ctf_event_name (event
);
1677 if (name
== NULL
|| strcmp (name
, "register") == 0
1678 || strcmp (name
, "frame") == 0)
1680 else if (strcmp (name
, "memory") == 0)
1682 const struct bt_definition
*scope
1683 = bt_ctf_get_top_level_scope (event
,
1685 const struct bt_definition
*def
;
1687 def
= bt_ctf_get_field (event
, scope
, "address");
1688 CORE_ADDR start
= bt_ctf_get_uint64 (def
);
1690 def
= bt_ctf_get_field (event
, scope
, "length");
1691 int length
= (uint16_t) bt_ctf_get_uint64 (def
);
1693 info
->memory
.emplace_back (start
, length
);
1695 else if (strcmp (name
, "tsv") == 0)
1698 const struct bt_definition
*scope
1699 = bt_ctf_get_top_level_scope (event
,
1701 const struct bt_definition
*def
;
1703 def
= bt_ctf_get_field (event
, scope
, "num");
1704 vnum
= (int) bt_ctf_get_uint64 (def
);
1705 info
->tvars
.push_back (vnum
);
1709 warning (_("Unhandled trace block type (%s) "
1710 "while building trace frame info."),
1714 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1717 while (name
!= NULL
&& strcmp (name
, "frame") != 0);
1719 /* Restore the position. */
1720 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1727 /* module initialization */
1730 _initialize_ctf (void)
1732 #if HAVE_LIBBABELTRACE
1733 add_target (ctf_target_info
, ctf_target_open
, filename_completer
);