* linux-nat.c (enum sigchld_state): Delete.
[deliverable/binutils-gdb.git] / gdb / tracepoint.c
index e522352c3dbd3487e9c61c721638c49917833c29..dece79964f47a954ce623bb6ed1f472a274498bc 100644 (file)
@@ -1,13 +1,13 @@
 /* Tracing functionality for remote targets in custom GDB protocol
 
 /* Tracing functionality for remote targets in custom GDB protocol
 
-   Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free
-   Software Foundation, Inc.
+   Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+   2007, 2008, 2009 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -16,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "symtab.h"
 
 #include "defs.h"
 #include "symtab.h"
 #include "language.h"
 #include "gdb_string.h"
 #include "inferior.h"
 #include "language.h"
 #include "gdb_string.h"
 #include "inferior.h"
+#include "breakpoint.h"
 #include "tracepoint.h"
 #include "remote.h"
 #include "linespec.h"
 #include "regcache.h"
 #include "completer.h"
 #include "tracepoint.h"
 #include "remote.h"
 #include "linespec.h"
 #include "regcache.h"
 #include "completer.h"
-#include "gdb-events.h"
 #include "block.h"
 #include "dictionary.h"
 #include "block.h"
 #include "dictionary.h"
+#include "observer.h"
+#include "user-regs.h"
+#include "valprint.h"
 
 #include "ax.h"
 #include "ax-gdb.h"
 
 #include "ax.h"
 #include "ax-gdb.h"
@@ -68,8 +69,6 @@
 extern void (*deprecated_readline_begin_hook) (char *, ...);
 extern char *(*deprecated_readline_hook) (char *);
 extern void (*deprecated_readline_end_hook) (void);
 extern void (*deprecated_readline_begin_hook) (char *, ...);
 extern char *(*deprecated_readline_hook) (char *);
 extern void (*deprecated_readline_end_hook) (void);
-extern void x_command (char *, int);
-extern int addressprint;       /* Print machine addresses? */
 
 /* GDB commands implemented in other modules:
  */  
 
 /* GDB commands implemented in other modules:
  */  
@@ -104,12 +103,6 @@ extern void output_command (char *, int);
 
 /* ======= Important global variables: ======= */
 
 
 /* ======= Important global variables: ======= */
 
-/* Chain of all tracepoints defined.  */
-struct tracepoint *tracepoint_chain;
-
-/* Number of last tracepoint made.  */
-static int tracepoint_count;
-
 /* Number of last traceframe collected.  */
 static int traceframe_number;
 
 /* Number of last traceframe collected.  */
 static int traceframe_number;
 
@@ -126,12 +119,6 @@ static struct symtab_and_line traceframe_sal;
 static struct cmd_list_element *tfindlist;
 
 /* ======= Important command functions: ======= */
 static struct cmd_list_element *tfindlist;
 
 /* ======= Important command functions: ======= */
-static void trace_command (char *, int);
-static void tracepoints_info (char *, int);
-static void delete_trace_command (char *, int);
-static void enable_trace_command (char *, int);
-static void disable_trace_command (char *, int);
-static void trace_pass_command (char *, int);
 static void trace_actions_command (char *, int);
 static void trace_start_command (char *, int);
 static void trace_stop_command (char *, int);
 static void trace_actions_command (char *, int);
 static void trace_start_command (char *, int);
 static void trace_stop_command (char *, int);
@@ -146,14 +133,13 @@ static void tracepoint_save_command (char *, int);
 static void trace_dump_command (char *, int);
 
 /* support routines */
 static void trace_dump_command (char *, int);
 
 /* support routines */
-static void trace_mention (struct tracepoint *);
 
 struct collection_list;
 static void add_aexpr (struct collection_list *, struct agent_expr *);
 static char *mem2hex (gdb_byte *, char *, int);
 static void add_register (struct collection_list *collection,
                          unsigned int regno);
 
 struct collection_list;
 static void add_aexpr (struct collection_list *, struct agent_expr *);
 static char *mem2hex (gdb_byte *, char *, int);
 static void add_register (struct collection_list *collection,
                          unsigned int regno);
-static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
+static struct cleanup *make_cleanup_free_actions (struct breakpoint *t);
 static void free_actions_list (char **actions_list);
 static void free_actions_list_cleanup_wrapper (void *);
 
 static void free_actions_list (char **actions_list);
 static void free_actions_list_cleanup_wrapper (void *);
 
@@ -194,13 +180,15 @@ trace_error (char *buf)
 
 /* Utility: wait for reply from stub, while accepting "O" packets.  */
 static char *
 
 /* Utility: wait for reply from stub, while accepting "O" packets.  */
 static char *
