X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftracefile.c;h=ecd2f5c678b862198d8e0d050b7ce4a9b9f7f36c;hb=4a1b91eabbe77f4d906a0895121d76a0653c3cf3;hp=c26d8db986f0034984dd057e220822756e85a994;hpb=19ba03f49581e407097a3e4821a957c422551ae5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/tracefile.c b/gdb/tracefile.c index c26d8db986..ecd2f5c678 100644 --- a/gdb/tracefile.c +++ b/gdb/tracefile.c @@ -1,6 +1,6 @@ /* Trace file support in GDB. - Copyright (C) 1997-2015 Free Software Foundation, Inc. + Copyright (C) 1997-2018 Free Software Foundation, Inc. This file is part of GDB. @@ -36,16 +36,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, @@ -57,14 +62,12 @@ 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 @@ -78,8 +81,10 @@ trace_save (const char *filename, struct trace_file_writer *writer, } /* 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); + 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); @@ -90,6 +95,9 @@ trace_save (const char *filename, struct trace_file_writer *writer, /* 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); @@ -303,26 +311,24 @@ trace_save (const char *filename, struct trace_file_writer *writer, } static void -trace_save_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")); - argv = gdb_buildargv (args); - back_to = make_cleanup_freeargv (argv); + gdb_argv built_argv (args); + argv = built_argv.get (); for (; *argv; ++argv) { if (strcmp (*argv, "-r") == 0) target_does_save = 1; - if (strcmp (*argv, "-ctf") == 0) + else if (strcmp (*argv, "-ctf") == 0) generate_ctf = 1; else if (**argv == '-') error (_("unknown option `%s'"), *argv); @@ -334,19 +340,13 @@ trace_save_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 (); - - 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. */ @@ -354,13 +354,8 @@ trace_save_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. */ @@ -368,14 +363,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 @@ -384,72 +373,54 @@ 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); - int regn, pc_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 (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. */ - 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)) + if (tp == NULL || tp->loc == NULL) return; - if (regno == -1 || regno == pc_regno) + /* But don't try to guess if tracepoint is multi-location... */ + if (tp->loc->next) { - 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 = (gdb_byte *) 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); - } + 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. */ -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; } @@ -458,8 +429,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; } @@ -468,8 +439,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; } @@ -477,8 +448,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; } @@ -486,8 +457,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. */ @@ -495,27 +466,15 @@ 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) +tracefile_target::tracefile_target () { - 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; + this->to_stratum = process_stratum; } -extern initialize_file_ftype _initialize_tracefile; - void _initialize_tracefile (void) { - add_com ("tsave", class_trace, trace_save_command, _("\ + 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\