gdb/
[deliverable/binutils-gdb.git] / gdb / tracepoint.c
index a33905a479c86229782561b5a9d7007a69319002..c086587ca7e3f0bd5056aab004af1b930bcbfab2 100644 (file)
@@ -54,6 +54,8 @@
 #include "cli/cli-utils.h"
 #include "probe.h"
 #include "ctf.h"
+#include "completer.h"
+#include "filestuff.h"
 
 /* readline include files */
 #include "readline/readline.h"
@@ -62,9 +64,7 @@
 /* readline defines this.  */
 #undef savestring
 
-#ifdef HAVE_UNISTD_H
 #include <unistd.h>
-#endif
 
 #ifndef O_LARGEFILE
 #define O_LARGEFILE 0
    large.  (400 - 31)/2 == 184 */
 #define MAX_AGENT_EXPR_LEN     184
 
-#define TFILE_PID (1)
-
 /* A hook used to notify the UI of tracepoint operations.  */
 
 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
 
-extern void (*deprecated_readline_begin_hook) (char *, ...);
-extern char *(*deprecated_readline_hook) (char *);
-extern void (*deprecated_readline_end_hook) (void);
-
 /* 
    Tracepoint.c:
 
@@ -126,14 +120,6 @@ extern void (*deprecated_readline_end_hook) (void);
 typedef struct trace_state_variable tsv_s;
 DEF_VEC_O(tsv_s);
 
-/* An object describing the contents of a traceframe.  */
-
-struct traceframe_info
-{
-  /* Collected memory.  */
-  VEC(mem_range_s) *memory;
-};
-
 static VEC(tsv_s) *tvariables;
 
 /* The next integer to assign to a variable.  */
@@ -212,6 +198,8 @@ static void add_register (struct collection_list *collection,
 static void free_uploaded_tps (struct uploaded_tp **utpp);
 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
 
+static struct command_line *
+  all_tracepoint_actions_and_cleanup (struct breakpoint *t);
 
 extern void _initialize_tracepoint (void);
 
@@ -241,6 +229,7 @@ free_traceframe_info (struct traceframe_info *info)
   if (info != NULL)
     {
       VEC_free (mem_range_s, info->memory);
+      VEC_free (int, info->tvars);
 
       xfree (info);
     }
@@ -345,6 +334,22 @@ find_trace_state_variable (const char *name)
   return NULL;
 }
 