-remote_get_noisy_reply (char *buf,
-                       long sizeof_buf)
+remote_get_noisy_reply (char **buf_p,
+                       long *sizeof_buf)
 {
   do                           /* Loop on reply from remote stub.  */
     {
 {
   do                           /* Loop on reply from remote stub.  */
     {
+      char *buf;
       QUIT;                    /* allow user to bail out with ^C */
       QUIT;                    /* allow user to bail out with ^C */
-      getpkt (buf, sizeof_buf, 0);
+      getpkt (buf_p, sizeof_buf, 0);
+      buf = *buf_p;
       if (buf[0] == 0)
        error (_("Target does not support this command."));
       else if (buf[0] == 'E')
       if (buf[0] == 0)
        error (_("Target does not support this command."));
       else if (buf[0] == 'E')
@@ -214,22 +202,13 @@ remote_get_noisy_reply (char *buf,
   while (1);
 }
 
   while (1);
 }
 
-/* Set tracepoint count to NUM.  */
-static void
-set_tracepoint_count (int num)
-{
-  tracepoint_count = num;
-  set_internalvar (lookup_internalvar ("tpnum"),
-                  value_from_longest (builtin_type_int, (LONGEST) num));
-}
-
 /* Set traceframe number to NUM.  */
 static void
 set_traceframe_num (int num)
 {
   traceframe_number = num;
   set_internalvar (lookup_internalvar ("trace_frame"),
 /* Set traceframe number to NUM.  */
 static void
 set_traceframe_num (int num)
 {
   traceframe_number = num;
   set_internalvar (lookup_internalvar ("trace_frame"),
-                  value_from_longest (builtin_type_int, (LONGEST) num));
+                  value_from_longest (builtin_type_int32, (LONGEST) num));
 }
 
 /* Set tracepoint number to NUM.  */
 }
 
 /* Set tracepoint number to NUM.  */
@@ -238,68 +217,66 @@ set_tracepoint_num (int num)
 {
   tracepoint_number = num;
   set_internalvar (lookup_internalvar ("tracepoint"),
 {
   tracepoint_number = num;
   set_internalvar (lookup_internalvar ("tracepoint"),
-                  value_from_longest (builtin_type_int, 
-                                      (LONGEST) num));
+                  value_from_longest (builtin_type_int32, (LONGEST) num));
 }
 
 /* Set externally visible debug variables for querying/printing
    the traceframe context (line, function, file) */
 
 static void
 }
 
 /* Set externally visible debug variables for querying/printing
    the traceframe context (line, function, file) */
 
 static void
-set_traceframe_context (CORE_ADDR trace_pc)
+set_traceframe_context (struct frame_info *trace_frame)
 {
 {
+  CORE_ADDR trace_pc;
+
   static struct type *func_string, *file_string;
   static struct type *func_range, *file_range;
   struct value *func_val;
   struct value *file_val;
   static struct type *func_string, *file_string;
   static struct type *func_range, *file_range;
   struct value *func_val;
   struct value *file_val;
-  static struct type *charstar;
   int len;
 
   int len;
 
-  if (charstar == (struct type *) NULL)
-    charstar = lookup_pointer_type (builtin_type_char);
-
-  if (trace_pc == -1)          /* Cease debugging any trace buffers.  */
+  if (trace_frame == NULL)             /* Cease debugging any trace buffers.  */
     {
       traceframe_fun = 0;
       traceframe_sal.pc = traceframe_sal.line = 0;
       traceframe_sal.symtab = NULL;
       set_internalvar (lookup_internalvar ("trace_func"),
     {
       traceframe_fun = 0;
       traceframe_sal.pc = traceframe_sal.line = 0;
       traceframe_sal.symtab = NULL;
       set_internalvar (lookup_internalvar ("trace_func"),
-                      value_from_pointer (charstar, (LONGEST) 0));
+                      allocate_value (builtin_type_void));
       set_internalvar (lookup_internalvar ("trace_file"),
       set_internalvar (lookup_internalvar ("trace_file"),
-                      value_from_pointer (charstar, (LONGEST) 0));
+                      allocate_value (builtin_type_void));
       set_internalvar (lookup_internalvar ("trace_line"),
       set_internalvar (lookup_internalvar ("trace_line"),
-                      value_from_longest (builtin_type_int
+                      value_from_longest (builtin_type_int32,
                                           (LONGEST) - 1));
       return;
     }
 
   /* Save as globals for internal use.  */
                                           (LONGEST) - 1));
       return;
     }
 
   /* Save as globals for internal use.  */
+  trace_pc = get_frame_pc (trace_frame);
   traceframe_sal = find_pc_line (trace_pc, 0);
   traceframe_fun = find_pc_function (trace_pc);
 
   /* Save linenumber as "$trace_line", a debugger variable visible to
      users.  */
   set_internalvar (lookup_internalvar ("trace_line"),
   traceframe_sal = find_pc_line (trace_pc, 0);
   traceframe_fun = find_pc_function (trace_pc);
 
   /* Save linenumber as "$trace_line", a debugger variable visible to
      users.  */
   set_internalvar (lookup_internalvar ("trace_line"),
-                  value_from_longest (builtin_type_int,
+                  value_from_longest (builtin_type_int32,
                                       (LONGEST) traceframe_sal.line));
 
   /* Save func name as "$trace_func", a debugger variable visible to
      users.  */
   if (traceframe_fun == NULL ||
                                       (LONGEST) traceframe_sal.line));
 
   /* Save func name as "$trace_func", a debugger variable visible to
      users.  */
   if (traceframe_fun == NULL ||
-      DEPRECATED_SYMBOL_NAME (traceframe_fun) == NULL)
+      SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
     set_internalvar (lookup_internalvar ("trace_func"),
     set_internalvar (lookup_internalvar ("trace_func"),
-                    value_from_pointer (charstar, (LONGEST) 0));
+                    allocate_value (builtin_type_void));
   else
     {
   else
     {
-      len = strlen (DEPRECATED_SYMBOL_NAME (traceframe_fun));
+      len = strlen (SYMBOL_LINKAGE_NAME (traceframe_fun));
       func_range = create_range_type (func_range,
       func_range = create_range_type (func_range,
-                                     builtin_type_int, 0, len - 1);
+                                     builtin_type_int32, 0, len - 1);
       func_string = create_array_type (func_string,
       func_string = create_array_type (func_string,
-                                      builtin_type_char, func_range);
+                                      builtin_type_true_char, func_range);
       func_val = allocate_value (func_string);
       deprecated_set_value_type (func_val, func_string);
       memcpy (value_contents_raw (func_val),
       func_val = allocate_value (func_string);
       deprecated_set_value_type (func_val, func_string);
       memcpy (value_contents_raw (func_val),
-             DEPRECATED_SYMBOL_NAME (traceframe_fun),
+             SYMBOL_LINKAGE_NAME (traceframe_fun),
              len);
       deprecated_set_value_modifiable (func_val, 0);
       set_internalvar (lookup_internalvar ("trace_func"), func_val);
              len);
       deprecated_set_value_modifiable (func_val, 0);
       set_internalvar (lookup_internalvar ("trace_func"), func_val);
@@ -310,14 +287,14 @@ set_traceframe_context (CORE_ADDR trace_pc)
   if (traceframe_sal.symtab == NULL ||
       traceframe_sal.symtab->filename == NULL)
     set_internalvar (lookup_internalvar ("trace_file"),
   if (traceframe_sal.symtab == NULL ||
       traceframe_sal.symtab->filename == NULL)
     set_internalvar (lookup_internalvar ("trace_file"),
-                    value_from_pointer (charstar, (LONGEST) 0));
+                    allocate_value (builtin_type_void));
   else
     {
       len = strlen (traceframe_sal.symtab->filename);
       file_range = create_range_type (file_range,
   else
     {
       len = strlen (traceframe_sal.symtab->filename);
       file_range = create_range_type (file_range,
-                                     builtin_type_int, 0, len - 1);
+                                     builtin_type_int32, 0, len - 1);
       file_string = create_array_type (file_string,
       file_string = create_array_type (file_string,
-                                      builtin_type_char, file_range);
+                                      builtin_type_true_char, file_range);
       file_val = allocate_value (file_string);
       deprecated_set_value_type (file_val, file_string);
       memcpy (value_contents_raw (file_val),
       file_val = allocate_value (file_string);
       deprecated_set_value_type (file_val, file_string);
       memcpy (value_contents_raw (file_val),
@@ -328,433 +305,10 @@ set_traceframe_context (CORE_ADDR trace_pc)
     }
 }
 
     }
 }
 
-/* Low level routine to set a tracepoint.
-   Returns the tracepoint object so caller can set other things.
-   Does not set the tracepoint number!
-   Does not print anything.
-
-   ==> This routine should not be called if there is a chance of later
-   error(); otherwise it leaves a bogus tracepoint on the chain.
-   Validate your arguments BEFORE calling this routine!  */
-
-static struct tracepoint *
-set_raw_tracepoint (struct symtab_and_line sal)
-{
-  struct tracepoint *t, *tc;
-  struct cleanup *old_chain;
-
-  t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
-  old_chain = make_cleanup (xfree, t);
-  memset (t, 0, sizeof (*t));
-  t->address = sal.pc;
-  if (sal.symtab == NULL)
-    t->source_file = NULL;
-  else
-    t->source_file = savestring (sal.symtab->filename,
-                                strlen (sal.symtab->filename));
-
-  t->section = sal.section;
-  t->language = current_language->la_language;
-  t->input_radix = input_radix;
-  t->line_number = sal.line;
-  t->enabled_p = 1;
-  t->next = 0;
-  t->step_count = 0;
-  t->pass_count = 0;
-  t->addr_string = NULL;
-
-  /* Add this tracepoint to the end of the chain
-     so that a list of tracepoints will come out in order
-     of increasing numbers.  */
-
-  tc = tracepoint_chain;
-  if (tc == 0)
-    tracepoint_chain = t;
-  else
-    {
-      while (tc->next)
-       tc = tc->next;
-      tc->next = t;
-    }
-  discard_cleanups (old_chain);
-  return t;
-}
-
-/* Set a tracepoint according to ARG (function, linenum or *address).  */
-static void
-trace_command (char *arg, int from_tty)
-{
-  char **canonical = (char **) NULL;
-  struct symtabs_and_lines sals;
-  struct symtab_and_line sal;
-  struct tracepoint *t;
-  char *addr_start = 0, *addr_end = 0;
-  int i;
-
-  if (!arg || !*arg)
-    error (_("trace command requires an argument"));
-
-  if (from_tty && info_verbose)
-    printf_filtered ("TRACE %s\n", arg);
-
-  addr_start = arg;
-  sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 
-                       0, &canonical, NULL);
-  addr_end = arg;
-  if (!sals.nelts)
-    return;    /* ??? Presumably decode_line_1 has already warned?  */
-
-  /* Resolve all line numbers to PC's */
-  for (i = 0; i < sals.nelts; i++)
-    resolve_sal_pc (&sals.sals[i]);
-
-  /* Now set all the tracepoints.  */
-  for (i = 0; i < sals.nelts; i++)
-    {
-      sal = sals.sals[i];
-
-      t = set_raw_tracepoint (sal);
-      set_tracepoint_count (tracepoint_count + 1);
-      t->number = tracepoint_count;
-
-      /* If a canonical line spec is needed use that instead of the
-         command string.  */
-      if (canonical != (char **) NULL && canonical[i] != NULL)
-       t->addr_string = canonical[i];
-      else if (addr_start)
-       t->addr_string = savestring (addr_start, addr_end - addr_start);
-
-      trace_mention (t);
-    }
-
-  if (sals.nelts > 1)
-    {
-      printf_filtered ("Multiple tracepoints were set.\n");
-      printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
-    }
-}
-
-/* Tell the user we have just set a tracepoint TP.  */
-
-static void
-trace_mention (struct tracepoint *tp)
-{
-  printf_filtered ("Tracepoint %d", tp->number);
-
-  if (addressprint || (tp->source_file == NULL))
-    {
-      printf_filtered (" at ");
-      deprecated_print_address_numeric (tp->address, 1, gdb_stdout);
-    }
-  if (tp->source_file)
-    printf_filtered (": file %s, line %d.",
-                    tp->source_file, tp->line_number);
-
-  printf_filtered ("\n");
-}
-
-/* Print information on tracepoint number TPNUM_EXP, or all if
-   omitted.  */
-
-static void
-tracepoints_info (char *tpnum_exp, int from_tty)
-{
-  struct tracepoint *t;
-  struct action_line *action;
-  int found_a_tracepoint = 0;
-  char wrap_indent[80];
-  struct symbol *sym;
-  int tpnum = -1;
-
-  if (tpnum_exp)
-    tpnum = parse_and_eval_long (tpnum_exp);
-
-  ALL_TRACEPOINTS (t)
-    if (tpnum == -1 || tpnum == t->number)
-    {
-      extern int addressprint; /* Print machine addresses?  */
-
-      if (!found_a_tracepoint++)
-       {
-         printf_filtered ("Num Enb ");
-         if (addressprint)
-           {
-             if (TARGET_ADDR_BIT <= 32)
-               printf_filtered ("Address    ");
-             else
-               printf_filtered ("Address            ");
-           }
-         printf_filtered ("PassC StepC What\n");
-       }
-      strcpy (wrap_indent, "                           ");
-      if (addressprint)
-       {
-         if (TARGET_ADDR_BIT <= 32)
-           strcat (wrap_indent, "           ");
-         else
-           strcat (wrap_indent, "                   ");
-       }
-
-      printf_filtered ("%-3d %-3s ", t->number,
-                      t->enabled_p ? "y" : "n");
-      if (addressprint)
-       {
-         char *tmp;
-
-         if (TARGET_ADDR_BIT <= 32)
-           tmp = hex_string_custom (t->address & (CORE_ADDR) 0xffffffff, 
-                                    8);
-         else
-           tmp = hex_string_custom (t->address, 16);
-
-         printf_filtered ("%s ", tmp);
-       }
-      printf_filtered ("%-5d %-5ld ", t->pass_count, t->step_count);
-
-      if (t->source_file)
-       {
-         sym = find_pc_sect_function (t->address, t->section);
-         if (sym)
-           {
-             fputs_filtered ("in ", gdb_stdout);
-             fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout);
-             wrap_here (wrap_indent);
-             fputs_filtered (" at ", gdb_stdout);
-           }
-         fputs_filtered (t->source_file, gdb_stdout);
-         printf_filtered (":%d", t->line_number);
-       }
-      else
-       print_address_symbolic (t->address, gdb_stdout, demangle, " ");
-
-      printf_filtered ("\n");
-      if (t->actions)
-       {
-         printf_filtered ("  Actions for tracepoint %d: \n", t->number);
-         for (action = t->actions; action; action = action->next)
-           {
-             printf_filtered ("\t%s\n", action->action);
-           }
-       }
-    }
-  if (!found_a_tracepoint)
-    {
-      if (tpnum == -1)
-       printf_filtered ("No tracepoints.\n");
-      else
-       printf_filtered ("No tracepoint number %d.\n", tpnum);
-    }
-}
-
-/* Optimization: the code to parse an enable, disable, or delete TP
-   command is virtually identical except for whether it performs an
-   enable, disable, or delete.  Therefore I've combined them into one
-   function with an opcode.  */
-enum tracepoint_opcode
-{
-  enable_op,
-  disable_op,
-  delete_op
-};
-
-/* This function implements enable, disable and delete commands.  */
-static void
-tracepoint_operation (struct tracepoint *t, int from_tty,
-                     enum tracepoint_opcode opcode)
-{
-  struct tracepoint *t2;
-
-  if (t == NULL)       /* no tracepoint operand */
-    return;
-
-  switch (opcode)
-    {
-    case enable_op:
-      t->enabled_p = 1;
-      tracepoint_modify_event (t->number);
-      break;
-    case disable_op:
-      t->enabled_p = 0;
-      tracepoint_modify_event (t->number);
-      break;
-    case delete_op:
-      if (tracepoint_chain == t)
-       tracepoint_chain = t->next;
-
-      ALL_TRACEPOINTS (t2)
-       if (t2->next == t)
-       {
-         tracepoint_delete_event (t2->number);
-         t2->next = t->next;
-         break;
-       }
-
-      if (t->addr_string)
-       xfree (t->addr_string);
-      if (t->source_file)
-       xfree (t->source_file);
-      if (t->actions)
-       free_actions (t);
-
-      xfree (t);
-      break;
-    }
-}
-
-/* Utility: parse a tracepoint number and look it up in the list.
-   If MULTI_P is true, there might be a range of tracepoints in ARG.
-   if OPTIONAL_P is true, then if the argument is missing, the most
-   recent tracepoint (tracepoint_count) is returned.  */
-struct tracepoint *
-get_tracepoint_by_number (char **arg, int multi_p, int optional_p)
-{
-  struct tracepoint *t;
-  int tpnum;
-  char *instring = arg == NULL ? NULL : *arg;
-
-  if (arg == NULL || *arg == NULL || ! **arg)
-    {
-      if (optional_p)
-       tpnum = tracepoint_count;
-      else
-       error_no_arg (_("tracepoint number"));
-    }
-  else
-    tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
-
-  if (tpnum <= 0)
-    {
-      if (instring && *instring)
-       printf_filtered ("bad tracepoint number at or near '%s'\n", 
-                        instring);
-      else
-       printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
-      return NULL;
-    }
-
-  ALL_TRACEPOINTS (t)
-    if (t->number == tpnum)
-    {
-      return t;
-    }
-
-  /* FIXME: if we are in the middle of a range we don't want to give
-     a message.  The current interface to get_number_or_range doesn't
-     allow us to discover this.  */
-  printf_unfiltered ("No tracepoint number %d.\n", tpnum);
-  return NULL;
-}
-
-/* Utility: 
-   parse a list of tracepoint numbers, and call a func for each.  */
-static void
-map_args_over_tracepoints (char *args, int from_tty,
-                          enum tracepoint_opcode opcode)
-{
-  struct tracepoint *t, *tmp;
-
-  if (args == 0 || *args == 0) /* do them all */
-    ALL_TRACEPOINTS_SAFE (t, tmp)
-      tracepoint_operation (t, from_tty, opcode);
-  else
-    while (*args)
-      {
-       QUIT;           /* Give user option to bail out with ^C.  */
-       t = get_tracepoint_by_number (&args, 1, 0);
-       tracepoint_operation (t, from_tty, opcode);
-       while (*args == ' ' || *args == '\t')
-         args++;
-      }
-}
-
-/* The 'enable trace' command enables tracepoints.  
-   Not supported by all targets.  */
-static void
-enable_trace_command (char *args, int from_tty)
-{
-  dont_repeat ();
-  map_args_over_tracepoints (args, from_tty, enable_op);
-}
-
-/* The 'disable trace' command disables tracepoints.  
-   Not supported by all targets.  */
-static void
-disable_trace_command (char *args, int from_tty)
-{
-  dont_repeat ();
-  map_args_over_tracepoints (args, from_tty, disable_op);
-}
-
-/* Remove a tracepoint (or all if no argument) */
-static void
-delete_trace_command (char *args, int from_tty)
-{
-  dont_repeat ();
-  if (!args || !*args)         /* No args implies all tracepoints; */
-    if (from_tty)              /* confirm only if from_tty...  */
-      if (tracepoint_chain)    /* and if there are tracepoints to
-                                  delete!  */
-       if (!query ("Delete all tracepoints? "))
-         return;
-
-  map_args_over_tracepoints (args, from_tty, delete_op);
-}
-
-/* Set passcount for tracepoint.
-
-   First command argument is passcount, second is tracepoint number.
-   If tracepoint number omitted, apply to most recently defined.
-   Also accepts special argument "all".  */
-
-static void
-trace_pass_command (char *args, int from_tty)
-{
-  struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
-  unsigned int count;
-  int all = 0;
-
-  if (args == 0 || *args == 0)
-    error (_("passcount command requires an argument (count + optional TP num)"));
-
-  count = strtoul (args, &args, 10);   /* Count comes first, then TP num. */
-
-  while (*args && isspace ((int) *args))
-    args++;
-
-  if (*args && strncasecmp (args, "all", 3) == 0)
-    {
-      args += 3;                       /* Skip special argument "all".  */
-      all = 1;
-      if (*args)
-       error (_("Junk at end of arguments."));
-    }
-  else
-    t1 = get_tracepoint_by_number (&args, 1, 1);
-
-  do
-    {
-      if (t1)
-       {
-         ALL_TRACEPOINTS (t2)
-           if (t1 == (struct tracepoint *) -1 || t1 == t2)
-             {
-               t2->pass_count = count;
-               tracepoint_modify_event (t2->number);
-               if (from_tty)
-                 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
-                                  t2->number, count);
-             }
-         if (! all && *args)
-           t1 = get_tracepoint_by_number (&args, 1, 0);
-       }
-    }
-  while (*args);
-}
-
 /* ACTIONS functions: */
 
 /* Prototypes for action-parsing utility commands  */
 /* ACTIONS functions: */
 
 /* Prototypes for action-parsing utility commands  */
-static void read_actions (struct tracepoint *);
+static void read_actions (struct breakpoint *);
 
 /* The three functions:
    collect_pseudocommand, 
 
 /* The three functions:
    collect_pseudocommand, 
@@ -765,13 +319,13 @@ static void read_actions (struct tracepoint *);
    it means that somebody issued the "command" at the top level,
    which is always an error.  */
 
    it means that somebody issued the "command" at the top level,
    which is always an error.  */
 
-static void
+void
 end_actions_pseudocommand (char *args, int from_tty)
 {
   error (_("This command cannot be used at the top level."));
 }
 
 end_actions_pseudocommand (char *args, int from_tty)
 {
   error (_("This command cannot be used at the top level."));
 }
 
-static void
+void
 while_stepping_pseudocommand (char *args, int from_tty)
 {
   error (_("This command can only be used in a tracepoint actions list."));
 while_stepping_pseudocommand (char *args, int from_tty)
 {
   error (_("This command can only be used in a tracepoint actions list."));
@@ -787,7 +341,7 @@ collect_pseudocommand (char *args, int from_tty)
 static void
 trace_actions_command (char *args, int from_tty)
 {
 static void
 trace_actions_command (char *args, int from_tty)
 {
-  struct tracepoint *t;
+  struct breakpoint *t;
   char tmpbuf[128];
   char *end_msg = "End with a line saying just \"end\".";
 
   char tmpbuf[128];
   char *end_msg = "End with a line saying just \"end\".";
 
@@ -818,7 +372,7 @@ trace_actions_command (char *args, int from_tty)
 
 /* worker function */
 static void
 
 /* worker function */
 static void
-read_actions (struct tracepoint *t)
+read_actions (struct breakpoint *t)
 {
   char *line;
   char *prompt1 = "> ", *prompt2 = "  > ";
 {
   char *line;
   char *prompt1 = "> ", *prompt2 = "  > ";
@@ -862,7 +416,10 @@ read_actions (struct tracepoint *t)
        line = gdb_readline (0);
 
       if (!line)
        line = gdb_readline (0);
 
       if (!line)
-       line = "end";
+        {
+          line = xstrdup ("end");
+          printf_filtered ("end\n");
+        }
       
       linetype = validate_actionline (&line, t);
       if (linetype == BADLINE)
       
       linetype = validate_actionline (&line, t);
       if (linetype == BADLINE)
@@ -919,7 +476,7 @@ read_actions (struct tracepoint *t)
 
 /* worker function */
 enum actionline_type
 
 /* worker function */
 enum actionline_type
-validate_actionline (char **line, struct tracepoint *t)
+validate_actionline (char **line, struct breakpoint *t)
 {
   struct cmd_list_element *c;
   struct expression *exp = NULL;
 {
   struct cmd_list_element *c;
   struct expression *exp = NULL;
@@ -970,7 +527,7 @@ validate_actionline (char **line, struct tracepoint *t)
                }
              /* else fall thru, treat p as an expression and parse it!  */
            }
                }
              /* else fall thru, treat p as an expression and parse it!  */
            }
-         exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
+         exp = parse_exp_1 (&p, block_for_pc (t->loc->address), 1);
          old_chain = make_cleanup (free_current_contents, &exp);
 
          if (exp->elts[0].opcode == OP_VAR_VALUE)
          old_chain = make_cleanup (free_current_contents, &exp);
 
          if (exp->elts[0].opcode == OP_VAR_VALUE)
@@ -978,14 +535,14 @@ validate_actionline (char **line, struct tracepoint *t)
              if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
                {
                  warning (_("constant %s (value %ld) will not be collected."),
              if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
                {
                  warning (_("constant %s (value %ld) will not be collected."),
-                          DEPRECATED_SYMBOL_NAME (exp->elts[2].symbol),
+                          SYMBOL_PRINT_NAME (exp->elts[2].symbol),
                           SYMBOL_VALUE (exp->elts[2].symbol));
                  return BADLINE;
                }
              else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
                {
                  warning (_("%s is optimized away and cannot be collected."),
                           SYMBOL_VALUE (exp->elts[2].symbol));
                  return BADLINE;
                }
              else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
                {
                  warning (_("%s is optimized away and cannot be collected."),
-                          DEPRECATED_SYMBOL_NAME (exp->elts[2].symbol));
+                          SYMBOL_PRINT_NAME (exp->elts[2].symbol));
                  return BADLINE;
                }
            }
                  return BADLINE;
                }
            }
@@ -993,7 +550,7 @@ validate_actionline (char **line, struct tracepoint *t)
          /* We have something to collect, make sure that the expr to
             bytecode translator can handle it and that it's not too
             long.  */
          /* We have something to collect, make sure that the expr to
             bytecode translator can handle it and that it's not too
             long.  */
-         aexpr = gen_trace_for_expr (t->address, exp);
+         aexpr = gen_trace_for_expr (t->loc->address, exp);
          make_cleanup_free_agent_expr (aexpr);
 
          if (aexpr->len > MAX_AGENT_EXPR_LEN)
          make_cleanup_free_agent_expr (aexpr);
 
          if (aexpr->len > MAX_AGENT_EXPR_LEN)
@@ -1043,7 +600,7 @@ validate_actionline (char **line, struct tracepoint *t)
 
 /* worker function */
 void
 
 /* worker function */
 void
-free_actions (struct tracepoint *t)
+free_actions (struct breakpoint *t)
 {
   struct action_line *line, *next;
 
 {
   struct action_line *line, *next;
 
@@ -1064,14 +621,19 @@ do_free_actions_cleanup (void *t)
 }
 
 static struct cleanup *
 }
 
 static struct cleanup *
-make_cleanup_free_actions (struct tracepoint *t)
+make_cleanup_free_actions (struct breakpoint *t)
 {
   return make_cleanup (do_free_actions_cleanup, t);
 }
 
 {
   return make_cleanup (do_free_actions_cleanup, t);
 }
 
+enum {
+  memrange_absolute = -1
+};
+
 struct memrange
 {
 struct memrange
 {
-  int type;            /* 0 for absolute memory range, else basereg number */
+  int type;            /* memrange_absolute for absolute memory range,
+                           else basereg number */
   bfd_signed_vma start;
   bfd_signed_vma end;
 };
   bfd_signed_vma start;
   bfd_signed_vma end;
 };
@@ -1103,7 +665,7 @@ memrange_cmp (const void *va, const void *vb)
     return -1;
   if (a->type > b->type)
     return 1;
     return -1;
   if (a->type > b->type)
     return 1;
-  if (a->type == 0)
+  if (a->type == memrange_absolute)
     {
       if ((bfd_vma) a->start < (bfd_vma) b->start)
        return -1;
     {
       if ((bfd_vma) a->start < (bfd_vma) b->start)
        return -1;
@@ -1156,7 +718,7 @@ add_register (struct collection_list *collection, unsigned int regno)
 {
   if (info_verbose)
     printf_filtered ("collect register %d\n", regno);
 {
   if (info_verbose)
     printf_filtered ("collect register %d\n", regno);
-  if (regno > (8 * sizeof (collection->regs_mask)))
+  if (regno >= (8 * sizeof (collection->regs_mask)))
     error (_("Internal: register number %d too large for tracepoint"),
           regno);
   collection->regs_mask[regno / 8] |= 1 << (regno % 8);
     error (_("Internal: register number %d too large for tracepoint"),
           regno);
   collection->regs_mask[regno / 8] |= 1 << (regno % 8);
@@ -1175,7 +737,7 @@ add_memrange (struct collection_list *memranges,
       printf_filtered (",%ld)\n", len);
     }
 
       printf_filtered (",%ld)\n", len);
     }
 
-  /* type: -1 == memory, n == basereg */
+  /* type: memrange_absolute == memory, other n == basereg */
   memranges->list[memranges->next_memrange].type = type;
   /* base: addr if memory, offset if reg relative.  */
   memranges->list[memranges->next_memrange].start = base;
   memranges->list[memranges->next_memrange].type = type;
   /* base: addr if memory, offset if reg relative.  */
   memranges->list[memranges->next_memrange].start = base;
@@ -1189,7 +751,7 @@ add_memrange (struct collection_list *memranges,
                                  memranges->listsize);
     }
 
                                  memranges->listsize);
     }
 
-  if (type != -1)              /* Better collect the base register!  */
+  if (type != memrange_absolute)               /* Better collect the base register!  */
     add_register (memranges, type);
 }
 
     add_register (memranges, type);
 }
 
@@ -1208,12 +770,12 @@ collect_symbol (struct collection_list *collect,
     {
     default:
       printf_filtered ("%s: don't know symbol class %d\n",
     {
     default:
       printf_filtered ("%s: don't know symbol class %d\n",
-                      DEPRECATED_SYMBOL_NAME (sym), 
+                      SYMBOL_PRINT_NAME (sym),
                       SYMBOL_CLASS (sym));
       break;
     case LOC_CONST:
       printf_filtered ("constant %s (value %ld) will not be collected.\n",
                       SYMBOL_CLASS (sym));
       break;
     case LOC_CONST:
       printf_filtered ("constant %s (value %ld) will not be collected.\n",
-                      DEPRECATED_SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
+                      SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
       break;
     case LOC_STATIC:
       offset = SYMBOL_VALUE_ADDRESS (sym);
       break;
     case LOC_STATIC:
       offset = SYMBOL_VALUE_ADDRESS (sym);
@@ -1223,17 +785,16 @@ collect_symbol (struct collection_list *collect,
 
          sprintf_vma (tmp, offset);
          printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
 
          sprintf_vma (tmp, offset);
          printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
-                          DEPRECATED_SYMBOL_NAME (sym), len, 
+                          SYMBOL_PRINT_NAME (sym), len,
                           tmp /* address */);
        }
                           tmp /* address */);
        }
-      add_memrange (collect, -1, offset, len); /* 0 == memory */
+      add_memrange (collect, memrange_absolute, offset, len);
       break;
     case LOC_REGISTER:
       break;
     case LOC_REGISTER:
-    case LOC_REGPARM:
       reg = SYMBOL_VALUE (sym);
       if (info_verbose)
        printf_filtered ("LOC_REG[parm] %s: ", 
       reg = SYMBOL_VALUE (sym);
       if (info_verbose)
        printf_filtered ("LOC_REG[parm] %s: ", 
-                        DEPRECATED_SYMBOL_NAME (sym));
+                        SYMBOL_PRINT_NAME (sym));
       add_register (collect, reg);
       /* Check for doubles stored in two registers.  */
       /* FIXME: how about larger types stored in 3 or more regs?  */
       add_register (collect, reg);
       /* Check for doubles stored in two registers.  */
       /* FIXME: how about larger types stored in 3 or more regs?  */
@@ -1244,7 +805,7 @@ collect_symbol (struct collection_list *collect,
     case LOC_REF_ARG:
       printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
       printf_filtered ("       (will not collect %s)\n",
     case LOC_REF_ARG:
       printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
       printf_filtered ("       (will not collect %s)\n",
-                      DEPRECATED_SYMBOL_NAME (sym));
+                      SYMBOL_PRINT_NAME (sym));
       break;
     case LOC_ARG:
       reg = frame_regno;
       break;
     case LOC_ARG:
       reg = frame_regno;
@@ -1252,7 +813,7 @@ collect_symbol (struct collection_list *collect,
       if (info_verbose)
        {
          printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
       if (info_verbose)
        {
          printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
-                          DEPRECATED_SYMBOL_NAME (sym), len);
+                          SYMBOL_PRINT_NAME (sym), len);
          printf_vma (offset);
          printf_filtered (" from frame ptr reg %d\n", reg);
        }
          printf_vma (offset);
          printf_filtered (" from frame ptr reg %d\n", reg);
        }
@@ -1264,45 +825,31 @@ collect_symbol (struct collection_list *collect,
       if (info_verbose)
        {
          printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
       if (info_verbose)
        {
          printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
-                          DEPRECATED_SYMBOL_NAME (sym), len);
+                          SYMBOL_PRINT_NAME (sym), len);
          printf_vma (offset);
          printf_filtered (" from reg %d\n", reg);
        }
       add_memrange (collect, reg, offset, len);
       break;
     case LOC_LOCAL:
          printf_vma (offset);
          printf_filtered (" from reg %d\n", reg);
        }
       add_memrange (collect, reg, offset, len);
       break;
     case LOC_LOCAL:
-    case LOC_LOCAL_ARG:
       reg = frame_regno;
       offset = frame_offset + SYMBOL_VALUE (sym);
       if (info_verbose)
        {
          printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
       reg = frame_regno;
       offset = frame_offset + SYMBOL_VALUE (sym);
       if (info_verbose)
        {
          printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
-                          DEPRECATED_SYMBOL_NAME (sym), len);
+                          SYMBOL_PRINT_NAME (sym), len);
          printf_vma (offset);
          printf_filtered (" from frame ptr reg %d\n", reg);
        }
       add_memrange (collect, reg, offset, len);
       break;
          printf_vma (offset);
          printf_filtered (" from frame ptr reg %d\n", reg);
        }
       add_memrange (collect, reg, offset, len);
       break;
-    case LOC_BASEREG:
-    case LOC_BASEREG_ARG:
-      reg = SYMBOL_BASEREG (sym);
-      offset = SYMBOL_VALUE (sym);
-      if (info_verbose)
-       {
-         printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
-                          DEPRECATED_SYMBOL_NAME (sym), len);
-         printf_vma (offset);
-         printf_filtered (" from basereg %d\n", reg);
-       }
-      add_memrange (collect, reg, offset, len);
-      break;
     case LOC_UNRESOLVED:
       printf_filtered ("Don't know LOC_UNRESOLVED %s\n", 
     case LOC_UNRESOLVED:
       printf_filtered ("Don't know LOC_UNRESOLVED %s\n", 
-                      DEPRECATED_SYMBOL_NAME (sym));
+                      SYMBOL_PRINT_NAME (sym));
       break;
     case LOC_OPTIMIZED_OUT:
       printf_filtered ("%s has been optimized out of existence.\n",
       break;
     case LOC_OPTIMIZED_OUT:
       printf_filtered ("%s has been optimized out of existence.\n",
-                      DEPRECATED_SYMBOL_NAME (sym));
+                      SYMBOL_PRINT_NAME (sym));
       break;
     }
 }
       break;
     }
 }
