/* Trace file TFILE format support in GDB.
- Copyright (C) 1997-2016 Free Software Foundation, Inc.
+ Copyright (C) 1997-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "filenames.h"
#include "remote.h"
#include "xml-tdesc.h"
+#include "target-descriptions.h"
+#include "buffer.h"
+#include <algorithm>
#ifndef O_LARGEFILE
#define O_LARGEFILE 0
= (struct tfile_trace_file_writer *) self;
writer->pathname = tilde_expand (filename);
- writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
+ writer->fp = gdb_fopen_cloexec (writer->pathname, "wb").release ();
if (writer->fp == NULL)
error (_("Unable to open file '%s' for saving trace data (%s)"),
writer->pathname, safe_strerror (errno));
fprintf (writer->fp, "status %c;%s",
(ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
if (ts->stop_reason == tracepoint_error
- || ts->stop_reason == tstop_command)
+ || ts->stop_reason == trace_stop_command)
{
char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
tfile_write_uploaded_tsv (struct trace_file_writer *self,
struct uploaded_tsv *utsv)
{
- char *buf = "";
+ char *buf = NULL;
struct tfile_trace_file_writer *writer
= (struct tfile_trace_file_writer *) self;
fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
utsv->number, phex_nz (utsv->initial_value, 8),
- utsv->builtin, buf);
+ utsv->builtin, buf != NULL ? buf : "");
if (utsv->name)
xfree (buf);
{
struct tfile_trace_file_writer *writer
= (struct tfile_trace_file_writer *) self;
- char *tdesc = target_fetch_description_xml (¤t_target);
- char *ptr = tdesc;
- char *next;
- if (tdesc == NULL)
+ gdb::optional<std::string> tdesc
+ = target_fetch_description_xml (¤t_target);
+
+ if (!tdesc)
return;
+ const char *ptr = tdesc->c_str ();
+
/* Write tdesc line by line, prefixing each line with "tdesc ". */
while (ptr != NULL)
{
- next = strchr (ptr, '\n');
+ const char *next = strchr (ptr, '\n');
if (next != NULL)
{
fprintf (writer->fp, "tdesc %.*s\n", (int) (next - ptr), ptr);
}
ptr = next;
}
-
- xfree (tdesc);
}
/* This is the implementation of trace_file_write_ops method
static off_t cur_offset;
static int cur_data_size;
int trace_regblock_size;
+static struct buffer trace_tdesc;
+static void tfile_append_tdesc_line (const char *line);
static void tfile_interp_line (char *line,
struct uploaded_tp **utpp,
struct uploaded_tsv **utsvp);
tfile_open (const char *arg, int from_tty)
{
char *temp;
- struct cleanup *old_chain;
int flags;
int scratch_chan;
char header[TRACE_HEADER_SIZE];
struct trace_status *ts;
struct uploaded_tp *uploaded_tps = NULL;
struct uploaded_tsv *uploaded_tsvs = NULL;
- char *filename;
target_preopen (from_tty);
if (!arg)
error (_("No trace file specified."));
- filename = tilde_expand (arg);
- if (!IS_ABSOLUTE_PATH(filename))
- {
- temp = concat (current_directory, "/", filename, (char *) NULL);
- xfree (filename);
- filename = temp;
- }
-
- old_chain = make_cleanup (xfree, filename);
+ gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg));
+ if (!IS_ABSOLUTE_PATH (filename.get ()))
+ filename.reset (concat (current_directory, "/", filename.get (),
+ (char *) NULL));
flags = O_BINARY | O_LARGEFILE;
flags |= O_RDONLY;
- scratch_chan = gdb_open_cloexec (filename, flags, 0);
+ scratch_chan = gdb_open_cloexec (filename.get (), flags, 0);
if (scratch_chan < 0)
- perror_with_name (filename);
+ perror_with_name (filename.get ());
/* Looks semi-reasonable. Toss the old trace file and work on the new. */
- discard_cleanups (old_chain); /* Don't free filename any more. */
unpush_target (&tfile_ops);
- trace_filename = xstrdup (filename);
+ trace_filename = filename.release ();
trace_fd = scratch_chan;
+ /* Make sure this is clear. */
+ buffer_free (&trace_tdesc);
+
bytes = 0;
/* Read the file header and test for validity. */
tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
error (_("Excessively long lines in trace file"));
}
+ /* By now, tdesc lines have been read from tfile - let's parse them. */
+ target_find_description ();
+
/* Record the starting offset of the binary trace data. */
trace_frames_offset = bytes;
p += strlen ("tsv ");
parse_tsv_definition (p, utsvp);
}
+ else if (startswith (p, "tdesc "))
+ {
+ p += strlen ("tdesc ");
+ tfile_append_tdesc_line (p);
+ }
else
warning (_("Ignoring trace file definition \"%s\""), line);
}
trace_fd = -1;
xfree (trace_filename);
trace_filename = NULL;
+ buffer_free (&trace_tdesc);
trace_reset_local_state ();
}
tp = get_tracepoint_by_number_on_target (tpnum);
/* FIXME this is a poor heuristic if multiple locations. */
- if (tp && tp->base.loc)
- addr = tp->base.loc->address;
+ if (tp && tp->loc)
+ addr = tp->loc->address;
/* Restore our seek position. */
cur_offset = saved_offset;
tfile_fetch_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct gdbarch *gdbarch = regcache->arch ();
int offset, regn, regsize, dummy;
/* An uninitialized reg size says we're not going to be
for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
{
- if (!remote_register_number_and_offset (get_regcache_arch (regcache),
+ if (!remote_register_number_and_offset (regcache->arch (),
regn, &dummy, &offset))
continue;
tracefile_fetch_registers (regcache, regno);
}
+static enum target_xfer_status
+tfile_xfer_partial_features (struct target_ops *ops, const char *annex,
+ gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
+{
+ if (strcmp (annex, "target.xml"))
+ return TARGET_XFER_E_IO;
+
+ if (readbuf == NULL)
+ error (_("tfile_xfer_partial: tdesc is read-only"));
+
+ if (trace_tdesc.used_size == 0)
+ return TARGET_XFER_E_IO;
+
+ if (offset >= trace_tdesc.used_size)
+ return TARGET_XFER_EOF;
+
+ if (len > trace_tdesc.used_size - offset)
+ len = trace_tdesc.used_size - offset;
+
+ memcpy (readbuf, trace_tdesc.buffer + offset, len);
+ *xfered_len = len;
+
+ return TARGET_XFER_OK;
+}
+
static enum target_xfer_status
tfile_xfer_partial (struct target_ops *ops, enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len)
{
- /* We're only doing regular memory for now. */
+ /* We're only doing regular memory and tdesc for now. */
+ if (object == TARGET_OBJECT_AVAILABLE_FEATURES)
+ return tfile_xfer_partial_features (ops, annex, readbuf, writebuf,
+ offset, len, xfered_len);
if (object != TARGET_OBJECT_MEMORY)
return TARGET_XFER_E_IO;
and this address falls within a read-only section, fallback
to reading from executable, up to LOW_ADDR_AVAILABLE. */
if (offset < low_addr_available)
- len = min (len, low_addr_available - offset);
+ len = std::min (len, low_addr_available - offset);
res = exec_read_partial_read_only (readbuf, offset, len, xfered_len);
if (res == TARGET_XFER_OK)
{
case 'M':
{
- struct mem_range *r;
ULONGEST maddr;
unsigned short mlen;
2, gdbarch_byte_order
(target_gdbarch ()));
- r = VEC_safe_push (mem_range_s, info->memory, NULL);
-
- r->start = maddr;
- r->length = mlen;
+ info->memory.emplace_back (maddr, mlen);
break;
}
case 'V':
int vnum;
tfile_read ((gdb_byte *) &vnum, 4);
- VEC_safe_push (int, info->tvars, vnum);
+ info->tvars.push_back (vnum);
}
case 'R':
case 'S':
return 0;
}
-static struct traceframe_info *
+static traceframe_info_up
tfile_traceframe_info (struct target_ops *self)
{
- struct traceframe_info *info = XCNEW (struct traceframe_info);
+ traceframe_info_up info (new traceframe_info);
+
+ traceframe_walk_blocks (build_traceframe_info, 0, info.get ());
- traceframe_walk_blocks (build_traceframe_info, 0, info);
return info;
}
+/* Handles tdesc lines from tfile by appending the payload to
+ a global trace_tdesc variable. */
+
+static void
+tfile_append_tdesc_line (const char *line)
+{
+ buffer_grow_str (&trace_tdesc, line);
+ buffer_grow_str (&trace_tdesc, "\n");
+}
+
static void
init_tfile_ops (void)
{
tfile_ops.to_traceframe_info = tfile_traceframe_info;
}
-extern initialize_file_ftype _initialize_tracefile_tfile;
-
void
_initialize_tracefile_tfile (void)
{
projects / deliverable / binutils-gdb.git / blobdiff