+/* Look for a trace state variable of the given number.  Return NULL if
+   not found.  */
+
+struct trace_state_variable *
+find_trace_state_variable_by_number (int number)
+{
+  struct trace_state_variable *tsv;
+  int ix;
+
+  for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+    if (tsv->number == number)
+      return tsv;
+
+  return NULL;
+}
+
 static void
 delete_trace_state_variable (const char *name)
 {
@@ -612,10 +617,12 @@ teval_pseudocommand (char *args, int from_tty)
 /* Parse any collection options, such as /s for strings.  */
 
 const char *
-decode_agent_options (const char *exp)
+decode_agent_options (const char *exp, int *trace_string)
 {
   struct value_print_options opts;
 
+  *trace_string = 0;
+
   if (*exp != '/')
     return exp;
 
@@ -631,10 +638,10 @@ decode_agent_options (const char *exp)
          /* Allow an optional decimal number giving an explicit maximum
             string length, defaulting it to the "print elements" value;
             so "collect/s80 mystr" gets at most 80 bytes of string.  */
-         trace_string_kludge = opts.print_max;
+         *trace_string = opts.print_max;
          exp++;
          if (*exp >= '0' && *exp <= '9')
-           trace_string_kludge = atoi (exp);
+           *trace_string = atoi (exp);
          while (*exp >= '0' && *exp <= '9')
            exp++;
        }
@@ -731,9 +738,10 @@ validate_actionline (const char *line, struct breakpoint *b)
 
   if (cmd_cfunc_eq (c, collect_pseudocommand))
     {
-      trace_string_kludge = 0;
+      int trace_string = 0;
+
       if (*p == '/')
-       p = decode_agent_options (p);
+       p = decode_agent_options (p, &trace_string);
 
       do
        {                       /* Repeat over a comma-separated list.  */
@@ -782,7 +790,7 @@ validate_actionline (const char *line, struct breakpoint *b)
              /* 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);
+             aexpr = gen_trace_for_expr (loc->address, exp, trace_string);
              make_cleanup_free_agent_expr (aexpr);
 
              if (aexpr->len > MAX_AGENT_EXPR_LEN)
@@ -855,30 +863,6 @@ enum {
   memrange_absolute = -1
 };
 
-struct memrange
-{
-  int type;            /* memrange_absolute for absolute memory range,
-                           else basereg number.  */
-  bfd_signed_vma start;
-  bfd_signed_vma end;
-};
-
-struct collection_list
-  {
-    unsigned char regs_mask[32];       /* room for up to 256 regs */
-    long listsize;
-    long next_memrange;
-    struct memrange *list;
-    long aexpr_listsize;       /* size of array pointed to by expr_list elt */
-    long next_aexpr_elt;
-    struct agent_expr **aexpr_list;
-
-    /* True is the user requested a collection of "$_sdata", "static
-       tracepoint data".  */
-    int strace_data;
-  }
-tracepoint_list, stepping_list;
-
 /* MEMRANGE functions: */
 
 static int memrange_cmp (const void *, const void *);
@@ -989,7 +973,8 @@ collect_symbol (struct collection_list *collect,
                struct symbol *sym,
                struct gdbarch *gdbarch,
                long frame_regno, long frame_offset,
-               CORE_ADDR scope)
+               CORE_ADDR scope,
+               int trace_string)
 {
   unsigned long len;
   unsigned int reg;
@@ -1100,7 +1085,7 @@ collect_symbol (struct collection_list *collect,
       struct agent_expr *aexpr;
       struct cleanup *old_chain1 = NULL;
 
-      aexpr = gen_trace_for_var (scope, gdbarch, sym);
+      aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string);
 
       /* It can happen that the symbol is recorded as a computed
         location, but it's been optimized away and doesn't actually
@@ -1153,6 +1138,7 @@ struct add_local_symbols_data
   long frame_regno;
   long frame_offset;
   int count;
+  int trace_string;
 };
 
 /* The callback for the locals and args iterators.  */
@@ -1165,15 +1151,19 @@ do_collect_symbol (const char *print_name,
   struct add_local_symbols_data *p = cb_data;
 
   collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
-                 p->frame_offset, p->pc);
+                 p->frame_offset, p->pc, p->trace_string);
   p->count++;
+
+  VEC_safe_push (char_ptr, p->collect->wholly_collected,
+                xstrdup (print_name));
 }
 
 /* Add all locals (or args) symbols to collection list.  */
 static void
 add_local_symbols (struct collection_list *collect,
                   struct gdbarch *gdbarch, CORE_ADDR pc,
-                  long frame_regno, long frame_offset, int type)
+                  long frame_regno, long frame_offset, int type,
+                  int trace_string)
 {
   struct block *block;
   struct add_local_symbols_data cb_data;
@@ -1184,6 +1174,7 @@ add_local_symbols (struct collection_list *collect,
   cb_data.frame_regno = frame_regno;
   cb_data.frame_offset = frame_offset;
   cb_data.count = 0;
+  cb_data.trace_string = trace_string;
 
   if (type == 'L')
     {
@@ -1238,11 +1229,43 @@ clear_collection_list (struct collection_list *list)
   list->next_aexpr_elt = 0;
   memset (list->regs_mask, 0, sizeof (list->regs_mask));
   list->strace_data = 0;
+
+  xfree (list->aexpr_list);
+  xfree (list->list);
+
+  VEC_free (char_ptr, list->wholly_collected);
+  VEC_free (char_ptr, list->computed);
+}
+
+/* A cleanup wrapper for function clear_collection_list.  */
+
+static void
+do_clear_collection_list (void *list)
+{
+  struct collection_list *l = list;
+
+  clear_collection_list (l);
+}
+
+/* Initialize collection_list CLIST.  */
+
+static void
+init_collection_list (struct collection_list *clist)
+{
+  memset (clist, 0, sizeof *clist);
+
+  clist->listsize = 128;
+  clist->list = xcalloc (clist->listsize,
+                        sizeof (struct memrange));
+
+  clist->aexpr_listsize = 128;
+  clist->aexpr_list = xcalloc (clist->aexpr_listsize,
+                              sizeof (struct agent_expr *));
 }
 
 /* Reduce a collection list to string form (for gdb protocol).  */
 static char **
-stringify_collection_list (struct collection_list *list, char *string)
+stringify_collection_list (struct collection_list *list)
 {
   char temp_buf[2048];
   char tmp2[40];
@@ -1362,10 +1385,24 @@ stringify_collection_list (struct collection_list *list, char *string)
     return *str_list;
 }
 
+/* Add the printed expression EXP to *LIST.  */
+
+static void
+append_exp (struct expression *exp, VEC(char_ptr) **list)
+{
+  struct ui_file *tmp_stream = mem_fileopen ();
+  char *text;
+
+  print_expression (exp, tmp_stream);
+
+  text = ui_file_xstrdup (tmp_stream, NULL);
+
+  VEC_safe_push (char_ptr, *list, text);
+  ui_file_delete (tmp_stream);
+}
 
 static void
 encode_actions_1 (struct command_line *action,
-                 struct breakpoint *t,
                  struct bp_location *tloc,
                  int frame_reg,
                  LONGEST frame_offset,
@@ -1391,9 +1428,10 @@ encode_actions_1 (struct command_line *action,
 
       if (cmd_cfunc_eq (cmd, collect_pseudocommand))
        {
-         trace_string_kludge = 0;
+         int trace_string = 0;
+
          if (*action_exp == '/')
-           action_exp = decode_agent_options (action_exp);
+           action_exp = decode_agent_options (action_exp, &trace_string);
 
          do
            {                   /* Repeat over a comma-separated list.  */
@@ -1413,7 +1451,8 @@ encode_actions_1 (struct command_line *action,
                                     tloc->address,
                                     frame_reg,
                                     frame_offset,
-                                    'A');
+                                    'A',
+                                    trace_string);
                  action_exp = strchr (action_exp, ',');        /* more? */
                }
              else if (0 == strncasecmp ("$loc", action_exp, 4))
@@ -1423,7 +1462,8 @@ encode_actions_1 (struct command_line *action,
                                     tloc->address,
                                     frame_reg,
                                     frame_offset,
-                                    'L');
+                                    'L',
+                                    trace_string);
                  action_exp = strchr (action_exp, ',');        /* more? */
                }
              else if (0 == strncasecmp ("$_ret", action_exp, 5))
@@ -1431,7 +1471,8 @@ encode_actions_1 (struct command_line *action,
                  struct cleanup *old_chain1 = NULL;
 
                  aexpr = gen_trace_for_return_address (tloc->address,
-                                                       tloc->gdbarch);
+                                                       tloc->gdbarch,
+                                                       trace_string);
 
                  old_chain1 = make_cleanup_free_agent_expr (aexpr);
 
@@ -1504,19 +1545,30 @@ encode_actions_1 (struct command_line *action,
                      check_typedef (exp->elts[1].type);
                      add_memrange (collect, memrange_absolute, addr,
                                    TYPE_LENGTH (exp->elts[1].type));
+                     append_exp (exp, &collect->computed);
                      break;
 
                    case OP_VAR_VALUE:
-                     collect_symbol (collect,
-                                     exp->elts[2].symbol,
-                                     tloc->gdbarch,
-                                     frame_reg,
-                                     frame_offset,
-                                     tloc->address);
+                     {
+                       struct symbol *sym = exp->elts[2].symbol;
+                       char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
+
+                       collect_symbol (collect,
+                                       exp->elts[2].symbol,
+                                       tloc->gdbarch,
+                                       frame_reg,
+                                       frame_offset,
+                                       tloc->address,
+                                       trace_string);
+                       VEC_safe_push (char_ptr,
+                                      collect->wholly_collected,
+                                      name);
+                     }
                      break;
 
                    default:    /* Full-fledged expression.  */
-                     aexpr = gen_trace_for_expr (tloc->address, exp);
+                     aexpr = gen_trace_for_expr (tloc->address, exp,
+                                                 trace_string);
 
                      old_chain1 = make_cleanup_free_agent_expr (aexpr);
 
@@ -1547,6 +1599,8 @@ encode_actions_1 (struct command_line *action,
                                }
                            }
                        }
+
+                     append_exp (exp, &collect->computed);
                      break;
                    }           /* switch */
                  do_cleanups (old_chain);