@@ -1323,34 +870,13 @@ add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
       QUIT;                    /* allow user to bail out with ^C */
       ALL_BLOCK_SYMBOLS (block, iter, sym)
        {
       QUIT;                    /* allow user to bail out with ^C */
       ALL_BLOCK_SYMBOLS (block, iter, sym)
        {
-         switch (SYMBOL_CLASS (sym))
+         if (SYMBOL_IS_ARGUMENT (sym)
+             ? type == 'A'     /* collecting Arguments */
+             : type == 'L')    /* collecting Locals */
            {
            {
-           default:
-             warning (_("don't know how to trace local symbol %s"), 
-                      DEPRECATED_SYMBOL_NAME (sym));
-           case LOC_LOCAL:
-           case LOC_STATIC:
-           case LOC_REGISTER:
-           case LOC_BASEREG:
-             if (type == 'L')  /* collecting Locals */
-               {
-                 count++;
-                 collect_symbol (collect, sym, frame_regno, 
-                                 frame_offset);
-               }
-             break;
-           case LOC_ARG:
-           case LOC_LOCAL_ARG:
-           case LOC_REF_ARG:
-           case LOC_REGPARM:
-           case LOC_REGPARM_ADDR:
-           case LOC_BASEREG_ARG:
-             if (type == 'A')  /* collecting Arguments */
-               {
-                 count++;
-                 collect_symbol (collect, sym, frame_regno, 
-                                 frame_offset);
-               }
+             count++;
+             collect_symbol (collect, sym, frame_regno, 
+                             frame_offset);
            }
        }
       if (BLOCK_FUNCTION (block))
            }
        }
       if (BLOCK_FUNCTION (block))
