mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
48b6e87ef2
Functions ctf_fetch_registers and tfile_fetch_registers have some duplicated code about guessing the PC in regcache. Sometimes, we may change one function and forget to update the other one, like this https://www.sourceware.org/ml/gdb-patches/2014-01/msg00292.html This patch is to move the duplicated code into a new function tracefile_fetch_registers, and let both ctf_fetch_registers and tfile_fetch_registers call it. gdb: 2014-04-22 Yao Qi <yao@codesourcery.com> * tracefile-tfile.c (tfile_fetch_registers): Move the bottom to ... * tracefile.c (tracefile_fetch_registers): ... it. New function. * tracefile.h (tracefile_fetch_registers): Declare. * ctf.c (ctf_fetch_registers): Remove the bottom. Call tracefile_fetch_registers.
524 lines
14 KiB
C
524 lines
14 KiB
C
/* Trace file support in GDB.
|
|
|
|
Copyright (C) 1997-2014 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "tracefile.h"
|
|
#include "ctf.h"
|
|
#include "exec.h"
|
|
#include "regcache.h"
|
|
|
|
/* Helper macros. */
|
|
|
|
#define TRACE_WRITE_R_BLOCK(writer, buf, size) \
|
|
writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
|
|
#define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
|
|
writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
|
|
(size))
|
|
#define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
|
|
writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
|
|
(size))
|
|
#define TRACE_WRITE_V_BLOCK(writer, num, val) \
|
|
writer->ops->frame_ops->write_v_block ((writer), (num), (val))
|
|
|
|
/* Free trace file writer. */
|
|
|
|
static void
|
|
trace_file_writer_xfree (void *arg)
|
|
{
|
|
struct trace_file_writer *writer = arg;
|
|
|
|
writer->ops->dtor (writer);
|
|
xfree (writer);
|
|
}
|
|
|
|
/* Save tracepoint data to file named FILENAME through WRITER. WRITER
|
|
determines the trace file format. If TARGET_DOES_SAVE is non-zero,
|
|
the save is performed on the target, otherwise GDB obtains all trace
|
|
data and saves it locally. */
|
|
|
|
static void
|
|
trace_save (const char *filename, struct trace_file_writer *writer,
|
|
int target_does_save)
|
|
{
|
|
struct trace_status *ts = current_trace_status ();
|
|
int status;
|
|
struct uploaded_tp *uploaded_tps = NULL, *utp;
|
|
struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
|
|
|
|
ULONGEST offset = 0;
|
|
#define MAX_TRACE_UPLOAD 2000
|
|
gdb_byte buf[MAX_TRACE_UPLOAD];
|
|
int written;
|
|
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
|
|
|
|
/* If the target is to save the data to a file on its own, then just
|
|
send the command and be done with it. */
|
|
if (target_does_save)
|
|
{
|
|
if (!writer->ops->target_save (writer, filename))
|
|
error (_("Target failed to save trace data to '%s'."),
|
|
filename);
|
|
return;
|
|
}
|
|
|
|
/* Get the trace status first before opening the file, so if the
|
|
target is losing, we can get out without touching files. */
|
|
status = target_get_trace_status (ts);
|
|
|
|
writer->ops->start (writer, filename);
|
|
|
|
writer->ops->write_header (writer);
|
|
|
|
/* Write descriptive info. */
|
|
|
|
/* Write out the size of a register block. */
|
|
writer->ops->write_regblock_type (writer, trace_regblock_size);
|
|
|
|
/* Write out status of the tracing run (aka "tstatus" info). */
|
|
writer->ops->write_status (writer, ts);
|
|
|
|
/* Note that we want to upload tracepoints and save those, rather
|
|
than simply writing out the local ones, because the user may have
|
|
changed tracepoints in GDB in preparation for a future tracing
|
|
run, or maybe just mass-deleted all types of breakpoints as part
|
|
of cleaning up. So as not to contaminate the session, leave the
|
|
data in its uploaded form, don't make into real tracepoints. */
|
|
|
|
/* Get trace state variables first, they may be checked when parsing
|
|
uploaded commands. */
|
|
|
|
target_upload_trace_state_variables (&uploaded_tsvs);
|
|
|
|
for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
|
|
writer->ops->write_uploaded_tsv (writer, utsv);
|
|
|
|
free_uploaded_tsvs (&uploaded_tsvs);
|
|
|
|
target_upload_tracepoints (&uploaded_tps);
|
|
|
|
for (utp = uploaded_tps; utp; utp = utp->next)
|
|
target_get_tracepoint_status (NULL, utp);
|
|
|
|
for (utp = uploaded_tps; utp; utp = utp->next)
|
|
writer->ops->write_uploaded_tp (writer, utp);
|
|
|
|
free_uploaded_tps (&uploaded_tps);
|
|
|
|
/* Mark the end of the definition section. */
|
|
writer->ops->write_definition_end (writer);
|
|
|
|
/* Get and write the trace data proper. */
|
|
while (1)
|
|
{
|
|
LONGEST gotten = 0;
|
|
|
|
/* The writer supports writing the contents of trace buffer
|
|
directly to trace file. Don't parse the contents of trace
|
|
buffer. */
|
|
if (writer->ops->write_trace_buffer != NULL)
|
|
{
|
|
/* We ask for big blocks, in the hopes of efficiency, but
|
|
will take less if the target has packet size limitations
|
|
or some such. */
|
|
gotten = target_get_raw_trace_data (buf, offset,
|
|
MAX_TRACE_UPLOAD);
|
|
if (gotten < 0)
|
|
error (_("Failure to get requested trace buffer data"));
|
|
/* No more data is forthcoming, we're done. */
|
|
if (gotten == 0)
|
|
break;
|
|
|
|
writer->ops->write_trace_buffer (writer, buf, gotten);
|
|
|
|
offset += gotten;
|
|
}
|
|
else
|
|
{
|
|
uint16_t tp_num;
|
|
uint32_t tf_size;
|
|
/* Parse the trace buffers according to how data are stored
|
|
in trace buffer in GDBserver. */
|
|
|
|
gotten = target_get_raw_trace_data (buf, offset, 6);
|
|
|
|
if (gotten == 0)
|
|
break;
|
|
|
|
/* Read the first six bytes in, which is the tracepoint
|
|
number and trace frame size. */
|
|
tp_num = (uint16_t)
|
|
extract_unsigned_integer (&buf[0], 2, byte_order);
|
|
|
|
tf_size = (uint32_t)
|
|
extract_unsigned_integer (&buf[2], 4, byte_order);
|
|
|
|
writer->ops->frame_ops->start (writer, tp_num);
|
|
gotten = 6;
|
|
|
|
if (tf_size > 0)
|
|
{
|
|
unsigned int block;
|
|
|
|
offset += 6;
|
|
|
|
for (block = 0; block < tf_size; )
|
|
{
|
|
gdb_byte block_type;
|
|
|
|
/* We'll fetch one block each time, in order to
|
|
handle the extremely large 'M' block. We first
|
|
fetch one byte to get the type of the block. */
|
|
gotten = target_get_raw_trace_data (buf, offset, 1);
|
|
if (gotten < 1)
|
|
error (_("Failure to get requested trace buffer data"));
|
|
|
|
gotten = 1;
|
|
block += 1;
|
|
offset += 1;
|
|
|
|
block_type = buf[0];
|
|
switch (block_type)
|
|
{
|
|
case 'R':
|
|
gotten
|
|
= target_get_raw_trace_data (buf, offset,
|
|
trace_regblock_size);
|
|
if (gotten < trace_regblock_size)
|
|
error (_("Failure to get requested trace"
|
|
" buffer data"));
|
|
|
|
TRACE_WRITE_R_BLOCK (writer, buf,
|
|
trace_regblock_size);
|
|
break;
|
|
case 'M':
|
|
{
|
|
unsigned short mlen;
|
|
ULONGEST addr;
|
|
LONGEST t;
|
|
int j;
|
|
|
|
t = target_get_raw_trace_data (buf,offset, 10);
|
|
if (t < 10)
|
|
error (_("Failure to get requested trace"
|
|
" buffer data"));
|
|
|
|
offset += 10;
|
|
block += 10;
|
|
|
|
gotten = 0;
|
|
addr = (ULONGEST)
|
|
extract_unsigned_integer (buf, 8,
|
|
byte_order);
|
|
mlen = (unsigned short)
|
|
extract_unsigned_integer (&buf[8], 2,
|
|
byte_order);
|
|
|
|
TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
|
|
mlen);
|
|
|
|
/* The memory contents in 'M' block may be
|
|
very large. Fetch the data from the target
|
|
and write them into file one by one. */
|
|
for (j = 0; j < mlen; )
|
|
{
|
|
unsigned int read_length;
|
|
|
|
if (mlen - j > MAX_TRACE_UPLOAD)
|
|
read_length = MAX_TRACE_UPLOAD;
|
|
else
|
|
read_length = mlen - j;
|
|
|
|
t = target_get_raw_trace_data (buf,
|
|
offset + j,
|
|
read_length);
|
|
if (t < read_length)
|
|
error (_("Failure to get requested"
|
|
" trace buffer data"));
|
|
|
|
TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
|
|
read_length);
|
|
|
|
j += read_length;
|
|
gotten += read_length;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 'V':
|
|
{
|
|
int vnum;
|
|
LONGEST val;
|
|
|
|
gotten
|
|
= target_get_raw_trace_data (buf, offset,
|
|
12);
|
|
if (gotten < 12)
|
|
error (_("Failure to get requested"
|
|
" trace buffer data"));
|
|
|
|
vnum = (int) extract_signed_integer (buf,
|
|
4,
|
|
byte_order);
|
|
val
|
|
= extract_signed_integer (&buf[4], 8,
|
|
byte_order);
|
|
|
|
TRACE_WRITE_V_BLOCK (writer, vnum, val);
|
|
}
|
|
break;
|
|
default:
|
|
error (_("Unknown block type '%c' (0x%x) in"
|
|
" trace frame"),
|
|
block_type, block_type);
|
|
}
|
|
|
|
block += gotten;
|
|
offset += gotten;
|
|
}
|
|
}
|
|
else
|
|
offset += gotten;
|
|
|
|
writer->ops->frame_ops->end (writer);
|
|
}
|
|
}
|
|
|
|
writer->ops->end (writer);
|
|
}
|
|
|
|
static void
|
|
trace_save_command (char *args, int from_tty)
|
|
{
|
|
int target_does_save = 0;
|
|
char **argv;
|
|
char *filename = NULL;
|
|
struct cleanup *back_to;
|
|
int generate_ctf = 0;
|
|
struct trace_file_writer *writer = NULL;
|
|
|
|
if (args == NULL)
|
|
error_no_arg (_("file in which to save trace data"));
|
|
|
|
argv = gdb_buildargv (args);
|
|
back_to = make_cleanup_freeargv (argv);
|
|
|
|
for (; *argv; ++argv)
|
|
{
|
|
if (strcmp (*argv, "-r") == 0)
|
|
target_does_save = 1;
|
|
if (strcmp (*argv, "-ctf") == 0)
|
|
generate_ctf = 1;
|
|
else if (**argv == '-')
|
|
error (_("unknown option `%s'"), *argv);
|
|
else
|
|
filename = *argv;
|
|
}
|
|
|
|
if (!filename)
|
|
error_no_arg (_("file in which to save trace data"));
|
|
|
|
if (generate_ctf)
|
|
writer = ctf_trace_file_writer_new ();
|
|
else
|
|
writer = tfile_trace_file_writer_new ();
|
|
|
|
make_cleanup (trace_file_writer_xfree, writer);
|
|
|
|
trace_save (filename, writer, target_does_save);
|
|
|
|
if (from_tty)
|
|
printf_filtered (_("Trace data saved to %s '%s'.\n"),
|
|
generate_ctf ? "directory" : "file", filename);
|
|
|
|
do_cleanups (back_to);
|
|
}
|
|
|
|
/* Save the trace data to file FILENAME of tfile format. */
|
|
|
|
void
|
|
trace_save_tfile (const char *filename, int target_does_save)
|
|
{
|
|
struct trace_file_writer *writer;
|
|
struct cleanup *back_to;
|
|
|
|
writer = tfile_trace_file_writer_new ();
|
|
back_to = make_cleanup (trace_file_writer_xfree, writer);
|
|
trace_save (filename, writer, target_does_save);
|
|
do_cleanups (back_to);
|
|
}
|
|
|
|
/* Save the trace data to dir DIRNAME of ctf format. */
|
|
|
|
void
|
|
trace_save_ctf (const char *dirname, int target_does_save)
|
|
{
|
|
struct trace_file_writer *writer;
|
|
struct cleanup *back_to;
|
|
|
|
writer = ctf_trace_file_writer_new ();
|
|
back_to = make_cleanup (trace_file_writer_xfree, writer);
|
|
|
|
trace_save (dirname, writer, target_does_save);
|
|
do_cleanups (back_to);
|
|
}
|
|
|
|
/* Fetch register data from tracefile, shared for both tfile and
|
|
ctf. */
|
|
|
|
void
|
|
tracefile_fetch_registers (struct regcache *regcache, int regno)
|
|
{
|
|
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
|
int regn, pc_regno;
|
|
|
|
/* We get here if no register data has been found. Mark registers
|
|
as unavailable. */
|
|
for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
|
|
regcache_raw_supply (regcache, regn, NULL);
|
|
|
|
/* We can often usefully guess that the PC is going to be the same
|
|
as the address of the tracepoint. */
|
|
pc_regno = gdbarch_pc_regnum (gdbarch);
|
|
|
|
/* XXX This guessing code below only works if the PC register isn't
|
|
a pseudo-register. The value of a pseudo-register isn't stored
|
|
in the (non-readonly) regcache -- instead it's recomputed
|
|
(probably from some other cached raw register) whenever the
|
|
register is read. This guesswork should probably move to some
|
|
higher layer. */
|
|
if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
|
|
return;
|
|
|
|
if (regno == -1 || regno == pc_regno)
|
|
{
|
|
struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
|
|
gdb_byte *regs;
|
|
|
|
if (tp && tp->base.loc)
|
|
{
|
|
/* But don't try to guess if tracepoint is multi-location... */
|
|
if (tp->base.loc->next)
|
|
{
|
|
warning (_("Tracepoint %d has multiple "
|
|
"locations, cannot infer $pc"),
|
|
tp->base.number);
|
|
return;
|
|
}
|
|
/* ... or does while-stepping. */
|
|
if (tp->step_count > 0)
|
|
{
|
|
warning (_("Tracepoint %d does while-stepping, "
|
|
"cannot infer $pc"),
|
|
tp->base.number);
|
|
return;
|
|
}
|
|
|
|
regs = alloca (register_size (gdbarch, pc_regno));
|
|
store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
|
|
gdbarch_byte_order (gdbarch),
|
|
tp->base.loc->address);
|
|
regcache_raw_supply (regcache, pc_regno, regs);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_has_all_memory. */
|
|
|
|
static int
|
|
tracefile_has_all_memory (struct target_ops *ops)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_has_memory. */
|
|
|
|
static int
|
|
tracefile_has_memory (struct target_ops *ops)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_has_stack.
|
|
The target has a stack when GDB has already selected one trace
|
|
frame. */
|
|
|
|
static int
|
|
tracefile_has_stack (struct target_ops *ops)
|
|
{
|
|
return get_traceframe_number () != -1;
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_has_registers.
|
|
The target has registers when GDB has already selected one trace
|
|
frame. */
|
|
|
|
static int
|
|
tracefile_has_registers (struct target_ops *ops)
|
|
{
|
|
return get_traceframe_number () != -1;
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_thread_alive.
|
|
tracefile has one thread faked by GDB. */
|
|
|
|
static int
|
|
tracefile_thread_alive (struct target_ops *ops, ptid_t ptid)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_get_trace_status.
|
|
The trace status for a file is that tracing can never be run. */
|
|
|
|
static int
|
|
tracefile_get_trace_status (struct target_ops *self, struct trace_status *ts)
|
|
{
|
|
/* Other bits of trace status were collected as part of opening the
|
|
trace files, so nothing to do here. */
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* Initialize OPS for tracefile related targets. */
|
|
|
|
void
|
|
init_tracefile_ops (struct target_ops *ops)
|
|
{
|
|
ops->to_stratum = process_stratum;
|
|
ops->to_get_trace_status = tracefile_get_trace_status;
|
|
ops->to_has_all_memory = tracefile_has_all_memory;
|
|
ops->to_has_memory = tracefile_has_memory;
|
|
ops->to_has_stack = tracefile_has_stack;
|
|
ops->to_has_registers = tracefile_has_registers;
|
|
ops->to_thread_alive = tracefile_thread_alive;
|
|
ops->to_magic = OPS_MAGIC;
|
|
}
|
|
|
|
extern initialize_file_ftype _initialize_tracefile;
|
|
|
|
void
|
|
_initialize_tracefile (void)
|
|
{
|
|
add_com ("tsave", class_trace, trace_save_command, _("\
|
|
Save the trace data to a file.\n\
|
|
Use the '-ctf' option to save the data to CTF format.\n\
|
|
Use the '-r' option to direct the target to save directly to the file,\n\
|
|
using its own filesystem."));
|
|
}
|