/* 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 "exec.h" /* exec_bfd */
#include "completer.h"
#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
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);
sizeof (utp->traceframe_usage)));
}
+/* This is the implementation of trace_file_write_ops method
+ write_tdesc. */
+
+static void
+tfile_write_tdesc (struct trace_file_writer *self)
+{
+ 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)
+ return;
+
+ /* Write tdesc line by line, prefixing each line with "tdesc ". */
+ while (ptr != NULL)
+ {
+ next = strchr (ptr, '\n');
+ if (next != NULL)
+ {
+ fprintf (writer->fp, "tdesc %.*s\n", (int) (next - ptr), ptr);
+ /* Skip the \n. */
+ next++;
+ }
+ else if (*ptr != '\0')
+ {
+ /* Last line, doesn't have a newline. */
+ fprintf (writer->fp, "tdesc %s\n", ptr);
+ }
+ ptr = next;
+ }
+
+ xfree (tdesc);
+}
+
/* This is the implementation of trace_file_write_ops method
write_definition_end. */
tfile_write_status,
tfile_write_uploaded_tsv,
tfile_write_uploaded_tp,
+ tfile_write_tdesc,
tfile_write_definition_end,
tfile_write_raw_data,
NULL,
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);
trace_filename = xstrdup (filename);
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 ();
}
struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- int offset, regn, regsize;
+ int offset, regn, regsize, dummy;
/* An uninitialized reg size says we're not going to be
successful at getting register blocks. */
tfile_read (regs, trace_regblock_size);
- /* Assume the block is laid out in GDB register number order,
- each register with the size that it has in GDB. */
- offset = 0;
for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
{
+ if (!remote_register_number_and_offset (get_regcache_arch (regcache),
+ regn, &dummy, &offset))
+ continue;
+
regsize = register_size (gdbarch, regn);
/* Make sure we stay within block bounds. */
if (offset + regsize > trace_regblock_size)
regcache_raw_supply (regcache, regn, regs + offset);
}
}
- offset += regsize;
}
}
else
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)
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)
{
projects / deliverable / binutils-gdb.git / blobdiff