@@ -1437,10 +963,18 @@ stringify_collection_list (struct collection_list *list, char *string)
          end = temp_buf;
        }
 
          end = temp_buf;
        }
 
-      sprintf (end, "M%X,%s,%lX", 
-              list->list[i].type,
-              tmp2,
-              (long) (list->list[i].end - list->list[i].start));
+      {
+        bfd_signed_vma length = list->list[i].end - list->list[i].start;
+
+        /* The "%X" conversion specifier expects an unsigned argument,
+           so passing -1 (memrange_absolute) to it directly gives you
+           "FFFFFFFF" (or more, depending on sizeof (unsigned)).
+           Special-case it.  */
+        if (list->list[i].type == memrange_absolute)
+          sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
+        else
+          sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
+      }
 
       count += strlen (end);
       end = temp_buf + count;
 
       count += strlen (end);
       end = temp_buf + count;
@@ -1475,7 +1009,10 @@ stringify_collection_list (struct collection_list *list, char *string)
   (*str_list)[ndx] = NULL;
 
   if (ndx == 0)
   (*str_list)[ndx] = NULL;
 
   if (ndx == 0)
-    return NULL;
+    {
+      xfree (str_list);
+      return NULL;
+    }
   else
     return *str_list;
 }
   else
     return *str_list;
 }
