X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Ftracepoint.c;h=e1679fadb6b470719eda2ad5d69a74ac28a9a041;hb=2f4d88753bc52c1104d9418fb843154ee8ef610c;hp=0dfe23cdf8a35ada9236eb2fba27af7a26ef4f5d;hpb=35b1e5cca081f63a45e2d6bbc90010e553f7c5c8;p=binutils-gdb.git diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index 0dfe23cdf8a..e1679fadb6b 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -43,6 +43,7 @@ #include "gdbcore.h" #include "objfiles.h" #include "filenames.h" +#include "gdbthread.h" #include "ax.h" #include "ax-gdb.h" @@ -58,6 +59,13 @@ #include #endif +#ifndef O_LARGEFILE +#define O_LARGEFILE 0 +#endif + +extern int hex2bin (const char *hex, gdb_byte *bin, int count); +extern int bin2hex (const gdb_byte *bin, char *hex, int count); + extern void stop_tracing (); /* Maximum length of an agent aexpression. @@ -156,7 +164,6 @@ static void trace_find_tracepoint_command (char *, int); static void trace_find_line_command (char *, int); static void trace_find_range_command (char *, int); static void trace_find_outside_command (char *, int); -static void tracepoint_save_command (char *, int); static void trace_dump_command (char *, int); /* support routines */ @@ -170,8 +177,29 @@ static struct cleanup *make_cleanup_free_actions (struct breakpoint *t); extern void send_disconnected_tracing_value (int value); +static void free_uploaded_tps (struct uploaded_tp **utpp); +static void free_uploaded_tsvs (struct uploaded_tsv **utsvp); + + extern void _initialize_tracepoint (void); +static struct trace_status trace_status; + +char *stop_reason_names[] = { + "tunknown", + "tnotrun", + "tstop", + "tfull", + "tdisconnected", + "tpasscount" +}; + +struct trace_status * +current_trace_status () +{ + return &trace_status; +} + /* Set traceframe number to NUM. */ static void set_traceframe_num (int num) @@ -405,7 +433,7 @@ tvariables_info (char *args, int from_tty) print_spaces_filtered (11 - strlen (plongest (tsv->initial_value)), gdb_stdout); if (tsv->value_known) printf_filtered (" %s", plongest (tsv->value)); - else if (trace_running_p || traceframe_number >= 0) + else if (current_trace_status ()->running || traceframe_number >= 0) /* The value is/was defined, but we don't have it. */ printf_filtered (_(" ")); else @@ -597,7 +625,8 @@ validate_actionline (char **line, struct breakpoint *t) struct cmd_list_element *c; struct expression *exp = NULL; struct cleanup *old_chain = NULL; - char *p; + char *p, *tmp_p; + struct bp_location *loc; /* if EOF is typed, *line is NULL */ if (*line == NULL) @@ -643,48 +672,53 @@ validate_actionline (char **line, struct breakpoint *t) } /* else fall thru, treat p as an expression and parse it! */ } - exp = parse_exp_1 (&p, block_for_pc (t->loc->address), 1); - old_chain = make_cleanup (free_current_contents, &exp); - - if (exp->elts[0].opcode == OP_VAR_VALUE) + tmp_p = p; + for (loc = t->loc; loc; loc = loc->next) { - if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST) - { - warning (_("constant %s (value %ld) will not be collected."), - SYMBOL_PRINT_NAME (exp->elts[2].symbol), - SYMBOL_VALUE (exp->elts[2].symbol)); - return BADLINE; - } - else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT) + p = tmp_p; + exp = parse_exp_1 (&p, block_for_pc (loc->address), 1); + old_chain = make_cleanup (free_current_contents, &exp); + + if (exp->elts[0].opcode == OP_VAR_VALUE) { - warning (_("%s is optimized away and cannot be collected."), - SYMBOL_PRINT_NAME (exp->elts[2].symbol)); - return BADLINE; + if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST) + { + warning (_("constant %s (value %ld) will not be collected."), + SYMBOL_PRINT_NAME (exp->elts[2].symbol), + SYMBOL_VALUE (exp->elts[2].symbol)); + return BADLINE; + } + else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT) + { + warning (_("%s is optimized away and cannot be collected."), + SYMBOL_PRINT_NAME (exp->elts[2].symbol)); + return BADLINE; + } } - } - /* We have something to collect, make sure that the expr to - bytecode translator can handle it and that it's not too - long. */ - aexpr = gen_trace_for_expr (t->loc->address, exp); - make_cleanup_free_agent_expr (aexpr); + /* We have something to collect, make sure that the expr to + bytecode translator can handle it and that it's not too + long. */ + aexpr = gen_trace_for_expr (loc->address, exp); + make_cleanup_free_agent_expr (aexpr); - if (aexpr->len > MAX_AGENT_EXPR_LEN) - error (_("expression too complicated, try simplifying")); + if (aexpr->len > MAX_AGENT_EXPR_LEN) + error (_("expression too complicated, try simplifying")); - ax_reqs (aexpr, &areqs); - (void) make_cleanup (xfree, areqs.reg_mask); + ax_reqs (aexpr, &areqs); + (void) make_cleanup (xfree, areqs.reg_mask); - if (areqs.flaw != agent_flaw_none) - error (_("malformed expression")); + if (areqs.flaw != agent_flaw_none) + error (_("malformed expression")); - if (areqs.min_height < 0) - error (_("gdb: Internal error: expression has min height < 0")); + if (areqs.min_height < 0) + error (_("gdb: Internal error: expression has min height < 0")); - if (areqs.max_height > 20) - error (_("expression too complicated, try simplifying")); + if (areqs.max_height > 20) + error (_("expression too complicated, try simplifying")); - do_cleanups (old_chain); + do_cleanups (old_chain); + } } while (p && *p++ == ','); return GENERIC; @@ -699,20 +733,25 @@ validate_actionline (char **line, struct breakpoint *t) while (isspace ((int) *p)) p++; - /* Only expressions are allowed for this action. */ - exp = parse_exp_1 (&p, block_for_pc (t->loc->address), 1); - old_chain = make_cleanup (free_current_contents, &exp); + tmp_p = p; + for (loc = t->loc; loc; loc = loc->next) + { + p = tmp_p; + /* Only expressions are allowed for this action. */ + exp = parse_exp_1 (&p, block_for_pc (loc->address), 1); + old_chain = make_cleanup (free_current_contents, &exp); - /* We have something to evaluate, make sure that the expr to - bytecode translator can handle it and that it's not too - long. */ - aexpr = gen_eval_for_expr (t->loc->address, exp); - make_cleanup_free_agent_expr (aexpr); + /* We have something to evaluate, make sure that the expr to + bytecode translator can handle it and that it's not too + long. */ + aexpr = gen_eval_for_expr (loc->address, exp); + make_cleanup_free_agent_expr (aexpr); - if (aexpr->len > MAX_AGENT_EXPR_LEN) - error (_("expression too complicated, try simplifying")); + if (aexpr->len > MAX_AGENT_EXPR_LEN) + error (_("expression too complicated, try simplifying")); - do_cleanups (old_chain); + do_cleanups (old_chain); + } } while (p && *p++ == ','); return GENERIC; @@ -1210,8 +1249,8 @@ stringify_collection_list (struct collection_list *list, char *string) /* Render all actions into gdb protocol. */ /*static*/ void -encode_actions (struct breakpoint *t, char ***tdp_actions, - char ***stepping_actions) +encode_actions (struct breakpoint *t, struct bp_location *tloc, + char ***tdp_actions, char ***stepping_actions) { static char tdp_buff[2048], step_buff[2048]; char *action_exp; @@ -1235,7 +1274,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions, *stepping_actions = NULL; gdbarch_virtual_frame_pointer (t->gdbarch, - t->loc->address, &frame_reg, &frame_offset); + tloc->address, &frame_reg, &frame_offset); action = t->actions; @@ -1294,7 +1333,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions, { add_local_symbols (collect, t->gdbarch, - t->loc->address, + tloc->address, frame_reg, frame_offset, 'A'); @@ -1304,7 +1343,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions, { add_local_symbols (collect, t->gdbarch, - t->loc->address, + tloc->address, frame_reg, frame_offset, 'L'); @@ -1318,7 +1357,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions, struct agent_reqs areqs; exp = parse_exp_1 (&action_exp, - block_for_pc (t->loc->address), 1); + block_for_pc (tloc->address), 1); old_chain = make_cleanup (free_current_contents, &exp); switch (exp->elts[0].opcode) @@ -1353,11 +1392,11 @@ encode_actions (struct breakpoint *t, char ***tdp_actions, t->gdbarch, frame_reg, frame_offset, - t->loc->address); + tloc->address); break; default: /* full-fledged expression */ - aexpr = gen_trace_for_expr (t->loc->address, exp); + aexpr = gen_trace_for_expr (tloc->address, exp); old_chain1 = make_cleanup_free_agent_expr (aexpr); @@ -1415,10 +1454,10 @@ encode_actions (struct breakpoint *t, char ***tdp_actions, struct agent_reqs areqs; exp = parse_exp_1 (&action_exp, - block_for_pc (t->loc->address), 1); + block_for_pc (tloc->address), 1); old_chain = make_cleanup (free_current_contents, &exp); - aexpr = gen_eval_for_expr (t->loc->address, exp); + aexpr = gen_eval_for_expr (tloc->address, exp); old_chain1 = make_cleanup_free_agent_expr (aexpr); ax_reqs (aexpr, &areqs); @@ -1513,11 +1552,10 @@ trace_start_command (char *args, int from_tty) if (!any_downloaded) error ("No tracepoints downloaded, not starting trace"); - /* Init any trace state variables that start with nonzero values. */ + /* Send down all the trace state variables too. */ for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix) { - if (tsv->initial_value != 0) - target_download_trace_state_variable (tsv); + target_download_trace_state_variable (tsv); } /* Tell target to treat text-like sections as transparent. */ @@ -1530,7 +1568,7 @@ trace_start_command (char *args, int from_tty) set_traceframe_num (-1); set_tracepoint_num (-1); set_traceframe_context (NULL); - trace_running_p = 1; + current_trace_status()->running = 1; } /* tstop command */ @@ -1544,31 +1582,35 @@ void stop_tracing () { target_trace_stop (); - trace_running_p = 0; -} - -unsigned long trace_running_p; - -int -get_trace_status () -{ - int status = target_get_trace_status (NULL); - - /* exported for use by the GUI */ - trace_running_p = (status > 0); - - return status; + /* should change in response to reply? */ + current_trace_status ()->running = 0; } /* tstatus command */ static void trace_status_command (char *args, int from_tty) { - int status = get_trace_status (); + struct trace_status *ts = current_trace_status (); + int status; - if (status < 0) - printf_filtered (_("Trace can not be run on the target.\n")); - else if (trace_running_p) + status = target_get_trace_status (ts); + + if (status == -1) + { + if (ts->from_file) + printf_filtered (_("Using a trace file.\n")); + else + { + printf_filtered (_("Trace can not be run on this target.\n")); + return; + } + } + + if (!ts->running_known) + { + printf_filtered (_("Run/stop status is unknown.\n")); + } + else if (ts->running) { printf_filtered (_("Trace is running on the target.\n")); if (disconnected_tracing) @@ -1577,8 +1619,49 @@ trace_status_command (char *args, int from_tty) printf_filtered (_("Trace will stop if GDB disconnects.\n")); } else - printf_filtered (_("Trace is not running on the target.\n")); + { + switch (ts->stop_reason) + { + case trace_never_run: + printf_filtered (_("No trace has been run on the target.\n")); + break; + case tstop_command: + printf_filtered (_("Trace stopped by a tstop command.\n")); + break; + case trace_buffer_full: + printf_filtered (_("Trace stopped because the buffer was full.\n")); + break; + case trace_disconnected: + printf_filtered (_("Trace stopped because of disconnection.\n")); + break; + case tracepoint_passcount: + /* FIXME account for number on target */ + printf_filtered (_("Trace stopped by tracepoint %d.\n"), + ts->stopping_tracepoint); + break; + case trace_stop_reason_unknown: + printf_filtered (_("Trace stopped for an unknown reason.\n")); + break; + default: + printf_filtered (_("Trace stopped for some other reason (%d).\n"), + ts->stop_reason); + break; + } + } + if (ts->traceframe_count >= 0) + { + printf_filtered (_("Collected %d trace frames.\n"), + ts->traceframe_count); + } + + if (ts->buffer_free) + { + printf_filtered (_("Trace buffer has %llu bytes free.\n"), + ts->buffer_free); + } + + /* Now report on what we're doing with tfind. */ if (traceframe_number >= 0) printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"), traceframe_number, tracepoint_number); @@ -1589,7 +1672,14 @@ trace_status_command (char *args, int from_tty) void disconnect_or_stop_tracing (int from_tty) { - if (trace_running_p && from_tty) + /* It can happen that the target that was tracing went away on its + own, and we didn't notice. Get a status update, and if the + current target doesn't even do tracing, then assume it's not + running anymore. */ + if (target_get_trace_status (current_trace_status ()) < 0) + current_trace_status ()->running = 0; + + if (current_trace_status ()->running && from_tty) { int cont = query (_("Trace is running. Continue tracing after detach? ")); /* Note that we send the query result without affecting the @@ -1667,6 +1757,7 @@ finish_tfind_command (enum trace_find_type type, int num, reinit_frame_cache (); registers_changed (); + target_dcache_invalidate (); set_traceframe_num (target_frameno); set_tracepoint_num (tp ? tp->number : target_tracept); if (target_frameno == -1) @@ -1674,7 +1765,11 @@ finish_tfind_command (enum trace_find_type type, int num, else set_traceframe_context (get_current_frame ()); - if (from_tty) + /* If we're in nonstop mode and getting out of looking at trace + frames, there won't be any current frame to go back to and + display. */ + if (from_tty + && (has_stack_frames () || traceframe_number >= 0)) { enum print_what print_what; @@ -1715,7 +1810,7 @@ trace_find_command (char *args, int from_tty) { /* this should only be called with a numeric argument */ int frameno = -1; - if (trace_running_p) + if (current_trace_status ()->running && !current_trace_status ()->from_file) error ("May not look at trace frames while trace is running."); if (args == 0 || *args == 0) @@ -1774,7 +1869,7 @@ trace_find_pc_command (char *args, int from_tty) CORE_ADDR pc; char tmp[40]; - if (trace_running_p) + if (current_trace_status ()->running && !current_trace_status ()->from_file) error ("May not look at trace frames while trace is running."); if (args == 0 || *args == 0) @@ -1792,7 +1887,7 @@ trace_find_tracepoint_command (char *args, int from_tty) int tdp; struct breakpoint *tp; - if (trace_running_p) + if (current_trace_status ()->running && !current_trace_status ()->from_file) error ("May not look at trace frames while trace is running."); if (args == 0 || *args == 0) @@ -1832,7 +1927,7 @@ trace_find_line_command (char *args, int from_tty) struct cleanup *old_chain; char startpc_str[40], endpc_str[40]; - if (trace_running_p) + if (current_trace_status ()->running && !current_trace_status ()->from_file) error ("May not look at trace frames while trace is running."); if (args == 0 || *args == 0) @@ -1914,7 +2009,7 @@ trace_find_range_command (char *args, int from_tty) char start_str[40], stop_str[40]; char *tmp; - if (trace_running_p) + if (current_trace_status ()->running && !current_trace_status ()->from_file) error ("May not look at trace frames while trace is running."); if (args == 0 || *args == 0) @@ -1948,7 +2043,7 @@ trace_find_outside_command (char *args, int from_tty) char start_str[40], stop_str[40]; char *tmp; - if (trace_running_p) + if (current_trace_status ()->running && !current_trace_status ()->from_file) error ("May not look at trace frames while trace is running."); if (args == 0 || *args == 0) @@ -2141,6 +2236,7 @@ trace_dump_command (char *args, int from_tty) struct cleanup *old_cleanups; int stepping_actions = 0; int stepping_frame = 0; + struct bp_location *loc; if (tracepoint_number == -1) { @@ -2166,7 +2262,14 @@ trace_dump_command (char *args, int from_tty) regcache = get_current_regcache (); gdbarch = get_regcache_arch (regcache); - stepping_frame = (t->loc->address != (regcache_read_pc (regcache))); + /* If the traceframe's address matches any of the tracepoint's + locations, assume it is a direct hit rather than a while-stepping + frame. (FIXME this is not reliable, should record each frame's + type.) */ + stepping_frame = 1; + for (loc = t->loc; loc; loc = loc->next) + if (loc->address == regcache_read_pc (regcache)) + stepping_frame = 0; for (action = t->actions; action; action = action->next) { @@ -2239,6 +2342,175 @@ trace_dump_command (char *args, int from_tty) discard_cleanups (old_cleanups); } +extern int trace_regblock_size; + +static void +trace_save_command (char *args, int from_tty) +{ + char **argv; + char *filename = NULL, *pathname; + int target_does_save = 0; + struct cleanup *cleanup; + struct trace_status *ts = current_trace_status (); + int err, status; + FILE *fp; + struct uploaded_tp *uploaded_tps = NULL, *utp; + struct uploaded_tsv *uploaded_tsvs = NULL, *utsv; + int a; + LONGEST gotten = 0; + ULONGEST offset = 0; +#define MAX_TRACE_UPLOAD 2000 + gdb_byte buf[MAX_TRACE_UPLOAD]; + int written; + + if (args == NULL) + error_no_arg (_("file in which to save trace data")); + + argv = gdb_buildargv (args); + make_cleanup_freeargv (argv); + + for (; *argv; ++argv) + { + if (strcmp (*argv, "-r") == 0) + target_does_save = 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 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) + { + err = target_save_trace_data (filename); + if (err < 0) + 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); + + pathname = tilde_expand (args); + cleanup = make_cleanup (xfree, pathname); + + fp = fopen (pathname, "w"); + if (!fp) + error (_("Unable to open file '%s' for saving trace data (%s)"), + args, safe_strerror (errno)); + make_cleanup_fclose (fp); + + /* Write a file header, with a high-bit-set char to indicate a + binary file, plus a hint as what this file is, and a version + number in case of future needs. */ + written = fwrite ("\x7fTRACE0\n", 8, 1, fp); + if (written < 8) + perror_with_name (pathname); + + /* Write descriptive info. */ + + /* Write out the size of a register block. */ + fprintf (fp, "R %x\n", trace_regblock_size); + + /* Write out status of the tracing run (aka "tstatus" info). */ + fprintf (fp, "status %c;%s:%x;tframes:%x;tfree:%llx\n", + (ts->running ? '1' : '0'), + stop_reason_names[ts->stop_reason], ts->stopping_tracepoint, + ts->traceframe_count, ts->buffer_free); + + /* 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) + { + char *buf = ""; + + if (utsv->name) + { + buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1); + bin2hex ((gdb_byte *) (utsv->name), buf, 0); + } + + fprintf (fp, "tsv %x:%s:%x:%s\n", + utsv->number, phex_nz (utsv->initial_value, 8), + utsv->builtin, buf); + + if (utsv->name) + xfree (buf); + } + + free_uploaded_tsvs (&uploaded_tsvs); + + target_upload_tracepoints (&uploaded_tps); + + for (utp = uploaded_tps; utp; utp = utp->next) + { + fprintf (fp, "tp T%x:%s:%c:%x:%x", + utp->number, phex_nz (utp->addr, sizeof (utp->addr)), + (utp->enabled ? 'E' : 'D'), utp->step, utp->pass); + if (utp->type == bp_fast_tracepoint) + fprintf (fp, ":F%x", utp->orig_size); + if (utp->cond) + fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2, + utp->cond); + fprintf (fp, "\n"); + for (a = 0; a < utp->numactions; ++a) + fprintf (fp, "tp A%x:%s:%s\n", + utp->number, phex_nz (utp->addr, sizeof (utp->addr)), + utp->actions[a]); + for (a = 0; a < utp->num_step_actions; ++a) + fprintf (fp, "tp S%x:%s:%s\n", + utp->number, phex_nz (utp->addr, sizeof (utp->addr)), + utp->step_actions[a]); + } + + free_uploaded_tps (&uploaded_tps); + + /* Mark the end of the definition section. */ + fprintf (fp, "\n"); + + /* Get and write the trace data proper. We ask for big blocks, in + the hopes of efficiency, but will take less if the target has + packet size limitations or some such. */ + while (1) + { + 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; + written = fwrite (buf, gotten, 1, fp); + if (written < gotten) + perror_with_name (pathname); + offset += gotten; + } + + /* Mark the end of trace data. */ + written = fwrite (&gotten, 4, 1, fp); + if (written < 4) + perror_with_name (pathname); + + do_cleanups (cleanup); + if (from_tty) + printf_filtered (_("Trace data saved to file '%s'.\n"), args); +} + /* Tell the target what to do with an ongoing tracing run if GDB disconnects for some reason. */ @@ -2286,6 +2558,1066 @@ get_traceframe_number (void) return traceframe_number; } +/* Make the traceframe NUM be the current trace frame. Does nothing + if NUM is already current. */ + +void +set_traceframe_number (int num) +{ + int newnum; + + if (traceframe_number == num) + { + /* Nothing to do. */ + return; + } + + newnum = target_trace_find (tfind_number, num, 0, 0, NULL); + + if (newnum != num) + warning (_("could not change traceframe")); + + traceframe_number = newnum; + + /* Changing the traceframe changes our view of registers and of the + frame chain. */ + registers_changed (); +} + +/* A cleanup used when switching away and back from tfind mode. */ + +struct current_traceframe_cleanup +{ + /* The traceframe we were inspecting. */ + int traceframe_number; +}; + +static void +do_restore_current_traceframe_cleanup (void *arg) +{ + struct current_traceframe_cleanup *old = arg; + + set_traceframe_number (old->traceframe_number); +} + +static void +restore_current_traceframe_cleanup_dtor (void *arg) +{ + struct current_traceframe_cleanup *old = arg; + + xfree (old); +} + +struct cleanup * +make_cleanup_restore_current_traceframe (void) +{ + struct current_traceframe_cleanup *old; + + old = xmalloc (sizeof (struct current_traceframe_cleanup)); + old->traceframe_number = traceframe_number; + + return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old, + restore_current_traceframe_cleanup_dtor); +} + +/* Given a number and address, return an uploaded tracepoint with that + number, creating if necessary. */ + +struct uploaded_tp * +get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp) +{ + struct uploaded_tp *utp; + + for (utp = *utpp; utp; utp = utp->next) + if (utp->number == num && utp->addr == addr) + return utp; + utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp)); + memset (utp, 0, sizeof (struct uploaded_tp)); + utp->number = num; + utp->addr = addr; + utp->next = *utpp; + *utpp = utp; + return utp; +} + +static void +free_uploaded_tps (struct uploaded_tp **utpp) +{ + struct uploaded_tp *next_one; + + while (*utpp) + { + next_one = (*utpp)->next; + xfree (*utpp); + *utpp = next_one; + } +} + +/* Given a number and address, return an uploaded tracepoint with that + number, creating if necessary. */ + +struct uploaded_tsv * +get_uploaded_tsv (int num, struct uploaded_tsv **utsvp) +{ + struct uploaded_tsv *utsv; + + for (utsv = *utsvp; utsv; utsv = utsv->next) + if (utsv->number == num) + return utsv; + utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv)); + memset (utsv, 0, sizeof (struct uploaded_tsv)); + utsv->number = num; + utsv->next = *utsvp; + *utsvp = utsv; + return utsv; +} + +static void +free_uploaded_tsvs (struct uploaded_tsv **utsvp) +{ + struct uploaded_tsv *next_one; + + while (*utsvp) + { + next_one = (*utsvp)->next; + xfree (*utsvp); + *utsvp = next_one; + } +} + +/* Look for an existing tracepoint that seems similar enough to the + uploaded one. Enablement isn't compared, because the user can + toggle that freely, and may have done so in anticipation of the + next trace run. */ + +struct breakpoint * +find_matching_tracepoint (struct uploaded_tp *utp) +{ + VEC(breakpoint_p) *tp_vec = all_tracepoints (); + int ix; + struct breakpoint *t; + struct bp_location *loc; + + for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++) + { + if (t->type == utp->type + && t->step_count == utp->step + && t->pass_count == utp->pass + /* FIXME also test conditionals and actions */ + ) + { + /* Scan the locations for an address match. */ + for (loc = t->loc; loc; loc = loc->next) + { + if (loc->address == utp->addr) + return t; + } + } + } + return NULL; +} + +/* Given a list of tracepoints uploaded from a target, attempt to + match them up with existing tracepoints, and create new ones if not + found. */ + +void +merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps) +{ + struct uploaded_tp *utp; + struct breakpoint *t; + + /* Look for GDB tracepoints that match up with our uploaded versions. */ + for (utp = *uploaded_tps; utp; utp = utp->next) + { + t = find_matching_tracepoint (utp); + if (t) + printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"), + t->number, utp->number, paddress (get_current_arch (), utp->addr)); + else + { + t = create_tracepoint_from_upload (utp); + if (t) + printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"), + t->number, utp->number, paddress (get_current_arch (), utp->addr)); + else + printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"), + utp->number, paddress (get_current_arch (), utp->addr)); + } + /* Whether found or created, record the number used by the + target, to help with mapping target tracepoints back to their + counterparts here. */ + if (t) + t->number_on_target = utp->number; + } + + free_uploaded_tps (uploaded_tps); +} + +/* Trace state variables don't have much to identify them beyond their + name, so just use that to detect matches. */ + +struct trace_state_variable * +find_matching_tsv (struct uploaded_tsv *utsv) +{ + if (!utsv->name) + return NULL; + + return find_trace_state_variable (utsv->name); +} + +struct trace_state_variable * +create_tsv_from_upload (struct uploaded_tsv *utsv) +{ + const char *namebase; + char buf[20]; + int try_num = 0; + struct trace_state_variable *tsv; + + if (utsv->name) + { + namebase = utsv->name; + sprintf (buf, "%s", namebase); + } + else + { + namebase = "__tsv"; + sprintf (buf, "%s_%d", namebase, try_num++); + } + + /* Fish for a name that is not in use. */ + /* (should check against all internal vars?) */ + while (find_trace_state_variable (buf)) + sprintf (buf, "%s_%d", namebase, try_num++); + + /* We have an available name, create the variable. */ + tsv = create_trace_state_variable (xstrdup (buf)); + tsv->initial_value = utsv->initial_value; + tsv->builtin = utsv->builtin; + + return tsv; +} + +/* Given a list of uploaded trace state variables, try to match them + up with existing variables, or create additional ones. */ + +void +merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs) +{ + int ix; + struct uploaded_tsv *utsv; + struct trace_state_variable *tsv; + int highest; + + /* Most likely some numbers will have to be reassigned as part of + the merge, so clear them all in anticipation. */ + for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix) + tsv->number = 0; + + for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next) + { + tsv = find_matching_tsv (utsv); + if (tsv) + printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"), + tsv->name, utsv->number); + else + { + tsv = create_tsv_from_upload (utsv); + printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"), + tsv->name, utsv->number); + } + /* Give precedence to numberings that come from the target. */ + if (tsv) + tsv->number = utsv->number; + } + + /* Renumber everything that didn't get a target-assigned number. */ + highest = 0; + for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix) + if (tsv->number > highest) + highest = tsv->number; + + ++highest; + for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix) + if (tsv->number == 0) + tsv->number = highest++; + + free_uploaded_tsvs (uploaded_tsvs); +} + +/* target tfile command */ + +struct target_ops tfile_ops; + +/* Fill in tfile_ops with its defined operations and properties. */ + +#define TRACE_HEADER_SIZE 8 + +char *trace_filename; +int trace_fd = -1; +off_t trace_frames_offset; +off_t cur_offset; +int cur_data_size; +int trace_regblock_size; + +static void tfile_interp_line (char *line, + struct uploaded_tp **utpp, + struct uploaded_tsv **utsvp); + +static void +tfile_open (char *filename, int from_tty) +{ + char *temp; + struct cleanup *old_chain; + int flags; + int scratch_chan; + char header[TRACE_HEADER_SIZE]; + char linebuf[1000]; /* should be max remote packet size or so */ + char byte; + int bytes, i, gotten; + struct trace_status *ts; + struct uploaded_tp *uploaded_tps = NULL; + struct uploaded_tsv *uploaded_tsvs = NULL; + + target_preopen (from_tty); + if (!filename) + error (_("No trace file specified.")); + + filename = tilde_expand (filename); + if (!IS_ABSOLUTE_PATH(filename)) + { + temp = concat (current_directory, "/", filename, (char *)NULL); + xfree (filename); + filename = temp; + } + + old_chain = make_cleanup (xfree, filename); + + flags = O_BINARY | O_LARGEFILE; + flags |= O_RDONLY; + scratch_chan = open (filename, flags, 0); + if (scratch_chan < 0) + perror_with_name (filename); + + /* Looks semi-reasonable. Toss the old trace file and work on the new. */ + + discard_cleanups (old_chain); /* Don't free filename any more */ + unpush_target (&tfile_ops); + + push_target (&tfile_ops); + + trace_filename = xstrdup (filename); + trace_fd = scratch_chan; + + bytes = 0; + /* Read the file header and test for validity. */ + gotten = read (trace_fd, &header, TRACE_HEADER_SIZE); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < TRACE_HEADER_SIZE) + error (_("Premature end of file while reading trace file")); + + bytes += TRACE_HEADER_SIZE; + if (!(header[0] == 0x7f + && (strncmp (header + 1, "TRACE0\n", 7) == 0))) + error (_("File is not a valid trace file.")); + + trace_regblock_size = 0; + ts = current_trace_status (); + /* We know we're working with a file. */ + ts->from_file = 1; + /* Set defaults in case there is no status line. */ + ts->running_known = 0; + ts->stop_reason = trace_stop_reason_unknown; + ts->traceframe_count = -1; + ts->buffer_free = 0; + + /* Read through a section of newline-terminated lines that + define things like tracepoints. */ + i = 0; + while (1) + { + gotten = read (trace_fd, &byte, 1); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 1) + error (_("Premature end of file while reading trace file")); + + ++bytes; + if (byte == '\n') + { + /* Empty line marks end of the definition section. */ + if (i == 0) + break; + linebuf[i] = '\0'; + i = 0; + tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs); + } + else + linebuf[i++] = byte; + if (i >= 1000) + error (_("Excessively long lines in trace file")); + } + + /* Add the file's tracepoints and variables into the current mix. */ + + /* Get trace state variables first, they may be checked when parsing + uploaded commands. */ + merge_uploaded_trace_state_variables (&uploaded_tsvs); + + merge_uploaded_tracepoints (&uploaded_tps); + + /* Record the starting offset of the binary trace data. */ + trace_frames_offset = bytes; + + /* If we don't have a blocksize, we can't interpret the + traceframes. */ + if (trace_regblock_size == 0) + error (_("No register block size recorded in trace file")); + if (ts->traceframe_count <= 0) + { + warning ("No traceframes present in this file."); + return; + } + +#define TFILE_PID (1) + inferior_appeared (current_inferior (), TFILE_PID); + inferior_ptid = pid_to_ptid (TFILE_PID); + add_thread_silent (inferior_ptid); + + post_create_inferior (&tfile_ops, from_tty); + +#if 0 + /* FIXME this will get defined in MI patch submission */ + tfind_1 (tfind_number, 0, 0, 0, 0); +#endif +} + +/* Interpret the given line from the definitions part of the trace + file. */ + +static void +tfile_interp_line (char *line, + struct uploaded_tp **utpp, struct uploaded_tsv **utsvp) +{ + char *p = line; + + if (strncmp (p, "R ", strlen ("R ")) == 0) + { + p += strlen ("R "); + trace_regblock_size = strtol (p, &p, 16); + } + else if (strncmp (p, "status ", strlen ("status ")) == 0) + { + p += strlen ("status "); + parse_trace_status (p, current_trace_status ()); + } + else if (strncmp (p, "tp ", strlen ("tp ")) == 0) + { + p += strlen ("tp "); + parse_tracepoint_definition (p, utpp); + } + else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0) + { + p += strlen ("tsv "); + parse_tsv_definition (p, utsvp); + } + else + warning ("Ignoring trace file definition \"%s\"", line); +} + +/* Parse the part of trace status syntax that is shared between + the remote protocol and the trace file reader. */ + +extern char *unpack_varlen_hex (char *buff, ULONGEST *result); + +void +parse_trace_status (char *line, struct trace_status *ts) +{ + char *p = line, *p1, *p_temp; + ULONGEST val; + + ts->running_known = 1; + ts->running = (*p++ == '1'); + ts->stop_reason = trace_stop_reason_unknown; + while (*p++) + { + p1 = strchr (p, ':'); + if (p1 == NULL) + error (_("Malformed trace status, at %s\n\ +Status line: '%s'\n"), p, line); + if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0) + { + p = unpack_varlen_hex (++p1, &val); + ts->stop_reason = trace_buffer_full; + } + else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0) + { + p = unpack_varlen_hex (++p1, &val); + ts->stop_reason = trace_never_run; + } + else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0) + { + p = unpack_varlen_hex (++p1, &val); + ts->stop_reason = tracepoint_passcount; + ts->stopping_tracepoint = val; + } + else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0) + { + p = unpack_varlen_hex (++p1, &val); + ts->stop_reason = tstop_command; + } + if (strncmp (p, "tframes", p1 - p) == 0) + { + p = unpack_varlen_hex (++p1, &val); + ts->traceframe_count = val; + } + if (strncmp (p, "tfree", p1 - p) == 0) + { + p = unpack_varlen_hex (++p1, &val); + ts->buffer_free = val; + } + else + { + /* Silently skip unknown optional info. */ + p_temp = strchr (p1 + 1, ';'); + if (p_temp) + p = p_temp; + else + /* Must be at the end. */ + break; + } + } +} + +/* Given a line of text defining a tracepoint or tracepoint action, parse + it into an "uploaded tracepoint". */ + +void +parse_tracepoint_definition (char *line, struct uploaded_tp **utpp) +{ + char *p; + char piece; + ULONGEST num, addr, step, pass, orig_size, xlen; + int enabled, i; + enum bptype type; + char *cond; + struct uploaded_tp *utp = NULL; + + p = line; + /* Both tracepoint and action definitions start with the same number + and address sequence. */ + piece = *p++; + p = unpack_varlen_hex (p, &num); + p++; /* skip a colon */ + p = unpack_varlen_hex (p, &addr); + p++; /* skip a colon */ + if (piece == 'T') + { + enabled = (*p++ == 'E'); + p++; /* skip a colon */ + p = unpack_varlen_hex (p, &step); + p++; /* skip a colon */ + p = unpack_varlen_hex (p, &pass); + type = bp_tracepoint; + cond = NULL; + /* Thumb through optional fields. */ + while (*p == ':') + { + p++; /* skip a colon */ + if (*p == 'F') + { + type = bp_fast_tracepoint; + p++; + p = unpack_varlen_hex (p, &orig_size); + } + else if (*p == 'X') + { + p++; + p = unpack_varlen_hex (p, &xlen); + p++; /* skip a comma */ + cond = (char *) xmalloc (2 * xlen + 1); + strncpy (cond, p, 2 * xlen); + cond[2 * xlen] = '\0'; + p += 2 * xlen; + } + else + warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p); + } + utp = get_uploaded_tp (num, addr, utpp); + utp->type = type; + utp->enabled = enabled; + utp->step = step; + utp->pass = pass; + utp->cond = cond; + } + else if (piece == 'A') + { + utp = get_uploaded_tp (num, addr, utpp); + utp->actions[utp->numactions++] = xstrdup (p); + } + else if (piece == 'S') + { + utp = get_uploaded_tp (num, addr, utpp); + utp->step_actions[utp->num_step_actions++] = xstrdup (p); + } + else + { + error ("Invalid tracepoint piece"); + } +} + +/* Convert a textual description of a trace state variable into an + uploaded object. */ + +void +parse_tsv_definition (char *line, struct uploaded_tsv **utsvp) +{ + char *p, *buf; + ULONGEST num, initval, builtin; + int end; + struct uploaded_tsv *utsv = NULL; + + buf = alloca (strlen (line)); + + p = line; + p = unpack_varlen_hex (p, &num); + p++; /* skip a colon */ + p = unpack_varlen_hex (p, &initval); + p++; /* skip a colon */ + p = unpack_varlen_hex (p, &builtin); + p++; /* skip a colon */ + end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2); + buf[end] = '\0'; + + utsv = get_uploaded_tsv (num, utsvp); + utsv->initial_value = initval; + utsv->builtin = builtin; + utsv->name = xstrdup (buf); +} + +/* Close the trace file and generally clean up. */ + +static void +tfile_close (int quitting) +{ + int pid; + + if (trace_fd < 0) + return; + + pid = ptid_get_pid (inferior_ptid); + inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */ + exit_inferior_silent (pid); + + close (trace_fd); + trace_fd = -1; + if (trace_filename) + xfree (trace_filename); +} + +static void +tfile_files_info (struct target_ops *t) +{ + /* (it would be useful to mention the name of the file) */ + printf_filtered ("Looking at a trace file.\n"); +} + +/* The trace status for a file is that tracing can never be run. */ + +static int +tfile_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; +} + +/* Given the position of a traceframe in the file, figure out what + address the frame was collected at. This would normally be the + value of a collected PC register, but if not available, we + improvise. */ + +static ULONGEST +tfile_get_traceframe_address (off_t tframe_offset) +{ + ULONGEST addr = 0; + short tpnum; + struct breakpoint *tp; + off_t saved_offset = cur_offset; + int gotten; + + /* FIXME dig pc out of collected registers */ + + /* Fall back to using tracepoint address. */ + lseek (trace_fd, tframe_offset, SEEK_SET); + gotten = read (trace_fd, &tpnum, 2); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 2) + error (_("Premature end of file while reading trace file")); + + tp = get_tracepoint_by_number_on_target (tpnum); + /* FIXME this is a poor heuristic if multiple locations */ + if (tp && tp->loc) + addr = tp->loc->address; + + /* Restore our seek position. */ + cur_offset = saved_offset; + lseek (trace_fd, cur_offset, SEEK_SET); + return addr; +} + +/* Given a type of search and some parameters, scan the collection of + traceframes in the file looking for a match. When found, return + both the traceframe and tracepoint number, otherwise -1 for + each. */ + +static int +tfile_trace_find (enum trace_find_type type, int num, + ULONGEST addr1, ULONGEST addr2, int *tpp) +{ + short tpnum; + int tfnum = 0, found = 0, gotten; + int data_size; + struct breakpoint *tp; + off_t offset, tframe_offset; + ULONGEST tfaddr; + + lseek (trace_fd, trace_frames_offset, SEEK_SET); + offset = trace_frames_offset; + while (1) + { + tframe_offset = offset; + gotten = read (trace_fd, &tpnum, 2); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 2) + error (_("Premature end of file while reading trace file")); + offset += 2; + if (tpnum == 0) + break; + gotten = read (trace_fd, &data_size, 4); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 4) + error (_("Premature end of file while reading trace file")); + offset += 4; + switch (type) + { + case tfind_number: + if (tfnum == num) + found = 1; + break; + case tfind_pc: + tfaddr = tfile_get_traceframe_address (tframe_offset); + if (tfaddr == addr1) + found = 1; + break; + case tfind_tp: + tp = get_tracepoint (num); + if (tp && tpnum == tp->number_on_target) + found = 1; + break; + case tfind_range: + tfaddr = tfile_get_traceframe_address (tframe_offset); + if (addr1 <= tfaddr && tfaddr <= addr2) + found = 1; + break; + case tfind_outside: + tfaddr = tfile_get_traceframe_address (tframe_offset); + if (!(addr1 <= tfaddr && tfaddr <= addr2)) + found = 1; + break; + default: + internal_error (__FILE__, __LINE__, _("unknown tfind type")); + } + if (found) + { + printf_filtered ("Found traceframe %d.\n", tfnum); + if (tpp) + *tpp = tpnum; + cur_offset = offset; + cur_data_size = data_size; + return tfnum; + } + /* Skip past the traceframe's data. */ + lseek (trace_fd, data_size, SEEK_CUR); + offset += data_size; + /* Update our own count of traceframes. */ + ++tfnum; + } + /* Did not find what we were looking for. */ + if (tpp) + *tpp = -1; + return -1; +} + +/* Look for a block of saved registers in the traceframe, and get the + requested register from it. */ + +static void +tfile_fetch_registers (struct target_ops *ops, + struct regcache *regcache, int regno) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + char block_type; + int i, pos, offset, regn, regsize, gotten; + unsigned short mlen; + char *regs; + + /* An uninitialized reg size says we're not going to be + successful at getting register blocks. */ + if (!trace_regblock_size) + return; + + regs = alloca (trace_regblock_size); + + lseek (trace_fd, cur_offset, SEEK_SET); + pos = 0; + while (pos < cur_data_size) + { + gotten = read (trace_fd, &block_type, 1); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 1) + error (_("Premature end of file while reading trace file")); + + ++pos; + switch (block_type) + { + case 'R': + gotten = read (trace_fd, regs, trace_regblock_size); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < trace_regblock_size) + error (_("Premature end of file while reading trace file")); + + /* 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++) + { + regsize = register_size (gdbarch, regn); + /* Make sure we stay within block bounds. */ + if (offset + regsize >= trace_regblock_size) + break; + if (!regcache_valid_p (regcache, regn)) + { + if (regno == regn) + { + regcache_raw_supply (regcache, regno, regs + offset); + break; + } + else if (regno == -1) + { + regcache_raw_supply (regcache, regn, regs + offset); + } + } + offset += regsize; + } + return; + case 'M': + lseek (trace_fd, 8, SEEK_CUR); + gotten = read (trace_fd, &mlen, 2); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 2) + error (_("Premature end of file while reading trace file")); + lseek (trace_fd, mlen, SEEK_CUR); + pos += (8 + 2 + mlen); + break; + case 'V': + lseek (trace_fd, 4 + 8, SEEK_CUR); + pos += (4 + 8); + break; + default: + error ("Unknown block type '%c' (0x%x) in trace frame", + block_type, block_type); + break; + } + } +} + +static LONGEST +tfile_xfer_partial (struct target_ops *ops, enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, ULONGEST offset, LONGEST len) +{ + char block_type; + int pos, gotten; + ULONGEST maddr; + unsigned short mlen; + + /* We're only doing regular memory for now. */ + if (object != TARGET_OBJECT_MEMORY) + return -1; + + if (readbuf == NULL) + error ("tfile_xfer_partial: trace file is read-only"); + + lseek (trace_fd, cur_offset, SEEK_SET); + pos = 0; + while (pos < cur_data_size) + { + gotten = read (trace_fd, &block_type, 1); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 1) + error (_("Premature end of file while reading trace file")); + ++pos; + switch (block_type) + { + case 'R': + lseek (trace_fd, trace_regblock_size, SEEK_CUR); + pos += trace_regblock_size; + break; + case 'M': + gotten = read (trace_fd, &maddr, 8); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 8) + error (_("Premature end of file while reading trace file")); + + gotten = read (trace_fd, &mlen, 2); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 2) + error (_("Premature end of file while reading trace file")); + if (maddr <= offset && (offset + len) <= (maddr + mlen)) + { + gotten = read (trace_fd, readbuf, mlen); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < mlen) + error (_("Premature end of file qwhile reading trace file")); + + return mlen; + } + lseek (trace_fd, mlen, SEEK_CUR); + pos += (8 + 2 + mlen); + break; + case 'V': + lseek (trace_fd, 4 + 8, SEEK_CUR); + pos += (4 + 8); + break; + default: + error ("Unknown block type '%c' (0x%x) in traceframe", + block_type, block_type); + break; + } + } + /* Indicate failure to find the requested memory block. */ + return -1; +} + +/* Iterate through the blocks of a trace frame, looking for a 'V' + block with a matching tsv number. */ + +static int +tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val) +{ + char block_type; + int pos, vnum, gotten; + unsigned short mlen; + + lseek (trace_fd, cur_offset, SEEK_SET); + pos = 0; + while (pos < cur_data_size) + { + gotten = read (trace_fd, &block_type, 1); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 1) + error (_("Premature end of file while reading trace file")); + ++pos; + switch (block_type) + { + case 'R': + lseek (trace_fd, trace_regblock_size, SEEK_CUR); + pos += trace_regblock_size; + break; + case 'M': + lseek (trace_fd, 8, SEEK_CUR); + gotten = read (trace_fd, &mlen, 2); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 2) + error (_("Premature end of file while reading trace file")); + lseek (trace_fd, mlen, SEEK_CUR); + pos += (8 + 2 + mlen); + break; + case 'V': + gotten = read (trace_fd, &vnum, 4); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 4) + error (_("Premature end of file while reading trace file")); + if (tsvnum == vnum) + { + gotten = read (trace_fd, val, 8); + if (gotten < 0) + perror_with_name (trace_filename); + else if (gotten < 8) + error (_("Premature end of file while reading trace file")); + return 1; + } + lseek (trace_fd, 8, SEEK_CUR); + pos += (4 + 8); + break; + default: + error ("Unknown block type '%c' (0x%x) in traceframe", + block_type, block_type); + break; + } + } + /* Didn't find anything. */ + return 0; +} + +static int +tfile_has_memory (struct target_ops *ops) +{ + return 1; +} + +static int +tfile_has_stack (struct target_ops *ops) +{ + return 1; +} + +static int +tfile_has_registers (struct target_ops *ops) +{ + return 1; +} + +static void +init_tfile_ops (void) +{ + tfile_ops.to_shortname = "tfile"; + tfile_ops.to_longname = "Local trace dump file"; + tfile_ops.to_doc = + "Use a trace file as a target. Specify the filename of the trace file."; + tfile_ops.to_open = tfile_open; + tfile_ops.to_close = tfile_close; + tfile_ops.to_fetch_registers = tfile_fetch_registers; + tfile_ops.to_xfer_partial = tfile_xfer_partial; + tfile_ops.to_files_info = tfile_files_info; + tfile_ops.to_get_trace_status = tfile_get_trace_status; + tfile_ops.to_trace_find = tfile_trace_find; + tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value; + /* core_stratum might seem more logical, but GDB doesn't like having + more than one core_stratum vector. */ + tfile_ops.to_stratum = process_stratum; + tfile_ops.to_has_memory = tfile_has_memory; + tfile_ops.to_has_stack = tfile_has_stack; + tfile_ops.to_has_registers = tfile_has_registers; + tfile_ops.to_magic = OPS_MAGIC; +} + /* module initialization */ void _initialize_tracepoint (void) @@ -2332,6 +3664,11 @@ _initialize_tracepoint (void) add_com ("tdump", class_trace, trace_dump_command, _("Print everything collected at the current tracepoint.")); + add_com ("tsave", class_trace, trace_save_command, _("\ +Save the trace data to a file.\n\ +Use the '-r' option to direct the target to save directly to the file,\n\ +using its own filesystem.")); + c = add_com ("tvariable", class_trace, trace_variable_command,_("\ Define a trace state variable.\n\ Argument is a $-prefixed name, optionally followed\n\ @@ -2355,12 +3692,12 @@ No argument means forward by one frame; '-' means backward by one frame."), &tfindlist, "tfind ", 1, &cmdlist); add_cmd ("outside", class_trace, trace_find_outside_command, _("\ -Select a trace frame whose PC is outside the given range.\n\ +Select a trace frame whose PC is outside the given range (exclusive).\n\ Usage: tfind outside addr1, addr2"), &tfindlist); add_cmd ("range", class_trace, trace_find_range_command, _("\ -Select a trace frame whose PC is in the given range.\n\ +Select a trace frame whose PC is in the given range (inclusive).\n\ Usage: tfind range addr1,addr2"), &tfindlist); @@ -2462,4 +3799,8 @@ trace data collected in the meantime."), NULL, &setlist, &showlist); + + init_tfile_ops (); + + add_target (&tfile_ops); }