@@ -1592,7 +1646,7 @@ encode_actions_1 (struct command_line *action,
             here.  */
          gdb_assert (stepping_list);
 
-         encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
+         encode_actions_1 (action->body_list[0], tloc, frame_reg,
                            frame_offset, stepping_list, NULL);
        }
       else
@@ -1600,63 +1654,64 @@ encode_actions_1 (struct command_line *action,
     }                          /* for */
 }
 
-/* Render all actions into gdb protocol.  */
+/* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
+   and STEPPING_LIST.  Return a cleanup pointer to clean up both
+   TRACEPOINT_LIST and STEPPING_LIST.  */
 
-void
-encode_actions (struct breakpoint *t, struct bp_location *tloc,
-               char ***tdp_actions, char ***stepping_actions)
+struct cleanup *
+encode_actions_and_make_cleanup (struct bp_location *tloc,
+                                struct collection_list *tracepoint_list,
+                                struct collection_list *stepping_list)
 {
-  static char tdp_buff[2048], step_buff[2048];
   char *default_collect_line = NULL;
   struct command_line *actions;
   struct command_line *default_collect_action = NULL;
   int frame_reg;
   LONGEST frame_offset;
-  struct cleanup *back_to;
-
-  back_to = make_cleanup (null_cleanup, NULL);
+  struct cleanup *back_to, *return_chain;
 
-  clear_collection_list (&tracepoint_list);
-  clear_collection_list (&stepping_list);
+  return_chain = make_cleanup (null_cleanup, NULL);
+  init_collection_list (tracepoint_list);
+  init_collection_list (stepping_list);
 
-  *tdp_actions = NULL;
-  *stepping_actions = NULL;
+  make_cleanup (do_clear_collection_list, tracepoint_list);
+  make_cleanup (do_clear_collection_list, stepping_list);
 
+  back_to = make_cleanup (null_cleanup, NULL);
   gdbarch_virtual_frame_pointer (tloc->gdbarch,
                                 tloc->address, &frame_reg, &frame_offset);
 
-  actions = breakpoint_commands (t);
+  actions = all_tracepoint_actions_and_cleanup (tloc->owner);
 
-  /* If there are default expressions to collect, make up a collect
-     action and prepend to the action list to encode.  Note that since
-     validation is per-tracepoint (local var "xyz" might be valid for
-     one tracepoint and not another, etc), we make up the action on
-     the fly, and don't cache it.  */
-  if (*default_collect)
-    {
-      default_collect_line =  xstrprintf ("collect %s", default_collect);
-      make_cleanup (xfree, default_collect_line);
+  encode_actions_1 (actions, tloc, frame_reg, frame_offset,
+                   tracepoint_list, stepping_list);
 
-      validate_actionline (default_collect_line, t);
+  memrange_sortmerge (tracepoint_list);
+  memrange_sortmerge (stepping_list);
 
-      default_collect_action = xmalloc (sizeof (struct command_line));
-      make_cleanup (xfree, default_collect_action);
-      default_collect_action->next = actions;
-      default_collect_action->line = default_collect_line;
-      actions = default_collect_action;
-    }
-  encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
-                   &tracepoint_list, &stepping_list);
+  do_cleanups (back_to);
+  return return_chain;
+}
+
+/* Render all actions into gdb protocol.  */
 
-  memrange_sortmerge (&tracepoint_list);
-  memrange_sortmerge (&stepping_list);
+void
+encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
+                   char ***stepping_actions)
+{
+  struct collection_list tracepoint_list, stepping_list;
+  struct cleanup *cleanup;
 
-  *tdp_actions = stringify_collection_list (&tracepoint_list,
-                                           tdp_buff);
-  *stepping_actions = stringify_collection_list (&stepping_list,
-                                                step_buff);
+  *tdp_actions = NULL;
+  *stepping_actions = NULL;
 
-  do_cleanups (back_to);
+  cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
+                                            &stepping_list);
+
+  *tdp_actions = stringify_collection_list (&tracepoint_list);
+  *stepping_actions = stringify_collection_list (&stepping_list);
+
+  do_cleanups (cleanup);
 }
 
 static void
@@ -1715,6 +1770,16 @@ process_tracepoint_on_disconnect (void)
               " GDB is disconnected\n"));
 }
 
+/* Reset local state of tracing.  */
+
+void
+trace_reset_local_state (void)
+{
+  set_traceframe_num (-1);
+  set_tracepoint_num (-1);
+  set_traceframe_context (NULL);
+  clear_traceframe_info ();
+}
 
 void
 start_tracing (char *notes)
@@ -1837,11 +1902,8 @@ start_tracing (char *notes)
   target_trace_start ();
 
   /* Reset our local state.  */