@@ -1502,7 +1039,7 @@ free_actions_list (char **actions_list)
 
 /* Render all actions into gdb protocol.  */
 static void
 
 /* Render all actions into gdb protocol.  */
 static void
-encode_actions (struct tracepoint *t, char ***tdp_actions,
+encode_actions (struct breakpoint *t, char ***tdp_actions,
                char ***stepping_actions)
 {
   static char tdp_buff[2048], step_buff[2048];
                char ***stepping_actions)
 {
   static char tdp_buff[2048], step_buff[2048];
@@ -1525,7 +1062,8 @@ encode_actions (struct tracepoint *t, char ***tdp_actions,
   *tdp_actions = NULL;
   *stepping_actions = NULL;
 
   *tdp_actions = NULL;
   *stepping_actions = NULL;
 
-  TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
+  gdbarch_virtual_frame_pointer (current_gdbarch, 
+                                t->loc->address, &frame_reg, &frame_offset);
 
   for (action = t->actions; action; action = action->next)
     {
 
   for (action = t->actions; action; action = action->next)
     {
@@ -1551,14 +1089,14 @@ encode_actions (struct tracepoint *t, char ***tdp_actions,
 
              if (0 == strncasecmp ("$reg", action_exp, 4))
                {
 
              if (0 == strncasecmp ("$reg", action_exp, 4))
                {
-                 for (i = 0; i < NUM_REGS; i++)
+                 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
                    add_register (collect, i);
                  action_exp = strchr (action_exp, ',');        /* more? */
                }
              else if (0 == strncasecmp ("$arg", action_exp, 4))
                {
                  add_local_symbols (collect,
                    add_register (collect, i);
                  action_exp = strchr (action_exp, ',');        /* more? */
                }
              else if (0 == strncasecmp ("$arg", action_exp, 4))
                {
                  add_local_symbols (collect,
-                                    t->address,
+                                    t->loc->address,
                                     frame_reg,
                                     frame_offset,
                                     'A');
                                     frame_reg,
                                     frame_offset,
                                     'A');
@@ -1567,7 +1105,7 @@ encode_actions (struct tracepoint *t, char ***tdp_actions,
              else if (0 == strncasecmp ("$loc", action_exp, 4))
                {
                  add_local_symbols (collect,
              else if (0 == strncasecmp ("$loc", action_exp, 4))
                {
                  add_local_symbols (collect,
-                                    t->address,
+                                    t->loc->address,
                                     frame_reg,
                                     frame_offset,
                                     'L');
                                     frame_reg,
                                     frame_offset,
                                     'L');
@@ -1581,24 +1119,33 @@ encode_actions (struct tracepoint *t, char ***tdp_actions,
                  struct agent_reqs areqs;
 
                  exp = parse_exp_1 (&action_exp, 
                  struct agent_reqs areqs;
 
                  exp = parse_exp_1 (&action_exp, 
-                                    block_for_pc (t->address), 1);
+                                    block_for_pc (t->loc->address), 1);
                  old_chain = make_cleanup (free_current_contents, &exp);
 
                  switch (exp->elts[0].opcode)
                    {
                    case OP_REGISTER:
                  old_chain = make_cleanup (free_current_contents, &exp);
 
                  switch (exp->elts[0].opcode)
                    {
                    case OP_REGISTER:
-                     i = exp->elts[1].longconst;
-                     if (info_verbose)
-                       printf_filtered ("OP_REGISTER: ");
-                     add_register (collect, i);
-                     break;
+                     {
+                       const char *name = &exp->elts[2].string;
+
+                       i = user_reg_map_name_to_regnum (current_gdbarch,
+                                                        name, strlen (name));
+                       if (i == -1)
+                         internal_error (__FILE__, __LINE__,
+                                         _("Register $%s not available"),
+                                         name);
+                       if (info_verbose)
+                         printf_filtered ("OP_REGISTER: ");
+                       add_register (collect, i);
+                       break;
+                     }
 
                    case UNOP_MEMVAL:
                      /* safe because we know it's a simple expression */
                      tempval = evaluate_expression (exp);
                      addr = VALUE_ADDRESS (tempval) + value_offset (tempval);
                      len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
 
                    case UNOP_MEMVAL:
                      /* safe because we know it's a simple expression */
                      tempval = evaluate_expression (exp);
                      addr = VALUE_ADDRESS (tempval) + value_offset (tempval);
                      len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
-                     add_memrange (collect, -1, addr, len);
+                     add_memrange (collect, memrange_absolute, addr, len);
                      break;
 
                    case OP_VAR_VALUE:
                      break;
 
                    case OP_VAR_VALUE:
@@ -1609,7 +1156,7 @@ encode_actions (struct tracepoint *t, char ***tdp_actions,
                      break;
 
                    default:    /* full-fledged expression */
                      break;
 
                    default:    /* full-fledged expression */
-                     aexpr = gen_trace_for_expr (t->address, exp);
+                     aexpr = gen_trace_for_expr (t->loc->address, exp);
 
                      old_chain1 = make_cleanup_free_agent_expr (aexpr);
 
 
                      old_chain1 = make_cleanup_free_agent_expr (aexpr);
 
@@ -1687,7 +1234,8 @@ add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
   collect->next_aexpr_elt++;
 }
 
   collect->next_aexpr_elt++;
 }
 
-static char target_buf[2048];
+static char *target_buf;
+static long target_buf_size;
 
 /* Set "transparent" memory ranges
 
 
 /* Set "transparent" memory ranges
 
@@ -1729,7 +1277,7 @@ remote_set_transparent_ranges (void)
   if (anysecs)
     {
       putpkt (target_buf);
   if (anysecs)
     {
       putpkt (target_buf);
-      getpkt (target_buf, sizeof (target_buf), 0);
+      getpkt (&target_buf, &target_buf_size, 0);
     }
 }
 
     }
 }
 
@@ -1740,99 +1288,41 @@ remote_set_transparent_ranges (void)
    to the target.  If no errors, 
    Tell target to start a new trace experiment.  */
 
    to the target.  If no errors, 
    Tell target to start a new trace experiment.  */
 
+void download_tracepoint (struct breakpoint *t);
+
 static void
 trace_start_command (char *args, int from_tty)
 {
 static void
 trace_start_command (char *args, int from_tty)
 {
-  struct tracepoint *t;
-  char buf[2048];
-  char **tdp_actions;
-  char **stepping_actions;
-  int ndx;
-  struct cleanup *old_chain = NULL;
+  VEC(breakpoint_p) *tp_vec = NULL;
+  int ix;
+  struct breakpoint *t;
 
   dont_repeat ();      /* Like "run", dangerous to repeat accidentally.  */
 
   if (target_is_remote ())
     {
       putpkt ("QTinit");
 
   dont_repeat ();      /* Like "run", dangerous to repeat accidentally.  */
 
   if (target_is_remote ())
     {
       putpkt ("QTinit");
-      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+      remote_get_noisy_reply (&target_buf, &target_buf_size);
       if (strcmp (target_buf, "OK"))
        error (_("Target does not support this command."));
 
       if (strcmp (target_buf, "OK"))
        error (_("Target does not support this command."));
 
-      ALL_TRACEPOINTS (t)
-      {
-       char tmp[40];
-
-       sprintf_vma (tmp, t->address);
-       sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, 
-                tmp, /* address */
-                t->enabled_p ? 'E' : 'D',
-                t->step_count, t->pass_count);
-
-       if (t->actions)
-         strcat (buf, "-");
-       putpkt (buf);
-       remote_get_noisy_reply (target_buf, sizeof (target_buf));
-       if (strcmp (target_buf, "OK"))
-         error (_("Target does not support tracepoints."));
-
-       if (t->actions)
-         {
-           encode_actions (t, &tdp_actions, &stepping_actions);
-           old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
-                                     tdp_actions);
-           (void) make_cleanup (free_actions_list_cleanup_wrapper,
-                                stepping_actions);
-
-           /* do_single_steps (t); */
-           if (tdp_actions)
-             {
-               for (ndx = 0; tdp_actions[ndx]; ndx++)
-                 {
-                   QUIT;       /* allow user to bail out with ^C */
-                   sprintf (buf, "QTDP:-%x:%s:%s%c",
-                            t->number, tmp, /* address */
-                            tdp_actions[ndx],
-                            ((tdp_actions[ndx + 1] || stepping_actions)
-                             ? '-' : 0));
-                   putpkt (buf);
-                   remote_get_noisy_reply (target_buf, 
-                                           sizeof (target_buf));
-                   if (strcmp (target_buf, "OK"))
-                     error (_("Error on target while setting tracepoints."));
-                 }
-             }
-           if (stepping_actions)
-             {
-               for (ndx = 0; stepping_actions[ndx]; ndx++)
-                 {
-                   QUIT;       /* allow user to bail out with ^C */
-                   sprintf (buf, "QTDP:-%x:%s:%s%s%s",
-                            t->number, tmp, /* address */
-                            ((ndx == 0) ? "S" : ""),
-                            stepping_actions[ndx],
-                            (stepping_actions[ndx + 1] ? "-" : ""));
-                   putpkt (buf);
-                   remote_get_noisy_reply (target_buf, 
-                                           sizeof (target_buf));
-                   if (strcmp (target_buf, "OK"))
-                     error (_("Error on target while setting tracepoints."));
-                 }
-             }
+      tp_vec = all_tracepoints ();
+      for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
+       {
+         download_tracepoint (t);
+       }
+      VEC_free (breakpoint_p, tp_vec);
 
 
-           do_cleanups (old_chain);
-         }
-      }
       /* Tell target to treat text-like sections as transparent.  */
       remote_set_transparent_ranges ();
       /* Now insert traps and begin collecting data.  */
       putpkt ("QTStart");
       /* Tell target to treat text-like sections as transparent.  */
       remote_set_transparent_ranges ();
       /* Now insert traps and begin collecting data.  */
       putpkt ("QTStart");
-      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+      remote_get_noisy_reply (&target_buf, &target_buf_size);
       if (strcmp (target_buf, "OK"))
        error (_("Bogus reply from target: %s"), target_buf);
       set_traceframe_num (-1); /* All old traceframes invalidated.  */
       set_tracepoint_num (-1);
       if (strcmp (target_buf, "OK"))
        error (_("Bogus reply from target: %s"), target_buf);
       set_traceframe_num (-1); /* All old traceframes invalidated.  */
       set_tracepoint_num (-1);
-      set_traceframe_context (-1);
+      set_traceframe_context (NULL);
       trace_running_p = 1;
       if (deprecated_trace_start_stop_hook)
        deprecated_trace_start_stop_hook (1, from_tty);
       trace_running_p = 1;
       if (deprecated_trace_start_stop_hook)
        deprecated_trace_start_stop_hook (1, from_tty);
@@ -1842,6 +1332,77 @@ trace_start_command (char *args, int from_tty)
     error (_("Trace can only be run on remote targets."));
 }
 
     error (_("Trace can only be run on remote targets."));
 }
 
+/* Send the definition of a single tracepoint to the target.  */
+
+void
+download_tracepoint (struct breakpoint *t)
+{
+  char tmp[40];
+  char buf[2048];
+  char **tdp_actions;
+  char **stepping_actions;
+  int ndx;
+  struct cleanup *old_chain = NULL;
+
+  sprintf_vma (tmp, (t->loc ? t->loc->address : 0));
+  sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, 
+          tmp, /* address */
+          (t->enable_state == bp_enabled ? 'E' : 'D'),
+          t->step_count, t->pass_count);
+
+  if (t->actions)
+    strcat (buf, "-");
+  putpkt (buf);
+  remote_get_noisy_reply (&target_buf, &target_buf_size);
+  if (strcmp (target_buf, "OK"))
+    error (_("Target does not support tracepoints."));
+
+  if (!t->actions)
+    return;
+
+  encode_actions (t, &tdp_actions, &stepping_actions);
+  old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
+                           tdp_actions);
+  (void) make_cleanup (free_actions_list_cleanup_wrapper, stepping_actions);
+
+  /* do_single_steps (t); */
+  if (tdp_actions)
+    {
+      for (ndx = 0; tdp_actions[ndx]; ndx++)
+       {
+         QUIT; /* allow user to bail out with ^C */
+         sprintf (buf, "QTDP:-%x:%s:%s%c",
+                  t->number, tmp, /* address */
+                  tdp_actions[ndx],
+                  ((tdp_actions[ndx + 1] || stepping_actions)
+                   ? '-' : 0));
+         putpkt (buf);
+         remote_get_noisy_reply (&target_buf,
+                                 &target_buf_size);
+         if (strcmp (target_buf, "OK"))
+           error (_("Error on target while setting tracepoints."));
+       }
+    }
+  if (stepping_actions)
+    {
+      for (ndx = 0; stepping_actions[ndx]; ndx++)
+       {
+         QUIT; /* allow user to bail out with ^C */
+         sprintf (buf, "QTDP:-%x:%s:%s%s%s",
+                  t->number, tmp, /* address */
+                  ((ndx == 0) ? "S" : ""),
+                  stepping_actions[ndx],
+                  (stepping_actions[ndx + 1] ? "-" : ""));
+         putpkt (buf);
+         remote_get_noisy_reply (&target_buf,
+                                 &target_buf_size);
+         if (strcmp (target_buf, "OK"))
+           error (_("Error on target while setting tracepoints."));
+       }
+    }
+  do_cleanups (old_chain);
+}
+
 /* tstop command */
 static void
 trace_stop_command (char *args, int from_tty)
 /* tstop command */
 static void
 trace_stop_command (char *args, int from_tty)
@@ -1849,7 +1410,7 @@ trace_stop_command (char *args, int from_tty)
   if (target_is_remote ())
     {
       putpkt ("QTStop");
   if (target_is_remote ())
     {
       putpkt ("QTStop");
-      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+      remote_get_noisy_reply (&target_buf, &target_buf_size);
       if (strcmp (target_buf, "OK"))
        error (_("Bogus reply from target: %s"), target_buf);
       trace_running_p = 0;
       if (strcmp (target_buf, "OK"))
        error (_("Bogus reply from target: %s"), target_buf);
       trace_running_p = 0;
@@ -1869,7 +1430,7 @@ trace_status_command (char *args, int from_tty)
   if (target_is_remote ())
     {
       putpkt ("qTStatus");
   if (target_is_remote ())
     {
       putpkt ("qTStatus");
-      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+      remote_get_noisy_reply (&target_buf, &target_buf_size);
 
       if (target_buf[0] != 'T' ||
          (target_buf[1] != '0' && target_buf[1] != '1'))
 
       if (target_buf[0] != 'T' ||
          (target_buf[1] != '0' && target_buf[1] != '1'))
@@ -1884,19 +1445,17 @@ trace_status_command (char *args, int from_tty)
 
 /* Worker function for the various flavors of the tfind command.  */
 static void
 
 /* Worker function for the various flavors of the tfind command.  */
 static void
-finish_tfind_command (char *msg,
-                     long sizeof_msg,
+finish_tfind_command (char **msg,
+                     long *sizeof_msg,
                      int from_tty)
 {
   int target_frameno = -1, target_tracept = -1;
                      int from_tty)
 {
   int target_frameno = -1, target_tracept = -1;
-  CORE_ADDR old_frame_addr;
-  struct symbol *old_func;
+  struct frame_id old_frame_id;
   char *reply;
 
   char *reply;
 
-  old_frame_addr = get_frame_base (get_current_frame ());
-  old_func = find_pc_function (read_pc ());
+  old_frame_id = get_frame_id (get_current_frame ());
 
 
-  putpkt (msg);
+  putpkt (*msg);
   reply = remote_get_noisy_reply (msg, sizeof_msg);
 
   while (reply && *reply)
   reply = remote_get_noisy_reply (msg, sizeof_msg);
 
   while (reply && *reply)
@@ -1954,15 +1513,14 @@ finish_tfind_command (char *msg,
        error (_("Bogus reply from target: %s"), reply);
       }
 
        error (_("Bogus reply from target: %s"), reply);
       }
 
-  flush_cached_frames ();
+  reinit_frame_cache ();
   registers_changed ();
   registers_changed ();
-  select_frame (get_current_frame ());
   set_traceframe_num (target_frameno);
   set_tracepoint_num (target_tracept);
   if (target_frameno == -1)
   set_traceframe_num (target_frameno);
   set_tracepoint_num (target_tracept);
   if (target_frameno == -1)
-    set_traceframe_context (-1);
+    set_traceframe_context (NULL);
   else
   else
-    set_traceframe_context (read_pc ());
+    set_traceframe_context (get_current_frame ());
 
   if (from_tty)
     {
 
   if (from_tty)
     {
@@ -1972,18 +1530,10 @@ finish_tfind_command (char *msg,
          whether we have made a transition from one function to
          another.  If so, we'll print the "stack frame" (ie. the new
          function and it's arguments) -- otherwise we'll just show the
          whether we have made a transition from one function to
          another.  If so, we'll print the "stack frame" (ie. the new
          function and it's arguments) -- otherwise we'll just show the
-         new source line.
-
-         This determination is made by checking (1) whether the
-         current function has changed, and (2) whether the current FP
-         has changed.  Hack: if the FP wasn't collected, either at the
-         current or the previous frame, assume that the FP has NOT
-         changed.  */
-
-      if (old_func == find_pc_function (read_pc ()) &&
-         (old_frame_addr == 0 ||
-          get_frame_base (get_current_frame ()) == 0 ||
-          old_frame_addr == get_frame_base (get_current_frame ())))
+         new source line.  */
+
+      if (frame_id_eq (old_frame_id,
+                      get_frame_id (get_current_frame ())))
        print_what = SRC_LINE;
       else
        print_what = SRC_AND_LOC;
        print_what = SRC_LINE;
       else
        print_what = SRC_AND_LOC;
@@ -2041,7 +1591,7 @@ trace_find_command (char *args, int from_tty)
        error (_("invalid input (%d is less than zero)"), frameno);
 
       sprintf (target_buf, "QTFrame:%x", frameno);
        error (_("invalid input (%d is less than zero)"), frameno);
 
       sprintf (target_buf, "QTFrame:%x", frameno);
-      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+      finish_tfind_command (&target_buf, &target_buf_size, from_tty);
     }
   else
     error (_("Trace can only be run on remote targets."));
     }
   else
     error (_("Trace can only be run on remote targets."));
@@ -2078,13 +1628,13 @@ trace_find_pc_command (char *args, int from_tty)
   if (target_is_remote ())
     {
       if (args == 0 || *args == 0)
   if (target_is_remote ())
     {
       if (args == 0 || *args == 0)
-       pc = read_pc ();        /* default is current pc */
+       pc = regcache_read_pc (get_current_regcache ());
       else
        pc = parse_and_eval_address (args);
 
       sprintf_vma (tmp, pc);
       sprintf (target_buf, "QTFrame:pc:%s", tmp);
       else
        pc = parse_and_eval_address (args);
 
       sprintf_vma (tmp, pc);
       sprintf (target_buf, "QTFrame:pc:%s", tmp);
-      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+      finish_tfind_command (&target_buf, &target_buf_size, from_tty);
     }
   else
     error (_("Trace can only be run on remote targets."));
     }
   else
     error (_("Trace can only be run on remote targets."));
@@ -2109,7 +1659,7 @@ trace_find_tracepoint_command (char *args, int from_tty)
        tdp = parse_and_eval_long (args);
 
       sprintf (target_buf, "QTFrame:tdp:%x", tdp);
        tdp = parse_and_eval_long (args);
 
       sprintf (target_buf, "QTFrame:tdp:%x", tdp);
-      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+      finish_tfind_command (&target_buf, &target_buf_size, from_tty);
     }
   else
     error (_("Trace can only be run on remote targets."));
     }
   else
     error (_("Trace can only be run on remote targets."));
@@ -2207,7 +1757,7 @@ trace_find_line_command (char *args, int from_tty)
       else
        sprintf (target_buf, "QTFrame:outside:%s:%s", 
                 startpc_str, endpc_str);
       else
        sprintf (target_buf, "QTFrame:outside:%s:%s", 
                 startpc_str, endpc_str);
-      finish_tfind_command (target_buf, sizeof (target_buf), 
+      finish_tfind_command (&target_buf, &target_buf_size,
                            from_tty);
       do_cleanups (old_chain);
     }
                            from_tty);
       do_cleanups (old_chain);
     }
@@ -2248,7 +1798,7 @@ trace_find_range_command (char *args, int from_tty)
       sprintf_vma (start_str, start);
       sprintf_vma (stop_str, stop);
       sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
       sprintf_vma (start_str, start);
       sprintf_vma (stop_str, stop);
       sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
-      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+      finish_tfind_command (&target_buf, &target_buf_size, from_tty);
     }
   else
     error (_("Trace can only be run on remote targets."));
     }
   else
     error (_("Trace can only be run on remote targets."));
@@ -2287,84 +1837,12 @@ trace_find_outside_command (char *args, int from_tty)
       sprintf_vma (start_str, start);
       sprintf_vma (stop_str, stop);
       sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
       sprintf_vma (start_str, start);
       sprintf_vma (stop_str, stop);
       sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
-      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+      finish_tfind_command (&target_buf, &target_buf_size, from_tty);
     }
   else
     error (_("Trace can only be run on remote targets."));
 }
 
     }
   else
     error (_("Trace can only be run on remote targets."));
 }
 
-/* save-tracepoints command */
-static void
-tracepoint_save_command (char *args, int from_tty)
-{
-  struct tracepoint *tp;
-  struct action_line *line;
-  FILE *fp;
-  char *i1 = "    ", *i2 = "      ";
-  char *indent, *actionline, *pathname;
-  char tmp[40];
-
-  if (args == 0 || *args == 0)
-    error (_("Argument required (file name in which to save tracepoints"));
-
-  if (tracepoint_chain == 0)
-    {
-      warning (_("save-tracepoints: no tracepoints to save."));
-      return;
-    }
-
-  pathname = tilde_expand (args);
-  if (!(fp = fopen (pathname, "w")))
-    error (_("Unable to open file '%s' for saving tracepoints (%s)"),
-          args, safe_strerror (errno));
-  xfree (pathname);
-  
-  ALL_TRACEPOINTS (tp)
-  {
-    if (tp->addr_string)
-      fprintf (fp, "trace %s\n", tp->addr_string);
-    else
-      {
-       sprintf_vma (tmp, tp->address);
-       fprintf (fp, "trace *0x%s\n", tmp);
-      }
-
-    if (tp->pass_count)
-      fprintf (fp, "  passcount %d\n", tp->pass_count);
-
-    if (tp->actions)
-      {
-       fprintf (fp, "  actions\n");
-       indent = i1;
-       for (line = tp->actions; line; line = line->next)
-         {
-           struct cmd_list_element *cmd;
-
-           QUIT;               /* allow user to bail out with ^C */
-           actionline = line->action;
-           while (isspace ((int) *actionline))
-             actionline++;
-
-           fprintf (fp, "%s%s\n", indent, actionline);
-           if (*actionline != '#')     /* skip for comment lines */
-             {
-               cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
-               if (cmd == 0)
-                 error (_("Bad action list item: %s"), actionline);
-               if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
-                 indent = i2;
-               else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
-                 indent = i1;
-             }
-         }
-      }
-  }
-  fclose (fp);
-  if (from_tty)
-    printf_filtered ("Tracepoints saved to file '%s'.\n", args);
-  return;
-}
-
 /* info scope command: list the locals for a scope.  */
 static void
 scope_info (char *args, int from_tty)
 /* info scope command: list the locals for a scope.  */
 static void
 scope_info (char *args, int from_tty)
@@ -2398,7 +1876,7 @@ scope_info (char *args, int from_tty)
            printf_filtered ("Scope for %s:\n", save_args);
          count++;
 
            printf_filtered ("Scope for %s:\n", save_args);
          count++;
 
-         symname = DEPRECATED_SYMBOL_NAME (sym);
+         symname = SYMBOL_PRINT_NAME (sym);
          if (symname == NULL || *symname == '\0')
            continue;           /* probably botched, certainly useless */
 
          if (symname == NULL || *symname == '\0')
            continue;           /* probably botched, certainly useless */
 
@@ -2424,15 +1902,19 @@ scope_info (char *args, int from_tty)
              break;
            case LOC_STATIC:
              printf_filtered ("in static storage at address ");
              break;
            case LOC_STATIC:
              printf_filtered ("in static storage at address ");
-             deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 
-                                    1, gdb_stdout);
+             printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym)));
              break;
            case LOC_REGISTER:
              break;
            case LOC_REGISTER:
-             printf_filtered ("a local variable in register $%s",
-                              REGISTER_NAME (SYMBOL_VALUE (sym)));
+             if (SYMBOL_IS_ARGUMENT (sym))
+               printf_filtered ("an argument in register $%s",
+                                gdbarch_register_name
+                                (current_gdbarch, SYMBOL_VALUE (sym)));
+             else
+               printf_filtered ("a local variable in register $%s",
+                                gdbarch_register_name
+                                (current_gdbarch, SYMBOL_VALUE (sym)));
              break;
            case LOC_ARG:
              break;
            case LOC_ARG:
-           case LOC_LOCAL_ARG:
              printf_filtered ("an argument at stack/frame offset %ld",
                               SYMBOL_VALUE (sym));
              break;
              printf_filtered ("an argument at stack/frame offset %ld",
                               SYMBOL_VALUE (sym));
              break;
@@ -2444,62 +1926,37 @@ scope_info (char *args, int from_tty)
              printf_filtered ("a reference argument at offset %ld",
                               SYMBOL_VALUE (sym));
              break;
              printf_filtered ("a reference argument at offset %ld",
                               SYMBOL_VALUE (sym));
              break;
-           case LOC_REGPARM:
-             printf_filtered ("an argument in register $%s",
-                              REGISTER_NAME (SYMBOL_VALUE (sym)));
-             break;
            case LOC_REGPARM_ADDR:
              printf_filtered ("the address of an argument, in register $%s",
            case LOC_REGPARM_ADDR:
              printf_filtered ("the address of an argument, in register $%s",
-                              REGISTER_NAME (SYMBOL_VALUE (sym)));
+                              gdbarch_register_name
+                                (current_gdbarch, SYMBOL_VALUE (sym)));
              break;
            case LOC_TYPEDEF:
              printf_filtered ("a typedef.\n");
              continue;
            case LOC_LABEL:
              printf_filtered ("a label at address ");
              break;
            case LOC_TYPEDEF:
              printf_filtered ("a typedef.\n");
              continue;
            case LOC_LABEL:
              printf_filtered ("a label at address ");
-             deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 
-                                    1, gdb_stdout);
+             printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym)));
              break;
            case LOC_BLOCK:
              printf_filtered ("a function at address ");
              break;
            case LOC_BLOCK:
              printf_filtered ("a function at address ");
