X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftracefile.c;h=7f1a25a2cc29ef3db50fe3c428d6846df2c1ec7b;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=b6a800cf7d19a2adeb02809b6c8a8f7bc78f116a;hpb=481695ed5f6e0a8a9c9c50bfac1cdd2b3151e6c9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/tracefile.c b/gdb/tracefile.c index b6a800cf7d..7f1a25a2cc 100644 --- a/gdb/tracefile.c +++ b/gdb/tracefile.c @@ -1,6 +1,6 @@ /* Trace file support in GDB. - Copyright (C) 1997-2017 Free Software Foundation, Inc. + Copyright (C) 1997-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -19,9 +19,11 @@ #include "defs.h" #include "tracefile.h" -#include "ctf.h" +#include "tracectf.h" #include "exec.h" #include "regcache.h" +#include "gdbsupport/byte-vector.h" +#include "gdbarch.h" /* Helper macros. */ @@ -36,16 +38,21 @@ #define TRACE_WRITE_V_BLOCK(writer, num, val) \ writer->ops->frame_ops->write_v_block ((writer), (num), (val)) -/* Free trace file writer. */ +/* A unique pointer policy class for trace_file_writer. */ -static void -trace_file_writer_xfree (void *arg) +struct trace_file_writer_deleter { - struct trace_file_writer *writer = (struct trace_file_writer *) arg; + void operator() (struct trace_file_writer *writer) + { + writer->ops->dtor (writer); + xfree (writer); + } +}; - writer->ops->dtor (writer); - xfree (writer); -} +/* A unique_ptr specialization for trace_file_writer. */ + +typedef std::unique_ptr + 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, @@ -62,7 +69,7 @@ trace_save (const char *filename, struct trace_file_writer *writer, ULONGEST offset = 0; #define MAX_TRACE_UPLOAD 2000 - gdb_byte buf[MAX_TRACE_UPLOAD]; + 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 @@ -139,7 +146,7 @@ trace_save (const char *filename, struct trace_file_writer *writer, /* 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, + gotten = target_get_raw_trace_data (buf.data (), offset, MAX_TRACE_UPLOAD); if (gotten < 0) error (_("Failure to get requested trace buffer data")); @@ -147,7 +154,7 @@ trace_save (const char *filename, struct trace_file_writer *writer, if (gotten == 0) break; - writer->ops->write_trace_buffer (writer, buf, gotten); + writer->ops->write_trace_buffer (writer, buf.data (), gotten); offset += gotten; } @@ -158,7 +165,7 @@ trace_save (const char *filename, struct trace_file_writer *writer, /* Parse the trace buffers according to how data are stored in trace buffer in GDBserver. */ - gotten = target_get_raw_trace_data (buf, offset, 6); + gotten = target_get_raw_trace_data (buf.data (), offset, 6); if (gotten == 0) break; @@ -166,10 +173,10 @@ trace_save (const char *filename, struct trace_file_writer *writer, /* 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); + extract_unsigned_integer (&((buf.data ())[0]), 2, byte_order); tf_size = (uint32_t) - extract_unsigned_integer (&buf[2], 4, byte_order); + extract_unsigned_integer (&((buf.data ())[2]), 4, byte_order); writer->ops->frame_ops->start (writer, tp_num); gotten = 6; @@ -187,7 +194,8 @@ trace_save (const char *filename, struct trace_file_writer *writer, /* 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); + gotten = target_get_raw_trace_data (buf.data (), + offset, 1); if (gotten < 1) error (_("Failure to get requested trace buffer data")); @@ -200,13 +208,13 @@ trace_save (const char *filename, struct trace_file_writer *writer, { case 'R': gotten - = target_get_raw_trace_data (buf, offset, + = 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, + TRACE_WRITE_R_BLOCK (writer, buf.data (), trace_regblock_size); break; case 'M': @@ -216,7 +224,8 @@ trace_save (const char *filename, struct trace_file_writer *writer, LONGEST t; int j; - t = target_get_raw_trace_data (buf,offset, 10); + t = target_get_raw_trace_data (buf.data (), + offset, 10); if (t < 10) error (_("Failure to get requested trace" " buffer data")); @@ -226,10 +235,10 @@ trace_save (const char *filename, struct trace_file_writer *writer, gotten = 0; addr = (ULONGEST) - extract_unsigned_integer (buf, 8, + extract_unsigned_integer (buf.data (), 8, byte_order); mlen = (unsigned short) - extract_unsigned_integer (&buf[8], 2, + extract_unsigned_integer (&((buf.data ())[8]), 2, byte_order); TRACE_WRITE_M_BLOCK_HEADER (writer, addr, @@ -247,14 +256,15 @@ trace_save (const char *filename, struct trace_file_writer *writer, else read_length = mlen - j; - t = target_get_raw_trace_data (buf, + 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, + TRACE_WRITE_M_BLOCK_MEMORY (writer, + buf.data (), read_length); j += read_length; @@ -269,18 +279,18 @@ trace_save (const char *filename, struct trace_file_writer *writer, LONGEST val; gotten - = target_get_raw_trace_data (buf, offset, - 12); + = 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, + vnum = (int) extract_signed_integer (buf.data (), 4, byte_order); val - = extract_signed_integer (&buf[4], 8, - byte_order); + = extract_signed_integer (&((buf.data ())[4]), + 8, byte_order); TRACE_WRITE_V_BLOCK (writer, vnum, val); } @@ -306,14 +316,12 @@ trace_save (const char *filename, struct trace_file_writer *writer, } static void -tsave_command (char *args, int from_tty) +tsave_command (const 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")); @@ -337,19 +345,13 @@ tsave_command (char *args, int from_tty) error_no_arg (_("file in which to save trace data")); if (generate_ctf) - writer = ctf_trace_file_writer_new (); + trace_save_ctf (filename, target_does_save); else - writer = tfile_trace_file_writer_new (); - - back_to = make_cleanup (trace_file_writer_xfree, writer); - - trace_save (filename, writer, target_does_save); + trace_save_tfile (filename, 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. */ @@ -357,13 +359,8 @@ tsave_command (char *args, int from_tty) 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); + 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. */ @@ -371,14 +368,8 @@ trace_save_tfile (const char *filename, int target_does_save) 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); + 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 @@ -387,14 +378,14 @@ trace_save_ctf (const char *dirname, int target_does_save) void tracefile_fetch_registers (struct regcache *regcache, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + 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 (regcache, regn, NULL); + 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. */ @@ -425,16 +416,16 @@ tracefile_fetch_registers (struct regcache *regcache, int regno) /* This is the implementation of target_ops method to_has_all_memory. */ -static int -tracefile_has_all_memory (struct target_ops *ops) +bool +tracefile_target::has_all_memory () { return 1; } /* This is the implementation of target_ops method to_has_memory. */ -static int -tracefile_has_memory (struct target_ops *ops) +bool +tracefile_target::has_memory () { return 1; } @@ -443,8 +434,8 @@ tracefile_has_memory (struct target_ops *ops) The target has a stack when GDB has already selected one trace frame. */ -static int -tracefile_has_stack (struct target_ops *ops) +bool +tracefile_target::has_stack () { return get_traceframe_number () != -1; } @@ -453,8 +444,8 @@ tracefile_has_stack (struct target_ops *ops) The target has registers when GDB has already selected one trace frame. */ -static int -tracefile_has_registers (struct target_ops *ops) +bool +tracefile_target::has_registers () { return get_traceframe_number () != -1; } @@ -462,8 +453,8 @@ tracefile_has_registers (struct target_ops *ops) /* 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) +bool +tracefile_target::thread_alive (ptid_t ptid) { return 1; } @@ -471,8 +462,8 @@ tracefile_thread_alive (struct target_ops *ops, ptid_t ptid) /* 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) +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. */ @@ -480,23 +471,9 @@ tracefile_get_trace_status (struct target_ops *self, struct trace_status *ts) 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; -} - +void _initialize_tracefile (); void -_initialize_tracefile (void) +_initialize_tracefile () { add_com ("tsave", class_trace, tsave_command, _("\ Save the trace data to a file.\n\