-  set_traceframe_num (-1);
-  set_tracepoint_num (-1);
-  set_traceframe_context (NULL);
+  trace_reset_local_state ();
   current_trace_status()->running = 1;
-  clear_traceframe_info ();
 }
 
 /* The tstart command requests the target to start a new trace run.
@@ -2057,20 +2119,20 @@ trace_status_command (char *args, int from_tty)
 
          /* Reporting a run time is more readable than two long numbers.  */
          printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
-                          (long int) ts->start_time / 1000000,
-                          (long int) ts->start_time % 1000000,
-                          (long int) run_time / 1000000,
-                          (long int) run_time % 1000000);
+                          (long int) (ts->start_time / 1000000),
+                          (long int) (ts->start_time % 1000000),
+                          (long int) (run_time / 1000000),
+                          (long int) (run_time % 1000000));
        }
       else
        printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
-                        (long int) ts->start_time / 1000000,
-                        (long int) ts->start_time % 1000000);
+                        (long int) (ts->start_time / 1000000),
+                        (long int) (ts->start_time % 1000000));
     }
   else if (ts->stop_time)
     printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
-                    (long int) ts->stop_time / 1000000,
-                    (long int) ts->stop_time % 1000000);
+                    (long int) (ts->stop_time / 1000000),
+                    (long int) (ts->stop_time % 1000000));
 
   /* Now report any per-tracepoint status available.  */
   tp_vec = all_tracepoints ();
@@ -2188,22 +2250,25 @@ trace_status_mi (int on_stop)
     char buf[100];
 
     xsnprintf (buf, sizeof buf, "%ld.%06ld",
-              (long int) ts->start_time / 1000000,
-              (long int) ts->start_time % 1000000);
+              (long int) (ts->start_time / 1000000),
+              (long int) (ts->start_time % 1000000));
     ui_out_field_string (uiout, "start-time", buf);
     xsnprintf (buf, sizeof buf, "%ld.%06ld",
-              (long int) ts->stop_time / 1000000,
-              (long int) ts->stop_time % 1000000);
+              (long int) (ts->stop_time / 1000000),
+              (long int) (ts->stop_time % 1000000));
     ui_out_field_string (uiout, "stop-time", buf);
   }
 }
 
-/* This function handles the details of what to do about an ongoing
-   tracing run if the user has asked to detach or otherwise disconnect
-   from the target.  */
+/* Check if a trace run is ongoing.  If so, and FROM_TTY, query the
+   user if she really wants to detach.  */
+
 void
-disconnect_tracing (int from_tty)
+query_if_trace_running (int from_tty)
 {
+  if (!from_tty)
+    return;
+
   /* 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
@@ -2216,7 +2281,7 @@ disconnect_tracing (int from_tty)
      just going to disconnect and let the target deal with it,
      according to how it's been instructed previously via
      disconnected-tracing.  */
-  if (current_trace_status ()->running && from_tty)
+  if (current_trace_status ()->running)
     {
       process_tracepoint_on_disconnect ();
 
@@ -2233,20 +2298,26 @@ disconnect_tracing (int from_tty)
            error (_("Not confirmed."));
        }
     }
+}
+
+/* This function handles the details of what to do about an ongoing
+   tracing run if the user has asked to detach or otherwise disconnect
+   from the target.  */
 
+void
+disconnect_tracing (void)
+{
   /* Also we want to be out of tfind mode, otherwise things can get
      confusing upon reconnection.  Just use these calls instead of
      full tfind_1 behavior because we're in the middle of detaching,
      and there's no point to updating current stack frame etc.  */
-  set_current_traceframe (-1);
-  set_tracepoint_num (-1);
-  set_traceframe_context (NULL);
+  trace_reset_local_state ();
 }
 
 /* Worker function for the various flavors of the tfind command.  */
 void
 tfind_1 (enum trace_find_type type, int num,
-        ULONGEST addr1, ULONGEST addr2,
+        CORE_ADDR addr1, CORE_ADDR addr2,
         int from_tty)
 {
   int target_frameno = -1, target_tracept = -1;
@@ -2373,7 +2444,7 @@ tfind_1 (enum trace_find_type type, int num,
       else
        print_what = SRC_AND_LOC;
 
-      print_stack_frame (get_selected_frame (NULL), 1, print_what);
+      print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
       do_displays ();
     }
 }
@@ -2678,101 +2749,107 @@ scope_info (char *args, int from_tty)
          gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
 
          printf_filtered ("Symbol %s is ", symname);