-             deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
-                                    1, gdb_stdout);
-             break;
-           case LOC_BASEREG:
-             printf_filtered ("a variable at offset %ld from register $%s",
-                              SYMBOL_VALUE (sym),
-                              REGISTER_NAME (SYMBOL_BASEREG (sym)));
-             break;
-           case LOC_BASEREG_ARG:
-             printf_filtered ("an argument at offset %ld from register $%s",
-                              SYMBOL_VALUE (sym),
-                              REGISTER_NAME (SYMBOL_BASEREG (sym)));
+             printf_filtered ("%s", paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
              break;
            case LOC_UNRESOLVED:
              break;
            case LOC_UNRESOLVED:
-             msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), 
+             msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
                                            NULL, NULL);
              if (msym == NULL)
                printf_filtered ("Unresolved Static");
              else
                {
                  printf_filtered ("static storage at address ");
                                            NULL, NULL);
              if (msym == NULL)
                printf_filtered ("Unresolved Static");
              else
                {
                  printf_filtered ("static storage at address ");
-                 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
-                                        gdb_stdout);
+                 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (msym)));
                }
              break;
            case LOC_OPTIMIZED_OUT:
              printf_filtered ("optimized out.\n");
              continue;
                }
              break;
            case LOC_OPTIMIZED_OUT:
              printf_filtered ("optimized out.\n");
              continue;
