Add trace file support.

	* tracepoint.h (enum trace_stop_reason): New enum.
	(struct trace_status): New struct.
	(parse_trace_status): Declare.
	(struct uploaded_tp): Move here from remote.c,
	add fields for actions.
	(struct uploaded_tsv): New struct.
	* tracepoint.c (tfile_ops): New target vector.
	(trace_fd): New global.
	(tfile_open): New function.
	(tfile_close): New function.
	(tfile_files_info): New function.
	(tfile_get_trace_status): New function.
	(tfile_get_traceframe_address): New function.
	(tfile_trace_find): New function.
	(tfile_fetch_registers): New function.
	(tfile_xfer_partial): New function.
	(tfile_get_trace_state_variable_value): New function.
	(init_tfile_ops): New function.
	(_initialize_tracepoint): Call it, add tfile target.
	(trace_status): New global.
	(current_trace_status): New function.
	(trace_running_p): Remove, change all users to get from
	current_trace_status()->running.
	(get_trace_status): Remove.
	(trace_status_command): Call target_get_trace_status directly,
	report more detail including tracing stop reasons.
	(trace_find_command): Always allow tfind on a file.
	(trace_find_pc_command): Ditto.
	(trace_find_tracepoint_command): Ditto.
	(trace_find_line_command): Ditto.
	(trace_find_range_command): Ditto.
	(trace_find_outside_command): Ditto.
	(trace_frames_offset, cur_offset): Declare as off_t.
	(trace_regblock_size): Rename from reg_size, update users.
	(parse_trace_status): New function.
	(tfile_interp_line): New function.
	(disconnect_or_stop_tracing): Ensure current trace
	status before asking what to do.
	(stop_reason_names): New global.
	(trace_save_command): New command.
	(get_uploaded_tp): Move here from remote.c.
	(find_matching_tracepoint): Ditto.
	(merge_uploaded_tracepoints): New function.
	(parse_trace_status): Use stop_reason_names.
	(_initialize_tracepoint): Define tsave command.
	* target.h (target_ops): New fields to_save_trace_data,
	to_upload_tracepoints, to_upload_trace_state_variables,
	to_get_raw_trace_data, change to_get_trace_status
	to take a pointer to a status struct.
	(target_save_trace_data): New macro.
	(target_upload_tracepoints): New macro.
	(target_upload_trace_state_variables): New macro.
	(target_get_raw_trace_data): New macro.
	* target.c (update_current_target): Add new methods, change
	signature of to_get_trace_status.
	* remote.c (hex2bin): Make globally visible.
	(bin2hex): Ditto.
	(remote_download_trace_state_variable): Download name also.
	(remote_get_trace_status): Update parameter, use
	parse_trace_status.
	(remote_save_trace_data): New function.
	(remote_upload_tracepoints): New function.
	(remote_upload_trace_state_variables): New function.
	(remote_get_raw_trace_data): New function.
	(remote_start_remote): Use them.
	(_initialize_remote_ops): Add operations.
	* ax-gdb.c: Include breakpoint.h.
	* breakpoint.c (create_tracepoint_from_upload): Use
	break_command_really, return tracepoint, warn about unimplemented
	parts.
	* NEWS: Mention trace file addition.

	* gdb.texinfo (Trace Files): New section.
	(Tracepoint Packets): Document QTSave and qTBuffer.
	(Trace File Format): New appendix.

	* generic/gdbtk-bp.c (gdb_trace_status): Use current_trace_status.

	* gdb.trace/tfile.c: New file.
	* gdb.trace/tfile.exp: New file.

1 files changed, 1208 insertions, 32 deletions

diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 0dfe23c..550a880 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 <unistd.h>
 #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.
@@ -170,8 +178,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 +434,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 (_("  <unknown>"));
       else
@@ -1513,11 +1542,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 +1558,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 +1572,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 +1609,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 %d 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 +1662,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
@@ -1674,7 +1754,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 +1799,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 +1858,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 +1876,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 +1916,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 +1998,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 +2032,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)
@@ -2239,6 +2323,168 @@ 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];
+
+  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.  */
+  fwrite ("\x7fTRACE0\n", 8, 1, fp);
+
+  /* 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:%x\n",
+	   (ts->running ? '1' : '0'),
+	   stop_reason_names[ts->stop_reason], ts->stopping_tracepoint,
+	   ts->traceframe_count, (unsigned int) 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;
+      fwrite (buf, gotten, 1, fp);
+      offset += gotten;
+    }
+
+  /* Mark the end of trace data.  */
+  fwrite (&gotten, 4, 1, fp);
+
+  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 +2532,927 @@ get_traceframe_number (void)
   return traceframe_number;
 }
 
+
+/* 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
+
+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;
+  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);
+  discard_cleanups (old_chain);
+
+  trace_fd = scratch_chan;
+
+  bytes = 0;
+  /* Read the file header and test for validity.  */
+  read (trace_fd, &header, TRACE_HEADER_SIZE);
+  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)
+    {
+      read (trace_fd, &byte, 1);
+      ++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.  */
+
+  merge_uploaded_tracepoints (&uploaded_tps);
+
+  merge_uploaded_trace_state_variables (&uploaded_tsvs);
+
+  /* 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;
+}
+
+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;
+
+  /* FIXME dig pc out of collected registers */
+
+  /* Fall back to using tracepoint address.  */
+  lseek (trace_fd, tframe_offset, SEEK_SET);
+  read (trace_fd, &tpnum, 2);
+  tp = get_tracepoint_by_number_on_target (tpnum);
+  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;
+  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;
+      read (trace_fd, &tpnum, 2);
+      offset += 2;
+      if (tpnum == 0)
+	break;
+      read (trace_fd, &data_size, 4);	
+      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;
+  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)
+    {
+      read (trace_fd, &block_type, 1);
+      ++pos;
+      switch (block_type)
+	{
+	case 'R':
+	  read (trace_fd, regs, trace_regblock_size);
+	  /* 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);
+	  read (trace_fd, &mlen, 2);
+	  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;
+  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)
+    {
+      read (trace_fd, &block_type, 1);
+      ++pos;
+      switch (block_type)
+	{
+	case 'R':
+	  lseek (trace_fd, trace_regblock_size, SEEK_CUR);
+	  pos += trace_regblock_size;
+	  break;
+	case 'M':
+	  read (trace_fd, &maddr, 8);
+	  read (trace_fd, &mlen, 2);
+	  if (maddr <= offset && (offset + len) <= (maddr + mlen))
+	    {
+	      read (trace_fd, readbuf, mlen);
+	      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;
+  unsigned short mlen;
+
+  lseek (trace_fd, cur_offset, SEEK_SET);
+  pos = 0;
+  while (pos < cur_data_size)
+    {
+      read (trace_fd, &block_type, 1);
+      ++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);
+	  read (trace_fd, &mlen, 2);
+	  lseek (trace_fd, mlen, SEEK_CUR);
+	  pos += (8 + 2 + mlen);
+	  break;
+	case 'V':
+	  read (trace_fd, &vnum, 4);
+	  if (tsvnum == vnum)
+	    {
+	      read (trace_fd, val, 8);
+	      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 +3499,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\
@@ -2462,4 +3634,8 @@ trace data collected in the meantime."),
 			   NULL,
 			   &setlist,
 			   &showlist);
+
+  init_tfile_ops ();
+
+  add_target (&tfile_ops);
 }