-         switch (SYMBOL_CLASS (sym))
+
+         if (SYMBOL_COMPUTED_OPS (sym) != NULL)
+           SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
+                                                         BLOCK_START (block),
+                                                         gdb_stdout);
+         else
            {
-           default:
-           case LOC_UNDEF:     /* Messed up symbol?  */
-             printf_filtered ("a bogus symbol, class %d.\n",
-                              SYMBOL_CLASS (sym));
-             count--;          /* Don't count this one.  */
-             continue;
-           case LOC_CONST:
-             printf_filtered ("a constant with value %s (%s)",
-                              plongest (SYMBOL_VALUE (sym)),
-                              hex_string (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_CONST_BYTES:
-             printf_filtered ("constant bytes: ");
-             if (SYMBOL_TYPE (sym))
-               for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
-                 fprintf_filtered (gdb_stdout, " %02x",
-                                   (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
-             break;
-           case LOC_STATIC:
-             printf_filtered ("in static storage at address ");
-             printf_filtered ("%s", paddress (gdbarch,
-                                              SYMBOL_VALUE_ADDRESS (sym)));
-             break;
-           case LOC_REGISTER:
-             /* GDBARCH is the architecture associated with the objfile
-                the symbol is defined in; the target architecture may be
-                different, and may provide additional registers.  However,
-                we do not know the target architecture at this point.
-                We assume the objfile architecture will contain all the
-                standard registers that occur in debug info in that
-                objfile.  */
-             regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
-                                                                 gdbarch);
-
-             if (SYMBOL_IS_ARGUMENT (sym))
-               printf_filtered ("an argument in register $%s",
-                                gdbarch_register_name (gdbarch, regno));
-             else
-               printf_filtered ("a local variable in register $%s",
-                                gdbarch_register_name (gdbarch, regno));
-             break;
-           case LOC_ARG:
-             printf_filtered ("an argument at stack/frame offset %s",
-                              plongest (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_LOCAL:
-             printf_filtered ("a local variable at frame offset %s",
-                              plongest (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_REF_ARG:
-             printf_filtered ("a reference argument at offset %s",
-                              plongest (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_REGPARM_ADDR:
-             /* Note comment at LOC_REGISTER.  */
-             regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
-                                                                 gdbarch);
-             printf_filtered ("the address of an argument, in register $%s",
-                              gdbarch_register_name (gdbarch, regno));
-             break;
-           case LOC_TYPEDEF:
-             printf_filtered ("a typedef.\n");
-             continue;
-           case LOC_LABEL:
-             printf_filtered ("a label at address ");
-             printf_filtered ("%s", paddress (gdbarch,
-                                              SYMBOL_VALUE_ADDRESS (sym)));
-             break;
-           case LOC_BLOCK:
-             printf_filtered ("a function at address ");
-             printf_filtered ("%s",
-               paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
-             break;
-           case LOC_UNRESOLVED:
-             msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
-                                           NULL, NULL);
-             if (msym == NULL)
-               printf_filtered ("Unresolved Static");
-             else
+             switch (SYMBOL_CLASS (sym))
                {
-                 printf_filtered ("static storage at address ");
+               default:
+               case LOC_UNDEF: /* Messed up symbol?  */
+                 printf_filtered ("a bogus symbol, class %d.\n",
+                                  SYMBOL_CLASS (sym));
+                 count--;              /* Don't count this one.  */
+                 continue;
+               case LOC_CONST:
+                 printf_filtered ("a constant with value %s (%s)",
+                                  plongest (SYMBOL_VALUE (sym)),
+                                  hex_string (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_CONST_BYTES:
+                 printf_filtered ("constant bytes: ");
+                 if (SYMBOL_TYPE (sym))
+                   for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
+                     fprintf_filtered (gdb_stdout, " %02x",
+                                       (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
+                 break;
+               case LOC_STATIC:
+                 printf_filtered ("in static storage at address ");
+                 printf_filtered ("%s", paddress (gdbarch,
+                                                  SYMBOL_VALUE_ADDRESS (sym)));
+                 break;
+               case LOC_REGISTER:
+                 /* GDBARCH is the architecture associated with the objfile
+                    the symbol is defined in; the target architecture may be
+                    different, and may provide additional registers.  However,
+                    we do not know the target architecture at this point.
+                    We assume the objfile architecture will contain all the
+                    standard registers that occur in debug info in that
+                    objfile.  */
+                 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
+                                                                     gdbarch);
+
+                 if (SYMBOL_IS_ARGUMENT (sym))
+                   printf_filtered ("an argument in register $%s",
+                                    gdbarch_register_name (gdbarch, regno));
+                 else
+                   printf_filtered ("a local variable in register $%s",
+                                    gdbarch_register_name (gdbarch, regno));
+                 break;
+               case LOC_ARG:
+                 printf_filtered ("an argument at stack/frame offset %s",
+                                  plongest (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_LOCAL:
+                 printf_filtered ("a local variable at frame offset %s",
+                                  plongest (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_REF_ARG:
+                 printf_filtered ("a reference argument at offset %s",
+                                  plongest (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_REGPARM_ADDR:
+                 /* Note comment at LOC_REGISTER.  */
+                 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
+                                                                     gdbarch);
+                 printf_filtered ("the address of an argument, in register $%s",
+                                  gdbarch_register_name (gdbarch, regno));
+                 break;
+               case LOC_TYPEDEF:
+                 printf_filtered ("a typedef.\n");
+                 continue;
+               case LOC_LABEL:
+                 printf_filtered ("a label at address ");
+                 printf_filtered ("%s", paddress (gdbarch,
+                                                  SYMBOL_VALUE_ADDRESS (sym)));
+                 break;
+               case LOC_BLOCK:
+                 printf_filtered ("a function at address ");
                  printf_filtered ("%s",
-                   paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
+                                  paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
+                 break;
+               case LOC_UNRESOLVED:
+                 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
+                                               NULL, NULL);
+                 if (msym == NULL)
+                   printf_filtered ("Unresolved Static");
+                 else
+                   {
+                     printf_filtered ("static storage at address ");
+                     printf_filtered ("%s",
+                                      paddress (gdbarch,
+                                                SYMBOL_VALUE_ADDRESS (msym)));
+                   }
+                 break;
+               case LOC_OPTIMIZED_OUT:
+                 printf_filtered ("optimized out.\n");
+                 continue;
+               case LOC_COMPUTED:
+                 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
                }
-             break;
-           case LOC_OPTIMIZED_OUT:
-             printf_filtered ("optimized out.\n");
-             continue;
-           case LOC_COMPUTED:
-             SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
-                                                           BLOCK_START (block),
-                                                           gdb_stdout);
-             break;
            }
          if (SYMBOL_TYPE (sym))
            printf_filtered (", length %d.\n",
@@ -2840,9 +2917,10 @@ trace_dump_actions (struct command_line *action,
              char *cmd = NULL;
              struct cleanup *old_chain
                = make_cleanup (free_current_contents, &cmd);
+             int trace_string = 0;
 
              if (*action_exp == '/')
-               action_exp = decode_agent_options (action_exp);
+               action_exp = decode_agent_options (action_exp, &trace_string);
 
              do
                {               /* Repeat over a comma-separated list.  */
@@ -2893,24 +2971,19 @@ trace_dump_actions (struct command_line *action,
     }
 }
 
-/* The tdump command.  */
+/* Return bp_location of the tracepoint associated with the current
+   traceframe.  Set *STEPPING_FRAME_P to 1 if the current traceframe
+   is a stepping traceframe.  */
 
-static void
-trace_dump_command (char *args, int from_tty)
+struct bp_location *
+get_traceframe_location (int *stepping_frame_p)
 {
-  struct regcache *regcache;
   struct tracepoint *t;
-  int stepping_frame = 0;
-  struct bp_location *loc;
-  char *default_collect_line = NULL;
-  struct command_line *actions, *default_collect_action = NULL;
-  struct cleanup *old_chain = NULL;
+  struct bp_location *tloc;
+  struct regcache *regcache;
 
   if (tracepoint_number == -1)
-    {
-      warning (_("No current trace frame."));
-      return;
-    }
+    error (_("No current trace frame."));
 
   t = get_tracepoint (tracepoint_number);
 
@@ -2918,35 +2991,53 @@ trace_dump_command (char *args, int from_tty)
     error (_("No known tracepoint matches 'current' tracepoint #%d."),
           tracepoint_number);
 
-  printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
-                  tracepoint_number, traceframe_number);
-
-  /* The current frame is a trap frame if the frame PC is equal
-     to the tracepoint PC.  If not, then the current frame was
-     collected during single-stepping.  */
-
+  /* The current frame is a trap frame if the frame PC is equal to the
+     tracepoint PC.  If not, then the current frame was collected
+     during single-stepping.  */
   regcache = get_current_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->base.loc; loc; loc = loc->next)
-    if (loc->address == regcache_read_pc (regcache))
-      stepping_frame = 0;
+  for (tloc = t->base.loc; tloc; tloc = tloc->next)
+    if (tloc->address == regcache_read_pc (regcache))
+      {
+       *stepping_frame_p = 0;
+       return tloc;
+      }
+
+  /* If this is a stepping frame, we don't know which location
+     triggered.  The first is as good (or bad) a guess as any...  */
+  *stepping_frame_p = 1;
+  return t->base.loc;
+}
+
+/* Return all the actions, including default collect, of a tracepoint
+   T.  It constructs cleanups into the chain, and leaves the caller to
+   handle them (call do_cleanups).  */
+
+static struct command_line *
+all_tracepoint_actions_and_cleanup (struct breakpoint *t)
+{
+  struct command_line *actions;
 
-  actions = breakpoint_commands (&t->base);
+  actions = breakpoint_commands (t);
 
-  /* If there is a default-collect list, make up a collect command,
-     prepend to the tracepoint's commands, and pass the whole mess to
-     the trace dump scanner.  We need to validate because
-     default-collect might have been junked since the trace run.  */
+  /* If there are default expressions to collect, make up a collect
+     action and prepend to the action list to encode.  Note that since
+     validation is per-tracepoint (local var "xyz" might be valid for
+     one tracepoint and not another, etc), we make up the action on
+     the fly, and don't cache it.  */
   if (*default_collect)
     {
+      struct command_line *default_collect_action;
+      char *default_collect_line;
+
       default_collect_line = xstrprintf ("collect %s", default_collect);
-      old_chain = make_cleanup (xfree, default_collect_line);
-      validate_actionline (default_collect_line, &t->base);
+      make_cleanup (xfree, default_collect_line);
+
+      validate_actionline (default_collect_line, t);
       default_collect_action = xmalloc (sizeof (struct command_line));
       make_cleanup (xfree, default_collect_action);
       default_collect_action->next = actions;
@@ -2954,10 +3045,37 @@ trace_dump_command (char *args, int from_tty)
       actions = default_collect_action;
     }
 
+  return actions;
+}
+
+/* The tdump command.  */
+
+static void
+trace_dump_command (char *args, int from_tty)
+{
+  int stepping_frame = 0;
+  struct bp_location *loc;
+  struct cleanup *old_chain;
+  struct command_line *actions;
+
+  /* This throws an error is not inspecting a trace frame.  */
+  loc = get_traceframe_location (&stepping_frame);
+
+  printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
+                  tracepoint_number, traceframe_number);
+
+  old_chain = make_cleanup (null_cleanup, NULL);
+
+  /* This command only makes sense for the current frame, not the
+     selected frame.  */
+  make_cleanup_restore_current_thread ();
+  select_frame (get_current_frame ());
+
+  actions = all_tracepoint_actions_and_cleanup (loc->owner);
+
   trace_dump_actions (actions, 0, stepping_frame, from_tty);
 
-  if (*default_collect)
-    do_cleanups (old_chain);
+  do_cleanups (old_chain);
 }
 
 /* Encode a piece of a tracepoint's source-level definition in a form
@@ -2976,7 +3094,7 @@ encode_source_string (int tpnum, ULONGEST addr,
           srctype, 0, (int) strlen (src));
   if (strlen (buf) + strlen (src) * 2 >= buf_size)
     error (_("Source string too long for buffer"));
-  bin2hex (src, buf + strlen (buf), 0);
+  bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
   return -1;
 }
 
@@ -3042,10 +3160,10 @@ tfile_start (struct trace_file_writer *self, const char *filename)
     = (struct tfile_trace_file_writer *) self;
 
   writer->pathname = tilde_expand (filename);
-  writer->fp = fopen (writer->pathname, "wb");
+  writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
   if (writer->fp == NULL)
     error (_("Unable to open file '%s' for saving trace data (%s)"),
-          filename, safe_strerror (errno));
+          writer->pathname, safe_strerror (errno));
 }
 
 /* This is the implementation of trace_file_write_ops method
@@ -3111,6 +3229,16 @@ tfile_write_status (struct trace_file_writer *self,
     fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
   if (ts->circular_buffer)
     fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
+  if (ts->start_time)
+    {
+      fprintf (writer->fp, ";starttime:%s",
+      phex_nz (ts->start_time, sizeof (ts->start_time)));
+    }
+  if (ts->stop_time)
+    {
+      fprintf (writer->fp, ";stoptime:%s",
+      phex_nz (ts->stop_time, sizeof (ts->stop_time)));
+    }
   if (ts->notes != NULL)
     {
       char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
@@ -3166,7 +3294,7 @@ tfile_write_uploaded_tp (struct trace_file_writer *self,
     = (struct tfile_trace_file_writer *) self;
   int a;
   char *act;
-  gdb_byte buf[MAX_TRACE_UPLOAD];
+  char buf[MAX_TRACE_UPLOAD];
 
   fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
           utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
@@ -3282,8 +3410,6 @@ static const struct trace_file_write_ops tfile_write_ops =
 #define TRACE_WRITE_V_BLOCK(writer, num, val)  \
   writer->ops->frame_ops->write_v_block ((writer), (num), (val))
 
-extern int trace_regblock_size;
-
 /* Save tracepoint data to file named FILENAME through WRITER.  WRITER
    determines the trace file format.  If TARGET_DOES_SAVE is non-zero,
    the save is performed on the target, otherwise GDB obtains all trace
@@ -3300,6 +3426,7 @@ trace_save (const char *filename, struct trace_file_writer *writer,
 
   ULONGEST offset = 0;
   gdb_byte buf[MAX_TRACE_UPLOAD];
+#define MAX_TRACE_UPLOAD 2000
   int written;
   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 
@@ -3720,6 +3847,12 @@ get_traceframe_number (void)
   return traceframe_number;
 }
 
+int
+get_tracepoint_number (void)
+{
+  return tracepoint_number;
+}
+
 /* Make the traceframe NUM be the current trace frame.  Does nothing
    if NUM is already current.  */
 
@@ -3838,7 +3971,7 @@ free_uploaded_tps (struct uploaded_tp **utpp)
 /* Given a number and address, return an uploaded tracepoint with that
    number, creating if necessary.  */
 
-static struct uploaded_tsv *
+struct uploaded_tsv *
 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
 {
   struct uploaded_tsv *utsv;
@@ -4147,7 +4280,7 @@ tfile_open (char *filename, int from_tty)
   int scratch_chan;
   char header[TRACE_HEADER_SIZE];
   char linebuf[1000]; /* Should be max remote packet size or so.  */
-  char byte;
+  gdb_byte byte;
   int bytes, i;
   struct trace_status *ts;
   struct uploaded_tp *uploaded_tps = NULL;
@@ -4169,7 +4302,7 @@ tfile_open (char *filename, int from_tty)
 
   flags = O_BINARY | O_LARGEFILE;
   flags |= O_RDONLY;
-  scratch_chan = open (filename, flags, 0);
+  scratch_chan = gdb_open_cloexec (filename, flags, 0);
   if (scratch_chan < 0)
     perror_with_name (filename);
 
@@ -4239,15 +4372,11 @@ tfile_open (char *filename, int from_tty)
     }
   if (ex.reason < 0)
     {
-      /* Pop the partially set up target.  */
-      pop_target ();
+      /* Remove the partially set up target.  */
+      unpush_target (&tfile_ops);
       throw_exception (ex);
     }
 
-  inferior_appeared (current_inferior (), TFILE_PID);
-  inferior_ptid = pid_to_ptid (TFILE_PID);
-  add_thread_silent (inferior_ptid);
-
   if (ts->traceframe_count <= 0)
     warning (_("No traceframes present in this file."));
 
@@ -4258,16 +4387,14 @@ tfile_open (char *filename, int from_tty)
   merge_uploaded_trace_state_variables (&uploaded_tsvs);
 
   merge_uploaded_tracepoints (&uploaded_tps);
-
-  post_create_inferior (&tfile_ops, from_tty);
 }
 
 /* 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)
+tfile_interp_line (char *line, struct uploaded_tp **utpp,
+                  struct uploaded_tsv **utsvp)
 {
   char *p = line;
 
@@ -4359,7 +4486,7 @@ Status line: '%s'\n"), p, line);
          else if (p2 != p1)
            {
              ts->stop_desc = xmalloc (strlen (line));
-             end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
+             end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
              ts->stop_desc[end] = '\0';
            }
          else
@@ -4379,7 +4506,7 @@ Status line: '%s'\n"), p, line);
          if (p2 != p1)
            {
              ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
-             end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
+             end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
              ts->stop_desc[end] = '\0';
            }
          else
@@ -4433,7 +4560,7 @@ Status line: '%s'\n"), p, line);
        {
          ++p1;
          ts->user_name = xmalloc (strlen (p) / 2);
-         end = hex2bin (p1, ts->user_name, (p3 - p1)  / 2);
+         end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1)  / 2);
          ts->user_name[end] = '\0';
          p = p3;
        }
@@ -4441,7 +4568,7 @@ Status line: '%s'\n"), p, line);
        {
          ++p1;
          ts->notes = xmalloc (strlen (p) / 2);
-         end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
+         end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
          ts->notes[end] = '\0';
          p = p3;
        }
@@ -4632,14 +4759,12 @@ tfile_close (void)
   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;
   xfree (trace_filename);
   trace_filename = NULL;
+
+  trace_reset_local_state ();
 }
 
 static void
@@ -4671,10 +4796,10 @@ tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
    value of a collected PC register, but if not available, we
    improvise.  */
 
-static ULONGEST
+static CORE_ADDR
 tfile_get_traceframe_address (off_t tframe_offset)
 {
-  ULONGEST addr = 0;
+  CORE_ADDR addr = 0;
   short tpnum;
   struct tracepoint *tp;
   off_t saved_offset = cur_offset;
@@ -4706,14 +4831,14 @@ tfile_get_traceframe_address (off_t tframe_offset)
 
 static int
 tfile_trace_find (enum trace_find_type type, int num,
-                 ULONGEST addr1, ULONGEST addr2, int *tpp)
+                 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
 {
   short tpnum;
   int tfnum = 0, found = 0;
   unsigned int data_size;
   struct tracepoint *tp;
   off_t offset, tframe_offset;
-  ULONGEST tfaddr;
+  CORE_ADDR tfaddr;
 
   if (num == -1)
     {
@@ -4837,7 +4962,7 @@ traceframe_walk_blocks (walk_blocks_callback_func callback,
       unsigned short mlen;
       char block_type;
 
-      tfile_read (&block_type, 1);
+      tfile_read ((gdb_byte *) &block_type, 1);
 
       ++pos;
 
@@ -4893,7 +5018,7 @@ tfile_fetch_registers (struct target_ops *ops,
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int offset, regn, regsize, pc_regno;
-  char *regs;
+  gdb_byte *regs;
 
   /* An uninitialized reg size says we're not going to be
      successful at getting register blocks.  */
@@ -5120,12 +5245,6 @@ tfile_has_registers (struct target_ops *ops)
   return traceframe_number != -1;
 }
 
-static int
-tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
-{
-  return 1;
-}
-
 /* Callback for traceframe_walk_blocks.  Builds a traceframe_info
    object for the tfile target's current traceframe.  */
 
@@ -5159,6 +5278,12 @@ build_traceframe_info (char blocktype, void *data)
        break;
       }
     case 'V':
+      {
+       int vnum;
+
+       tfile_read ((gdb_byte *) &vnum, 4);
+       VEC_safe_push (int, info->tvars, vnum);
+      }
     case 'R':
     case 'S':
       {
@@ -5206,7 +5331,6 @@ init_tfile_ops (void)
   tfile_ops.to_has_stack = tfile_has_stack;
   tfile_ops.to_has_registers = tfile_has_registers;
   tfile_ops.to_traceframe_info = tfile_traceframe_info;
-  tfile_ops.to_thread_alive = tfile_thread_alive;
   tfile_ops.to_magic = OPS_MAGIC;
 }
 
@@ -5517,6 +5641,21 @@ traceframe_info_start_memory (struct gdb_xml_parser *parser,
   r->length = *length_p;
 }
 
+/* Handle the start of a <tvar> element.  */
+
+static void
+traceframe_info_start_tvar (struct gdb_xml_parser *parser,
+                            const struct gdb_xml_element *element,
+                            void *user_data,
+                            VEC(gdb_xml_value_s) *attributes)
+{
+  struct traceframe_info *info = user_data;
+  const char *id_attrib = xml_find_attribute (attributes, "id")->value;
+  int id = gdb_xml_parse_ulongest (parser, id_attrib);
+
+  VEC_safe_push (int, info->tvars, id);
+}
+
 /* Discard the constructed trace frame info (if an error occurs).  */
 
 static void
@@ -5535,10 +5674,18 @@ static const struct gdb_xml_attribute memory_attributes[] = {
   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 };
 
+static const struct gdb_xml_attribute tvar_attributes[] = {
+  { "id", GDB_XML_AF_NONE, NULL, NULL },
+  { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
 static const struct gdb_xml_element traceframe_info_children[] = {
   { "memory", memory_attributes, NULL,
     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
     traceframe_info_start_memory, NULL },
+  { "tvar", tvar_attributes, NULL,
+    GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
+    traceframe_info_start_tvar, NULL },
   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 };
 
@@ -5579,7 +5726,7 @@ parse_traceframe_info (const char *tframe_info)
    This is where we avoid re-fetching the object from the target if we
    already have it cached.  */
 
-static struct traceframe_info *
+struct traceframe_info *
 get_traceframe_info (void)
 {
   if (traceframe_info == NULL)
@@ -5656,33 +5803,6 @@ _initialize_tracepoint (void)
   traceframe_number = -1;
   tracepoint_number = -1;
 
-  if (tracepoint_list.list == NULL)
-    {
-      tracepoint_list.listsize = 128;
-      tracepoint_list.list = xmalloc
-       (tracepoint_list.listsize * sizeof (struct memrange));
-    }
-  if (tracepoint_list.aexpr_list == NULL)
-    {
-      tracepoint_list.aexpr_listsize = 128;
-      tracepoint_list.aexpr_list = xmalloc
-       (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
-    }
-
-  if (stepping_list.list == NULL)
-    {
-      stepping_list.listsize = 128;
-      stepping_list.list = xmalloc
-       (stepping_list.listsize * sizeof (struct memrange));
-    }
-
-  if (stepping_list.aexpr_list == NULL)
-    {
-      stepping_list.aexpr_listsize = 128;
-      stepping_list.aexpr_list = xmalloc
-       (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
-    }
-
   add_info ("scope", scope_info,
            _("List the variables local to a scope"));
 
@@ -5856,8 +5976,8 @@ up and stopping the trace run."),
 Set requested size of trace buffer."), _("\
 Show requested size of trace buffer."), _("\
 Use this to choose a size for the trace buffer.  Some targets\n\
-may have fixed or limited buffer sizes.  A value of -1 disables\n\
-any attempt to set the buffer size and lets the target choose."),
+may have fixed or limited buffer sizes.  Specifying \"unlimited\" or -1\n\
+disables any attempt to set the buffer size and lets the target choose."),
                                       set_trace_buffer_size, NULL,
                                       &setlist, &showlist);
 
@@ -5884,5 +6004,5 @@ Show the notes string to use for future tstop commands"), NULL,
 
   init_tfile_ops ();
 
-  add_target (&tfile_ops);
+  add_target_with_completer (&tfile_ops, filename_completer);
 }
This page took 0.041073 seconds and 4 git commands to generate.