-           case LOC_HP_THREAD_LOCAL_STATIC:
-             printf_filtered ("HP thread local static ");
-             break;
-           case LOC_INDIRECT:
-             printf_filtered ("extern (local indirect) at address ");
-             deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 
-                                    1, gdb_stdout);
-             break;
            case LOC_COMPUTED:
            case LOC_COMPUTED:
-           case LOC_COMPUTED_ARG:
              SYMBOL_OPS (sym)->describe_location (sym, gdb_stdout);
              break;
            }
              SYMBOL_OPS (sym)->describe_location (sym, gdb_stdout);
              break;
            }
@@ -2529,7 +1986,9 @@ replace_comma (void *data)
 static void
 trace_dump_command (char *args, int from_tty)
 {
 static void
 trace_dump_command (char *args, int from_tty)
 {
-  struct tracepoint *t;
+  struct regcache *regcache;
+  struct gdbarch *gdbarch;
+  struct breakpoint *t;
   struct action_line *action;
   char *action_exp, *next_comma;
   struct cleanup *old_cleanups;
   struct action_line *action;
   char *action_exp, *next_comma;
   struct cleanup *old_cleanups;
@@ -2548,9 +2007,7 @@ trace_dump_command (char *args, int from_tty)
       return;
     }
 
       return;
     }
 
