1 /* Trace file TFILE format support in GDB.
3 Copyright (C) 1997-2016 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"
37 /* TFILE trace writer. */
39 struct tfile_trace_file_writer
41 struct trace_file_writer base;
43 /* File pointer to tfile trace file. */
45 /* Path name of the tfile trace file. */
49 /* This is the implementation of trace_file_write_ops method
50 target_save. We just call the generic target
51 target_save_trace_data to do target-side saving. */
54 tfile_target_save (struct trace_file_writer *self,
57 int err = target_save_trace_data (filename);
62 /* This is the implementation of trace_file_write_ops method
66 tfile_dtor (struct trace_file_writer *self)
68 struct tfile_trace_file_writer *writer
69 = (struct tfile_trace_file_writer *) self;
71 xfree (writer->pathname);
73 if (writer->fp != NULL)
77 /* This is the implementation of trace_file_write_ops method
78 start. It creates the trace file FILENAME and registers some
82 tfile_start (struct trace_file_writer *self, const char *filename)
84 struct tfile_trace_file_writer *writer
85 = (struct tfile_trace_file_writer *) self;
87 writer->pathname = tilde_expand (filename);
88 writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
89 if (writer->fp == NULL)
90 error (_("Unable to open file '%s' for saving trace data (%s)"),
91 writer->pathname, safe_strerror (errno));
94 /* This is the implementation of trace_file_write_ops method
95 write_header. Write the TFILE header. */
98 tfile_write_header (struct trace_file_writer *self)
100 struct tfile_trace_file_writer *writer
101 = (struct tfile_trace_file_writer *) self;
104 /* Write a file header, with a high-bit-set char to indicate a
105 binary file, plus a hint as what this file is, and a version
106 number in case of future needs. */
107 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
109 perror_with_name (writer->pathname);
112 /* This is the implementation of trace_file_write_ops method
113 write_regblock_type. Write the size of register block. */
116 tfile_write_regblock_type (struct trace_file_writer *self, int size)
118 struct tfile_trace_file_writer *writer
119 = (struct tfile_trace_file_writer *) self;
121 fprintf (writer->fp, "R %x\n", size);
124 /* This is the implementation of trace_file_write_ops method
128 tfile_write_status (struct trace_file_writer *self,
129 struct trace_status *ts)
131 struct tfile_trace_file_writer *writer
132 = (struct tfile_trace_file_writer *) self;
134 fprintf (writer->fp, "status %c;%s",
135 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
136 if (ts->stop_reason == tracepoint_error
137 || ts->stop_reason == tstop_command)
139 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
141 bin2hex ((gdb_byte *) ts->stop_desc, buf, strlen (ts->stop_desc));
142 fprintf (writer->fp, ":%s", buf);
144 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
145 if (ts->traceframe_count >= 0)
146 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
147 if (ts->traceframes_created >= 0)
148 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
149 if (ts->buffer_free >= 0)
150 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
151 if (ts->buffer_size >= 0)
152 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
153 if (ts->disconnected_tracing)
154 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
155 if (ts->circular_buffer)
156 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
159 fprintf (writer->fp, ";starttime:%s",
160 phex_nz (ts->start_time, sizeof (ts->start_time)));
164 fprintf (writer->fp, ";stoptime:%s",
165 phex_nz (ts->stop_time, sizeof (ts->stop_time)));
167 if (ts->notes != NULL)
169 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
171 bin2hex ((gdb_byte *) ts->notes, buf, strlen (ts->notes));
172 fprintf (writer->fp, ";notes:%s", buf);
174 if (ts->user_name != NULL)
176 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
178 bin2hex ((gdb_byte *) ts->user_name, buf, strlen (ts->user_name));
179 fprintf (writer->fp, ";username:%s", buf);
181 fprintf (writer->fp, "\n");
184 /* This is the implementation of trace_file_write_ops method
185 write_uploaded_tsv. */
188 tfile_write_uploaded_tsv (struct trace_file_writer *self,
189 struct uploaded_tsv *utsv)
192 struct tfile_trace_file_writer *writer
193 = (struct tfile_trace_file_writer *) self;
197 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
198 bin2hex ((gdb_byte *) (utsv->name), buf, strlen (utsv->name));
201 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
202 utsv->number, phex_nz (utsv->initial_value, 8),
209 #define MAX_TRACE_UPLOAD 2000
211 /* This is the implementation of trace_file_write_ops method
212 write_uploaded_tp. */
215 tfile_write_uploaded_tp (struct trace_file_writer *self,
216 struct uploaded_tp *utp)
218 struct tfile_trace_file_writer *writer
219 = (struct tfile_trace_file_writer *) self;
222 char buf[MAX_TRACE_UPLOAD];
224 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
225 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
226 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
227 if (utp->type == bp_fast_tracepoint)
228 fprintf (writer->fp, ":F%x", utp->orig_size);
231 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
233 fprintf (writer->fp, "\n");
234 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
235 fprintf (writer->fp, "tp A%x:%s:%s\n",
236 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
237 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
238 fprintf (writer->fp, "tp S%x:%s:%s\n",
239 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
242 encode_source_string (utp->number, utp->addr,
243 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
244 fprintf (writer->fp, "tp Z%s\n", buf);
246 if (utp->cond_string)
248 encode_source_string (utp->number, utp->addr,
249 "cond", utp->cond_string,
250 buf, MAX_TRACE_UPLOAD);
251 fprintf (writer->fp, "tp Z%s\n", buf);
253 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
255 encode_source_string (utp->number, utp->addr, "cmd", act,
256 buf, MAX_TRACE_UPLOAD);
257 fprintf (writer->fp, "tp Z%s\n", buf);
259 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
260 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
262 phex_nz (utp->traceframe_usage,
263 sizeof (utp->traceframe_usage)));
266 /* This is the implementation of trace_file_write_ops method
267 write_definition_end. */
270 tfile_write_definition_end (struct trace_file_writer *self)
272 struct tfile_trace_file_writer *writer
273 = (struct tfile_trace_file_writer *) self;
275 fprintf (writer->fp, "\n");
278 /* This is the implementation of trace_file_write_ops method
282 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
285 struct tfile_trace_file_writer *writer
286 = (struct tfile_trace_file_writer *) self;
288 if (fwrite (buf, len, 1, writer->fp) < 1)
289 perror_with_name (writer->pathname);
292 /* This is the implementation of trace_file_write_ops method
296 tfile_end (struct trace_file_writer *self)
298 struct tfile_trace_file_writer *writer
299 = (struct tfile_trace_file_writer *) self;
302 /* Mark the end of trace data. */
303 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
304 perror_with_name (writer->pathname);
307 /* Operations to write trace buffers into TFILE format. */
309 static const struct trace_file_write_ops tfile_write_ops =
315 tfile_write_regblock_type,
317 tfile_write_uploaded_tsv,
318 tfile_write_uploaded_tp,
319 tfile_write_definition_end,
320 tfile_write_raw_data,
325 /* Return a trace writer for TFILE format. */
327 struct trace_file_writer *
328 tfile_trace_file_writer_new (void)
330 struct tfile_trace_file_writer *writer
331 = XNEW (struct tfile_trace_file_writer);
333 writer->base.ops = &tfile_write_ops;
335 writer->pathname = NULL;
337 return (struct trace_file_writer *) writer;
340 /* target tfile command */
342 static struct target_ops tfile_ops;
344 /* Fill in tfile_ops with its defined operations and properties. */
346 #define TRACE_HEADER_SIZE 8
348 #define TFILE_PID (1)
350 static char *trace_filename;
351 static int trace_fd = -1;
352 static off_t trace_frames_offset;
353 static off_t cur_offset;
354 static int cur_data_size;
355 int trace_regblock_size;
357 static void tfile_interp_line (char *line,
358 struct uploaded_tp **utpp,
359 struct uploaded_tsv **utsvp);
361 /* Read SIZE bytes into READBUF from the trace frame, starting at
362 TRACE_FD's current position. Note that this call `read'
363 underneath, hence it advances the file's seek position. Throws an
364 error if the `read' syscall fails, or less than SIZE bytes are
368 tfile_read (gdb_byte *readbuf, int size)
372 gotten = read (trace_fd, readbuf, size);
374 perror_with_name (trace_filename);
375 else if (gotten < size)
376 error (_("Premature end of file while reading trace file"));
380 tfile_open (const char *arg, int from_tty)
383 struct cleanup *old_chain;
386 char header[TRACE_HEADER_SIZE];
387 char linebuf[1000]; /* Should be max remote packet size or so. */
390 struct trace_status *ts;
391 struct uploaded_tp *uploaded_tps = NULL;
392 struct uploaded_tsv *uploaded_tsvs = NULL;
395 target_preopen (from_tty);
397 error (_("No trace file specified."));
399 filename = tilde_expand (arg);
400 if (!IS_ABSOLUTE_PATH(filename))
402 temp = concat (current_directory, "/", filename, (char *) NULL);
407 old_chain = make_cleanup (xfree, filename);
409 flags = O_BINARY | O_LARGEFILE;
411 scratch_chan = gdb_open_cloexec (filename, flags, 0);
412 if (scratch_chan < 0)
413 perror_with_name (filename);
415 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
417 discard_cleanups (old_chain); /* Don't free filename any more. */
418 unpush_target (&tfile_ops);
420 trace_filename = xstrdup (filename);
421 trace_fd = scratch_chan;
424 /* Read the file header and test for validity. */
425 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
427 bytes += TRACE_HEADER_SIZE;
428 if (!(header[0] == 0x7f
429 && (startswith (header + 1, "TRACE0\n"))))
430 error (_("File is not a valid trace file."));
432 push_target (&tfile_ops);
434 trace_regblock_size = 0;
435 ts = current_trace_status ();
436 /* We know we're working with a file. Record its name. */
437 ts->filename = trace_filename;
438 /* Set defaults in case there is no status line. */
439 ts->running_known = 0;
440 ts->stop_reason = trace_stop_reason_unknown;
441 ts->traceframe_count = -1;
443 ts->disconnected_tracing = 0;
444 ts->circular_buffer = 0;
448 /* Read through a section of newline-terminated lines that
449 define things like tracepoints. */
453 tfile_read (&byte, 1);
458 /* Empty line marks end of the definition section. */
463 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
468 error (_("Excessively long lines in trace file"));
471 /* Record the starting offset of the binary trace data. */
472 trace_frames_offset = bytes;
474 /* If we don't have a blocksize, we can't interpret the
476 if (trace_regblock_size == 0)
477 error (_("No register block size recorded in trace file"));
479 CATCH (ex, RETURN_MASK_ALL)
481 /* Remove the partially set up target. */
482 unpush_target (&tfile_ops);
483 throw_exception (ex);
487 inferior_appeared (current_inferior (), TFILE_PID);
488 inferior_ptid = pid_to_ptid (TFILE_PID);
489 add_thread_silent (inferior_ptid);
491 if (ts->traceframe_count <= 0)
492 warning (_("No traceframes present in this file."));
494 /* Add the file's tracepoints and variables into the current mix. */
496 /* Get trace state variables first, they may be checked when parsing
497 uploaded commands. */
498 merge_uploaded_trace_state_variables (&uploaded_tsvs);
500 merge_uploaded_tracepoints (&uploaded_tps);
502 post_create_inferior (&tfile_ops, from_tty);
505 /* Interpret the given line from the definitions part of the trace
509 tfile_interp_line (char *line, struct uploaded_tp **utpp,
510 struct uploaded_tsv **utsvp)
514 if (startswith (p, "R "))
517 trace_regblock_size = strtol (p, &p, 16);
519 else if (startswith (p, "status "))
521 p += strlen ("status ");
522 parse_trace_status (p, current_trace_status ());
524 else if (startswith (p, "tp "))
527 parse_tracepoint_definition (p, utpp);
529 else if (startswith (p, "tsv "))
531 p += strlen ("tsv ");
532 parse_tsv_definition (p, utsvp);
535 warning (_("Ignoring trace file definition \"%s\""), line);
538 /* Close the trace file and generally clean up. */
541 tfile_close (struct target_ops *self)
548 pid = ptid_get_pid (inferior_ptid);
549 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
550 exit_inferior_silent (pid);
554 xfree (trace_filename);
555 trace_filename = NULL;
557 trace_reset_local_state ();
561 tfile_files_info (struct target_ops *t)
563 printf_filtered ("\t`%s'\n", trace_filename);
567 tfile_get_tracepoint_status (struct target_ops *self,
568 struct breakpoint *tp, struct uploaded_tp *utp)
570 /* Other bits of trace status were collected as part of opening the
571 trace files, so nothing to do here. */
574 /* Given the position of a traceframe in the file, figure out what
575 address the frame was collected at. This would normally be the
576 value of a collected PC register, but if not available, we
580 tfile_get_traceframe_address (off_t tframe_offset)
584 struct tracepoint *tp;
585 off_t saved_offset = cur_offset;
587 /* FIXME dig pc out of collected registers. */
589 /* Fall back to using tracepoint address. */
590 lseek (trace_fd, tframe_offset, SEEK_SET);
591 tfile_read ((gdb_byte *) &tpnum, 2);
592 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
594 (target_gdbarch ()));
596 tp = get_tracepoint_by_number_on_target (tpnum);
597 /* FIXME this is a poor heuristic if multiple locations. */
598 if (tp && tp->base.loc)
599 addr = tp->base.loc->address;
601 /* Restore our seek position. */
602 cur_offset = saved_offset;
603 lseek (trace_fd, cur_offset, SEEK_SET);
607 /* Given a type of search and some parameters, scan the collection of
608 traceframes in the file looking for a match. When found, return
609 both the traceframe and tracepoint number, otherwise -1 for
613 tfile_trace_find (struct target_ops *self, enum trace_find_type type, int num,
614 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
617 int tfnum = 0, found = 0;
618 unsigned int data_size;
619 struct tracepoint *tp;
620 off_t offset, tframe_offset;
630 lseek (trace_fd, trace_frames_offset, SEEK_SET);
631 offset = trace_frames_offset;
634 tframe_offset = offset;
635 tfile_read ((gdb_byte *) &tpnum, 2);
636 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
638 (target_gdbarch ()));
642 tfile_read ((gdb_byte *) &data_size, 4);
643 data_size = (unsigned int) extract_unsigned_integer
644 ((gdb_byte *) &data_size, 4,
645 gdbarch_byte_order (target_gdbarch ()));
648 if (type == tfind_number)
650 /* Looking for a specific trace frame. */
656 /* Start from the _next_ trace frame. */
657 if (tfnum > get_traceframe_number ())
662 tfaddr = tfile_get_traceframe_address (tframe_offset);
667 tp = get_tracepoint (num);
668 if (tp && tpnum == tp->number_on_target)
672 tfaddr = tfile_get_traceframe_address (tframe_offset);
673 if (addr1 <= tfaddr && tfaddr <= addr2)
677 tfaddr = tfile_get_traceframe_address (tframe_offset);
678 if (!(addr1 <= tfaddr && tfaddr <= addr2))
682 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
692 cur_data_size = data_size;
696 /* Skip past the traceframe's data. */
697 lseek (trace_fd, data_size, SEEK_CUR);
699 /* Update our own count of traceframes. */
702 /* Did not find what we were looking for. */
708 /* Prototype of the callback passed to tframe_walk_blocks. */
709 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
711 /* Callback for traceframe_walk_blocks, used to find a given block
712 type in a traceframe. */
715 match_blocktype (char blocktype, void *data)
717 char *wantedp = (char *) data;
719 if (*wantedp == blocktype)
725 /* Walk over all traceframe block starting at POS offset from
726 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
727 unmodified. If CALLBACK returns true, this returns the position in
728 the traceframe where the block is found, relative to the start of
729 the traceframe (cur_offset). Returns -1 if no callback call
730 returned true, indicating that all blocks have been walked. */
733 traceframe_walk_blocks (walk_blocks_callback_func callback,
736 /* Iterate through a traceframe's blocks, looking for a block of the
739 lseek (trace_fd, cur_offset + pos, SEEK_SET);
740 while (pos < cur_data_size)
745 tfile_read ((gdb_byte *) &block_type, 1);
749 if ((*callback) (block_type, data))
755 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
756 pos += trace_regblock_size;
759 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
760 tfile_read ((gdb_byte *) &mlen, 2);
761 mlen = (unsigned short)
762 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
764 (target_gdbarch ()));
765 lseek (trace_fd, mlen, SEEK_CUR);
766 pos += (8 + 2 + mlen);
769 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
773 error (_("Unknown block type '%c' (0x%x) in trace frame"),
774 block_type, block_type);
782 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
783 position offset of a block of type TYPE_WANTED in the current trace
784 frame, starting at POS. Returns -1 if no such block was found. */
787 traceframe_find_block_type (char type_wanted, int pos)
789 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
792 /* Look for a block of saved registers in the traceframe, and get the
793 requested register from it. */
796 tfile_fetch_registers (struct target_ops *ops,
797 struct regcache *regcache, int regno)
799 struct gdbarch *gdbarch = get_regcache_arch (regcache);
800 int offset, regn, regsize, dummy;
802 /* An uninitialized reg size says we're not going to be
803 successful at getting register blocks. */
804 if (!trace_regblock_size)
807 if (traceframe_find_block_type ('R', 0) >= 0)
809 gdb_byte *regs = (gdb_byte *) alloca (trace_regblock_size);
811 tfile_read (regs, trace_regblock_size);
813 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
815 if (!remote_register_number_and_offset (get_regcache_arch (regcache),
816 regn, &dummy, &offset))
819 regsize = register_size (gdbarch, regn);
820 /* Make sure we stay within block bounds. */
821 if (offset + regsize > trace_regblock_size)
823 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
827 regcache_raw_supply (regcache, regno, regs + offset);
830 else if (regno == -1)
832 regcache_raw_supply (regcache, regn, regs + offset);
838 tracefile_fetch_registers (regcache, regno);
841 static enum target_xfer_status
842 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
843 const char *annex, gdb_byte *readbuf,
844 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
845 ULONGEST *xfered_len)
847 /* We're only doing regular memory for now. */
848 if (object != TARGET_OBJECT_MEMORY)
849 return TARGET_XFER_E_IO;
852 error (_("tfile_xfer_partial: trace file is read-only"));
854 if (get_traceframe_number () != -1)
857 enum target_xfer_status res;
858 /* Records the lowest available address of all blocks that
859 intersects the requested range. */
860 ULONGEST low_addr_available = 0;
862 /* Iterate through the traceframe's blocks, looking for
864 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
868 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
870 tfile_read ((gdb_byte *) &maddr, 8);
871 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
873 tfile_read ((gdb_byte *) &mlen, 2);
874 mlen = (unsigned short)
875 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
877 /* If the block includes the first part of the desired
878 range, return as much it has; GDB will re-request the
879 remainder, which might be in a different block of this
881 if (maddr <= offset && offset < (maddr + mlen))
883 amt = (maddr + mlen) - offset;
888 lseek (trace_fd, offset - maddr, SEEK_CUR);
889 tfile_read (readbuf, amt);
891 return TARGET_XFER_OK;
894 if (offset < maddr && maddr < (offset + len))
895 if (low_addr_available == 0 || low_addr_available > maddr)
896 low_addr_available = maddr;
898 /* Skip over this block. */
899 pos += (8 + 2 + mlen);
902 /* Requested memory is unavailable in the context of traceframes,
903 and this address falls within a read-only section, fallback
904 to reading from executable, up to LOW_ADDR_AVAILABLE. */
905 if (offset < low_addr_available)
906 len = min (len, low_addr_available - offset);
907 res = exec_read_partial_read_only (readbuf, offset, len, xfered_len);
909 if (res == TARGET_XFER_OK)
910 return TARGET_XFER_OK;
913 /* No use trying further, we know some memory starting
914 at MEMADDR isn't available. */
916 return TARGET_XFER_UNAVAILABLE;
921 /* Fallback to reading from read-only sections. */
922 return section_table_read_available_memory (readbuf, offset, len,
927 /* Iterate through the blocks of a trace frame, looking for a 'V'
928 block with a matching tsv number. */
931 tfile_get_trace_state_variable_value (struct target_ops *self,
932 int tsvnum, LONGEST *val)
937 /* Iterate over blocks in current frame and find the last 'V'
938 block in which tsv number is TSVNUM. In one trace frame, there
939 may be multiple 'V' blocks created for a given trace variable,
940 and the last matched 'V' block contains the updated value. */
942 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
946 tfile_read ((gdb_byte *) &vnum, 4);
947 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
949 (target_gdbarch ()));
952 tfile_read ((gdb_byte *) val, 8);
953 *val = extract_signed_integer ((gdb_byte *) val, 8,
955 (target_gdbarch ()));
964 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
965 object for the tfile target's current traceframe. */
968 build_traceframe_info (char blocktype, void *data)
970 struct traceframe_info *info = (struct traceframe_info *) data;
980 tfile_read ((gdb_byte *) &maddr, 8);
981 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
983 (target_gdbarch ()));
984 tfile_read ((gdb_byte *) &mlen, 2);
985 mlen = (unsigned short)
986 extract_unsigned_integer ((gdb_byte *) &mlen,
987 2, gdbarch_byte_order
988 (target_gdbarch ()));
990 r = VEC_safe_push (mem_range_s, info->memory, NULL);
1000 tfile_read ((gdb_byte *) &vnum, 4);
1001 VEC_safe_push (int, info->tvars, vnum);
1009 warning (_("Unhandled trace block type (%d) '%c ' "
1010 "while building trace frame info."),
1011 blocktype, blocktype);
1018 static struct traceframe_info *
1019 tfile_traceframe_info (struct target_ops *self)
1021 struct traceframe_info *info = XCNEW (struct traceframe_info);
1023 traceframe_walk_blocks (build_traceframe_info, 0, info);
1028 init_tfile_ops (void)
1030 init_tracefile_ops (&tfile_ops);
1032 tfile_ops.to_shortname = "tfile";
1033 tfile_ops.to_longname = "Local trace dump file";
1035 = "Use a trace file as a target. Specify the filename of the trace file.";
1036 tfile_ops.to_open = tfile_open;
1037 tfile_ops.to_close = tfile_close;
1038 tfile_ops.to_fetch_registers = tfile_fetch_registers;
1039 tfile_ops.to_xfer_partial = tfile_xfer_partial;
1040 tfile_ops.to_files_info = tfile_files_info;
1041 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
1042 tfile_ops.to_trace_find = tfile_trace_find;
1043 tfile_ops.to_get_trace_state_variable_value
1044 = tfile_get_trace_state_variable_value;
1045 tfile_ops.to_traceframe_info = tfile_traceframe_info;
1048 extern initialize_file_ftype _initialize_tracefile_tfile;
1051 _initialize_tracefile_tfile (void)
1055 add_target_with_completer (&tfile_ops, filename_completer);