1 /* Trace file TFILE format support in GDB.
3 Copyright (C) 1997-2014 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"
36 /* TFILE trace writer. */
38 struct tfile_trace_file_writer
40 struct trace_file_writer base;
42 /* File pointer to tfile trace file. */
44 /* Path name of the tfile trace file. */
48 /* This is the implementation of trace_file_write_ops method
49 target_save. We just call the generic target
50 target_save_trace_data to do target-side saving. */
53 tfile_target_save (struct trace_file_writer *self,
56 int err = target_save_trace_data (filename);
61 /* This is the implementation of trace_file_write_ops method
65 tfile_dtor (struct trace_file_writer *self)
67 struct tfile_trace_file_writer *writer
68 = (struct tfile_trace_file_writer *) self;
70 xfree (writer->pathname);
72 if (writer->fp != NULL)
76 /* This is the implementation of trace_file_write_ops method
77 start. It creates the trace file FILENAME and registers some
81 tfile_start (struct trace_file_writer *self, const char *filename)
83 struct tfile_trace_file_writer *writer
84 = (struct tfile_trace_file_writer *) self;
86 writer->pathname = tilde_expand (filename);
87 writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
88 if (writer->fp == NULL)
89 error (_("Unable to open file '%s' for saving trace data (%s)"),
90 writer->pathname, safe_strerror (errno));
93 /* This is the implementation of trace_file_write_ops method
94 write_header. Write the TFILE header. */
97 tfile_write_header (struct trace_file_writer *self)
99 struct tfile_trace_file_writer *writer
100 = (struct tfile_trace_file_writer *) self;
103 /* Write a file header, with a high-bit-set char to indicate a
104 binary file, plus a hint as what this file is, and a version
105 number in case of future needs. */
106 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
108 perror_with_name (writer->pathname);
111 /* This is the implementation of trace_file_write_ops method
112 write_regblock_type. Write the size of register block. */
115 tfile_write_regblock_type (struct trace_file_writer *self, int size)
117 struct tfile_trace_file_writer *writer
118 = (struct tfile_trace_file_writer *) self;
120 fprintf (writer->fp, "R %x\n", size);
123 /* This is the implementation of trace_file_write_ops method
127 tfile_write_status (struct trace_file_writer *self,
128 struct trace_status *ts)
130 struct tfile_trace_file_writer *writer
131 = (struct tfile_trace_file_writer *) self;
133 fprintf (writer->fp, "status %c;%s",
134 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
135 if (ts->stop_reason == tracepoint_error
136 || ts->stop_reason == tstop_command)
138 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
140 bin2hex ((gdb_byte *) ts->stop_desc, buf, strlen (ts->stop_desc));
141 fprintf (writer->fp, ":%s", buf);
143 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
144 if (ts->traceframe_count >= 0)
145 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
146 if (ts->traceframes_created >= 0)
147 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
148 if (ts->buffer_free >= 0)
149 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
150 if (ts->buffer_size >= 0)
151 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
152 if (ts->disconnected_tracing)
153 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
154 if (ts->circular_buffer)
155 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
158 fprintf (writer->fp, ";starttime:%s",
159 phex_nz (ts->start_time, sizeof (ts->start_time)));
163 fprintf (writer->fp, ";stoptime:%s",
164 phex_nz (ts->stop_time, sizeof (ts->stop_time)));
166 if (ts->notes != NULL)
168 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
170 bin2hex ((gdb_byte *) ts->notes, buf, strlen (ts->notes));
171 fprintf (writer->fp, ";notes:%s", buf);
173 if (ts->user_name != NULL)
175 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
177 bin2hex ((gdb_byte *) ts->user_name, buf, strlen (ts->user_name));
178 fprintf (writer->fp, ";username:%s", buf);
180 fprintf (writer->fp, "\n");
183 /* This is the implementation of trace_file_write_ops method
184 write_uploaded_tsv. */
187 tfile_write_uploaded_tsv (struct trace_file_writer *self,
188 struct uploaded_tsv *utsv)
191 struct tfile_trace_file_writer *writer
192 = (struct tfile_trace_file_writer *) self;
196 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
197 bin2hex ((gdb_byte *) (utsv->name), buf, strlen (utsv->name));
200 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
201 utsv->number, phex_nz (utsv->initial_value, 8),
208 #define MAX_TRACE_UPLOAD 2000
210 /* This is the implementation of trace_file_write_ops method
211 write_uploaded_tp. */
214 tfile_write_uploaded_tp (struct trace_file_writer *self,
215 struct uploaded_tp *utp)
217 struct tfile_trace_file_writer *writer
218 = (struct tfile_trace_file_writer *) self;
221 char buf[MAX_TRACE_UPLOAD];
223 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
224 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
225 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
226 if (utp->type == bp_fast_tracepoint)
227 fprintf (writer->fp, ":F%x", utp->orig_size);
230 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
232 fprintf (writer->fp, "\n");
233 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
234 fprintf (writer->fp, "tp A%x:%s:%s\n",
235 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
236 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
237 fprintf (writer->fp, "tp S%x:%s:%s\n",
238 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
241 encode_source_string (utp->number, utp->addr,
242 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
243 fprintf (writer->fp, "tp Z%s\n", buf);
245 if (utp->cond_string)
247 encode_source_string (utp->number, utp->addr,
248 "cond", utp->cond_string,
249 buf, MAX_TRACE_UPLOAD);
250 fprintf (writer->fp, "tp Z%s\n", buf);
252 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
254 encode_source_string (utp->number, utp->addr, "cmd", act,
255 buf, MAX_TRACE_UPLOAD);
256 fprintf (writer->fp, "tp Z%s\n", buf);
258 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
259 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
261 phex_nz (utp->traceframe_usage,
262 sizeof (utp->traceframe_usage)));
265 /* This is the implementation of trace_file_write_ops method
266 write_definition_end. */
269 tfile_write_definition_end (struct trace_file_writer *self)
271 struct tfile_trace_file_writer *writer
272 = (struct tfile_trace_file_writer *) self;
274 fprintf (writer->fp, "\n");
277 /* This is the implementation of trace_file_write_ops method
281 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
284 struct tfile_trace_file_writer *writer
285 = (struct tfile_trace_file_writer *) self;
287 if (fwrite (buf, len, 1, writer->fp) < 1)
288 perror_with_name (writer->pathname);
291 /* This is the implementation of trace_file_write_ops method
295 tfile_end (struct trace_file_writer *self)
297 struct tfile_trace_file_writer *writer
298 = (struct tfile_trace_file_writer *) self;
301 /* Mark the end of trace data. */
302 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
303 perror_with_name (writer->pathname);
306 /* Operations to write trace buffers into TFILE format. */
308 static const struct trace_file_write_ops tfile_write_ops =
314 tfile_write_regblock_type,
316 tfile_write_uploaded_tsv,
317 tfile_write_uploaded_tp,
318 tfile_write_definition_end,
319 tfile_write_raw_data,
324 /* Return a trace writer for TFILE format. */
326 struct trace_file_writer *
327 tfile_trace_file_writer_new (void)
329 struct tfile_trace_file_writer *writer
330 = xmalloc (sizeof (struct tfile_trace_file_writer));
332 writer->base.ops = &tfile_write_ops;
334 writer->pathname = NULL;
336 return (struct trace_file_writer *) writer;
339 /* target tfile command */
341 static struct target_ops tfile_ops;
343 /* Fill in tfile_ops with its defined operations and properties. */
345 #define TRACE_HEADER_SIZE 8
347 #define TFILE_PID (1)
349 static char *trace_filename;
350 static int trace_fd = -1;
351 static off_t trace_frames_offset;
352 static off_t cur_offset;
353 static int cur_data_size;
354 int trace_regblock_size;
356 static void tfile_interp_line (char *line,
357 struct uploaded_tp **utpp,
358 struct uploaded_tsv **utsvp);
360 /* Read SIZE bytes into READBUF from the trace frame, starting at
361 TRACE_FD's current position. Note that this call `read'
362 underneath, hence it advances the file's seek position. Throws an
363 error if the `read' syscall fails, or less than SIZE bytes are
367 tfile_read (gdb_byte *readbuf, int size)
371 gotten = read (trace_fd, readbuf, size);
373 perror_with_name (trace_filename);
374 else if (gotten < size)
375 error (_("Premature end of file while reading trace file"));
379 tfile_open (char *filename, int from_tty)
381 volatile struct gdb_exception ex;
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;
394 target_preopen (from_tty);
396 error (_("No trace file specified."));
398 filename = tilde_expand (filename);
399 if (!IS_ABSOLUTE_PATH(filename))
401 temp = concat (current_directory, "/", filename, (char *) NULL);
406 old_chain = make_cleanup (xfree, filename);
408 flags = O_BINARY | O_LARGEFILE;
410 scratch_chan = gdb_open_cloexec (filename, flags, 0);
411 if (scratch_chan < 0)
412 perror_with_name (filename);
414 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
416 discard_cleanups (old_chain); /* Don't free filename any more. */
417 unpush_target (&tfile_ops);
419 trace_filename = xstrdup (filename);
420 trace_fd = scratch_chan;
423 /* Read the file header and test for validity. */
424 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
426 bytes += TRACE_HEADER_SIZE;
427 if (!(header[0] == 0x7f
428 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
429 error (_("File is not a valid trace file."));
431 push_target (&tfile_ops);
433 trace_regblock_size = 0;
434 ts = current_trace_status ();
435 /* We know we're working with a file. Record its name. */
436 ts->filename = trace_filename;
437 /* Set defaults in case there is no status line. */
438 ts->running_known = 0;
439 ts->stop_reason = trace_stop_reason_unknown;
440 ts->traceframe_count = -1;
442 ts->disconnected_tracing = 0;
443 ts->circular_buffer = 0;
445 TRY_CATCH (ex, RETURN_MASK_ALL)
447 /* Read through a section of newline-terminated lines that
448 define things like tracepoints. */
452 tfile_read (&byte, 1);
457 /* Empty line marks end of the definition section. */
462 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
467 error (_("Excessively long lines in trace file"));
470 /* Record the starting offset of the binary trace data. */
471 trace_frames_offset = bytes;
473 /* If we don't have a blocksize, we can't interpret the
475 if (trace_regblock_size == 0)
476 error (_("No register block size recorded in trace file"));
480 /* Remove the partially set up target. */
481 unpush_target (&tfile_ops);
482 throw_exception (ex);
485 inferior_appeared (current_inferior (), TFILE_PID);
486 inferior_ptid = pid_to_ptid (TFILE_PID);
487 add_thread_silent (inferior_ptid);
489 if (ts->traceframe_count <= 0)
490 warning (_("No traceframes present in this file."));
492 /* Add the file's tracepoints and variables into the current mix. */
494 /* Get trace state variables first, they may be checked when parsing
495 uploaded commands. */
496 merge_uploaded_trace_state_variables (&uploaded_tsvs);
498 merge_uploaded_tracepoints (&uploaded_tps);
500 post_create_inferior (&tfile_ops, from_tty);
503 /* Interpret the given line from the definitions part of the trace
507 tfile_interp_line (char *line, struct uploaded_tp **utpp,
508 struct uploaded_tsv **utsvp)
512 if (strncmp (p, "R ", strlen ("R ")) == 0)
515 trace_regblock_size = strtol (p, &p, 16);
517 else if (strncmp (p, "status ", strlen ("status ")) == 0)
519 p += strlen ("status ");
520 parse_trace_status (p, current_trace_status ());
522 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
525 parse_tracepoint_definition (p, utpp);
527 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
529 p += strlen ("tsv ");
530 parse_tsv_definition (p, utsvp);
533 warning (_("Ignoring trace file definition \"%s\""), line);
536 /* Close the trace file and generally clean up. */
539 tfile_close (struct target_ops *self)
546 pid = ptid_get_pid (inferior_ptid);
547 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
548 exit_inferior_silent (pid);
552 xfree (trace_filename);
553 trace_filename = NULL;
555 trace_reset_local_state ();
559 tfile_files_info (struct target_ops *t)
561 printf_filtered ("\t`%s'\n", trace_filename);
565 tfile_get_tracepoint_status (struct target_ops *self,
566 struct breakpoint *tp, struct uploaded_tp *utp)
568 /* Other bits of trace status were collected as part of opening the
569 trace files, so nothing to do here. */
572 /* Given the position of a traceframe in the file, figure out what
573 address the frame was collected at. This would normally be the
574 value of a collected PC register, but if not available, we
578 tfile_get_traceframe_address (off_t tframe_offset)
582 struct tracepoint *tp;
583 off_t saved_offset = cur_offset;
585 /* FIXME dig pc out of collected registers. */
587 /* Fall back to using tracepoint address. */
588 lseek (trace_fd, tframe_offset, SEEK_SET);
589 tfile_read ((gdb_byte *) &tpnum, 2);
590 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
592 (target_gdbarch ()));
594 tp = get_tracepoint_by_number_on_target (tpnum);
595 /* FIXME this is a poor heuristic if multiple locations. */
596 if (tp && tp->base.loc)
597 addr = tp->base.loc->address;
599 /* Restore our seek position. */
600 cur_offset = saved_offset;
601 lseek (trace_fd, cur_offset, SEEK_SET);
605 /* Given a type of search and some parameters, scan the collection of
606 traceframes in the file looking for a match. When found, return
607 both the traceframe and tracepoint number, otherwise -1 for
611 tfile_trace_find (struct target_ops *self, enum trace_find_type type, int num,
612 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
615 int tfnum = 0, found = 0;
616 unsigned int data_size;
617 struct tracepoint *tp;
618 off_t offset, tframe_offset;
628 lseek (trace_fd, trace_frames_offset, SEEK_SET);
629 offset = trace_frames_offset;
632 tframe_offset = offset;
633 tfile_read ((gdb_byte *) &tpnum, 2);
634 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
636 (target_gdbarch ()));
640 tfile_read ((gdb_byte *) &data_size, 4);
641 data_size = (unsigned int) extract_unsigned_integer
642 ((gdb_byte *) &data_size, 4,
643 gdbarch_byte_order (target_gdbarch ()));
646 if (type == tfind_number)
648 /* Looking for a specific trace frame. */
654 /* Start from the _next_ trace frame. */
655 if (tfnum > get_traceframe_number ())
660 tfaddr = tfile_get_traceframe_address (tframe_offset);
665 tp = get_tracepoint (num);
666 if (tp && tpnum == tp->number_on_target)
670 tfaddr = tfile_get_traceframe_address (tframe_offset);
671 if (addr1 <= tfaddr && tfaddr <= addr2)
675 tfaddr = tfile_get_traceframe_address (tframe_offset);
676 if (!(addr1 <= tfaddr && tfaddr <= addr2))
680 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
690 cur_data_size = data_size;
694 /* Skip past the traceframe's data. */
695 lseek (trace_fd, data_size, SEEK_CUR);
697 /* Update our own count of traceframes. */
700 /* Did not find what we were looking for. */
706 /* Prototype of the callback passed to tframe_walk_blocks. */
707 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
709 /* Callback for traceframe_walk_blocks, used to find a given block
710 type in a traceframe. */
713 match_blocktype (char blocktype, void *data)
715 char *wantedp = data;
717 if (*wantedp == blocktype)
723 /* Walk over all traceframe block starting at POS offset from
724 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
725 unmodified. If CALLBACK returns true, this returns the position in
726 the traceframe where the block is found, relative to the start of
727 the traceframe (cur_offset). Returns -1 if no callback call
728 returned true, indicating that all blocks have been walked. */
731 traceframe_walk_blocks (walk_blocks_callback_func callback,
734 /* Iterate through a traceframe's blocks, looking for a block of the
737 lseek (trace_fd, cur_offset + pos, SEEK_SET);
738 while (pos < cur_data_size)
743 tfile_read ((gdb_byte *) &block_type, 1);
747 if ((*callback) (block_type, data))
753 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
754 pos += trace_regblock_size;
757 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
758 tfile_read ((gdb_byte *) &mlen, 2);
759 mlen = (unsigned short)
760 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
762 (target_gdbarch ()));
763 lseek (trace_fd, mlen, SEEK_CUR);
764 pos += (8 + 2 + mlen);
767 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
771 error (_("Unknown block type '%c' (0x%x) in trace frame"),
772 block_type, block_type);
780 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
781 position offset of a block of type TYPE_WANTED in the current trace
782 frame, starting at POS. Returns -1 if no such block was found. */
785 traceframe_find_block_type (char type_wanted, int pos)
787 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
790 /* Look for a block of saved registers in the traceframe, and get the
791 requested register from it. */
794 tfile_fetch_registers (struct target_ops *ops,
795 struct regcache *regcache, int regno)
797 struct gdbarch *gdbarch = get_regcache_arch (regcache);
798 int offset, regn, regsize, pc_regno;
801 /* An uninitialized reg size says we're not going to be
802 successful at getting register blocks. */
803 if (!trace_regblock_size)
806 regs = alloca (trace_regblock_size);
808 if (traceframe_find_block_type ('R', 0) >= 0)
810 tfile_read (regs, trace_regblock_size);
812 /* Assume the block is laid out in GDB register number order,
813 each register with the size that it has in GDB. */
815 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
817 regsize = register_size (gdbarch, regn);
818 /* Make sure we stay within block bounds. */
819 if (offset + regsize >= trace_regblock_size)
821 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
825 regcache_raw_supply (regcache, regno, regs + offset);
828 else if (regno == -1)
830 regcache_raw_supply (regcache, regn, regs + offset);
838 /* We get here if no register data has been found. Mark registers
840 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
841 regcache_raw_supply (regcache, regn, NULL);
843 /* We can often usefully guess that the PC is going to be the same
844 as the address of the tracepoint. */
845 pc_regno = gdbarch_pc_regnum (gdbarch);
847 /* XXX This guessing code below only works if the PC register isn't
848 a pseudo-register. The value of a pseudo-register isn't stored
849 in the (non-readonly) regcache -- instead it's recomputed
850 (probably from some other cached raw register) whenever the
851 register is read. This guesswork should probably move to some
853 if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
856 if (regno == -1 || regno == pc_regno)
858 struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
860 if (tp && tp->base.loc)
862 /* But don't try to guess if tracepoint is multi-location... */
863 if (tp->base.loc->next)
865 warning (_("Tracepoint %d has multiple "
866 "locations, cannot infer $pc"),
870 /* ... or does while-stepping. */
871 if (tp->step_count > 0)
873 warning (_("Tracepoint %d does while-stepping, "
879 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
880 gdbarch_byte_order (gdbarch),
881 tp->base.loc->address);
882 regcache_raw_supply (regcache, pc_regno, regs);
887 static enum target_xfer_status
888 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
889 const char *annex, gdb_byte *readbuf,
890 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
891 ULONGEST *xfered_len)
893 /* We're only doing regular memory for now. */
894 if (object != TARGET_OBJECT_MEMORY)
895 return TARGET_XFER_E_IO;
898 error (_("tfile_xfer_partial: trace file is read-only"));
900 if (get_traceframe_number () != -1)
904 /* Iterate through the traceframe's blocks, looking for
906 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
910 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
912 tfile_read ((gdb_byte *) &maddr, 8);
913 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
915 tfile_read ((gdb_byte *) &mlen, 2);
916 mlen = (unsigned short)
917 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
919 /* If the block includes the first part of the desired
920 range, return as much it has; GDB will re-request the
921 remainder, which might be in a different block of this
923 if (maddr <= offset && offset < (maddr + mlen))
925 amt = (maddr + mlen) - offset;
930 lseek (trace_fd, offset - maddr, SEEK_CUR);
931 tfile_read (readbuf, amt);
933 return TARGET_XFER_OK;
936 /* Skip over this block. */
937 pos += (8 + 2 + mlen);
941 /* It's unduly pedantic to refuse to look at the executable for
942 read-only pieces; so do the equivalent of readonly regions aka
944 /* FIXME account for relocation at some point. */
951 for (s = exec_bfd->sections; s; s = s->next)
953 if ((s->flags & SEC_LOAD) == 0
954 || (s->flags & SEC_READONLY) == 0)
958 size = bfd_get_section_size (s);
959 if (vma <= offset && offset < (vma + size))
963 amt = (vma + size) - offset;
967 *xfered_len = bfd_get_section_contents (exec_bfd, s,
968 readbuf, offset - vma, amt);
969 return TARGET_XFER_OK;
974 /* Indicate failure to find the requested memory block. */
975 return TARGET_XFER_E_IO;
978 /* Iterate through the blocks of a trace frame, looking for a 'V'
979 block with a matching tsv number. */
982 tfile_get_trace_state_variable_value (struct target_ops *self,
983 int tsvnum, LONGEST *val)
988 /* Iterate over blocks in current frame and find the last 'V'
989 block in which tsv number is TSVNUM. In one trace frame, there
990 may be multiple 'V' blocks created for a given trace variable,
991 and the last matched 'V' block contains the updated value. */
993 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
997 tfile_read ((gdb_byte *) &vnum, 4);
998 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
1000 (target_gdbarch ()));
1003 tfile_read ((gdb_byte *) val, 8);
1004 *val = extract_signed_integer ((gdb_byte *) val, 8,
1006 (target_gdbarch ()));
1015 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
1016 object for the tfile target's current traceframe. */
1019 build_traceframe_info (char blocktype, void *data)
1021 struct traceframe_info *info = data;
1027 struct mem_range *r;
1029 unsigned short mlen;
1031 tfile_read ((gdb_byte *) &maddr, 8);
1032 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
1034 (target_gdbarch ()));
1035 tfile_read ((gdb_byte *) &mlen, 2);
1036 mlen = (unsigned short)
1037 extract_unsigned_integer ((gdb_byte *) &mlen,
1038 2, gdbarch_byte_order
1039 (target_gdbarch ()));
1041 r = VEC_safe_push (mem_range_s, info->memory, NULL);
1051 tfile_read ((gdb_byte *) &vnum, 4);
1052 VEC_safe_push (int, info->tvars, vnum);
1060 warning (_("Unhandled trace block type (%d) '%c ' "
1061 "while building trace frame info."),
1062 blocktype, blocktype);
1069 static struct traceframe_info *
1070 tfile_traceframe_info (struct target_ops *self)
1072 struct traceframe_info *info = XCNEW (struct traceframe_info);
1074 traceframe_walk_blocks (build_traceframe_info, 0, info);
1079 init_tfile_ops (void)
1081 init_tracefile_ops (&tfile_ops);
1083 tfile_ops.to_shortname = "tfile";
1084 tfile_ops.to_longname = "Local trace dump file";
1086 = "Use a trace file as a target. Specify the filename of the trace file.";
1087 tfile_ops.to_open = tfile_open;
1088 tfile_ops.to_close = tfile_close;
1089 tfile_ops.to_fetch_registers = tfile_fetch_registers;
1090 tfile_ops.to_xfer_partial = tfile_xfer_partial;
1091 tfile_ops.to_files_info = tfile_files_info;
1092 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
1093 tfile_ops.to_trace_find = tfile_trace_find;
1094 tfile_ops.to_get_trace_state_variable_value
1095 = tfile_get_trace_state_variable_value;
1096 tfile_ops.to_traceframe_info = tfile_traceframe_info;
1099 extern initialize_file_ftype _initialize_tracefile_tfile;
1102 _initialize_tracefile_tfile (void)
1106 add_target_with_completer (&tfile_ops, filename_completer);