-  ALL_TRACEPOINTS (t)
-    if (t->number == tracepoint_number)
-    break;
+  t = get_tracepoint (tracepoint_number);
 
   if (t == NULL)
     error (_("No known tracepoint matches 'current' tracepoint #%d."),
 
   if (t == NULL)
     error (_("No known tracepoint matches 'current' tracepoint #%d."),
@@ -2565,7 +2022,11 @@ trace_dump_command (char *args, int from_tty)
      to the tracepoint PC.  If not, then the current frame was
      collected during single-stepping.  */
 
      to the tracepoint PC.  If not, then the current frame was
      collected during single-stepping.  */
 
-  stepping_frame = (t->address != (read_pc () - DECR_PC_AFTER_BREAK));
+  regcache = get_current_regcache ();
+  gdbarch = get_regcache_arch (regcache);
+
+  stepping_frame = (t->loc->address != (regcache_read_pc (regcache)
+                                  - gdbarch_decr_pc_after_break (gdbarch)));
 
   for (action = t->actions; action; action = action->next)
     {
 
   for (action = t->actions; action; action = action->next)
     {
@@ -2676,16 +2137,9 @@ _initialize_tracepoint (void)
 {
   struct cmd_list_element *c;
 
 {
   struct cmd_list_element *c;
 
-  tracepoint_chain = 0;
-  tracepoint_count = 0;
   traceframe_number = -1;
   tracepoint_number = -1;
 
   traceframe_number = -1;
   tracepoint_number = -1;
 
-  set_internalvar (lookup_internalvar ("tpnum"),
-                  value_from_longest (builtin_type_int, (LONGEST) 0));
-  set_internalvar (lookup_internalvar ("trace_frame"),
-                  value_from_longest (builtin_type_int, (LONGEST) - 1));
-
   if (tracepoint_list.list == NULL)
     {
       tracepoint_list.listsize = 128;
   if (tracepoint_list.list == NULL)
     {
       tracepoint_list.listsize = 128;
@@ -2720,18 +2174,6 @@ _initialize_tracepoint (void)
           _("Tracing of program execution without stopping the program."),
           &cmdlist);
 
           _("Tracing of program execution without stopping the program."),
           &cmdlist);
 
-  add_info ("tracepoints", tracepoints_info, _("\
-Status of tracepoints, or tracepoint number NUMBER.\n\
-Convenience variable \"$tpnum\" contains the number of the\n\
-last tracepoint set."));
-
-  add_info_alias ("tp", "tracepoints", 1);
-
-  c = add_com ("save-tracepoints", class_trace, tracepoint_save_command, _("\
-Save current tracepoint definitions as a script.\n\
-Use the 'source' command in another debug session to restore them."));
-  set_cmd_completer (c, filename_completer);
-
   add_com ("tdump", class_trace, trace_dump_command,
           _("Print everything collected at the current tracepoint."));
 
   add_com ("tdump", class_trace, trace_dump_command,
           _("Print everything collected at the current tracepoint."));
 
@@ -2789,12 +2231,6 @@ De-select any trace frame and resume 'live' debugging."),
   add_com ("tstart", class_trace, trace_start_command,
           _("Start trace data collection."));
 
   add_com ("tstart", class_trace, trace_start_command,
           _("Start trace data collection."));
 
-  add_com ("passcount", class_trace, trace_pass_command, _("\
-Set the passcount for a tracepoint.\n\
-The trace will end when the tracepoint has been passed 'count' times.\n\
-Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
-if TPNUM is omitted, passcount refers to the last tracepoint defined."));
-
   add_com ("end", class_trace, end_actions_pseudocommand, _("\
 Ends a list of commands or actions.\n\
 Several GDB commands allow you to enter a list of commands or actions.\n\
   add_com ("end", class_trace, end_actions_pseudocommand, _("\
 Ends a list of commands or actions.\n\
 Several GDB commands allow you to enter a list of commands or actions.\n\
@@ -2829,34 +2265,6 @@ Tracepoint actions may include collecting of specified data, \n\
 single-stepping, or enabling/disabling other tracepoints, \n\
 depending on target's capabilities."));
 
 single-stepping, or enabling/disabling other tracepoints, \n\
 depending on target's capabilities."));
 
-  add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
-Delete specified tracepoints.\n\
-Arguments are tracepoint numbers, separated by spaces.\n\
-No argument means delete all tracepoints."),
-          &deletelist);
-
-  add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
-Disable specified tracepoints.\n\
-Arguments are tracepoint numbers, separated by spaces.\n\
-No argument means disable all tracepoints."),
-          &disablelist);
-
-  add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
-Enable specified tracepoints.\n\
-Arguments are tracepoint numbers, separated by spaces.\n\
-No argument means enable all tracepoints."),
-          &enablelist);
-
-  c = add_com ("trace", class_trace, trace_command, _("\
-Set a tracepoint at a specified line or function or address.\n\
-Argument may be a line number, function name, or '*' plus an address.\n\
-For a line number or function, trace at the start of its code.\n\
-If an address is specified, trace at that exact address.\n\n\
-Do \"help tracepoints\" for info on other tracepoint commands."));
-  set_cmd_completer (c, location_completer);
-
-  add_com_alias ("tp", "trace", class_alias, 0);
-  add_com_alias ("tr", "trace", class_alias, 1);
-  add_com_alias ("tra", "trace", class_alias, 1);
-  add_com_alias ("trac", "trace", class_alias, 1);
+  target_buf_size = 2048;
+  target_buf = xmalloc (target_buf_size);
 }
 }
This page took 0.046315 seconds and 4 git commands to generate.