1 /* Trace file TFILE format support in GDB.
3 Copyright (C) 1997-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "tracefile.h"
22 #include "readline/tilde.h"
23 #include "filestuff.h"
24 #include "rsp-low.h" /* bin2hex */
27 #include "gdbthread.h"
28 #include "exec.h" /* exec_bfd */
29 #include "completer.h"
30 #include "filenames.h"
32 #include "xml-tdesc.h"
33 #include "target-descriptions.h"
41 /* TFILE trace writer. */
43 struct tfile_trace_file_writer
45 struct trace_file_writer base
;
47 /* File pointer to tfile trace file. */
49 /* Path name of the tfile trace file. */
53 /* This is the implementation of trace_file_write_ops method
54 target_save. We just call the generic target
55 target_save_trace_data to do target-side saving. */
58 tfile_target_save (struct trace_file_writer
*self
,
61 int err
= target_save_trace_data (filename
);
66 /* This is the implementation of trace_file_write_ops method
70 tfile_dtor (struct trace_file_writer
*self
)
72 struct tfile_trace_file_writer
*writer
73 = (struct tfile_trace_file_writer
*) self
;
75 xfree (writer
->pathname
);
77 if (writer
->fp
!= NULL
)
81 /* This is the implementation of trace_file_write_ops method
82 start. It creates the trace file FILENAME and registers some
86 tfile_start (struct trace_file_writer
*self
, const char *filename
)
88 struct tfile_trace_file_writer
*writer
89 = (struct tfile_trace_file_writer
*) self
;
91 writer
->pathname
= tilde_expand (filename
);
92 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb").release ();
93 if (writer
->fp
== NULL
)
94 error (_("Unable to open file '%s' for saving trace data (%s)"),
95 writer
->pathname
, safe_strerror (errno
));
98 /* This is the implementation of trace_file_write_ops method
99 write_header. Write the TFILE header. */
102 tfile_write_header (struct trace_file_writer
*self
)
104 struct tfile_trace_file_writer
*writer
105 = (struct tfile_trace_file_writer
*) self
;
108 /* Write a file header, with a high-bit-set char to indicate a
109 binary file, plus a hint as what this file is, and a version
110 number in case of future needs. */
111 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
113 perror_with_name (writer
->pathname
);
116 /* This is the implementation of trace_file_write_ops method
117 write_regblock_type. Write the size of register block. */
120 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
122 struct tfile_trace_file_writer
*writer
123 = (struct tfile_trace_file_writer
*) self
;
125 fprintf (writer
->fp
, "R %x\n", size
);
128 /* This is the implementation of trace_file_write_ops method
132 tfile_write_status (struct trace_file_writer
*self
,
133 struct trace_status
*ts
)
135 struct tfile_trace_file_writer
*writer
136 = (struct tfile_trace_file_writer
*) self
;
138 fprintf (writer
->fp
, "status %c;%s",
139 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
140 if (ts
->stop_reason
== tracepoint_error
141 || ts
->stop_reason
== trace_stop_command
)
143 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
145 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, strlen (ts
->stop_desc
));
146 fprintf (writer
->fp
, ":%s", buf
);
148 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
149 if (ts
->traceframe_count
>= 0)
150 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
151 if (ts
->traceframes_created
>= 0)
152 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
153 if (ts
->buffer_free
>= 0)
154 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
155 if (ts
->buffer_size
>= 0)
156 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
157 if (ts
->disconnected_tracing
)
158 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
159 if (ts
->circular_buffer
)
160 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
163 fprintf (writer
->fp
, ";starttime:%s",
164 phex_nz (ts
->start_time
, sizeof (ts
->start_time
)));
168 fprintf (writer
->fp
, ";stoptime:%s",
169 phex_nz (ts
->stop_time
, sizeof (ts
->stop_time
)));
171 if (ts
->notes
!= NULL
)
173 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
175 bin2hex ((gdb_byte
*) ts
->notes
, buf
, strlen (ts
->notes
));
176 fprintf (writer
->fp
, ";notes:%s", buf
);
178 if (ts
->user_name
!= NULL
)
180 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
182 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, strlen (ts
->user_name
));
183 fprintf (writer
->fp
, ";username:%s", buf
);
185 fprintf (writer
->fp
, "\n");
188 /* This is the implementation of trace_file_write_ops method
189 write_uploaded_tsv. */
192 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
193 struct uploaded_tsv
*utsv
)
196 struct tfile_trace_file_writer
*writer
197 = (struct tfile_trace_file_writer
*) self
;
201 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
202 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, strlen (utsv
->name
));
205 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
206 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
207 utsv
->builtin
, buf
!= NULL
? buf
: "");
213 #define MAX_TRACE_UPLOAD 2000
215 /* This is the implementation of trace_file_write_ops method
216 write_uploaded_tp. */
219 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
220 struct uploaded_tp
*utp
)
222 struct tfile_trace_file_writer
*writer
223 = (struct tfile_trace_file_writer
*) self
;
224 char buf
[MAX_TRACE_UPLOAD
];
226 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
227 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
228 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
229 if (utp
->type
== bp_fast_tracepoint
)
230 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
233 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
235 fprintf (writer
->fp
, "\n");
236 for (char *act
: utp
->actions
)
237 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
238 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
239 for (char *act
: utp
->step_actions
)
240 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
241 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
244 encode_source_string (utp
->number
, utp
->addr
,
245 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
246 fprintf (writer
->fp
, "tp Z%s\n", buf
);
248 if (utp
->cond_string
)
250 encode_source_string (utp
->number
, utp
->addr
,
251 "cond", utp
->cond_string
,
252 buf
, MAX_TRACE_UPLOAD
);
253 fprintf (writer
->fp
, "tp Z%s\n", buf
);
255 for (char *act
: utp
->cmd_strings
)
257 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
258 buf
, MAX_TRACE_UPLOAD
);
259 fprintf (writer
->fp
, "tp Z%s\n", buf
);
261 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
262 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
264 phex_nz (utp
->traceframe_usage
,
265 sizeof (utp
->traceframe_usage
)));
268 /* This is the implementation of trace_file_write_ops method
272 tfile_write_tdesc (struct trace_file_writer
*self
)
274 struct tfile_trace_file_writer
*writer
275 = (struct tfile_trace_file_writer
*) self
;
277 gdb::optional
<std::string
> tdesc
278 = target_fetch_description_xml (¤t_target
);
283 const char *ptr
= tdesc
->c_str ();
285 /* Write tdesc line by line, prefixing each line with "tdesc ". */
288 const char *next
= strchr (ptr
, '\n');
291 fprintf (writer
->fp
, "tdesc %.*s\n", (int) (next
- ptr
), ptr
);
295 else if (*ptr
!= '\0')
297 /* Last line, doesn't have a newline. */
298 fprintf (writer
->fp
, "tdesc %s\n", ptr
);
304 /* This is the implementation of trace_file_write_ops method
305 write_definition_end. */
308 tfile_write_definition_end (struct trace_file_writer
*self
)
310 struct tfile_trace_file_writer
*writer
311 = (struct tfile_trace_file_writer
*) self
;
313 fprintf (writer
->fp
, "\n");
316 /* This is the implementation of trace_file_write_ops method
320 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
323 struct tfile_trace_file_writer
*writer
324 = (struct tfile_trace_file_writer
*) self
;
326 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
327 perror_with_name (writer
->pathname
);
330 /* This is the implementation of trace_file_write_ops method
334 tfile_end (struct trace_file_writer
*self
)
336 struct tfile_trace_file_writer
*writer
337 = (struct tfile_trace_file_writer
*) self
;
340 /* Mark the end of trace data. */
341 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
342 perror_with_name (writer
->pathname
);
345 /* Operations to write trace buffers into TFILE format. */
347 static const struct trace_file_write_ops tfile_write_ops
=
353 tfile_write_regblock_type
,
355 tfile_write_uploaded_tsv
,
356 tfile_write_uploaded_tp
,
358 tfile_write_definition_end
,
359 tfile_write_raw_data
,
364 /* Return a trace writer for TFILE format. */
366 struct trace_file_writer
*
367 tfile_trace_file_writer_new (void)
369 struct tfile_trace_file_writer
*writer
370 = XNEW (struct tfile_trace_file_writer
);
372 writer
->base
.ops
= &tfile_write_ops
;
374 writer
->pathname
= NULL
;
376 return (struct trace_file_writer
*) writer
;
379 /* target tfile command */
381 static struct target_ops tfile_ops
;
383 /* Fill in tfile_ops with its defined operations and properties. */
385 #define TRACE_HEADER_SIZE 8
387 #define TFILE_PID (1)
389 static char *trace_filename
;
390 static int trace_fd
= -1;
391 static off_t trace_frames_offset
;
392 static off_t cur_offset
;
393 static int cur_data_size
;
394 int trace_regblock_size
;
395 static struct buffer trace_tdesc
;
397 static void tfile_append_tdesc_line (const char *line
);
398 static void tfile_interp_line (char *line
,
399 struct uploaded_tp
**utpp
,
400 struct uploaded_tsv
**utsvp
);
402 /* Read SIZE bytes into READBUF from the trace frame, starting at
403 TRACE_FD's current position. Note that this call `read'
404 underneath, hence it advances the file's seek position. Throws an
405 error if the `read' syscall fails, or less than SIZE bytes are
409 tfile_read (gdb_byte
*readbuf
, int size
)
413 gotten
= read (trace_fd
, readbuf
, size
);
415 perror_with_name (trace_filename
);
416 else if (gotten
< size
)
417 error (_("Premature end of file while reading trace file"));
421 tfile_open (const char *arg
, int from_tty
)
425 char header
[TRACE_HEADER_SIZE
];
426 char linebuf
[1000]; /* Should be max remote packet size or so. */
429 struct trace_status
*ts
;
430 struct uploaded_tp
*uploaded_tps
= NULL
;
431 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
433 target_preopen (from_tty
);
435 error (_("No trace file specified."));
437 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (arg
));
438 if (!IS_ABSOLUTE_PATH (filename
.get ()))
439 filename
.reset (concat (current_directory
, "/", filename
.get (),
442 flags
= O_BINARY
| O_LARGEFILE
;
444 scratch_chan
= gdb_open_cloexec (filename
.get (), flags
, 0);
445 if (scratch_chan
< 0)
446 perror_with_name (filename
.get ());
448 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
450 unpush_target (&tfile_ops
);
452 trace_filename
= filename
.release ();
453 trace_fd
= scratch_chan
;
455 /* Make sure this is clear. */
456 buffer_free (&trace_tdesc
);
459 /* Read the file header and test for validity. */
460 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
462 bytes
+= TRACE_HEADER_SIZE
;
463 if (!(header
[0] == 0x7f
464 && (startswith (header
+ 1, "TRACE0\n"))))
465 error (_("File is not a valid trace file."));
467 push_target (&tfile_ops
);
469 trace_regblock_size
= 0;
470 ts
= current_trace_status ();
471 /* We know we're working with a file. Record its name. */
472 ts
->filename
= trace_filename
;
473 /* Set defaults in case there is no status line. */
474 ts
->running_known
= 0;
475 ts
->stop_reason
= trace_stop_reason_unknown
;
476 ts
->traceframe_count
= -1;
478 ts
->disconnected_tracing
= 0;
479 ts
->circular_buffer
= 0;
483 /* Read through a section of newline-terminated lines that
484 define things like tracepoints. */
488 tfile_read (&byte
, 1);
493 /* Empty line marks end of the definition section. */
498 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
503 error (_("Excessively long lines in trace file"));
506 /* By now, tdesc lines have been read from tfile - let's parse them. */
507 target_find_description ();
509 /* Record the starting offset of the binary trace data. */
510 trace_frames_offset
= bytes
;
512 /* If we don't have a blocksize, we can't interpret the
514 if (trace_regblock_size
== 0)
515 error (_("No register block size recorded in trace file"));
517 CATCH (ex
, RETURN_MASK_ALL
)
519 /* Remove the partially set up target. */
520 unpush_target (&tfile_ops
);
521 throw_exception (ex
);
525 inferior_appeared (current_inferior (), TFILE_PID
);
526 inferior_ptid
= pid_to_ptid (TFILE_PID
);
527 add_thread_silent (inferior_ptid
);
529 if (ts
->traceframe_count
<= 0)
530 warning (_("No traceframes present in this file."));
532 /* Add the file's tracepoints and variables into the current mix. */
534 /* Get trace state variables first, they may be checked when parsing
535 uploaded commands. */
536 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
538 merge_uploaded_tracepoints (&uploaded_tps
);
540 post_create_inferior (&tfile_ops
, from_tty
);
543 /* Interpret the given line from the definitions part of the trace
547 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
548 struct uploaded_tsv
**utsvp
)
552 if (startswith (p
, "R "))
555 trace_regblock_size
= strtol (p
, &p
, 16);
557 else if (startswith (p
, "status "))
559 p
+= strlen ("status ");
560 parse_trace_status (p
, current_trace_status ());
562 else if (startswith (p
, "tp "))
565 parse_tracepoint_definition (p
, utpp
);
567 else if (startswith (p
, "tsv "))
569 p
+= strlen ("tsv ");
570 parse_tsv_definition (p
, utsvp
);
572 else if (startswith (p
, "tdesc "))
574 p
+= strlen ("tdesc ");
575 tfile_append_tdesc_line (p
);
578 warning (_("Ignoring trace file definition \"%s\""), line
);
581 /* Close the trace file and generally clean up. */
584 tfile_close (struct target_ops
*self
)
591 pid
= ptid_get_pid (inferior_ptid
);
592 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
593 exit_inferior_silent (pid
);
597 xfree (trace_filename
);
598 trace_filename
= NULL
;
599 buffer_free (&trace_tdesc
);
601 trace_reset_local_state ();
605 tfile_files_info (struct target_ops
*t
)
607 printf_filtered ("\t`%s'\n", trace_filename
);
611 tfile_get_tracepoint_status (struct target_ops
*self
,
612 struct breakpoint
*tp
, struct uploaded_tp
*utp
)
614 /* Other bits of trace status were collected as part of opening the
615 trace files, so nothing to do here. */
618 /* Given the position of a traceframe in the file, figure out what
619 address the frame was collected at. This would normally be the
620 value of a collected PC register, but if not available, we
624 tfile_get_traceframe_address (off_t tframe_offset
)
628 struct tracepoint
*tp
;
629 off_t saved_offset
= cur_offset
;
631 /* FIXME dig pc out of collected registers. */
633 /* Fall back to using tracepoint address. */
634 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
635 tfile_read ((gdb_byte
*) &tpnum
, 2);
636 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
638 (target_gdbarch ()));
640 tp
= get_tracepoint_by_number_on_target (tpnum
);
641 /* FIXME this is a poor heuristic if multiple locations. */
643 addr
= tp
->loc
->address
;
645 /* Restore our seek position. */
646 cur_offset
= saved_offset
;
647 lseek (trace_fd
, cur_offset
, SEEK_SET
);
651 /* Given a type of search and some parameters, scan the collection of
652 traceframes in the file looking for a match. When found, return
653 both the traceframe and tracepoint number, otherwise -1 for
657 tfile_trace_find (struct target_ops
*self
, enum trace_find_type type
, int num
,
658 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
661 int tfnum
= 0, found
= 0;
662 unsigned int data_size
;
663 struct tracepoint
*tp
;
664 off_t offset
, tframe_offset
;
674 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
675 offset
= trace_frames_offset
;
678 tframe_offset
= offset
;
679 tfile_read ((gdb_byte
*) &tpnum
, 2);
680 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
682 (target_gdbarch ()));
686 tfile_read ((gdb_byte
*) &data_size
, 4);
687 data_size
= (unsigned int) extract_unsigned_integer
688 ((gdb_byte
*) &data_size
, 4,
689 gdbarch_byte_order (target_gdbarch ()));
692 if (type
== tfind_number
)
694 /* Looking for a specific trace frame. */
700 /* Start from the _next_ trace frame. */
701 if (tfnum
> get_traceframe_number ())
706 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
711 tp
= get_tracepoint (num
);
712 if (tp
&& tpnum
== tp
->number_on_target
)
716 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
717 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
721 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
722 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
726 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
736 cur_data_size
= data_size
;
740 /* Skip past the traceframe's data. */
741 lseek (trace_fd
, data_size
, SEEK_CUR
);
743 /* Update our own count of traceframes. */
746 /* Did not find what we were looking for. */
752 /* Prototype of the callback passed to tframe_walk_blocks. */
753 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
755 /* Callback for traceframe_walk_blocks, used to find a given block
756 type in a traceframe. */
759 match_blocktype (char blocktype
, void *data
)
761 char *wantedp
= (char *) data
;
763 if (*wantedp
== blocktype
)
769 /* Walk over all traceframe block starting at POS offset from
770 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
771 unmodified. If CALLBACK returns true, this returns the position in
772 the traceframe where the block is found, relative to the start of
773 the traceframe (cur_offset). Returns -1 if no callback call
774 returned true, indicating that all blocks have been walked. */
777 traceframe_walk_blocks (walk_blocks_callback_func callback
,
780 /* Iterate through a traceframe's blocks, looking for a block of the
783 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
784 while (pos
< cur_data_size
)
789 tfile_read ((gdb_byte
*) &block_type
, 1);
793 if ((*callback
) (block_type
, data
))
799 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
800 pos
+= trace_regblock_size
;
803 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
804 tfile_read ((gdb_byte
*) &mlen
, 2);
805 mlen
= (unsigned short)
806 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
808 (target_gdbarch ()));
809 lseek (trace_fd
, mlen
, SEEK_CUR
);
810 pos
+= (8 + 2 + mlen
);
813 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
817 error (_("Unknown block type '%c' (0x%x) in trace frame"),
818 block_type
, block_type
);
826 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
827 position offset of a block of type TYPE_WANTED in the current trace
828 frame, starting at POS. Returns -1 if no such block was found. */
831 traceframe_find_block_type (char type_wanted
, int pos
)
833 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
836 /* Look for a block of saved registers in the traceframe, and get the
837 requested register from it. */
840 tfile_fetch_registers (struct target_ops
*ops
,
841 struct regcache
*regcache
, int regno
)
843 struct gdbarch
*gdbarch
= regcache
->arch ();
844 int offset
, regn
, regsize
, dummy
;
846 /* An uninitialized reg size says we're not going to be
847 successful at getting register blocks. */
848 if (!trace_regblock_size
)
851 if (traceframe_find_block_type ('R', 0) >= 0)
853 gdb_byte
*regs
= (gdb_byte
*) alloca (trace_regblock_size
);
855 tfile_read (regs
, trace_regblock_size
);
857 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
859 if (!remote_register_number_and_offset (regcache
->arch (),
860 regn
, &dummy
, &offset
))
863 regsize
= register_size (gdbarch
, regn
);
864 /* Make sure we stay within block bounds. */
865 if (offset
+ regsize
> trace_regblock_size
)
867 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
871 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
874 else if (regno
== -1)
876 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
882 tracefile_fetch_registers (regcache
, regno
);
885 static enum target_xfer_status
886 tfile_xfer_partial_features (struct target_ops
*ops
, const char *annex
,
887 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
888 ULONGEST offset
, ULONGEST len
,
889 ULONGEST
*xfered_len
)
891 if (strcmp (annex
, "target.xml"))
892 return TARGET_XFER_E_IO
;
895 error (_("tfile_xfer_partial: tdesc is read-only"));
897 if (trace_tdesc
.used_size
== 0)
898 return TARGET_XFER_E_IO
;
900 if (offset
>= trace_tdesc
.used_size
)
901 return TARGET_XFER_EOF
;
903 if (len
> trace_tdesc
.used_size
- offset
)
904 len
= trace_tdesc
.used_size
- offset
;
906 memcpy (readbuf
, trace_tdesc
.buffer
+ offset
, len
);
909 return TARGET_XFER_OK
;
912 static enum target_xfer_status
913 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
914 const char *annex
, gdb_byte
*readbuf
,
915 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
916 ULONGEST
*xfered_len
)
918 /* We're only doing regular memory and tdesc for now. */
919 if (object
== TARGET_OBJECT_AVAILABLE_FEATURES
)
920 return tfile_xfer_partial_features (ops
, annex
, readbuf
, writebuf
,
921 offset
, len
, xfered_len
);
922 if (object
!= TARGET_OBJECT_MEMORY
)
923 return TARGET_XFER_E_IO
;
926 error (_("tfile_xfer_partial: trace file is read-only"));
928 if (get_traceframe_number () != -1)
931 enum target_xfer_status res
;
932 /* Records the lowest available address of all blocks that
933 intersects the requested range. */
934 ULONGEST low_addr_available
= 0;
936 /* Iterate through the traceframe's blocks, looking for
938 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
942 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
944 tfile_read ((gdb_byte
*) &maddr
, 8);
945 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
947 tfile_read ((gdb_byte
*) &mlen
, 2);
948 mlen
= (unsigned short)
949 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
951 /* If the block includes the first part of the desired
952 range, return as much it has; GDB will re-request the
953 remainder, which might be in a different block of this
955 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
957 amt
= (maddr
+ mlen
) - offset
;
962 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
963 tfile_read (readbuf
, amt
);
965 return TARGET_XFER_OK
;
968 if (offset
< maddr
&& maddr
< (offset
+ len
))
969 if (low_addr_available
== 0 || low_addr_available
> maddr
)
970 low_addr_available
= maddr
;
972 /* Skip over this block. */
973 pos
+= (8 + 2 + mlen
);
976 /* Requested memory is unavailable in the context of traceframes,
977 and this address falls within a read-only section, fallback
978 to reading from executable, up to LOW_ADDR_AVAILABLE. */
979 if (offset
< low_addr_available
)
980 len
= std::min (len
, low_addr_available
- offset
);
981 res
= exec_read_partial_read_only (readbuf
, offset
, len
, xfered_len
);
983 if (res
== TARGET_XFER_OK
)
984 return TARGET_XFER_OK
;
987 /* No use trying further, we know some memory starting
988 at MEMADDR isn't available. */
990 return TARGET_XFER_UNAVAILABLE
;
995 /* Fallback to reading from read-only sections. */
996 return section_table_read_available_memory (readbuf
, offset
, len
,
1001 /* Iterate through the blocks of a trace frame, looking for a 'V'
1002 block with a matching tsv number. */
1005 tfile_get_trace_state_variable_value (struct target_ops
*self
,
1006 int tsvnum
, LONGEST
*val
)
1011 /* Iterate over blocks in current frame and find the last 'V'
1012 block in which tsv number is TSVNUM. In one trace frame, there
1013 may be multiple 'V' blocks created for a given trace variable,
1014 and the last matched 'V' block contains the updated value. */
1016 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
1020 tfile_read ((gdb_byte
*) &vnum
, 4);
1021 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
1023 (target_gdbarch ()));
1026 tfile_read ((gdb_byte
*) val
, 8);
1027 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
1029 (target_gdbarch ()));
1038 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
1039 object for the tfile target's current traceframe. */
1042 build_traceframe_info (char blocktype
, void *data
)
1044 struct traceframe_info
*info
= (struct traceframe_info
*) data
;
1051 unsigned short mlen
;
1053 tfile_read ((gdb_byte
*) &maddr
, 8);
1054 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
1056 (target_gdbarch ()));
1057 tfile_read ((gdb_byte
*) &mlen
, 2);
1058 mlen
= (unsigned short)
1059 extract_unsigned_integer ((gdb_byte
*) &mlen
,
1060 2, gdbarch_byte_order
1061 (target_gdbarch ()));
1063 info
->memory
.emplace_back (maddr
, mlen
);
1070 tfile_read ((gdb_byte
*) &vnum
, 4);
1071 info
->tvars
.push_back (vnum
);
1079 warning (_("Unhandled trace block type (%d) '%c ' "
1080 "while building trace frame info."),
1081 blocktype
, blocktype
);
1088 static traceframe_info_up
1089 tfile_traceframe_info (struct target_ops
*self
)
1091 traceframe_info_up
info (new traceframe_info
);
1093 traceframe_walk_blocks (build_traceframe_info
, 0, info
.get ());
1098 /* Handles tdesc lines from tfile by appending the payload to
1099 a global trace_tdesc variable. */
1102 tfile_append_tdesc_line (const char *line
)
1104 buffer_grow_str (&trace_tdesc
, line
);
1105 buffer_grow_str (&trace_tdesc
, "\n");
1109 init_tfile_ops (void)
1111 init_tracefile_ops (&tfile_ops
);
1113 tfile_ops
.to_shortname
= "tfile";
1114 tfile_ops
.to_longname
= "Local trace dump file";
1116 = "Use a trace file as a target. Specify the filename of the trace file.";
1117 tfile_ops
.to_open
= tfile_open
;
1118 tfile_ops
.to_close
= tfile_close
;
1119 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
1120 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
1121 tfile_ops
.to_files_info
= tfile_files_info
;
1122 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
1123 tfile_ops
.to_trace_find
= tfile_trace_find
;
1124 tfile_ops
.to_get_trace_state_variable_value
1125 = tfile_get_trace_state_variable_value
;
1126 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
1130 _initialize_tracefile_tfile (void)
1134 add_target_with_completer (&tfile_ops
, filename_completer
);