mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-06 00:34:26 +08:00
268a13a5a3
This is the next patch in the ongoing series to move gdbsever to the top level. This patch just renames the "common" directory. The idea is to do this move in two parts: first rename the directory (this patch), then move the directory to the top. This approach makes the patches a bit more tractable. I chose the name "gdbsupport" for the directory. However, as this patch was largely written by sed, we could pick a new name without too much difficulty. Tested by the buildbot. gdb/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * contrib/ari/gdb_ari.sh: Change common to gdbsupport. * configure: Rebuild. * configure.ac: Change common to gdbsupport. * gdbsupport: Rename from common. * acinclude.m4: Change common to gdbsupport. * Makefile.in (CONFIG_SRC_SUBDIR, COMMON_SFILES) (HFILES_NO_SRCDIR, stamp-version, ALLDEPFILES): Change common to gdbsupport. * aarch64-tdep.c, ada-lang.c, ada-lang.h, agent.c, alloc.c, amd64-darwin-tdep.c, amd64-dicos-tdep.c, amd64-fbsd-nat.c, amd64-fbsd-tdep.c, amd64-linux-nat.c, amd64-linux-tdep.c, amd64-nbsd-tdep.c, amd64-obsd-tdep.c, amd64-sol2-tdep.c, amd64-tdep.c, amd64-windows-tdep.c, arch-utils.c, arch/aarch64-insn.c, arch/aarch64.c, arch/aarch64.h, arch/amd64.c, arch/amd64.h, arch/arm-get-next-pcs.c, arch/arm-linux.c, arch/arm.c, arch/i386.c, arch/i386.h, arch/ppc-linux-common.c, arch/riscv.c, arch/riscv.h, arch/tic6x.c, arm-tdep.c, auto-load.c, auxv.c, ax-gdb.c, ax-general.c, ax.h, breakpoint.c, breakpoint.h, btrace.c, btrace.h, build-id.c, build-id.h, c-lang.h, charset.c, charset.h, cli/cli-cmds.c, cli/cli-cmds.h, cli/cli-decode.c, cli/cli-dump.c, cli/cli-option.h, cli/cli-script.c, coff-pe-read.c, command.h, compile/compile-c-support.c, compile/compile-c.h, compile/compile-cplus-symbols.c, compile/compile-cplus-types.c, compile/compile-cplus.h, compile/compile-loc2c.c, compile/compile.c, completer.c, completer.h, contrib/ari/gdb_ari.sh, corefile.c, corelow.c, cp-support.c, cp-support.h, cp-valprint.c, csky-tdep.c, ctf.c, darwin-nat.c, debug.c, defs.h, disasm-selftests.c, disasm.c, disasm.h, dtrace-probe.c, dwarf-index-cache.c, dwarf-index-cache.h, dwarf-index-write.c, dwarf2-frame.c, dwarf2expr.c, dwarf2loc.c, dwarf2read.c, event-loop.c, event-top.c, exceptions.c, exec.c, extension.h, fbsd-nat.c, features/aarch64-core.c, features/aarch64-fpu.c, features/aarch64-pauth.c, features/aarch64-sve.c, features/i386/32bit-avx.c, features/i386/32bit-avx512.c, features/i386/32bit-core.c, features/i386/32bit-linux.c, features/i386/32bit-mpx.c, features/i386/32bit-pkeys.c, features/i386/32bit-segments.c, features/i386/32bit-sse.c, features/i386/64bit-avx.c, features/i386/64bit-avx512.c, features/i386/64bit-core.c, features/i386/64bit-linux.c, features/i386/64bit-mpx.c, features/i386/64bit-pkeys.c, features/i386/64bit-segments.c, features/i386/64bit-sse.c, features/i386/x32-core.c, features/riscv/32bit-cpu.c, features/riscv/32bit-csr.c, features/riscv/32bit-fpu.c, features/riscv/64bit-cpu.c, features/riscv/64bit-csr.c, features/riscv/64bit-fpu.c, features/tic6x-c6xp.c, features/tic6x-core.c, features/tic6x-gp.c, filename-seen-cache.h, findcmd.c, findvar.c, fork-child.c, gcore.c, gdb_bfd.c, gdb_bfd.h, gdb_proc_service.h, gdb_regex.c, gdb_select.h, gdb_usleep.c, gdbarch-selftests.c, gdbthread.h, gdbtypes.h, gnu-nat.c, go32-nat.c, guile/guile.c, guile/scm-ports.c, guile/scm-safe-call.c, guile/scm-type.c, i386-fbsd-nat.c, i386-fbsd-tdep.c, i386-go32-tdep.c, i386-linux-nat.c, i386-linux-tdep.c, i386-tdep.c, i387-tdep.c, ia64-libunwind-tdep.c, ia64-linux-nat.c, inf-child.c, inf-ptrace.c, infcall.c, infcall.h, infcmd.c, inferior-iter.h, inferior.c, inferior.h, inflow.c, inflow.h, infrun.c, infrun.h, inline-frame.c, language.h, linespec.c, linux-fork.c, linux-nat.c, linux-tdep.c, linux-thread-db.c, location.c, machoread.c, macrotab.h, main.c, maint.c, maint.h, memattr.c, memrange.h, mi/mi-cmd-break.h, mi/mi-cmd-env.c, mi/mi-cmd-stack.c, mi/mi-cmd-var.c, mi/mi-interp.c, mi/mi-main.c, mi/mi-parse.h, minsyms.c, mips-linux-tdep.c, namespace.h, nat/aarch64-linux-hw-point.c, nat/aarch64-linux-hw-point.h, nat/aarch64-linux.c, nat/aarch64-sve-linux-ptrace.c, nat/amd64-linux-siginfo.c, nat/fork-inferior.c, nat/linux-btrace.c, nat/linux-btrace.h, nat/linux-namespaces.c, nat/linux-nat.h, nat/linux-osdata.c, nat/linux-personality.c, nat/linux-procfs.c, nat/linux-ptrace.c, nat/linux-ptrace.h, nat/linux-waitpid.c, nat/mips-linux-watch.c, nat/mips-linux-watch.h, nat/ppc-linux.c, nat/x86-dregs.c, nat/x86-dregs.h, nat/x86-linux-dregs.c, nat/x86-linux.c, nto-procfs.c, nto-tdep.c, objfile-flags.h, objfiles.c, objfiles.h, obsd-nat.c, observable.h, osdata.c, p-valprint.c, parse.c, parser-defs.h, ppc-linux-nat.c, printcmd.c, probe.c, proc-api.c, procfs.c, producer.c, progspace.h, psymtab.h, python/py-framefilter.c, python/py-inferior.c, python/py-ref.h, python/py-type.c, python/python.c, record-btrace.c, record-full.c, record.c, record.h, regcache-dump.c, regcache.c, regcache.h, remote-fileio.c, remote-fileio.h, remote-sim.c, remote.c, riscv-tdep.c, rs6000-aix-tdep.c, rust-exp.y, s12z-tdep.c, selftest-arch.c, ser-base.c, ser-event.c, ser-pipe.c, ser-tcp.c, ser-unix.c, skip.c, solib-aix.c, solib-target.c, solib.c, source-cache.c, source.c, source.h, sparc-nat.c, spu-linux-nat.c, stack.c, stap-probe.c, symfile-add-flags.h, symfile.c, symfile.h, symtab.c, symtab.h, target-descriptions.c, target-descriptions.h, target-memory.c, target.c, target.h, target/waitstatus.c, target/waitstatus.h, thread-iter.h, thread.c, tilegx-tdep.c, top.c, top.h, tracefile-tfile.c, tracefile.c, tracepoint.c, tracepoint.h, tui/tui-io.c, ui-file.c, ui-out.h, unittests/array-view-selftests.c, unittests/child-path-selftests.c, unittests/cli-utils-selftests.c, unittests/common-utils-selftests.c, unittests/copy_bitwise-selftests.c, unittests/environ-selftests.c, unittests/format_pieces-selftests.c, unittests/function-view-selftests.c, unittests/lookup_name_info-selftests.c, unittests/memory-map-selftests.c, unittests/memrange-selftests.c, unittests/mkdir-recursive-selftests.c, unittests/observable-selftests.c, unittests/offset-type-selftests.c, unittests/optional-selftests.c, unittests/parse-connection-spec-selftests.c, unittests/ptid-selftests.c, unittests/rsp-low-selftests.c, unittests/scoped_fd-selftests.c, unittests/scoped_mmap-selftests.c, unittests/scoped_restore-selftests.c, unittests/string_view-selftests.c, unittests/style-selftests.c, unittests/tracepoint-selftests.c, unittests/unpack-selftests.c, unittests/utils-selftests.c, unittests/xml-utils-selftests.c, utils.c, utils.h, valarith.c, valops.c, valprint.c, value.c, value.h, varobj.c, varobj.h, windows-nat.c, x86-linux-nat.c, xml-support.c, xml-support.h, xml-tdesc.h, xstormy16-tdep.c, xtensa-linux-nat.c, dwarf2read.h: Change common to gdbsupport. gdb/gdbserver/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * configure: Rebuild. * configure.ac: Change common to gdbsupport. * acinclude.m4: Change common to gdbsupport. * Makefile.in (SFILES, OBS, GDBREPLAY_OBS, IPA_OBJS) (version-generated.c, gdbsupport/%-ipa.o, gdbsupport/%.o): Change common to gdbsupport. * ax.c, event-loop.c, fork-child.c, gdb_proc_service.h, gdbreplay.c, gdbthread.h, hostio-errno.c, hostio.c, i387-fp.c, inferiors.c, inferiors.h, linux-aarch64-tdesc-selftest.c, linux-amd64-ipa.c, linux-i386-ipa.c, linux-low.c, linux-tic6x-low.c, linux-x86-low.c, linux-x86-tdesc-selftest.c, linux-x86-tdesc.c, lynx-i386-low.c, lynx-low.c, mem-break.h, nto-x86-low.c, regcache.c, regcache.h, remote-utils.c, server.c, server.h, spu-low.c, symbol.c, target.h, tdesc.c, tdesc.h, thread-db.c, tracepoint.c, win32-i386-low.c, win32-low.c: Change common to gdbsupport.
482 lines
13 KiB
C
482 lines
13 KiB
C
/* Trace file support in GDB.
|
|
|
|
Copyright (C) 1997-2019 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"
|
|
#include "gdbsupport/byte-vector.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))
|
|
|
|
/* A unique pointer policy class for trace_file_writer. */
|
|
|
|
struct trace_file_writer_deleter
|
|
{
|
|
void operator() (struct trace_file_writer *writer)
|
|
{
|
|
writer->ops->dtor (writer);
|
|
xfree (writer);
|
|
}
|
|
};
|
|
|
|
/* A unique_ptr specialization for trace_file_writer. */
|
|
|
|
typedef std::unique_ptr<trace_file_writer, trace_file_writer_deleter>
|
|
trace_file_writer_up;
|
|
|
|
/* 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 ();
|
|
struct uploaded_tp *uploaded_tps = NULL, *utp;
|
|
struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
|
|
|
|
ULONGEST offset = 0;
|
|
#define MAX_TRACE_UPLOAD 2000
|
|
gdb::byte_vector buf (std::max (MAX_TRACE_UPLOAD, trace_regblock_size));
|
|
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. Since
|
|
we're just calling this for side effects, we ignore the
|
|
result. */
|
|
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 the target description info. */
|
|
writer->ops->write_tdesc (writer);
|
|
|
|
/* 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.data (), 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.data (), 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.data (), 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.data ())[0]), 2, byte_order);
|
|
|
|
tf_size = (uint32_t)
|
|
extract_unsigned_integer (&((buf.data ())[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.data (),
|
|
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.data (), offset,
|
|
trace_regblock_size);
|
|
if (gotten < trace_regblock_size)
|
|
error (_("Failure to get requested trace"
|
|
" buffer data"));
|
|
|
|
TRACE_WRITE_R_BLOCK (writer, buf.data (),
|
|
trace_regblock_size);
|
|
break;
|
|
case 'M':
|
|
{
|
|
unsigned short mlen;
|
|
ULONGEST addr;
|
|
LONGEST t;
|
|
int j;
|
|
|
|
t = target_get_raw_trace_data (buf.data (),
|
|
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.data (), 8,
|
|
byte_order);
|
|
mlen = (unsigned short)
|
|
extract_unsigned_integer (&((buf.data ())[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.data (),
|
|
offset + j,
|
|
read_length);
|
|
if (t < read_length)
|
|
error (_("Failure to get requested"
|
|
" trace buffer data"));
|
|
|
|
TRACE_WRITE_M_BLOCK_MEMORY (writer,
|
|
buf.data (),
|
|
read_length);
|
|
|
|
j += read_length;
|
|
gotten += read_length;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 'V':
|
|
{
|
|
int vnum;
|
|
LONGEST val;
|
|
|
|
gotten
|
|
= target_get_raw_trace_data (buf.data (),
|
|
offset, 12);
|
|
if (gotten < 12)
|
|
error (_("Failure to get requested"
|
|
" trace buffer data"));
|
|
|
|
vnum = (int) extract_signed_integer (buf.data (),
|
|
4,
|
|
byte_order);
|
|
val
|
|
= extract_signed_integer (&((buf.data ())[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
|
|
tsave_command (const char *args, int from_tty)
|
|
{
|
|
int target_does_save = 0;
|
|
char **argv;
|
|
char *filename = NULL;
|
|
int generate_ctf = 0;
|
|
|
|
if (args == NULL)
|
|
error_no_arg (_("file in which to save trace data"));
|
|
|
|
gdb_argv built_argv (args);
|
|
argv = built_argv.get ();
|
|
|
|
for (; *argv; ++argv)
|
|
{
|
|
if (strcmp (*argv, "-r") == 0)
|
|
target_does_save = 1;
|
|
else 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)
|
|
trace_save_ctf (filename, target_does_save);
|
|
else
|
|
trace_save_tfile (filename, target_does_save);
|
|
|
|
if (from_tty)
|
|
printf_filtered (_("Trace data saved to %s '%s'.\n"),
|
|
generate_ctf ? "directory" : "file", filename);
|
|
}
|
|
|
|
/* Save the trace data to file FILENAME of tfile format. */
|
|
|
|
void
|
|
trace_save_tfile (const char *filename, int target_does_save)
|
|
{
|
|
trace_file_writer_up writer (tfile_trace_file_writer_new ());
|
|
trace_save (filename, writer.get (), target_does_save);
|
|
}
|
|
|
|
/* Save the trace data to dir DIRNAME of ctf format. */
|
|
|
|
void
|
|
trace_save_ctf (const char *dirname, int target_does_save)
|
|
{
|
|
trace_file_writer_up writer (ctf_trace_file_writer_new ());
|
|
trace_save (dirname, writer.get (), target_does_save);
|
|
}
|
|
|
|
/* Fetch register data from tracefile, shared for both tfile and
|
|
ctf. */
|
|
|
|
void
|
|
tracefile_fetch_registers (struct regcache *regcache, int regno)
|
|
{
|
|
struct gdbarch *gdbarch = regcache->arch ();
|
|
struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
|
|
int regn;
|
|
|
|
/* 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 (regn, NULL);
|
|
|
|
/* We can often usefully guess that the PC is going to be the same
|
|
as the address of the tracepoint. */
|
|
if (tp == NULL || tp->loc == NULL)
|
|
return;
|
|
|
|
/* But don't try to guess if tracepoint is multi-location... */
|
|
if (tp->loc->next)
|
|
{
|
|
warning (_("Tracepoint %d has multiple "
|
|
"locations, cannot infer $pc"),
|
|
tp->number);
|
|
return;
|
|
}
|
|
/* ... or does while-stepping. */
|
|
else if (tp->step_count > 0)
|
|
{
|
|
warning (_("Tracepoint %d does while-stepping, "
|
|
"cannot infer $pc"),
|
|
tp->number);
|
|
return;
|
|
}
|
|
|
|
/* Guess what we can from the tracepoint location. */
|
|
gdbarch_guess_tracepoint_registers (gdbarch, regcache,
|
|
tp->loc->address);
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_has_all_memory. */
|
|
|
|
bool
|
|
tracefile_target::has_all_memory ()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_has_memory. */
|
|
|
|
bool
|
|
tracefile_target::has_memory ()
|
|
{
|
|
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. */
|
|
|
|
bool
|
|
tracefile_target::has_stack ()
|
|
{
|
|
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. */
|
|
|
|
bool
|
|
tracefile_target::has_registers ()
|
|
{
|
|
return get_traceframe_number () != -1;
|
|
}
|
|
|
|
/* This is the implementation of target_ops method to_thread_alive.
|
|
tracefile has one thread faked by GDB. */
|
|
|
|
bool
|
|
tracefile_target::thread_alive (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. */
|
|
|
|
int
|
|
tracefile_target::get_trace_status (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;
|
|
}
|
|
|
|
void
|
|
_initialize_tracefile (void)
|
|
{
|
|
add_com ("tsave", class_trace, tsave_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."));
|
|
}
|