3 Copyright (C) 2012-2015 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"
35 /* GDB saves trace buffers and other information (such as trace
36 status) got from the remote target into Common Trace Format (CTF).
37 The following types of information are expected to save in CTF:
39 1. The length (in bytes) of register cache. Event "register" will
40 be defined in metadata, which includes the length.
42 2. Trace status. Event "status" is defined in metadata, which
43 includes all aspects of trace status.
45 3. Uploaded trace variables. Event "tsv_def" is defined in
46 metadata, which is about all aspects of a uploaded trace variable.
47 Uploaded tracepoints. Event "tp_def" is defined in meta, which
48 is about all aspects of an uploaded tracepoint. Note that the
49 "sequence" (a CTF type, which is a dynamically-sized array.) is
50 used for "actions" "step_actions" and "cmd_strings".
52 4. Trace frames. Each trace frame is composed by several blocks
53 of different types ('R', 'M', 'V'). One trace frame is saved in
54 one CTF packet and the blocks of this frame are saved as events.
55 4.1: The trace frame related information (such as the number of
56 tracepoint associated with this frame) is saved in the packet
58 4.2: The block 'M', 'R' and 'V' are saved in event "memory",
59 "register" and "tsv" respectively.
60 4.3: When iterating over events, babeltrace can't tell iterator
61 goes to a new packet, so we need a marker or anchor to tell GDB
62 that iterator goes into a new packet or frame. We define event
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"
72 /* Reserved event id. */
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
84 /* The state kept while writing the CTF datastream file. */
86 struct trace_write_handler
88 /* File descriptor of metadata. */
90 /* File descriptor of traceframes. */
93 /* This is the content size of the current packet. */
96 /* This is the start offset of current packet. */
100 /* Write metadata in FORMAT. */
103 ctf_save_write_metadata (struct trace_write_handler
*handler
,
104 const char *format
, ...)
105 ATTRIBUTE_PRINTF (2, 3);
108 ctf_save_write_metadata (struct trace_write_handler
*handler
,
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)"),
116 safe_strerror (errno
));
120 /* Write BUF of length SIZE to datastream file represented by
124 ctf_save_write (struct trace_write_handler
*handler
,
125 const gdb_byte
*buf
, size_t size
)
127 if (fwrite (buf
, size
, 1, handler
->datastream_fd
) != 1)
128 error (_("Unable to write file for saving trace data (%s)"),
129 safe_strerror (errno
));
131 handler
->content_size
+= size
;
136 /* Write a unsigned 32-bit integer to datastream file represented by
139 #define ctf_save_write_uint32(HANDLER, U32) \
140 ctf_save_write (HANDLER, (gdb_byte *) &U32, 4)
142 /* Write a signed 32-bit integer to datastream file represented by
145 #define ctf_save_write_int32(HANDLER, INT32) \
146 ctf_save_write ((HANDLER), (gdb_byte *) &(INT32), 4)
148 /* Set datastream file position. Update HANDLER->content_size
149 if WHENCE is SEEK_CUR. */
152 ctf_save_fseek (struct trace_write_handler
*handler
, long offset
,
155 gdb_assert (whence
!= SEEK_END
);
156 gdb_assert (whence
!= SEEK_SET
157 || offset
<= handler
->content_size
+ handler
->packet_start
);
159 if (fseek (handler
->datastream_fd
, offset
, whence
))
160 error (_("Unable to seek file for saving trace data (%s)"),
161 safe_strerror (errno
));
163 if (whence
== SEEK_CUR
)
164 handler
->content_size
+= offset
;
169 /* Change the datastream file position to align on ALIGN_SIZE,
170 and write BUF to datastream file. The size of BUF is SIZE. */
173 ctf_save_align_write (struct trace_write_handler
*handler
,
175 size_t size
, size_t align_size
)
178 = (align_up (handler
->content_size
, align_size
)
179 - handler
->content_size
);
181 if (ctf_save_fseek (handler
, offset
, SEEK_CUR
))
184 if (ctf_save_write (handler
, buf
, size
))
190 /* Write events to next new packet. */
193 ctf_save_next_packet (struct trace_write_handler
*handler
)
195 handler
->packet_start
+= (handler
->content_size
+ 4);
196 ctf_save_fseek (handler
, handler
->packet_start
, SEEK_SET
);
197 handler
->content_size
= 0;
200 /* Write the CTF metadata header. */
203 ctf_save_metadata_header (struct trace_write_handler
*handler
)
205 const char metadata_fmt
[] =
209 " byte_order = %s;\n" /* be or le */
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"
226 ctf_save_write_metadata (handler
, "/* CTF %d.%d */\n",
227 CTF_SAVE_MAJOR
, CTF_SAVE_MINOR
);
228 ctf_save_write_metadata (handler
,
229 "typealias integer { size = 8; align = 8; "
230 "signed = false; encoding = ascii;}"
232 ctf_save_write_metadata (handler
,
233 "typealias integer { size = 8; align = 8; "
236 ctf_save_write_metadata (handler
,
237 "typealias integer { size = 16; align = 16;"
238 "signed = false; } := uint16_t;\n");
239 ctf_save_write_metadata (handler
,
240 "typealias integer { size = 32; align = 32;"
241 "signed = false; } := uint32_t;\n");
242 ctf_save_write_metadata (handler
,
243 "typealias integer { size = 64; align = 64;"
244 "signed = false; base = hex;}"
246 ctf_save_write_metadata (handler
,
247 "typealias integer { size = 32; align = 32;"
248 "signed = true; } := int32_t;\n");
249 ctf_save_write_metadata (handler
,
250 "typealias integer { size = 64; align = 64;"
251 "signed = true; } := int64_t;\n");
252 ctf_save_write_metadata (handler
,
253 "typealias string { encoding = ascii;"
255 ctf_save_write_metadata (handler
, "\n");
257 /* Get the byte order of the host and write CTF data in this byte
260 #define HOST_ENDIANNESS "be"
262 #define HOST_ENDIANNESS "le"
265 ctf_save_write_metadata (handler
, metadata_fmt
,
266 CTF_SAVE_MAJOR
, CTF_SAVE_MINOR
,
268 ctf_save_write_metadata (handler
, "\n");
271 /* CTF trace writer. */
273 struct ctf_trace_file_writer
275 struct trace_file_writer base
;
277 /* States related to writing CTF trace file. */
278 struct trace_write_handler tcs
;
281 /* This is the implementation of trace_file_write_ops method
285 ctf_dtor (struct trace_file_writer
*self
)
287 struct ctf_trace_file_writer
*writer
288 = (struct ctf_trace_file_writer
*) self
;
290 if (writer
->tcs
.metadata_fd
!= NULL
)
291 fclose (writer
->tcs
.metadata_fd
);
293 if (writer
->tcs
.datastream_fd
!= NULL
)
294 fclose (writer
->tcs
.datastream_fd
);
298 /* This is the implementation of trace_file_write_ops method
302 ctf_target_save (struct trace_file_writer
*self
,
305 /* Don't support save trace file to CTF format in the target. */
311 #define mkdir(pathname, mode) mkdir (pathname)
314 /* This is the implementation of trace_file_write_ops method
315 start. It creates the directory DIRNAME, metadata and datastream
319 ctf_start (struct trace_file_writer
*self
, const char *dirname
)
322 struct cleanup
*old_chain
;
323 struct ctf_trace_file_writer
*writer
324 = (struct ctf_trace_file_writer
*) self
;
326 mode_t hmode
= S_IRUSR
| S_IWUSR
| S_IXUSR
| S_IRGRP
| S_IXGRP
| S_IROTH
;
328 /* Create DIRNAME. */
329 if (mkdir (dirname
, hmode
) && errno
!= EEXIST
)
330 error (_("Unable to open directory '%s' for saving trace data (%s)"),
331 dirname
, safe_strerror (errno
));
333 memset (&writer
->tcs
, '\0', sizeof (writer
->tcs
));
335 file_name
= xstrprintf ("%s/%s", dirname
, CTF_METADATA_NAME
);
336 old_chain
= make_cleanup (xfree
, file_name
);
338 writer
->tcs
.metadata_fd
= fopen (file_name
, "w");
339 if (writer
->tcs
.metadata_fd
== NULL
)
340 error (_("Unable to open file '%s' for saving trace data (%s)"),
341 file_name
, safe_strerror (errno
));
342 do_cleanups (old_chain
);
344 ctf_save_metadata_header (&writer
->tcs
);
346 file_name
= xstrprintf ("%s/%s", dirname
, CTF_DATASTREAM_NAME
);
347 old_chain
= make_cleanup (xfree
, file_name
);
348 writer
->tcs
.datastream_fd
= fopen (file_name
, "w");
349 if (writer
->tcs
.datastream_fd
== NULL
)
350 error (_("Unable to open file '%s' for saving trace data (%s)"),
351 file_name
, safe_strerror (errno
));
352 do_cleanups (old_chain
);
355 /* This is the implementation of trace_file_write_ops method
356 write_header. Write the types of events on trace variable and
360 ctf_write_header (struct trace_file_writer
*self
)
362 struct ctf_trace_file_writer
*writer
363 = (struct ctf_trace_file_writer
*) self
;
366 ctf_save_write_metadata (&writer
->tcs
, "\n");
367 ctf_save_write_metadata (&writer
->tcs
,
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"
374 "};\n", CTF_EVENT_ID_MEMORY
);
376 ctf_save_write_metadata (&writer
->tcs
, "\n");
377 ctf_save_write_metadata (&writer
->tcs
,
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"
383 "};\n", CTF_EVENT_ID_TSV
);
385 ctf_save_write_metadata (&writer
->tcs
, "\n");
386 ctf_save_write_metadata (&writer
->tcs
,
387 "event {\n\tname = \"frame\";\n\tid = %u;\n"
388 "\tfields := struct { \n"
390 "};\n", CTF_EVENT_ID_FRAME
);
392 ctf_save_write_metadata (&writer
->tcs
, "\n");
393 ctf_save_write_metadata (&writer
->tcs
,
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"
401 "};\n", CTF_EVENT_ID_TSV_DEF
);
403 ctf_save_write_metadata (&writer
->tcs
, "\n");
404 ctf_save_write_metadata (&writer
->tcs
,
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"
429 "};\n", CTF_EVENT_ID_TP_DEF
);
431 gdb_assert (writer
->tcs
.content_size
== 0);
432 gdb_assert (writer
->tcs
.packet_start
== 0);
434 /* Create a new packet to contain this event. */
435 self
->ops
->frame_ops
->start (self
, 0);
438 /* This is the implementation of trace_file_write_ops method
439 write_regblock_type. Write the type of register event in
443 ctf_write_regblock_type (struct trace_file_writer
*self
, int size
)
445 struct ctf_trace_file_writer
*writer
446 = (struct ctf_trace_file_writer
*) self
;
448 ctf_save_write_metadata (&writer
->tcs
, "\n");
450 ctf_save_write_metadata (&writer
->tcs
,
451 "event {\n\tname = \"register\";\n\tid = %u;\n"
452 "\tfields := struct { \n"
453 "\t\tascii contents[%d];\n"
456 CTF_EVENT_ID_REGISTER
, size
);
459 /* This is the implementation of trace_file_write_ops method
463 ctf_write_status (struct trace_file_writer
*self
,
464 struct trace_status
*ts
)
466 struct ctf_trace_file_writer
*writer
467 = (struct ctf_trace_file_writer
*) self
;
471 ctf_save_write_metadata (&writer
->tcs
, "\n");
472 ctf_save_write_metadata (&writer
->tcs
,
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"
485 CTF_EVENT_ID_STATUS
);
487 id
= CTF_EVENT_ID_STATUS
;
489 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
491 ctf_save_write_int32 (&writer
->tcs
, ts
->stop_reason
);
492 ctf_save_write_int32 (&writer
->tcs
, ts
->stopping_tracepoint
);
493 ctf_save_write_int32 (&writer
->tcs
, ts
->traceframe_count
);
494 ctf_save_write_int32 (&writer
->tcs
, ts
->traceframes_created
);
495 ctf_save_write_int32 (&writer
->tcs
, ts
->buffer_free
);
496 ctf_save_write_int32 (&writer
->tcs
, ts
->buffer_size
);
497 ctf_save_write_int32 (&writer
->tcs
, ts
->disconnected_tracing
);
498 ctf_save_write_int32 (&writer
->tcs
, ts
->circular_buffer
);
501 /* This is the implementation of trace_file_write_ops method
502 write_uploaded_tsv. */
505 ctf_write_uploaded_tsv (struct trace_file_writer
*self
,
506 struct uploaded_tsv
*tsv
)
508 struct ctf_trace_file_writer
*writer
509 = (struct ctf_trace_file_writer
*) self
;
513 const gdb_byte zero
= 0;
516 int32
= CTF_EVENT_ID_TSV_DEF
;
517 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int32
, 4, 4);
520 int64
= tsv
->initial_value
;
521 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int64
, 8, 8);
524 ctf_save_write_int32 (&writer
->tcs
, tsv
->number
);
527 ctf_save_write_int32 (&writer
->tcs
, tsv
->builtin
);
530 if (tsv
->name
!= NULL
)
531 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tsv
->name
,
533 ctf_save_write (&writer
->tcs
, &zero
, 1);
536 /* This is the implementation of trace_file_write_ops method
537 write_uploaded_tp. */
540 ctf_write_uploaded_tp (struct trace_file_writer
*self
,
541 struct uploaded_tp
*tp
)
543 struct ctf_trace_file_writer
*writer
544 = (struct ctf_trace_file_writer
*) self
;
548 const gdb_byte zero
= 0;
553 int32
= CTF_EVENT_ID_TP_DEF
;
554 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int32
, 4, 4);
558 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int64
, 8, 8);
560 /* traceframe_usage */
561 int64
= tp
->traceframe_usage
;
562 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &int64
, 8, 8);
565 ctf_save_write_int32 (&writer
->tcs
, tp
->number
);
568 ctf_save_write_int32 (&writer
->tcs
, tp
->enabled
);
571 ctf_save_write_int32 (&writer
->tcs
, tp
->step
);
574 ctf_save_write_int32 (&writer
->tcs
, tp
->pass
);
577 ctf_save_write_int32 (&writer
->tcs
, tp
->hit_count
);
580 ctf_save_write_int32 (&writer
->tcs
, tp
->type
);
583 if (tp
->cond
!= NULL
)
584 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tp
->cond
, strlen (tp
->cond
));
585 ctf_save_write (&writer
->tcs
, &zero
, 1);
588 u32
= VEC_length (char_ptr
, tp
->actions
);
589 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &u32
, 4, 4);
590 for (a
= 0; VEC_iterate (char_ptr
, tp
->actions
, a
, act
); ++a
)
591 ctf_save_write (&writer
->tcs
, (gdb_byte
*) act
, strlen (act
) + 1);
594 u32
= VEC_length (char_ptr
, tp
->step_actions
);
595 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &u32
, 4, 4);
596 for (a
= 0; VEC_iterate (char_ptr
, tp
->step_actions
, a
, act
); ++a
)
597 ctf_save_write (&writer
->tcs
, (gdb_byte
*) act
, strlen (act
) + 1);
600 if (tp
->at_string
!= NULL
)
601 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tp
->at_string
,
602 strlen (tp
->at_string
));
603 ctf_save_write (&writer
->tcs
, &zero
, 1);
606 if (tp
->cond_string
!= NULL
)
607 ctf_save_write (&writer
->tcs
, (gdb_byte
*) tp
->cond_string
,
608 strlen (tp
->cond_string
));
609 ctf_save_write (&writer
->tcs
, &zero
, 1);
612 u32
= VEC_length (char_ptr
, tp
->cmd_strings
);
613 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &u32
, 4, 4);
614 for (a
= 0; VEC_iterate (char_ptr
, tp
->cmd_strings
, a
, act
); ++a
)
615 ctf_save_write (&writer
->tcs
, (gdb_byte
*) act
, strlen (act
) + 1);
619 /* This is the implementation of trace_file_write_ops method
620 write_definition_end. */
623 ctf_write_definition_end (struct trace_file_writer
*self
)
625 struct ctf_trace_file_writer
*writer
626 = (struct ctf_trace_file_writer
*) self
;
628 self
->ops
->frame_ops
->end (self
);
631 /* This is the implementation of trace_file_write_ops method
635 ctf_end (struct trace_file_writer
*self
)
637 struct ctf_trace_file_writer
*writer
= (struct ctf_trace_file_writer
*) self
;
639 gdb_assert (writer
->tcs
.content_size
== 0);
642 /* This is the implementation of trace_frame_write_ops method
646 ctf_write_frame_start (struct trace_file_writer
*self
, uint16_t tpnum
)
648 struct ctf_trace_file_writer
*writer
649 = (struct ctf_trace_file_writer
*) self
;
650 uint32_t id
= CTF_EVENT_ID_FRAME
;
653 /* Step 1: Write packet context. */
656 ctf_save_write_uint32 (&writer
->tcs
, u32
);
657 /* content_size and packet_size.. We still don't know the value,
659 ctf_save_fseek (&writer
->tcs
, 4, SEEK_CUR
);
660 ctf_save_fseek (&writer
->tcs
, 4, SEEK_CUR
);
661 /* Tracepoint number. */
662 ctf_save_write (&writer
->tcs
, (gdb_byte
*) &tpnum
, 2);
664 /* Step 2: Write event "frame". */
666 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
669 /* This is the implementation of trace_frame_write_ops method
673 ctf_write_frame_r_block (struct trace_file_writer
*self
,
674 gdb_byte
*buf
, int32_t size
)
676 struct ctf_trace_file_writer
*writer
677 = (struct ctf_trace_file_writer
*) self
;
678 uint32_t id
= CTF_EVENT_ID_REGISTER
;
681 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
683 /* array contents. */
684 ctf_save_align_write (&writer
->tcs
, buf
, size
, 1);
687 /* This is the implementation of trace_frame_write_ops method
688 write_m_block_header. */
691 ctf_write_frame_m_block_header (struct trace_file_writer
*self
,
692 uint64_t addr
, uint16_t length
)
694 struct ctf_trace_file_writer
*writer
695 = (struct ctf_trace_file_writer
*) self
;
696 uint32_t event_id
= CTF_EVENT_ID_MEMORY
;
699 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &event_id
, 4, 4);
702 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &addr
, 8, 8);
705 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &length
, 2, 2);
708 /* This is the implementation of trace_frame_write_ops method
709 write_m_block_memory. */
712 ctf_write_frame_m_block_memory (struct trace_file_writer
*self
,
713 gdb_byte
*buf
, uint16_t length
)
715 struct ctf_trace_file_writer
*writer
716 = (struct ctf_trace_file_writer
*) self
;
719 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) buf
, length
, 1);
722 /* This is the implementation of trace_frame_write_ops method
726 ctf_write_frame_v_block (struct trace_file_writer
*self
,
727 int32_t num
, uint64_t val
)
729 struct ctf_trace_file_writer
*writer
730 = (struct ctf_trace_file_writer
*) self
;
731 uint32_t id
= CTF_EVENT_ID_TSV
;
734 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &id
, 4, 4);
737 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &val
, 8, 8);
739 ctf_save_align_write (&writer
->tcs
, (gdb_byte
*) &num
, 4, 4);
742 /* This is the implementation of trace_frame_write_ops method
746 ctf_write_frame_end (struct trace_file_writer
*self
)
748 struct ctf_trace_file_writer
*writer
749 = (struct ctf_trace_file_writer
*) self
;
753 /* Write the content size to packet header. */
754 ctf_save_fseek (&writer
->tcs
, writer
->tcs
.packet_start
+ 4,
756 u32
= writer
->tcs
.content_size
* TARGET_CHAR_BIT
;
758 t
= writer
->tcs
.content_size
;
759 ctf_save_write_uint32 (&writer
->tcs
, u32
);
761 /* Write the packet size. */
762 u32
+= 4 * TARGET_CHAR_BIT
;
763 ctf_save_write_uint32 (&writer
->tcs
, u32
);
765 writer
->tcs
.content_size
= t
;
767 /* Write zero at the end of the packet. */
768 ctf_save_fseek (&writer
->tcs
, writer
->tcs
.packet_start
+ t
,
771 ctf_save_write_uint32 (&writer
->tcs
, u32
);
772 writer
->tcs
.content_size
= t
;
774 ctf_save_next_packet (&writer
->tcs
);
777 /* Operations to write various types of trace frames into CTF
780 static const struct trace_frame_write_ops ctf_write_frame_ops
=
782 ctf_write_frame_start
,
783 ctf_write_frame_r_block
,
784 ctf_write_frame_m_block_header
,
785 ctf_write_frame_m_block_memory
,
786 ctf_write_frame_v_block
,
790 /* Operations to write trace buffers into CTF format. */
792 static const struct trace_file_write_ops ctf_write_ops
=
798 ctf_write_regblock_type
,
800 ctf_write_uploaded_tsv
,
801 ctf_write_uploaded_tp
,
802 ctf_write_definition_end
,
804 &ctf_write_frame_ops
,
808 /* Return a trace writer for CTF format. */
810 struct trace_file_writer
*
811 ctf_trace_file_writer_new (void)
813 struct ctf_trace_file_writer
*writer
= XNEW (struct ctf_trace_file_writer
);
815 writer
->base
.ops
= &ctf_write_ops
;
817 return (struct trace_file_writer
*) writer
;
820 #if HAVE_LIBBABELTRACE
821 /* Use libbabeltrace to read CTF data. The libbabeltrace provides
822 iterator to iterate over each event in CTF data and APIs to get
823 details of event and packet, so it is very convenient to use
824 libbabeltrace to access events in CTF. */
826 #include <babeltrace/babeltrace.h>
827 #include <babeltrace/ctf/events.h>
828 #include <babeltrace/ctf/iterator.h>
830 /* The struct pointer for current CTF directory. */
831 static int handle_id
= -1;
832 static struct bt_context
*ctx
= NULL
;
833 static struct bt_ctf_iter
*ctf_iter
= NULL
;
834 /* The position of the first packet containing trace frame. */
835 static struct bt_iter_pos
*start_pos
;
837 /* The name of CTF directory. */
838 static char *trace_dirname
;
840 static struct target_ops ctf_ops
;
842 /* Destroy ctf iterator and context. */
847 if (ctf_iter
!= NULL
)
849 bt_ctf_iter_destroy (ctf_iter
);
854 bt_context_put (ctx
);
859 /* Open CTF trace data in DIRNAME. */
862 ctf_open_dir (const char *dirname
)
864 struct bt_iter_pos begin_pos
;
865 struct bt_iter_pos
*pos
;
866 unsigned int count
, i
;
867 struct bt_ctf_event_decl
* const *list
;
869 ctx
= bt_context_create ();
871 error (_("Unable to create bt_context"));
872 handle_id
= bt_context_add_trace (ctx
, dirname
, "ctf", NULL
, NULL
, NULL
);
876 error (_("Unable to use libbabeltrace on directory \"%s\""),
880 begin_pos
.type
= BT_SEEK_BEGIN
;
881 ctf_iter
= bt_ctf_iter_create (ctx
, &begin_pos
, NULL
);
882 if (ctf_iter
== NULL
)
885 error (_("Unable to create bt_iterator"));
888 /* Look for the declaration of register block. Get the length of
889 array "contents" to set trace_regblock_size. */
891 bt_ctf_get_event_decl_list (handle_id
, ctx
, &list
, &count
);
892 for (i
= 0; i
< count
; i
++)
893 if (strcmp ("register", bt_ctf_get_decl_event_name (list
[i
])) == 0)
896 const struct bt_ctf_field_decl
* const *field_list
;
897 const struct bt_declaration
*decl
;
899 bt_ctf_get_decl_fields (list
[i
], BT_EVENT_FIELDS
, &field_list
,
902 gdb_assert (count
== 1);
903 gdb_assert (0 == strcmp ("contents",
904 bt_ctf_get_decl_field_name (field_list
[0])));
905 decl
= bt_ctf_get_decl_from_field_decl (field_list
[0]);
906 trace_regblock_size
= bt_ctf_get_array_len (decl
);
912 #define SET_INT32_FIELD(EVENT, SCOPE, VAR, FIELD) \
913 (VAR)->FIELD = (int) bt_ctf_get_int64 (bt_ctf_get_field ((EVENT), \
917 /* EVENT is the "status" event and TS is filled in. */
920 ctf_read_status (struct bt_ctf_event
*event
, struct trace_status
*ts
)
922 const struct bt_definition
*scope
923 = bt_ctf_get_top_level_scope (event
, BT_EVENT_FIELDS
);
925 SET_INT32_FIELD (event
, scope
, ts
, stop_reason
);
926 SET_INT32_FIELD (event
, scope
, ts
, stopping_tracepoint
);
927 SET_INT32_FIELD (event
, scope
, ts
, traceframe_count
);
928 SET_INT32_FIELD (event
, scope
, ts
, traceframes_created
);
929 SET_INT32_FIELD (event
, scope
, ts
, buffer_free
);
930 SET_INT32_FIELD (event
, scope
, ts
, buffer_size
);
931 SET_INT32_FIELD (event
, scope
, ts
, disconnected_tracing
);
932 SET_INT32_FIELD (event
, scope
, ts
, circular_buffer
);
934 bt_iter_next (bt_ctf_get_iter (ctf_iter
));
937 /* Read the events "tsv_def" one by one, extract its contents and fill
938 in the list UPLOADED_TSVS. */
941 ctf_read_tsv (struct uploaded_tsv
**uploaded_tsvs
)
943 gdb_assert (ctf_iter
!= NULL
);
947 struct bt_ctf_event
*event
;
948 const struct bt_definition
*scope
;
949 const struct bt_definition
*def
;
951 struct uploaded_tsv
*utsv
= NULL
;
953 event
= bt_ctf_iter_read_event (ctf_iter
);
954 scope
= bt_ctf_get_top_level_scope (event
,
955 BT_STREAM_EVENT_HEADER
);
956 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
,
958 if (event_id
!= CTF_EVENT_ID_TSV_DEF
)
961 scope
= bt_ctf_get_top_level_scope (event
,
964 def
= bt_ctf_get_field (event
, scope
, "number");
965 utsv
= get_uploaded_tsv ((int32_t) bt_ctf_get_int64 (def
),
968 def
= bt_ctf_get_field (event
, scope
, "builtin");
969 utsv
->builtin
= (int32_t) bt_ctf_get_int64 (def
);
970 def
= bt_ctf_get_field (event
, scope
, "initial_value");
971 utsv
->initial_value
= bt_ctf_get_int64 (def
);
973 def
= bt_ctf_get_field (event
, scope
, "name");
974 utsv
->name
= xstrdup (bt_ctf_get_string (def
));
976 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
982 /* Read the value of element whose index is NUM from CTF and write it
983 to the corresponding VAR->ARRAY. */
985 #define SET_ARRAY_FIELD(EVENT, SCOPE, VAR, NUM, ARRAY) \
989 const struct bt_definition *def; \
991 u32 = (uint32_t) bt_ctf_get_uint64 (bt_ctf_get_field ((EVENT), \
994 def = bt_ctf_get_field ((EVENT), (SCOPE), #ARRAY); \
995 for (i = 0; i < u32; i++) \
997 const struct bt_definition *element \
998 = bt_ctf_get_index ((EVENT), def, i); \
1000 VEC_safe_push (char_ptr, (VAR)->ARRAY, \
1001 xstrdup (bt_ctf_get_string (element))); \
1006 /* Read a string from CTF and set VAR->FIELD. If the length of string
1007 is zero, set VAR->FIELD to NULL. */
1009 #define SET_STRING_FIELD(EVENT, SCOPE, VAR, FIELD) \
1012 const char *p = bt_ctf_get_string (bt_ctf_get_field ((EVENT), \
1016 if (strlen (p) > 0) \
1017 (VAR)->FIELD = xstrdup (p); \
1019 (VAR)->FIELD = NULL; \
1023 /* Read the events "tp_def" one by one, extract its contents and fill
1024 in the list UPLOADED_TPS. */
1027 ctf_read_tp (struct uploaded_tp
**uploaded_tps
)
1029 gdb_assert (ctf_iter
!= NULL
);
1033 struct bt_ctf_event
*event
;
1034 const struct bt_definition
*scope
;
1038 struct uploaded_tp
*utp
= NULL
;
1040 event
= bt_ctf_iter_read_event (ctf_iter
);
1041 scope
= bt_ctf_get_top_level_scope (event
,
1042 BT_STREAM_EVENT_HEADER
);
1043 u32
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
,
1045 if (u32
!= CTF_EVENT_ID_TP_DEF
)
1048 scope
= bt_ctf_get_top_level_scope (event
,
1050 int32
= (int32_t) bt_ctf_get_int64 (bt_ctf_get_field (event
,
1053 u64
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
,
1055 utp
= get_uploaded_tp (int32
, u64
, uploaded_tps
);
1057 SET_INT32_FIELD (event
, scope
, utp
, enabled
);
1058 SET_INT32_FIELD (event
, scope
, utp
, step
);
1059 SET_INT32_FIELD (event
, scope
, utp
, pass
);
1060 SET_INT32_FIELD (event
, scope
, utp
, hit_count
);
1061 SET_INT32_FIELD (event
, scope
, utp
, type
);
1063 /* Read 'cmd_strings'. */
1064 SET_ARRAY_FIELD (event
, scope
, utp
, cmd_num
, cmd_strings
);
1065 /* Read 'actions'. */
1066 SET_ARRAY_FIELD (event
, scope
, utp
, action_num
, actions
);
1067 /* Read 'step_actions'. */
1068 SET_ARRAY_FIELD (event
, scope
, utp
, step_action_num
,
1071 SET_STRING_FIELD(event
, scope
, utp
, at_string
);
1072 SET_STRING_FIELD(event
, scope
, utp
, cond_string
);
1074 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1079 /* This is the implementation of target_ops method to_open. Open CTF
1080 trace data, read trace status, trace state variables and tracepoint
1081 definitions from the first packet. Set the start position at the
1082 second packet which contains events on trace blocks. */
1085 ctf_open (const char *dirname
, int from_tty
)
1087 struct bt_ctf_event
*event
;
1089 const struct bt_definition
*scope
;
1090 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
1091 struct uploaded_tp
*uploaded_tps
= NULL
;
1094 error (_("No CTF directory specified."));
1096 ctf_open_dir (dirname
);
1098 target_preopen (from_tty
);
1100 /* Skip the first packet which about the trace status. The first
1101 event is "frame". */
1102 event
= bt_ctf_iter_read_event (ctf_iter
);
1103 scope
= bt_ctf_get_top_level_scope (event
, BT_STREAM_EVENT_HEADER
);
1104 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
, "id"));
1105 if (event_id
!= CTF_EVENT_ID_FRAME
)
1106 error (_("Wrong event id of the first event"));
1107 /* The second event is "status". */
1108 bt_iter_next (bt_ctf_get_iter (ctf_iter
));
1109 event
= bt_ctf_iter_read_event (ctf_iter
);
1110 scope
= bt_ctf_get_top_level_scope (event
, BT_STREAM_EVENT_HEADER
);
1111 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
, "id"));
1112 if (event_id
!= CTF_EVENT_ID_STATUS
)
1113 error (_("Wrong event id of the second event"));
1114 ctf_read_status (event
, current_trace_status ());
1116 ctf_read_tsv (&uploaded_tsvs
);
1118 ctf_read_tp (&uploaded_tps
);
1120 event
= bt_ctf_iter_read_event (ctf_iter
);
1121 /* EVENT can be NULL if we've already gone to the end of stream of
1125 scope
= bt_ctf_get_top_level_scope (event
,
1126 BT_STREAM_EVENT_HEADER
);
1127 event_id
= bt_ctf_get_uint64 (bt_ctf_get_field (event
,
1129 if (event_id
!= CTF_EVENT_ID_FRAME
)
1130 error (_("Wrong event id of the first event of the second packet"));
1133 start_pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1134 gdb_assert (start_pos
->type
== BT_SEEK_RESTORE
);
1136 trace_dirname
= xstrdup (dirname
);
1137 push_target (&ctf_ops
);
1139 inferior_appeared (current_inferior (), CTF_PID
);
1140 inferior_ptid
= pid_to_ptid (CTF_PID
);
1141 add_thread_silent (inferior_ptid
);
1143 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
1144 merge_uploaded_tracepoints (&uploaded_tps
);
1146 post_create_inferior (&ctf_ops
, from_tty
);
1149 /* This is the implementation of target_ops method to_close. Destroy
1150 CTF iterator and context. */
1153 ctf_close (struct target_ops
*self
)
1158 xfree (trace_dirname
);
1159 trace_dirname
= NULL
;
1161 pid
= ptid_get_pid (inferior_ptid
);
1162 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
1163 exit_inferior_silent (pid
);
1165 trace_reset_local_state ();
1168 /* This is the implementation of target_ops method to_files_info.
1169 Print the directory name of CTF trace data. */
1172 ctf_files_info (struct target_ops
*t
)
1174 printf_filtered ("\t`%s'\n", trace_dirname
);
1177 /* This is the implementation of target_ops method to_fetch_registers.
1178 Iterate over events whose name is "register" in current frame,
1179 extract contents from events, and set REGCACHE with the contents.
1180 If no matched events are found, mark registers unavailable. */
1183 ctf_fetch_registers (struct target_ops
*ops
,
1184 struct regcache
*regcache
, int regno
)
1186 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1187 struct bt_ctf_event
*event
= NULL
;
1188 struct bt_iter_pos
*pos
;
1190 /* An uninitialized reg size says we're not going to be
1191 successful at getting register blocks. */
1192 if (trace_regblock_size
== 0)
1195 gdb_assert (ctf_iter
!= NULL
);
1196 /* Save the current position. */
1197 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1198 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1203 struct bt_ctf_event
*event1
;
1205 event1
= bt_ctf_iter_read_event (ctf_iter
);
1207 name
= bt_ctf_event_name (event1
);
1209 if (name
== NULL
|| strcmp (name
, "frame") == 0)
1211 else if (strcmp (name
, "register") == 0)
1217 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1221 /* Restore the position. */
1222 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1226 int offset
, regsize
, regn
;
1227 const struct bt_definition
*scope
1228 = bt_ctf_get_top_level_scope (event
,
1230 const struct bt_definition
*array
1231 = bt_ctf_get_field (event
, scope
, "contents");
1232 gdb_byte
*regs
= (gdb_byte
*) bt_ctf_get_char_array (array
);
1234 /* Assume the block is laid out in GDB register number order,
1235 each register with the size that it has in GDB. */
1237 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
1239 regsize
= register_size (gdbarch
, regn
);
1240 /* Make sure we stay within block bounds. */
1241 if (offset
+ regsize
>= trace_regblock_size
)
1243 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
1247 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
1250 else if (regno
== -1)
1252 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
1259 tracefile_fetch_registers (regcache
, regno
);
1262 /* This is the implementation of target_ops method to_xfer_partial.
1263 Iterate over events whose name is "memory" in
1264 current frame, extract the address and length from events. If
1265 OFFSET is within the range, read the contents from events to
1268 static enum target_xfer_status
1269 ctf_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1270 const char *annex
, gdb_byte
*readbuf
,
1271 const gdb_byte
*writebuf
, ULONGEST offset
,
1272 ULONGEST len
, ULONGEST
*xfered_len
)
1274 /* We're only doing regular memory for now. */
1275 if (object
!= TARGET_OBJECT_MEMORY
)
1278 if (readbuf
== NULL
)
1279 error (_("ctf_xfer_partial: trace file is read-only"));
1281 if (get_traceframe_number () != -1)
1283 struct bt_iter_pos
*pos
;
1285 enum target_xfer_status res
;
1286 /* Records the lowest available address of all blocks that
1287 intersects the requested range. */
1288 ULONGEST low_addr_available
= 0;
1290 gdb_assert (ctf_iter
!= NULL
);
1291 /* Save the current position. */
1292 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1293 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1295 /* Iterate through the traceframe's blocks, looking for
1302 enum bfd_endian byte_order
1303 = gdbarch_byte_order (target_gdbarch ());
1304 const struct bt_definition
*scope
;
1305 const struct bt_definition
*def
;
1306 struct bt_ctf_event
*event
1307 = bt_ctf_iter_read_event (ctf_iter
);
1308 const char *name
= bt_ctf_event_name (event
);
1310 if (name
== NULL
|| strcmp (name
, "frame") == 0)
1312 else if (strcmp (name
, "memory") != 0)
1314 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1320 scope
= bt_ctf_get_top_level_scope (event
,
1323 def
= bt_ctf_get_field (event
, scope
, "address");
1324 maddr
= bt_ctf_get_uint64 (def
);
1325 def
= bt_ctf_get_field (event
, scope
, "length");
1326 mlen
= (uint16_t) bt_ctf_get_uint64 (def
);
1328 /* If the block includes the first part of the desired
1329 range, return as much it has; GDB will re-request the
1330 remainder, which might be in a different block of this
1332 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
1334 const struct bt_definition
*array
1335 = bt_ctf_get_field (event
, scope
, "contents");
1336 const struct bt_declaration
*decl
1337 = bt_ctf_get_decl_from_def (array
);
1341 contents
= (gdb_byte
*) xmalloc (mlen
);
1343 for (k
= 0; k
< mlen
; k
++)
1345 const struct bt_definition
*element
1346 = bt_ctf_get_index (event
, array
, k
);
1348 contents
[k
] = (gdb_byte
) bt_ctf_get_uint64 (element
);
1351 amt
= (maddr
+ mlen
) - offset
;
1355 memcpy (readbuf
, &contents
[offset
- maddr
], amt
);
1359 /* Restore the position. */
1360 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1363 return TARGET_XFER_EOF
;
1367 return TARGET_XFER_OK
;
1371 if (offset
< maddr
&& maddr
< (offset
+ len
))
1372 if (low_addr_available
== 0 || low_addr_available
> maddr
)
1373 low_addr_available
= maddr
;
1375 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1379 /* Restore the position. */
1380 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1382 /* Requested memory is unavailable in the context of traceframes,
1383 and this address falls within a read-only section, fallback
1384 to reading from executable, up to LOW_ADDR_AVAILABLE */
1385 if (offset
< low_addr_available
)
1386 len
= min (len
, low_addr_available
- offset
);
1387 res
= exec_read_partial_read_only (readbuf
, offset
, len
, xfered_len
);
1389 if (res
== TARGET_XFER_OK
)
1390 return TARGET_XFER_OK
;
1393 /* No use trying further, we know some memory starting
1394 at MEMADDR isn't available. */
1396 return TARGET_XFER_UNAVAILABLE
;
1401 /* Fallback to reading from read-only sections. */
1402 return section_table_read_available_memory (readbuf
, offset
, len
, xfered_len
);
1406 /* This is the implementation of target_ops method
1407 to_get_trace_state_variable_value.
1408 Iterate over events whose name is "tsv" in current frame. When the
1409 trace variable is found, set the value of it to *VAL and return
1410 true, otherwise return false. */
1413 ctf_get_trace_state_variable_value (struct target_ops
*self
,
1414 int tsvnum
, LONGEST
*val
)
1416 struct bt_iter_pos
*pos
;
1419 gdb_assert (ctf_iter
!= NULL
);
1420 /* Save the current position. */
1421 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1422 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1424 /* Iterate through the traceframe's blocks, looking for 'V'
1428 struct bt_ctf_event
*event
1429 = bt_ctf_iter_read_event (ctf_iter
);
1430 const char *name
= bt_ctf_event_name (event
);
1432 if (name
== NULL
|| strcmp (name
, "frame") == 0)
1434 else if (strcmp (name
, "tsv") == 0)
1436 const struct bt_definition
*scope
;
1437 const struct bt_definition
*def
;
1439 scope
= bt_ctf_get_top_level_scope (event
,
1442 def
= bt_ctf_get_field (event
, scope
, "num");
1443 if (tsvnum
== (int32_t) bt_ctf_get_uint64 (def
))
1445 def
= bt_ctf_get_field (event
, scope
, "val");
1446 *val
= bt_ctf_get_uint64 (def
);
1452 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1456 /* Restore the position. */
1457 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1462 /* Return the tracepoint number in "frame" event. */
1465 ctf_get_tpnum_from_frame_event (struct bt_ctf_event
*event
)
1467 /* The packet context of events has a field "tpnum". */
1468 const struct bt_definition
*scope
1469 = bt_ctf_get_top_level_scope (event
, BT_STREAM_PACKET_CONTEXT
);
1471 = bt_ctf_get_uint64 (bt_ctf_get_field (event
, scope
, "tpnum"));
1476 /* Return the address at which the current frame was collected. */
1479 ctf_get_traceframe_address (void)
1481 struct bt_ctf_event
*event
= NULL
;
1482 struct bt_iter_pos
*pos
;
1485 gdb_assert (ctf_iter
!= NULL
);
1486 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1487 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1492 struct bt_ctf_event
*event1
;
1494 event1
= bt_ctf_iter_read_event (ctf_iter
);
1496 name
= bt_ctf_event_name (event1
);
1500 else if (strcmp (name
, "frame") == 0)
1506 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1512 int tpnum
= ctf_get_tpnum_from_frame_event (event
);
1513 struct tracepoint
*tp
1514 = get_tracepoint_by_number_on_target (tpnum
);
1516 if (tp
&& tp
->base
.loc
)
1517 addr
= tp
->base
.loc
->address
;
1520 /* Restore the position. */
1521 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1526 /* This is the implementation of target_ops method to_trace_find.
1527 Iterate the events whose name is "frame", extract the tracepoint
1528 number in it. Return traceframe number when matched. */
1531 ctf_trace_find (struct target_ops
*self
, enum trace_find_type type
, int num
,
1532 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
1537 struct bt_iter_pos pos
;
1546 gdb_assert (ctf_iter
!= NULL
);
1547 /* Set iterator back to the start. */
1548 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), start_pos
);
1553 struct bt_ctf_event
*event
;
1556 event
= bt_ctf_iter_read_event (ctf_iter
);
1558 name
= bt_ctf_event_name (event
);
1560 if (event
== NULL
|| name
== NULL
)
1563 if (strcmp (name
, "frame") == 0)
1567 if (type
== tfind_number
)
1569 /* Looking for a specific trace frame. */
1575 /* Start from the _next_ trace frame. */
1576 if (tfnum
> get_traceframe_number ())
1582 struct tracepoint
*tp
= get_tracepoint (num
);
1585 && (tp
->number_on_target
1586 == ctf_get_tpnum_from_frame_event (event
)))
1591 tfaddr
= ctf_get_traceframe_address ();
1592 if (tfaddr
== addr1
)
1596 tfaddr
= ctf_get_traceframe_address ();
1597 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
1601 tfaddr
= ctf_get_traceframe_address ();
1602 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
1606 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
1613 *tpp
= ctf_get_tpnum_from_frame_event (event
);
1615 /* Skip the event "frame". */
1616 bt_iter_next (bt_ctf_get_iter (ctf_iter
));
1623 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1630 /* This is the implementation of target_ops method to_traceframe_info.
1631 Iterate the events whose name is "memory", in current
1632 frame, extract memory range information, and return them in
1635 static struct traceframe_info
*
1636 ctf_traceframe_info (struct target_ops
*self
)
1638 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
1640 struct bt_iter_pos
*pos
;
1642 gdb_assert (ctf_iter
!= NULL
);
1643 /* Save the current position. */
1644 pos
= bt_iter_get_pos (bt_ctf_get_iter (ctf_iter
));
1645 gdb_assert (pos
->type
== BT_SEEK_RESTORE
);
1649 struct bt_ctf_event
*event
1650 = bt_ctf_iter_read_event (ctf_iter
);
1652 name
= bt_ctf_event_name (event
);
1654 if (name
== NULL
|| strcmp (name
, "register") == 0
1655 || strcmp (name
, "frame") == 0)
1657 else if (strcmp (name
, "memory") == 0)
1659 const struct bt_definition
*scope
1660 = bt_ctf_get_top_level_scope (event
,
1662 const struct bt_definition
*def
;
1663 struct mem_range
*r
;
1665 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
1666 def
= bt_ctf_get_field (event
, scope
, "address");
1667 r
->start
= bt_ctf_get_uint64 (def
);
1669 def
= bt_ctf_get_field (event
, scope
, "length");
1670 r
->length
= (uint16_t) bt_ctf_get_uint64 (def
);
1672 else if (strcmp (name
, "tsv") == 0)
1675 const struct bt_definition
*scope
1676 = bt_ctf_get_top_level_scope (event
,
1678 const struct bt_definition
*def
;
1680 def
= bt_ctf_get_field (event
, scope
, "num");
1681 vnum
= (int) bt_ctf_get_int64 (def
);
1682 VEC_safe_push (int, info
->tvars
, vnum
);
1686 warning (_("Unhandled trace block type (%s) "
1687 "while building trace frame info."),
1691 if (bt_iter_next (bt_ctf_get_iter (ctf_iter
)) < 0)
1694 while (name
!= NULL
&& strcmp (name
, "frame") != 0);
1696 /* Restore the position. */
1697 bt_iter_set_pos (bt_ctf_get_iter (ctf_iter
), pos
);
1705 memset (&ctf_ops
, 0, sizeof (ctf_ops
));
1707 init_tracefile_ops (&ctf_ops
);
1708 ctf_ops
.to_shortname
= "ctf";
1709 ctf_ops
.to_longname
= "CTF file";
1710 ctf_ops
.to_doc
= "Use a CTF directory as a target.\n\
1711 Specify the filename of the CTF directory.";
1712 ctf_ops
.to_open
= ctf_open
;
1713 ctf_ops
.to_close
= ctf_close
;
1714 ctf_ops
.to_fetch_registers
= ctf_fetch_registers
;
1715 ctf_ops
.to_xfer_partial
= ctf_xfer_partial
;
1716 ctf_ops
.to_files_info
= ctf_files_info
;
1717 ctf_ops
.to_trace_find
= ctf_trace_find
;
1718 ctf_ops
.to_get_trace_state_variable_value
1719 = ctf_get_trace_state_variable_value
;
1720 ctf_ops
.to_traceframe_info
= ctf_traceframe_info
;
1725 /* -Wmissing-prototypes */
1727 extern initialize_file_ftype _initialize_ctf
;
1729 /* module initialization */
1732 _initialize_ctf (void)
1734 #if HAVE_LIBBABELTRACE
1737 add_target_with_completer (&ctf_ops
, filename_completer
);