Support DWARF 2.1 tags, encodings, languages.

[binutils.git] / gdb / tracepoint.c

diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index b0b2d3324bf4f8a35d0a54cadb436bbf72173fd9..fbe377e02a1f3adbcca1b30f6583f55a26b47e0f 100644 (file)
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -1,26 +1,26 @@
 /* Tracing functionality for remote targets in custom GDB protocol
 /* Tracing functionality for remote targets in custom GDB protocol

-   Copyright 1997, 1998 Free Software Foundation, Inc.
+   Copyright 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.

 
 

-This file is part of GDB.
+   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
-(at your option) any later version.
+   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
+   (at your option) any later version.

 
 

-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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.  */
+   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.  */

 
 #include "defs.h"
 #include "symtab.h"
 #include "frame.h"
 
 #include "defs.h"
 #include "symtab.h"
 #include "frame.h"

-#include "tracepoint.h"

 #include "gdbtypes.h"
 #include "expression.h"
 #include "gdbcmd.h"
 #include "gdbtypes.h"
 #include "expression.h"
 #include "gdbcmd.h"


@@ -28,13 +28,20 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "target.h"
 #include "language.h"
 #include "gdb_string.h"
 #include "target.h"
 #include "language.h"
 #include "gdb_string.h"

+#include "inferior.h"
+#include "tracepoint.h"
+#include "remote.h"
+#include "linespec.h"
+#include "regcache.h"
+#include "completer.h"
+#include "gdb-events.h"

 
 #include "ax.h"
 #include "ax-gdb.h"
 
 /* readline include files */
 
 #include "ax.h"
 #include "ax-gdb.h"
 
 /* readline include files */

-#include "readline.h"
-#include "history.h"
+#include <readline/readline.h>
+#include <readline/history.h>

 
 /* readline defines this.  */
 #undef savestring
 
 /* readline defines this.  */
 #undef savestring


@@ -48,18 +55,27 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    (which includes everything -- including the checksum), and assumes
    the worst case of maximum length for each of the pieces of a
    continuation packet.
    (which includes everything -- including the checksum), and assumes
    the worst case of maximum length for each of the pieces of a
    continuation packet.

-   
+

    NOTE: expressions get mem2hex'ed otherwise this would be twice as
    large.  (400 - 31)/2 == 184 */
 #define MAX_AGENT_EXPR_LEN     184
 
 
 extern int info_verbose;
    NOTE: expressions get mem2hex'ed otherwise this would be twice as
    large.  (400 - 31)/2 == 184 */
 #define MAX_AGENT_EXPR_LEN     184
 
 
 extern int info_verbose;

-extern void (*readline_begin_hook) PARAMS ((char *, ...));
-extern char * (*readline_hook) PARAMS ((char *));
-extern void (*readline_end_hook) PARAMS ((void));
-extern void x_command PARAMS ((char *, int));
-extern int addressprint;               /* Print machine addresses? */
+extern void (*readline_begin_hook) (char *, ...);
+extern char *(*readline_hook) (char *);
+extern void (*readline_end_hook) (void);
+extern void x_command (char *, int);
+extern int addressprint;       /* Print machine addresses? */
+
+/* GDB commands implemented in other modules:
+ */  
+
+extern void output_command (char *, int);
+extern void registers_info (char *, int);
+extern void args_info (char *, int);
+extern void locals_info (char *, int);
+

 
 /* If this definition isn't overridden by the header files, assume
    that isatty and fileno exist on this system.  */
 
 /* If this definition isn't overridden by the header files, assume
    that isatty and fileno exist on this system.  */


@@ -90,7 +106,7 @@ extern int addressprint;             /* Print machine addresses? */
    $trace_line  : source line of trace frame currently being debugged.
    $trace_file  : source file of trace frame currently being debugged.
    $tracepoint  : tracepoint number of trace frame currently being debugged.
    $trace_line  : source line of trace frame currently being debugged.
    $trace_file  : source file of trace frame currently being debugged.
    $tracepoint  : tracepoint number of trace frame currently being debugged.

-   */
+ */

 
 
 /* ======= Important global variables: ======= */
 
 
 /* ======= Important global variables: ======= */


@@ -117,35 +133,42 @@ 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                 PARAMS ((char *, int));
-static void tracepoints_info              PARAMS ((char *, int));
-static void delete_trace_command          PARAMS ((char *, int));
-static void enable_trace_command          PARAMS ((char *, int));
-static void disable_trace_command         PARAMS ((char *, int));
-static void trace_pass_command            PARAMS ((char *, int));
-static void trace_actions_command         PARAMS ((char *, int));
-static void trace_start_command           PARAMS ((char *, int));
-static void trace_stop_command            PARAMS ((char *, int));
-static void trace_status_command          PARAMS ((char *, int));
-static void trace_find_command            PARAMS ((char *, int));
-static void trace_find_pc_command         PARAMS ((char *, int));
-static void trace_find_tracepoint_command PARAMS ((char *, int));
-static void trace_find_line_command       PARAMS ((char *, int));
-static void trace_find_range_command      PARAMS ((char *, int));
-static void trace_find_outside_command    PARAMS ((char *, int));
-static void tracepoint_save_command       PARAMS ((char *, int));
-static void trace_dump_command            PARAMS ((char *, int));
+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_status_command (char *, int);
+static void trace_find_command (char *, int);
+static void trace_find_pc_command (char *, int);
+static void trace_find_tracepoint_command (char *, int);
+static void trace_find_line_command (char *, int);
+static void trace_find_range_command (char *, int);
+static void trace_find_outside_command (char *, int);
+static void tracepoint_save_command (char *, int);
+static void trace_dump_command (char *, int);

 
 /* support routines */
 
 /* support routines */

-static void trace_mention                 PARAMS ((struct tracepoint *));
+static void trace_mention (struct tracepoint *);

 
 struct collection_list;
 
 struct collection_list;

-static void add_aexpr PARAMS ((struct collection_list *, struct agent_expr *));
-static unsigned char *mem2hex(unsigned char *, unsigned char *, int);
+static void add_aexpr (struct collection_list *, struct agent_expr *);
+static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
+static void add_register (struct collection_list *collection,
+                         unsigned int regno);
+static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
+static void free_actions_list (char **actions_list);
+static void free_actions_list_cleanup_wrapper (void *);
+
+extern void _initialize_tracepoint (void);

 
 /* Utility: returns true if "target remote" */
 static int
 
 /* Utility: returns true if "target remote" */
 static int

-target_is_remote ()
+target_is_remote (void)

 {
   if (current_target.to_shortname &&
       strcmp (current_target.to_shortname, "remote") == 0)
 {
   if (current_target.to_shortname &&
       strcmp (current_target.to_shortname, "remote") == 0)


@@ -155,19 +178,18 @@ target_is_remote ()
 }
 
 /* Utility: generate error from an incoming stub packet.  */
 }
 
 /* Utility: generate error from an incoming stub packet.  */

-static void 
-trace_error (buf)
-     char *buf;
+static void
+trace_error (char *buf)

 {
   if (*buf++ != 'E')
     return;                    /* not an error msg */
 {
   if (*buf++ != 'E')
     return;                    /* not an error msg */

-  switch (*buf) 
+  switch (*buf)

     {
     case '1':                  /* malformed packet error */
       if (*++buf == '0')       /*   general case: */
        error ("tracepoint.c: error in outgoing packet.");
       else
     {
     case '1':                  /* malformed packet error */
       if (*++buf == '0')       /*   general case: */
        error ("tracepoint.c: error in outgoing packet.");
       else

-       error ("tracepoint.c: error in outgoing packet at field #%d.", 
+       error ("tracepoint.c: error in outgoing packet at field #%d.",

               strtol (buf, NULL, 16));
     case '2':
       error ("trace API error 0x%s.", ++buf);
               strtol (buf, NULL, 16));
     case '2':
       error ("trace API error 0x%s.", ++buf);


@@ -178,13 +200,13 @@ trace_error (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 (buf)
-     char *buf;
+remote_get_noisy_reply (char *buf,
+                       long sizeof_buf)

 {
 {

-  do   /* loop on reply from remote stub */
+  do                           /* loop on reply from remote stub */

     {
     {

-      QUIT;                            /* allow user to bail out with ^C */
-      getpkt (buf, 0);
+      QUIT;                    /* allow user to bail out with ^C */
+      getpkt (buf, sizeof_buf, 0);

       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')


@@ -193,14 +215,14 @@ remote_get_noisy_reply (buf)
               buf[1] != 'K')
        remote_console_output (buf + 1);        /* 'O' message from stub */
       else
               buf[1] != 'K')
        remote_console_output (buf + 1);        /* 'O' message from stub */
       else

-       return buf;                             /* here's the actual reply */
-    } while (1);
+       return buf;             /* here's the actual reply */
+    }
+  while (1);

 }
 
 /* Set tracepoint count to NUM.  */
 static void
 }
 
 /* Set tracepoint count to NUM.  */
 static void

-set_tracepoint_count (num)
-     int num;
+set_tracepoint_count (int num)

 {
   tracepoint_count = num;
   set_internalvar (lookup_internalvar ("tpnum"),
 {
   tracepoint_count = num;
   set_internalvar (lookup_internalvar ("tpnum"),


@@ -209,8 +231,7 @@ set_tracepoint_count (num)
 
 /* Set traceframe number to NUM.  */
 static void
 
 /* Set traceframe number to NUM.  */
 static void

-set_traceframe_num (num)
-     int num;
+set_traceframe_num (int num)

 {
   traceframe_number = num;
   set_internalvar (lookup_internalvar ("trace_frame"),
 {
   traceframe_number = num;
   set_internalvar (lookup_internalvar ("trace_frame"),


@@ -219,8 +240,7 @@ set_traceframe_num (num)
 
 /* Set tracepoint number to NUM.  */
 static void
 
 /* Set tracepoint number to NUM.  */
 static void

-set_tracepoint_num (num)
-     int num;
+set_tracepoint_num (int num)

 {
   tracepoint_number = num;
   set_internalvar (lookup_internalvar ("tracepoint"),
 {
   tracepoint_number = num;
   set_internalvar (lookup_internalvar ("tracepoint"),


@@ -231,29 +251,28 @@ set_tracepoint_num (num)
    the traceframe context (line, function, file) */
 
 static void
    the traceframe context (line, function, file) */
 
 static void

-set_traceframe_context (trace_pc)
-     CORE_ADDR trace_pc;
+set_traceframe_context (CORE_ADDR trace_pc)

 {
   static struct type *func_string, *file_string;
 {
   static struct type *func_string, *file_string;

-  static struct type *func_range,  *file_range;
-  static value_ptr    func_val,     file_val;
+  static struct type *func_range, *file_range;
+  static value_ptr func_val, file_val;

   static struct type *charstar;
   int len;
 
   if (charstar == (struct type *) NULL)
     charstar = lookup_pointer_type (builtin_type_char);
 
   static struct type *charstar;
   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_pc == -1)          /* cease debugging any trace buffers */

     {
       traceframe_fun = 0;
       traceframe_sal.pc = traceframe_sal.line = 0;
       traceframe_sal.symtab = NULL;
     {
       traceframe_fun = 0;
       traceframe_sal.pc = traceframe_sal.line = 0;
       traceframe_sal.symtab = NULL;

-      set_internalvar (lookup_internalvar ("trace_func"), 
-                      value_from_longest (charstar, (LONGEST) 0));
-      set_internalvar (lookup_internalvar ("trace_file"), 
-                      value_from_longest (charstar, (LONGEST) 0));
+      set_internalvar (lookup_internalvar ("trace_func"),
+                      value_from_pointer (charstar, (LONGEST) 0));
+      set_internalvar (lookup_internalvar ("trace_file"),
+                      value_from_pointer (charstar, (LONGEST) 0));

       set_internalvar (lookup_internalvar ("trace_line"),
       set_internalvar (lookup_internalvar ("trace_line"),

-                      value_from_longest (builtin_type_int, (LONGEST) -1));
+                      value_from_pointer (builtin_type_int, (LONGEST) - 1));

       return;
     }
 
       return;
     }
 


@@ -263,46 +282,46 @@ set_traceframe_context (trace_pc)
 
   /* save linenumber as "$trace_line", a debugger variable visible to users */
   set_internalvar (lookup_internalvar ("trace_line"),
 
   /* 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_int,

                                       (LONGEST) traceframe_sal.line));
 
   /* save func name as "$trace_func", a debugger variable visible to users */
                                       (LONGEST) traceframe_sal.line));
 
   /* save func name as "$trace_func", a debugger variable visible to users */

-  if (traceframe_fun == NULL || 
+  if (traceframe_fun == NULL ||

       SYMBOL_NAME (traceframe_fun) == NULL)
       SYMBOL_NAME (traceframe_fun) == NULL)

-    set_internalvar (lookup_internalvar ("trace_func"), 
-                    value_from_longest (charstar, (LONGEST) 0));
+    set_internalvar (lookup_internalvar ("trace_func"),
+                    value_from_pointer (charstar, (LONGEST) 0));

   else
     {
       len = strlen (SYMBOL_NAME (traceframe_fun));
   else
     {
       len = strlen (SYMBOL_NAME (traceframe_fun));

-      func_range  = create_range_type (func_range,  
-                                      builtin_type_int, 0, len - 1);
-      func_string = create_array_type (func_string, 
+      func_range = create_range_type (func_range,
+                                     builtin_type_int, 0, len - 1);
+      func_string = create_array_type (func_string,

                                       builtin_type_char, func_range);
       func_val = allocate_value (func_string);
       VALUE_TYPE (func_val) = func_string;
                                       builtin_type_char, func_range);
       func_val = allocate_value (func_string);
       VALUE_TYPE (func_val) = func_string;

-      memcpy (VALUE_CONTENTS_RAW (func_val), 
-             SYMBOL_NAME (traceframe_fun), 
+      memcpy (VALUE_CONTENTS_RAW (func_val),
+             SYMBOL_NAME (traceframe_fun),

              len);
       func_val->modifiable = 0;
       set_internalvar (lookup_internalvar ("trace_func"), func_val);
     }
 
   /* save file name as "$trace_file", a debugger variable visible to users */
              len);
       func_val->modifiable = 0;
       set_internalvar (lookup_internalvar ("trace_func"), func_val);
     }
 
   /* save file name as "$trace_file", a debugger variable visible to users */

-  if (traceframe_sal.symtab == NULL || 
+  if (traceframe_sal.symtab == NULL ||

       traceframe_sal.symtab->filename == NULL)
       traceframe_sal.symtab->filename == NULL)

-    set_internalvar (lookup_internalvar ("trace_file"), 
-                    value_from_longest (charstar, (LONGEST) 0));
+    set_internalvar (lookup_internalvar ("trace_file"),
+                    value_from_pointer (charstar, (LONGEST) 0));

   else
     {
       len = strlen (traceframe_sal.symtab->filename);
   else
     {
       len = strlen (traceframe_sal.symtab->filename);

-      file_range  = create_range_type (file_range,  
-                                      builtin_type_int, 0, len - 1);
-      file_string = create_array_type (file_string, 
+      file_range = create_range_type (file_range,
+                                     builtin_type_int, 0, len - 1);
+      file_string = create_array_type (file_string,

                                       builtin_type_char, file_range);
       file_val = allocate_value (file_string);
       VALUE_TYPE (file_val) = file_string;
                                       builtin_type_char, file_range);
       file_val = allocate_value (file_string);
       VALUE_TYPE (file_val) = file_string;

-      memcpy (VALUE_CONTENTS_RAW (file_val), 
-             traceframe_sal.symtab->filename, 
+      memcpy (VALUE_CONTENTS_RAW (file_val),
+             traceframe_sal.symtab->filename,

              len);
       file_val->modifiable = 0;
       set_internalvar (lookup_internalvar ("trace_file"), file_val);
              len);
       file_val->modifiable = 0;
       set_internalvar (lookup_internalvar ("trace_file"), file_val);


@@ -319,30 +338,29 @@ set_traceframe_context (trace_pc)
    your arguments BEFORE calling this routine!  */
 
 static struct tracepoint *
    your arguments BEFORE calling this routine!  */
 
 static struct tracepoint *

-set_raw_tracepoint (sal)
-     struct symtab_and_line sal;
+set_raw_tracepoint (struct symtab_and_line sal)

 {
   register struct tracepoint *t, *tc;
   struct cleanup *old_chain;
 
   t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
 {
   register struct tracepoint *t, *tc;
   struct cleanup *old_chain;
 
   t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));

-  old_chain = make_cleanup (free, t);
+  old_chain = make_cleanup (xfree, t);

   memset (t, 0, sizeof (*t));
   t->address = sal.pc;
   if (sal.symtab == NULL)
     t->source_file = NULL;
   else
   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, 
+    t->source_file = savestring (sal.symtab->filename,

                                 strlen (sal.symtab->filename));
 
                                 strlen (sal.symtab->filename));
 

-  t->section     = sal.section;
-  t->language    = current_language->la_language;
+  t->section = sal.section;
+  t->language = current_language->la_language;

   t->input_radix = input_radix;
   t->line_number = sal.line;
   t->input_radix = input_radix;
   t->line_number = sal.line;

-  t->enabled     = enabled;
-  t->next        = 0;
-  t->step_count  = 0;
-  t->pass_count  = 0;
+  t->enabled = enabled;
+  t->next = 0;
+  t->step_count = 0;
+  t->pass_count = 0;

   t->addr_string = NULL;
 
   /* Add this tracepoint to the end of the chain
   t->addr_string = NULL;
 
   /* Add this tracepoint to the end of the chain


@@ -364,11 +382,9 @@ set_raw_tracepoint (sal)
 
 /* Set a tracepoint according to ARG (function, linenum or *address) */
 static void
 
 /* Set a tracepoint according to ARG (function, linenum or *address) */
 static void

-trace_command (arg, from_tty)
-     char *arg;
-     int from_tty;
+trace_command (char *arg, int from_tty)

 {
 {

-  char **canonical = (char **)NULL;
+  char **canonical = (char **) NULL;

   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
   struct tracepoint *t;
   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
   struct tracepoint *t;


@@ -382,10 +398,10 @@ trace_command (arg, from_tty)
     printf_filtered ("TRACE %s\n", arg);
 
   addr_start = arg;
     printf_filtered ("TRACE %s\n", arg);
 
   addr_start = arg;

-  sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, &canonical);
-  addr_end   = arg;
-  if (! sals.nelts) 
-    return;    /* ??? Presumably decode_line_1 has already warned? */
+  sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical);
+  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 all line numbers to PC's */
   for (i = 0; i < sals.nelts; i++)


@@ -401,17 +417,13 @@ trace_command (arg, from_tty)
       t->number = tracepoint_count;
 
       /* If a canonical line spec is needed use that instead of the
       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)
+         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);
        t->addr_string = canonical[i];
       else if (addr_start)
        t->addr_string = savestring (addr_start, addr_end - addr_start);
 
       trace_mention (t);

-
-      /* Let the UI know of any additions */
-      if (create_tracepoint_hook)
-       create_tracepoint_hook (t);

     }
 
   if (sals.nelts > 1)
     }
 
   if (sals.nelts > 1)


@@ -424,8 +436,7 @@ trace_command (arg, from_tty)
 /* Tell the user we have just set a tracepoint TP. */
 
 static void
 /* Tell the user we have just set a tracepoint TP. */
 
 static void

-trace_mention (tp)
-     struct tracepoint *tp;
+trace_mention (struct tracepoint *tp)

 {
   printf_filtered ("Tracepoint %d", tp->number);
 
 {
   printf_filtered ("Tracepoint %d", tp->number);
 


@@ -444,9 +455,7 @@ trace_mention (tp)
 /* Print information on tracepoint number TPNUM_EXP, or all if omitted.  */
 
 static void
 /* Print information on tracepoint number TPNUM_EXP, or all if omitted.  */
 
 static void

-tracepoints_info (tpnum_exp, from_tty)
-     char *tpnum_exp;
-     int from_tty;
+tracepoints_info (char *tpnum_exp, int from_tty)

 {
   struct tracepoint *t;
   struct action_line *action;
 {
   struct tracepoint *t;
   struct action_line *action;


@@ -456,183 +465,190 @@ tracepoints_info (tpnum_exp, from_tty)
   int tpnum = -1;
 
   if (tpnum_exp)
   int tpnum = -1;
 
   if (tpnum_exp)

-    tpnum = parse_and_eval_address (tpnum_exp);
+    tpnum = parse_and_eval_long (tpnum_exp);

 
   ALL_TRACEPOINTS (t)
     if (tpnum == -1 || tpnum == t->number)
 
   ALL_TRACEPOINTS (t)
     if (tpnum == -1 || tpnum == t->number)

-      {
-       extern int addressprint;        /* print machine addresses? */
+    {
+      extern int addressprint; /* print machine addresses? */

 
 

-       if (!found_a_tracepoint++)
-         {
-           printf_filtered ("Num Enb ");
-           if (addressprint)
-             printf_filtered ("Address    ");
-           printf_filtered ("PassC StepC What\n");
-         }
-       strcpy (wrap_indent, "                           ");
-       if (addressprint)
-         strcat (wrap_indent, "           ");
-
-       printf_filtered ("%-3d %-3s ", t->number, 
-                        t->enabled == enabled ? "y" : "n");
-       if (addressprint)
-         printf_filtered ("%s ", 
-                          local_hex_string_custom ((unsigned long) t->address,
-                                                   "08l"));
-       printf_filtered ("%-5d %-5d ", 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_SOURCE_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, " ");
+      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 ("\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);
-             }
-         }
-      }
+      printf_filtered ("%-3d %-3s ", t->number,
+                      t->enabled == enabled ? "y" : "n");
+      if (addressprint)
+       {
+         char *tmp;
+
+         if (TARGET_ADDR_BIT <= 32)
+           tmp = longest_local_hex_string_custom (t->address
+                                                  & (CORE_ADDR) 0xffffffff, 
+                                                  "08l");
+         else
+           tmp = longest_local_hex_string_custom (t->address, "016l");
+
+         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_SOURCE_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)
   if (!found_a_tracepoint)
     {
       if (tpnum == -1)

-        printf_filtered ("No tracepoints.\n");
+       printf_filtered ("No tracepoints.\n");

       else
       else

-        printf_filtered ("No tracepoint number %d.\n", tpnum);
+       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.
     }
 }
 
 /* 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 
+ */
+enum tracepoint_opcode

 {
 {

-  enable, 
-  disable,
-  delete
+  enable_op,
+  disable_op,
+  delete_op

 };
 
 };
 

-/* This function implements enable, disable and delete. */
+/* This function implements enable, disable and delete commands. */

 static void
 static void

-tracepoint_operation (t, from_tty, opcode)
-     struct tracepoint *t;
-     int from_tty;
-     enum tracepoint_opcode opcode;
+tracepoint_operation (struct tracepoint *t, int from_tty,
+                     enum tracepoint_opcode opcode)

 {
   struct tracepoint *t2;
 
 {
   struct tracepoint *t2;
 

-  switch (opcode) {
-  case enable:
-    t->enabled = enabled;
-    if (modify_tracepoint_hook)
-      modify_tracepoint_hook (t);
-    break;
-  case disable:
-    t->enabled = disabled;
-    if (modify_tracepoint_hook)
-      modify_tracepoint_hook (t);
-    break;
-  case delete:
-    if (tracepoint_chain == t)
-      tracepoint_chain = t->next;
+  if (t == NULL)       /* no tracepoint operand */
+    return;

 
 

-    ALL_TRACEPOINTS (t2)
-      if (t2->next == t)
+  switch (opcode)
+    {
+    case enable_op:
+      t->enabled = enabled;
+      tracepoint_modify_event (t->number);
+      break;
+    case disable_op:
+      t->enabled = disabled;
+      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;
        }
 
          t2->next = t->next;
          break;
        }
 

-    /* Let the UI know of any deletions */
-    if (delete_tracepoint_hook)
-      delete_tracepoint_hook (t);
-
-    if (t->addr_string)
-      free (t->addr_string);
-    if (t->source_file)
-      free (t->source_file);
-    if (t->actions)
-      free_actions (t);
+      if (t->addr_string)
+       xfree (t->addr_string);
+      if (t->source_file)
+       xfree (t->source_file);
+      if (t->actions)
+       free_actions (t);

 
 

-    free (t);
-    break;
-  }
+      xfree (t);
+      break;
+    }

 }
 
 }
 

-/* Utility: parse a tracepoint number and look it up in the list.  */
+/* 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 *
 struct tracepoint *

-get_tracepoint_by_number (arg)
-     char **arg;
+get_tracepoint_by_number (char **arg, int multi_p, int optional_p)

 {
   struct tracepoint *t;
 {
   struct tracepoint *t;

-  char *end, *copy;
-  value_ptr val;

   int tpnum;
   int tpnum;

+  char *instring = arg == NULL ? NULL : *arg;

 
 

-  if (arg == 0)
-    error ("Bad tracepoint argument");
-
-  if (*arg == 0 || **arg == 0) /* empty arg means refer to last tp */
-    tpnum = tracepoint_count;
-  else if (**arg == '$')       /* handle convenience variable */
+  if (arg == NULL || *arg == NULL || ! **arg)

     {
     {

-      /* Make a copy of the name, so we can null-terminate it
-        to pass to lookup_internalvar().  */
-      end = *arg + 1;
-      while (isalnum(*end) || *end == '_')
-       end++;
-      copy = (char *) alloca (end - *arg);
-      strncpy (copy, *arg + 1, (end - *arg - 1));
-      copy[end - *arg - 1] = '\0';
-      *arg = end;
-
-      val = value_of_internalvar (lookup_internalvar (copy));
-      if (TYPE_CODE( VALUE_TYPE (val)) != TYPE_CODE_INT)
-       error ("Convenience variable must have integral type.");
-      tpnum = (int) value_as_long (val);
+      if (optional_p)
+       tpnum = tracepoint_count;
+      else
+       error_no_arg ("tracepoint number");

     }
     }

-  else         /* handle tracepoint number */
+  else
+    tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
+
+  if (tpnum <= 0)

     {
     {

-      tpnum = strtol (*arg, arg, 0);
-      if (tpnum == 0)          /* possible strtol failure */
-       while (**arg && !isspace (**arg))
-         (*arg)++;             /* advance to next white space, if any */
+      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)
   ALL_TRACEPOINTS (t)
     if (t->number == tpnum)

-      {
-       return t;
-      }
+    {
+      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
   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 (args, from_tty, opcode)
-     char *args;
-     int from_tty;
-     enum tracepoint_opcode opcode;
+map_args_over_tracepoints (char *args, int from_tty,
+                          enum tracepoint_opcode opcode)

 {
   struct tracepoint *t, *tmp;
 {
   struct tracepoint *t, *tmp;

-  int tpnum;
-  char *cp;

 
   if (args == 0 || *args == 0) /* do them all */
     ALL_TRACEPOINTS_SAFE (t, tmp)
 
   if (args == 0 || *args == 0) /* do them all */
     ALL_TRACEPOINTS_SAFE (t, tmp)


@@ -640,9 +656,9 @@ map_args_over_tracepoints (args, from_tty, opcode)
   else
     while (*args)
       {
   else
     while (*args)
       {

-       QUIT;           /* give user option to bail out with ^C */
-       if (t = get_tracepoint_by_number (&args))
-         tracepoint_operation (t, from_tty, opcode);
+       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++;
       }
        while (*args == ' ' || *args == '\t')
          args++;
       }


@@ -650,38 +666,32 @@ map_args_over_tracepoints (args, from_tty, opcode)
 
 /* The 'enable trace' command enables tracepoints.  Not supported by all targets.  */
 static void
 
 /* The 'enable trace' command enables tracepoints.  Not supported by all targets.  */
 static void

-enable_trace_command (args, from_tty)
-     char *args;
-     int from_tty;
+enable_trace_command (char *args, int from_tty)

 {
   dont_repeat ();
 {
   dont_repeat ();

-  map_args_over_tracepoints (args, from_tty, enable);
+  map_args_over_tracepoints (args, from_tty, enable_op);

 }
 
 /* The 'disable trace' command enables tracepoints.  Not supported by all targets.  */
 static void
 }
 
 /* The 'disable trace' command enables tracepoints.  Not supported by all targets.  */
 static void

-disable_trace_command (args, from_tty)
-     char *args;
-     int from_tty;
+disable_trace_command (char *args, int from_tty)

 {
   dont_repeat ();
 {
   dont_repeat ();

-  map_args_over_tracepoints (args, from_tty, disable);
+  map_args_over_tracepoints (args, from_tty, disable_op);

 }
 
 /* Remove a tracepoint (or all if no argument) */
 static void
 }
 
 /* Remove a tracepoint (or all if no argument) */
 static void

-delete_trace_command (args, from_tty)
-     char *args;
-     int from_tty;
+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... */
 {
   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 (tracepoint_chain)    /* and if there are tracepoints to delete! */

        if (!query ("Delete all tracepoints? "))
          return;
 
        if (!query ("Delete all tracepoints? "))
          return;
 

-  map_args_over_tracepoints (args, from_tty, delete);
+  map_args_over_tracepoints (args, from_tty, delete_op);

 }
 
 /* Set passcount for tracepoint.
 }
 
 /* Set passcount for tracepoint.


@@ -691,99 +701,92 @@ delete_trace_command (args, from_tty)
    Also accepts special argument "all".  */
 
 static void
    Also accepts special argument "all".  */
 
 static void

-trace_pass_command (args, from_tty)
-     char *args;
-     int from_tty;
+trace_pass_command (char *args, int from_tty)

 {
   struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
 {
   struct tracepoint *t1 = (struct tracepoint *) -1, *t2;

-  unsigned long count;
+  unsigned int count;
+  int all = 0;

 
   if (args == 0 || *args == 0)
 
   if (args == 0 || *args == 0)

-    error ("PASS command requires an argument (count + optional TP num)");
+    error ("passcount command requires an argument (count + optional TP num)");

 
   count = strtoul (args, &args, 10);   /* count comes first, then TP num */
 
 
   count = strtoul (args, &args, 10);   /* count comes first, then TP num */
 

-  while (*args && isspace (*args))
+  while (*args && isspace ((int) *args))

     args++;
 
   if (*args && strncasecmp (args, "all", 3) == 0)
     args++;
 
   if (*args && strncasecmp (args, "all", 3) == 0)

-    args += 3; /* skip special argument "all" */
+    {
+      args += 3;                       /* skip special argument "all" */
+      all = 1;
+      if (*args)
+       error ("Junk at end of arguments.");
+    }

   else
   else

-    t1 = get_tracepoint_by_number (&args);
+    t1 = get_tracepoint_by_number (&args, 1, 1);

 
 

-  if (*args)
-    error ("Junk at end of arguments.");
-
-  if (t1 == NULL)
-    return;    /* error, bad tracepoint number */
-
-  ALL_TRACEPOINTS (t2)
-    if (t1 == (struct tracepoint *) -1 || t1 == t2)
-      {
-       t2->pass_count = count;
-        if (modify_tracepoint_hook)
-          modify_tracepoint_hook (t2);
-       if (from_tty)
-         printf_filtered ("Setting tracepoint %d's passcount to %d\n", 
-                          t2->number, count);
-      }
+  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 PARAMS((struct tracepoint *));
-static char *parse_and_eval_memrange PARAMS ((char *,
-                                             CORE_ADDR, 
-                                             long *,
-                                             bfd_signed_vma *,
-                                             long *));
+static void read_actions (struct tracepoint *);

 
 /* The three functions:
 
 /* The three functions:

-       collect_pseudocommand, 
-       while_stepping_pseudocommand, and 
-       end_actions_pseudocommand
+   collect_pseudocommand, 
+   while_stepping_pseudocommand, and 
+   end_actions_pseudocommand

    are placeholders for "commands" that are actually ONLY to be used
    within a tracepoint action list.  If the actual function is ever called,
    it means that somebody issued the "command" at the top level,
    which is always an error.  */
 
    are placeholders for "commands" that are actually ONLY to be used
    within a tracepoint action list.  If the actual function is ever called,
    it means that somebody issued the "command" at the top level,
    which is always an error.  */
 

-static void 
-end_actions_pseudocommand (args, from_tty)
-     char *args;
-     int from_tty;
+static void
+end_actions_pseudocommand (char *args, int from_tty)

 {
   error ("This command cannot be used at the top level.");
 }
 
 static void
 {
   error ("This command cannot be used at the top level.");
 }
 
 static void

-while_stepping_pseudocommand (args, from_tty)
-     char *args;
-     int from_tty;
+while_stepping_pseudocommand (char *args, int from_tty)

 {
   error ("This command can only be used in a tracepoint actions list.");
 }
 
 static void
 {
   error ("This command can only be used in a tracepoint actions list.");
 }
 
 static void

-collect_pseudocommand (args, from_tty)
-     char *args;
-     int from_tty;
+collect_pseudocommand (char *args, int from_tty)

 {
   error ("This command can only be used in a tracepoint actions list.");
 }
 
 /* Enter a list of actions for a tracepoint.  */
 static void
 {
   error ("This command can only be used in a tracepoint actions list.");
 }
 
 /* Enter a list of actions for a tracepoint.  */
 static void

-trace_actions_command (args, from_tty)
-     char *args;
-     int from_tty;
+trace_actions_command (char *args, int from_tty)

 {
   struct tracepoint *t;
 {
   struct tracepoint *t;

-  char *actions;

   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\".";
 

-  if (t = get_tracepoint_by_number (&args))
+  t = get_tracepoint_by_number (&args, 0, 1);
+  if (t)

     {
       sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
               t->number);
     {
       sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
               t->number);


@@ -802,16 +805,14 @@ trace_actions_command (args, from_tty)
 
       if (readline_end_hook)
        (*readline_end_hook) ();
 
       if (readline_end_hook)
        (*readline_end_hook) ();

-

       /* tracepoints_changed () */
     }
       /* tracepoints_changed () */
     }

-  /* else error, just return; */
+  /* else just return */

 }
 
 /* worker function */
 static void
 }
 
 /* worker function */
 static void

-read_actions (t)
-     struct tracepoint *t;
+read_actions (struct tracepoint *t)

 {
   char *line;
   char *prompt1 = "> ", *prompt2 = "  > ";
 {
   char *line;
   char *prompt1 = "> ", *prompt2 = "  > ";


@@ -826,13 +827,18 @@ read_actions (t)
   immediate_quit++;
 #ifdef STOP_SIGNAL
   if (job_control)
   immediate_quit++;
 #ifdef STOP_SIGNAL
   if (job_control)

-    signal (STOP_SIGNAL, stop_sig);
+    {
+      if (event_loop_p)
+       signal (STOP_SIGNAL, handle_stop_sig);
+      else
+       signal (STOP_SIGNAL, stop_sig);
+    }

 #endif
 #endif

-  old_chain = make_cleanup ((make_cleanup_func) free_actions, (void *) t);
+  old_chain = make_cleanup_free_actions (t);

   while (1)
     {
       /* Make sure that all output has been output.  Some machines may let
   while (1)
     {
       /* Make sure that all output has been output.  Some machines may let

-        you get away with leaving out some of the gdb_flush, but not all.  */
+         you get away with leaving out some of the gdb_flush, but not all.  */

       wrap_here ("");
       gdb_flush (gdb_stdout);
       gdb_flush (gdb_stderr);
       wrap_here ("");
       gdb_flush (gdb_stdout);
       gdb_flush (gdb_stderr);


@@ -842,7 +848,7 @@ read_actions (t)
       else if (instream == stdin && ISATTY (instream))
        {
          line = readline (prompt);
       else if (instream == stdin && ISATTY (instream))
        {
          line = readline (prompt);

-         if (line && *line)            /* add it to command history */
+         if (line && *line)    /* add it to command history */

            add_history (line);
        }
       else
            add_history (line);
        }
       else


@@ -850,7 +856,7 @@ read_actions (t)
 
       linetype = validate_actionline (&line, t);
       if (linetype == BADLINE)
 
       linetype = validate_actionline (&line, t);
       if (linetype == BADLINE)

-       continue;       /* already warned -- collect another line */
+       continue;               /* already warned -- collect another line */

 
       temp = xmalloc (sizeof (struct action_line));
       temp->next = NULL;
 
       temp = xmalloc (sizeof (struct action_line));
       temp->next = NULL;


@@ -865,57 +871,58 @@ read_actions (t)
        }
 
       if (linetype == STEPPING)        /* begin "while-stepping" */
        }
 
       if (linetype == STEPPING)        /* begin "while-stepping" */

-       if (prompt == prompt2)
-         {
-           warning ("Already processing 'while-stepping'");
-           continue;
-         }
-       else
-         prompt = prompt2;     /* change prompt for stepping actions */
+       {
+         if (prompt == prompt2)
+           {
+             warning ("Already processing 'while-stepping'");
+             continue;
+           }
+         else
+           prompt = prompt2;   /* change prompt for stepping actions */
+       }

       else if (linetype == END)
       else if (linetype == END)

-       if (prompt == prompt2)
-         {
-           prompt = prompt1;   /* end of single-stepping actions */
-         }
-       else
-         { /* end of actions */
-           if (t->actions->next == NULL)
-             {
-               /* an "end" all by itself with no other actions means
-                  this tracepoint has no actions.  Discard empty list. */
-               free_actions (t);
-             }
-           break;
-         }
+       {
+         if (prompt == prompt2)
+           {
+             prompt = prompt1; /* end of single-stepping actions */
+           }
+         else
+           {                   /* end of actions */
+             if (t->actions->next == NULL)
+               {
+                 /* an "end" all by itself with no other actions means
+                    this tracepoint has no actions.  Discard empty list. */
+                 free_actions (t);
+               }
+             break;
+           }
+       }

     }
 #ifdef STOP_SIGNAL
   if (job_control)
     signal (STOP_SIGNAL, SIG_DFL);
 #endif
     }
 #ifdef STOP_SIGNAL
   if (job_control)
     signal (STOP_SIGNAL, SIG_DFL);
 #endif

-  immediate_quit = 0;
+  immediate_quit--;

   discard_cleanups (old_chain);
 }
 
 /* worker function */
 enum actionline_type
   discard_cleanups (old_chain);
 }
 
 /* worker function */
 enum actionline_type

-validate_actionline (line, t)
-     char **line;
-     struct tracepoint *t;
+validate_actionline (char **line, struct tracepoint *t)

 {
   struct cmd_list_element *c;
   struct expression *exp = NULL;
 {
   struct cmd_list_element *c;
   struct expression *exp = NULL;

-  value_ptr temp, temp2;

   struct cleanup *old_chain = NULL;
   char *p;
 
   struct cleanup *old_chain = NULL;
   char *p;
 

-  for (p = *line; isspace (*p); )
+  for (p = *line; isspace ((int) *p);)

     p++;
 
   /* symbol lookup etc. */
     p++;
 
   /* symbol lookup etc. */

-  if (*p == '\0')      /* empty line: just prompt for another line. */
+  if (*p == '\0')              /* empty line: just prompt for another line. */

     return BADLINE;
 
     return BADLINE;
 

-  if (*p == '#')       /* comment line */
+  if (*p == '#')               /* comment line */

     return GENERIC;
 
   c = lookup_cmd (&p, cmdlist, "", -1, 1);
     return GENERIC;
 
   c = lookup_cmd (&p, cmdlist, "", -1, 1);


@@ -924,86 +931,86 @@ validate_actionline (line, t)
       warning ("'%s' is not an action that I know, or is ambiguous.", p);
       return BADLINE;
     }
       warning ("'%s' is not an action that I know, or is ambiguous.", p);
       return BADLINE;
     }

-    
+

   if (c->function.cfunc == collect_pseudocommand)
     {
       struct agent_expr *aexpr;
       struct agent_reqs areqs;
 
   if (c->function.cfunc == collect_pseudocommand)
     {
       struct agent_expr *aexpr;
       struct agent_reqs areqs;
 

-      do {                     /* repeat over a comma-separated list */
-       QUIT;                   /* allow user to bail out with ^C */
-       while (isspace (*p))
-         p++;
-
-       if (*p == '$')                  /* look for special pseudo-symbols */
-         {
-           long typecode, size;
-           bfd_signed_vma offset;
+      do
+       {                       /* repeat over a comma-separated list */
+         QUIT;                 /* allow user to bail out with ^C */
+         while (isspace ((int) *p))
+           p++;

 
 

-           if ((0 == strncasecmp ("reg", p + 1, 3)) ||
-               (0 == strncasecmp ("arg", p + 1, 3)) ||
-               (0 == strncasecmp ("loc", p + 1, 3)))
-             {
-               p = strchr (p, ',');
-               continue;
-             }
-           /* else fall thru, treat p as an expression and parse it! */
-         }
-       exp   = parse_exp_1 (&p, block_for_pc (t->address), 1);
-       old_chain = make_cleanup ((make_cleanup_func) free_current_contents, 
-                                  &exp);
-
-       if (exp->elts[0].opcode == OP_VAR_VALUE)
-         if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
+         if (*p == '$')        /* look for special pseudo-symbols */

            {
            {

-             warning ("%s is constant (value %d): will not be collected.",
-                      SYMBOL_NAME (exp->elts[2].symbol),
-                      SYMBOL_VALUE (exp->elts[2].symbol));
-             return BADLINE;
+             if ((0 == strncasecmp ("reg", p + 1, 3)) ||
+                 (0 == strncasecmp ("arg", p + 1, 3)) ||
+                 (0 == strncasecmp ("loc", p + 1, 3)))
+               {
+                 p = strchr (p, ',');
+                 continue;
+               }
+             /* else fall thru, treat p as an expression and parse it! */

            }
            }

-         else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
+         exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
+         old_chain = make_cleanup (free_current_contents, &exp);
+
+         if (exp->elts[0].opcode == OP_VAR_VALUE)

            {
            {

-             warning ("%s is optimized away and cannot be collected.",
-                      SYMBOL_NAME (exp->elts[2].symbol));
-             return BADLINE;
+             if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
+               {
+                 warning ("constant %s (value %ld) will not be collected.",
+                          SYMBOL_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_NAME (exp->elts[2].symbol));
+                 return BADLINE;
+               }

            }
 
            }
 

-       /* we have something to collect, make sure that the expr to
-          bytecode translator can handle it and that it's not too long */
-       aexpr = gen_trace_for_expr(exp);
-       (void) make_cleanup ((make_cleanup_func) free_agent_expr, aexpr);
+         /* we have something to collect, make sure that the expr to
+            bytecode translator can handle it and that it's not too long */
+         aexpr = gen_trace_for_expr (t->address, exp);
+         make_cleanup_free_agent_expr (aexpr);

 
 

-       if (aexpr->len > MAX_AGENT_EXPR_LEN)
-         error ("expression too complicated, try simplifying");
+         if (aexpr->len > MAX_AGENT_EXPR_LEN)
+           error ("expression too complicated, try simplifying");

 
 

-       ax_reqs(aexpr, &areqs);
-       (void) make_cleanup (free, areqs.reg_mask);
+         ax_reqs (aexpr, &areqs);
+         (void) make_cleanup (xfree, areqs.reg_mask);

 
 

-       if (areqs.flaw != agent_flaw_none)
-         error ("malformed expression");
+         if (areqs.flaw != agent_flaw_none)
+           error ("malformed expression");

 
 

-       if (areqs.min_height < 0)
-         error ("gdb: Internal error: expression has min height < 0");
+         if (areqs.min_height < 0)
+           error ("gdb: Internal error: expression has min height < 0");

 
 

-       if (areqs.max_height > 20)
-         error ("expression too complicated, try simplifying");
+         if (areqs.max_height > 20)
+           error ("expression too complicated, try simplifying");

 
 

-       do_cleanups (old_chain);
-      } while (p && *p++ == ',');
+         do_cleanups (old_chain);
+       }
+      while (p && *p++ == ',');

       return GENERIC;
     }
   else if (c->function.cfunc == while_stepping_pseudocommand)
     {
       return GENERIC;
     }
   else if (c->function.cfunc == while_stepping_pseudocommand)
     {

-      char *steparg;   /* in case warning is necessary */
+      char *steparg;           /* in case warning is necessary */

 
 

-      while (isspace (*p))
+      while (isspace ((int) *p))

        p++;
       steparg = p;
 
       if (*p == '\0' ||
          (t->step_count = strtol (p, &p, 0)) == 0)
        {
        p++;
       steparg = p;
 
       if (*p == '\0' ||
          (t->step_count = strtol (p, &p, 0)) == 0)
        {

-         warning ("bad step-count: command ignored.", *line);
+         warning ("'%s': bad step-count; command ignored.", *line);

          return BADLINE;
        }
       return STEPPING;
          return BADLINE;
        }
       return STEPPING;


@@ -1018,85 +1025,98 @@ validate_actionline (line, t)
 }
 
 /* worker function */
 }
 
 /* worker function */

-void 
-free_actions (t)
-     struct tracepoint *t;
+void
+free_actions (struct tracepoint *t)

 {
   struct action_line *line, *next;
 
   for (line = t->actions; line; line = next)
     {
       next = line->next;
 {
   struct action_line *line, *next;
 
   for (line = t->actions; line; line = next)
     {
       next = line->next;

-      if (line->action) 
-       free (line->action);
-      free (line);
+      if (line->action)
+       xfree (line->action);
+      xfree (line);

     }
   t->actions = NULL;
 }
 
     }
   t->actions = NULL;
 }
 

-struct memrange {
+static void
+do_free_actions_cleanup (void *t)
+{
+  free_actions (t);
+}
+
+static struct cleanup *
+make_cleanup_free_actions (struct tracepoint *t)
+{
+  return make_cleanup (do_free_actions_cleanup, t);
+}
+
+struct memrange
+{

   int type;            /* 0 for absolute memory range, else basereg number */
   bfd_signed_vma start;
   bfd_signed_vma end;
 };
 
   int type;            /* 0 for absolute memory range, else basereg number */
   bfd_signed_vma start;
   bfd_signed_vma end;
 };
 

-struct collection_list {
-  unsigned char regs_mask[8];  /* 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;
-  
-} tracepoint_list, stepping_list;
+struct collection_list
+  {
+    unsigned char regs_mask[8];        /* 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;
+
+  }
+tracepoint_list, stepping_list;

 
 /* MEMRANGE functions: */
 
 
 /* MEMRANGE functions: */
 

-static int memrange_cmp PARAMS ((const void *, const void *));
+static int memrange_cmp (const void *, const void *);

 
 /* compare memranges for qsort */
 static int
 
 /* compare memranges for qsort */
 static int

-memrange_cmp (va, vb)
-     const void *va;
-     const void *vb;
+memrange_cmp (const void *va, const void *vb)

 {
   const struct memrange *a = va, *b = vb;
 
   if (a->type < b->type)
     return -1;
   if (a->type > b->type)
 {
   const struct memrange *a = va, *b = vb;
 
   if (a->type < b->type)
     return -1;
   if (a->type > b->type)

-    return  1;
+    return 1;

   if (a->type == 0)
     {
   if (a->type == 0)
     {

-      if ((bfd_vma) a->start  < (bfd_vma) b->start)  return -1;
-      if ((bfd_vma) a->start  > (bfd_vma) b->start)  return  1;
+      if ((bfd_vma) a->start < (bfd_vma) b->start)
+       return -1;
+      if ((bfd_vma) a->start > (bfd_vma) b->start)
+       return 1;

     }
   else
     {
     }
   else
     {

-      if (a->start  < b->start)
+      if (a->start < b->start)

        return -1;
        return -1;

-      if (a->start  > b->start)
-       return  1;
+      if (a->start > b->start)
+       return 1;

     }
   return 0;
 }
 
 /* Sort the memrange list using qsort, and merge adjacent memranges */
 static void
     }
   return 0;
 }
 
 /* Sort the memrange list using qsort, and merge adjacent memranges */
 static void

-memrange_sortmerge (memranges)
-     struct collection_list *memranges;
+memrange_sortmerge (struct collection_list *memranges)

 {
   int a, b;
 
 {
   int a, b;
 

-  qsort (memranges->list, memranges->next_memrange, 
+  qsort (memranges->list, memranges->next_memrange,

         sizeof (struct memrange), memrange_cmp);
   if (memranges->next_memrange > 0)
     {
       for (a = 0, b = 1; b < memranges->next_memrange; b++)
        {
          if (memranges->list[a].type == memranges->list[b].type &&
         sizeof (struct memrange), memrange_cmp);
   if (memranges->next_memrange > 0)
     {
       for (a = 0, b = 1; b < memranges->next_memrange; b++)
        {
          if (memranges->list[a].type == memranges->list[b].type &&

-             memranges->list[b].start - memranges->list[a].end <= 
+             memranges->list[b].start - memranges->list[a].end <=

              MAX_REGISTER_VIRTUAL_SIZE)
            {
              /* memrange b starts before memrange a ends; merge them.  */
              MAX_REGISTER_VIRTUAL_SIZE)
            {
              /* memrange b starts before memrange a ends; merge them.  */


@@ -1106,7 +1126,7 @@ memrange_sortmerge (memranges)
            }
          a++;                  /* next a */
          if (a != b)
            }
          a++;                  /* next a */
          if (a != b)

-           memcpy (&memranges->list[a], &memranges->list[b], 
+           memcpy (&memranges->list[a], &memranges->list[b],

                    sizeof (struct memrange));
        }
       memranges->next_memrange = a + 1;
                    sizeof (struct memrange));
        }
       memranges->next_memrange = a + 1;


@@ -1114,188 +1134,200 @@ memrange_sortmerge (memranges)
 }
 
 /* Add a register to a collection list */
 }
 
 /* Add a register to a collection list */

-void
-add_register (collection, regno)
-     struct collection_list *collection;
-     unsigned long regno;
+static void
+add_register (struct collection_list *collection, unsigned int regno)

 {
   if (info_verbose)
     printf_filtered ("collect register %d\n", regno);
   if (regno > (8 * sizeof (collection->regs_mask)))
     error ("Internal: register number %d too large for tracepoint",
           regno);
 {
   if (info_verbose)
     printf_filtered ("collect register %d\n", regno);
   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);
+  collection->regs_mask[regno / 8] |= 1 << (regno % 8);

 }
 
 /* Add a memrange to a collection list */
 static void
 }
 
 /* Add a memrange to a collection list */
 static void

-add_memrange (memranges, type, base, len)
-     struct collection_list *memranges;
-     int type;
-     bfd_signed_vma base;
-     unsigned long len;
+add_memrange (struct collection_list *memranges, int type, bfd_signed_vma base,
+             unsigned long len)

 {
   if (info_verbose)
 {
   if (info_verbose)

-    printf_filtered ("(%d,0x%x,%d)\n", type, base, len);
+    {
+      printf_filtered ("(%d,", type);
+      printf_vma (base);
+      printf_filtered (",%ld)\n", len);
+    }
+

   /* type: 0 == memory, n == basereg */
   /* type: 0 == memory, n == basereg */

-  memranges->list[memranges->next_memrange].type  = type;
+  memranges->list[memranges->next_memrange].type = type;

   /* base: addr if memory, offset if reg relative. */
   memranges->list[memranges->next_memrange].start = base;
   /* len: we actually save end (base + len) for convenience */
   /* base: addr if memory, offset if reg relative. */
   memranges->list[memranges->next_memrange].start = base;
   /* len: we actually save end (base + len) for convenience */

-  memranges->list[memranges->next_memrange].end   = base + len;
+  memranges->list[memranges->next_memrange].end = base + len;

   memranges->next_memrange++;
   if (memranges->next_memrange >= memranges->listsize)
     {
       memranges->listsize *= 2;
   memranges->next_memrange++;
   if (memranges->next_memrange >= memranges->listsize)
     {
       memranges->listsize *= 2;

-      memranges->list = xrealloc (memranges->list, 
+      memranges->list = xrealloc (memranges->list,

                                  memranges->listsize);
     }
 
                                  memranges->listsize);
     }
 

-  if (type != -1)      /* better collect the base register! */
+  if (type != -1)              /* better collect the base register! */

     add_register (memranges, type);
 }
 
 /* Add a symbol to a collection list */
 static void
     add_register (memranges, type);
 }
 
 /* Add a symbol to a collection list */
 static void

-collect_symbol (collect, sym)
-     struct collection_list *collect;
-     struct symbol *sym;
+collect_symbol (struct collection_list *collect, struct symbol *sym,
+               long frame_regno, long frame_offset)

 {
 {

-  unsigned long  len;
-  unsigned long  reg;
+  unsigned long len;
+  unsigned int reg;

   bfd_signed_vma offset;
 
   bfd_signed_vma offset;
 

-  len  = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
-  switch (SYMBOL_CLASS (sym)) {
-  default:
-    printf_filtered ("%s: don't know symbol class %d\n",
-                    SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
-    break;
-  case LOC_CONST:
-    printf_filtered ("%s is constant, value is %d: will not be collected.\n",
-                    SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
-    break;
-  case LOC_STATIC:
-    offset = SYMBOL_VALUE_ADDRESS (sym); 
-    if (info_verbose)
-      printf_filtered ("LOC_STATIC %s: collect %d bytes at 0x%08x\n",
-                      SYMBOL_NAME (sym), len, offset);
-    add_memrange (collect, -1, offset, len);   /* 0 == memory */
-    break;
-  case LOC_REGISTER:
-  case LOC_REGPARM:
-    reg = SYMBOL_VALUE (sym); 
-    if (info_verbose)
-      printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
-    add_register (collect, reg);
-    /* check for doubles stored in two registers */
-    /* FIXME: how about larger types stored in 3 or more regs? */
-    if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
-       len > REGISTER_RAW_SIZE (reg))
-      add_register (collect, reg + 1);
-    break;
-  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", 
-                    SYMBOL_NAME (sym));
-    break;
-  case LOC_ARG:
-    offset = SYMBOL_VALUE (sym);
-    reg = FP_REGNUM;
-    if (info_verbose)
-      {
-       printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
-                        SYMBOL_NAME (sym), len);
-       printf_filtered (" %d from frame ptr reg %d\n", offset, reg);
-      }
-    add_memrange (collect, reg, offset, len);
-    break;
-  case LOC_REGPARM_ADDR:
-    reg = SYMBOL_VALUE (sym);
-    offset = 0;
-    if (info_verbose)
-      {
-       printf_filtered ("LOC_REGPARM_ADDR %s: Collect %d bytes at offset",
-                        SYMBOL_NAME (sym), len);
-       printf_filtered (" %d from reg %d\n", offset, reg);
-      }
-    add_memrange (collect, reg, offset, len);
-    break;
-  case LOC_LOCAL:
-  case LOC_LOCAL_ARG:
-    offset = SYMBOL_VALUE (sym);
-    reg = FP_REGNUM;
-    if (info_verbose)
-      {
-       printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
-                        SYMBOL_NAME (sym), len);
-       printf_filtered (" %d from frame ptr reg %d\n", offset, 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 %d bytes at offset %d from basereg %d\n", 
-                        SYMBOL_NAME (sym), len, offset, reg);
-      }
-    add_memrange (collect, reg, offset, len);
-    break;
-  case LOC_UNRESOLVED:
-    printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
-    break;
-  case LOC_OPTIMIZED_OUT:
-    printf_filtered ("%s has been optimized out of existance.\n",
-                    SYMBOL_NAME (sym));
-    break;
-  }
+  len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
+  switch (SYMBOL_CLASS (sym))
+    {
+    default:
+      printf_filtered ("%s: don't know symbol class %d\n",
+                      SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
+      break;
+    case LOC_CONST:
+      printf_filtered ("constant %s (value %ld) will not be collected.\n",
+                      SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
+      break;
+    case LOC_STATIC:
+      offset = SYMBOL_VALUE_ADDRESS (sym);
+      if (info_verbose)
+       {
+         char tmp[40];
+
+         sprintf_vma (tmp, offset);
+         printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
+                          SYMBOL_NAME (sym), len, tmp /* address */);
+       }
+      add_memrange (collect, -1, offset, len); /* 0 == memory */
+      break;
+    case LOC_REGISTER:
+    case LOC_REGPARM:
+      reg = SYMBOL_VALUE (sym);
+      if (info_verbose)
+       printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
+      add_register (collect, reg);
+      /* check for doubles stored in two registers */
+      /* FIXME: how about larger types stored in 3 or more regs? */
+      if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
+         len > REGISTER_RAW_SIZE (reg))
+       add_register (collect, reg + 1);
+      break;
+    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",
+                      SYMBOL_NAME (sym));
+      break;
+    case LOC_ARG:
+      reg = frame_regno;
+      offset = frame_offset + SYMBOL_VALUE (sym);
+      if (info_verbose)
+       {
+         printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
+                          SYMBOL_NAME (sym), len);
+         printf_vma (offset);
+         printf_filtered (" from frame ptr reg %d\n", reg);
+       }
+      add_memrange (collect, reg, offset, len);
+      break;
+    case LOC_REGPARM_ADDR:
+      reg = SYMBOL_VALUE (sym);
+      offset = 0;
+      if (info_verbose)
+       {
+         printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
+                          SYMBOL_NAME (sym), len);
+         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 ",
+                          SYMBOL_NAME (sym), len);
+         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 ",
+                          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", SYMBOL_NAME (sym));
+      break;
+    case LOC_OPTIMIZED_OUT:
+      printf_filtered ("%s has been optimized out of existence.\n",
+                      SYMBOL_NAME (sym));
+      break;
+    }

 }
 
 /* Add all locals (or args) symbols to collection list */
 static void
 }
 
 /* Add all locals (or args) symbols to collection list */
 static void

-add_local_symbols (collect, pc, type)
-     struct collection_list *collect;
-     CORE_ADDR pc;
-     int type;
+add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
+                  long frame_regno, long frame_offset, int type)

 {
   struct symbol *sym;
 {
   struct symbol *sym;

-  struct block  *block;
+  struct block *block;

   int i, nsyms, count = 0;
 
   block = block_for_pc (pc);
   while (block != 0)
     {
   int i, nsyms, count = 0;
 
   block = block_for_pc (pc);
   while (block != 0)
     {

-      QUIT;                            /* allow user to bail out with ^C */
+      QUIT;                    /* allow user to bail out with ^C */

       nsyms = BLOCK_NSYMS (block);
       for (i = 0; i < nsyms; i++)
        {
          sym = BLOCK_SYM (block, i);
       nsyms = BLOCK_NSYMS (block);
       for (i = 0; i < nsyms; i++)
        {
          sym = BLOCK_SYM (block, i);

-         switch (SYMBOL_CLASS (sym)) {
-         case LOC_LOCAL:
-         case LOC_STATIC:
-         case LOC_REGISTER:
-         case LOC_BASEREG:
-           if (type == 'L')    /* collecting Locals */
-             {
-               count++;
-               collect_symbol (collect, sym);
-             }
-           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);
-             }
-         }
+         switch (SYMBOL_CLASS (sym))
+           {
+           default:
+             warning ("don't know how to trace local symbol %s", 
+                      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);
+               }
+           }

        }
       if (BLOCK_FUNCTION (block))
        break;
        }
       if (BLOCK_FUNCTION (block))
        break;


@@ -1308,15 +1340,14 @@ add_local_symbols (collect, pc, type)
 
 /* worker function */
 static void
 
 /* worker function */
 static void

-clear_collection_list (list)
-     struct collection_list *list;
+clear_collection_list (struct collection_list *list)

 {
   int ndx;
 
   list->next_memrange = 0;
   for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
     {
 {
   int ndx;
 
   list->next_memrange = 0;
   for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
     {

-      free_agent_expr(list->aexpr_list[ndx]);
+      free_agent_expr (list->aexpr_list[ndx]);

       list->aexpr_list[ndx] = NULL;
     }
   list->next_aexpr_elt = 0;
       list->aexpr_list[ndx] = NULL;
     }
   list->next_aexpr_elt = 0;


@@ -1325,19 +1356,18 @@ clear_collection_list (list)
 
 /* reduce a collection list to string form (for gdb protocol) */
 static char **
 
 /* reduce a collection list to string form (for gdb protocol) */
 static char **

-stringify_collection_list (list, string)
-     struct collection_list *list;
-     char *string;
+stringify_collection_list (struct collection_list *list, char *string)

 {
   char temp_buf[2048];
 {
   char temp_buf[2048];

+  char tmp2[40];

   int count;
   int ndx = 0;
   char *(*str_list)[];
   char *end;
   int count;
   int ndx = 0;
   char *(*str_list)[];
   char *end;

-  long  i;
+  long i;

 
   count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
 
   count = 1 + list->next_memrange + list->next_aexpr_elt + 1;

-  str_list = (char *(*)[])xmalloc(count * sizeof (char *));
+  str_list = (char *(*)[]) xmalloc (count * sizeof (char *));

 
   for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
     if (list->regs_mask[i] != 0)       /* skip leading zeroes in regs_mask */
 
   for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
     if (list->regs_mask[i] != 0)       /* skip leading zeroes in regs_mask */


@@ -1347,16 +1377,16 @@ stringify_collection_list (list, string)
       if (info_verbose)
        printf_filtered ("\nCollecting registers (mask): 0x");
       end = temp_buf;
       if (info_verbose)
        printf_filtered ("\nCollecting registers (mask): 0x");
       end = temp_buf;

-      *end++='R';
+      *end++ = 'R';

       for (; i >= 0; i--)
        {
       for (; i >= 0; i--)
        {

-         QUIT;                         /* allow user to bail out with ^C */
+         QUIT;                 /* allow user to bail out with ^C */

          if (info_verbose)
            printf_filtered ("%02X", list->regs_mask[i]);
          if (info_verbose)
            printf_filtered ("%02X", list->regs_mask[i]);

-         sprintf (end,  "%02X", list->regs_mask[i]);
+         sprintf (end, "%02X", list->regs_mask[i]);

          end += 2;
        }
          end += 2;
        }

-      (*str_list)[ndx] = savestring(temp_buf, end - temp_buf);
+      (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);

       ndx++;
     }
   if (info_verbose)
       ndx++;
     }
   if (info_verbose)


@@ -1366,24 +1396,29 @@ stringify_collection_list (list, string)
   for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
     {
       QUIT;                    /* allow user to bail out with ^C */
   for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
     {
       QUIT;                    /* allow user to bail out with ^C */

+      sprintf_vma (tmp2, list->list[i].start);

       if (info_verbose)
       if (info_verbose)

-       printf_filtered ("(%d, 0x%x, %d)\n", 
-                        list->list[i].type, 
-                        list->list[i].start, 
-                        list->list[i].end - list->list[i].start);
+       {
+         printf_filtered ("(%d, %s, %ld)\n", 
+                          list->list[i].type, 
+                          tmp2, 
+                          (long) (list->list[i].end - list->list[i].start));
+       }

       if (count + 27 > MAX_AGENT_EXPR_LEN)
        {
       if (count + 27 > MAX_AGENT_EXPR_LEN)
        {

-         (*str_list)[ndx] = savestring(temp_buf, count);
+         (*str_list)[ndx] = savestring (temp_buf, count);

          ndx++;
          count = 0;
          end = temp_buf;
        }
          ndx++;
          count = 0;
          end = temp_buf;
        }

-      sprintf (end, "M%X,%X,%X", 
-              list->list[i].type, 
-              list->list[i].start, 
-              list->list[i].end - list->list[i].start);
+
+      sprintf (end, "M%X,%s,%lX", 
+              list->list[i].type,
+              tmp2,
+              (long) (list->list[i].end - list->list[i].start));
+

       count += strlen (end);
       count += strlen (end);

-      end += strlen (end);
+      end += count;

     }
 
   for (i = 0; i < list->next_aexpr_elt; i++)
     }
 
   for (i = 0; i < list->next_aexpr_elt; i++)


@@ -1391,7 +1426,7 @@ stringify_collection_list (list, string)
       QUIT;                    /* allow user to bail out with ^C */
       if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
        {
       QUIT;                    /* allow user to bail out with ^C */
       if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
        {

-         (*str_list)[ndx] = savestring(temp_buf, count);
+         (*str_list)[ndx] = savestring (temp_buf, count);

          ndx++;
          count = 0;
          end = temp_buf;
          ndx++;
          count = 0;
          end = temp_buf;


@@ -1400,13 +1435,13 @@ stringify_collection_list (list, string)
       end += 10;               /* 'X' + 8 hex digits + ',' */
       count += 10;
 
       end += 10;               /* 'X' + 8 hex digits + ',' */
       count += 10;
 

-      end = mem2hex(list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
+      end = mem2hex (list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);

       count += 2 * list->aexpr_list[i]->len;
     }
 
   if (count != 0)
     {
       count += 2 * list->aexpr_list[i]->len;
     }
 
   if (count != 0)
     {

-      (*str_list)[ndx] = savestring(temp_buf, count);
+      (*str_list)[ndx] = savestring (temp_buf, count);

       ndx++;
       count = 0;
       end = temp_buf;
       ndx++;
       count = 0;
       end = temp_buf;


@@ -1419,9 +1454,14 @@ stringify_collection_list (list, string)
     return *str_list;
 }
 
     return *str_list;
 }
 

-void
-free_actions_list(actions_list)
-     char **actions_list;
+static void
+free_actions_list_cleanup_wrapper (void *al)
+{
+  free_actions_list (al);
+}
+
+static void
+free_actions_list (char **actions_list)

 {
   int ndx;
 
 {
   int ndx;
 


@@ -1429,28 +1469,27 @@ free_actions_list(actions_list)
     return;
 
   for (ndx = 0; actions_list[ndx]; ndx++)
     return;
 
   for (ndx = 0; actions_list[ndx]; ndx++)

-    free(actions_list[ndx]);
+    xfree (actions_list[ndx]);

 
 

-  free(actions_list);
+  xfree (actions_list);

 }
 
 /* render all actions into gdb protocol */
 static void
 }
 
 /* render all actions into gdb protocol */
 static void

-encode_actions (t, tdp_actions, stepping_actions)
-     struct tracepoint  *t;
-     char              ***tdp_actions;
-     char              ***stepping_actions;
+encode_actions (struct tracepoint *t, char ***tdp_actions,
+               char ***stepping_actions)

 {
 {

-  static char        tdp_buff[2048], step_buff[2048];
-  char               *action_exp;
-  struct expression  *exp = NULL;
+  static char tdp_buff[2048], step_buff[2048];
+  char *action_exp;
+  struct expression *exp = NULL;

   struct action_line *action;
   struct action_line *action;

-  bfd_signed_vma      offset;
-  long                i;
-  value_ptr           tempval;
-  struct collection_list  *collect;
+  int i;
+  value_ptr tempval;
+  struct collection_list *collect;

   struct cmd_list_element *cmd;
   struct agent_expr *aexpr;
   struct cmd_list_element *cmd;
   struct agent_expr *aexpr;

+  long frame_reg, frame_offset;
+

 
   clear_collection_list (&tracepoint_list);
   clear_collection_list (&stepping_list);
 
   clear_collection_list (&tracepoint_list);
   clear_collection_list (&stepping_list);


@@ -1459,11 +1498,13 @@ encode_actions (t, tdp_actions, stepping_actions)
   *tdp_actions = NULL;
   *stepping_actions = NULL;
 
   *tdp_actions = NULL;
   *stepping_actions = NULL;
 

+  TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
+

   for (action = t->actions; action; action = action->next)
     {
       QUIT;                    /* allow user to bail out with ^C */
       action_exp = action->action;
   for (action = t->actions; action; action = action->next)
     {
       QUIT;                    /* allow user to bail out with ^C */
       action_exp = action->action;

-      while (isspace (*action_exp))
+      while (isspace ((int) *action_exp))

        action_exp++;
 
       if (*action_exp == '#')  /* comment line */
        action_exp++;
 
       if (*action_exp == '#')  /* comment line */


@@ -1475,101 +1516,114 @@ encode_actions (t, tdp_actions, stepping_actions)
 
       if (cmd->function.cfunc == collect_pseudocommand)
        {
 
       if (cmd->function.cfunc == collect_pseudocommand)
        {

-         do {  /* repeat over a comma-separated list */
-           QUIT;               /* allow user to bail out with ^C */
-           while (isspace (*action_exp))
-             action_exp++;
+         do
+           {                   /* repeat over a comma-separated list */
+             QUIT;             /* allow user to bail out with ^C */
+             while (isspace ((int) *action_exp))
+               action_exp++;

 
 

-           if (0 == strncasecmp ("$reg", action_exp, 4))
-             {
-               for (i = 0; i < NUM_REGS; i++)
-                 add_register (collect, i);
-               action_exp = strchr (action_exp, ','); /* more? */
-             }
-           else if (0 == strncasecmp ("$arg", action_exp, 4))
-             {
-               add_local_symbols (collect, t->address, 'A');
-               action_exp = strchr (action_exp, ','); /* more? */
-             }
-           else if (0 == strncasecmp ("$loc", action_exp, 4))
-             {
-               add_local_symbols (collect, t->address, 'L');
-               action_exp = strchr (action_exp, ','); /* more? */
-             }
-           else
-             {
-               unsigned long addr, len;
-               struct cleanup *old_chain = NULL;
-               struct cleanup *old_chain1 = NULL;
-               struct agent_reqs areqs;
-
-               exp = parse_exp_1 (&action_exp, block_for_pc (t->address), 1);
-               old_chain = make_cleanup ((make_cleanup_func) 
-                                          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;
-
-               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);
-                 break;
-
-               case OP_VAR_VALUE:
-                 collect_symbol (collect, exp->elts[2].symbol);
-                 break;
-
-               default:        /* full-fledged expression */
-                 aexpr = gen_trace_for_expr (exp);
-
-                 old_chain1 = make_cleanup ((make_cleanup_func) 
-                                             free_agent_expr, aexpr);
-
-                 ax_reqs (aexpr, &areqs);
-                 if (areqs.flaw != agent_flaw_none)
-                   error ("malformed expression");
-
-                 if (areqs.min_height < 0)
-                   error ("gdb: Internal error: expression has min height < 0");
-                 if (areqs.max_height > 20)
-                   error ("expression too complicated, try simplifying");
-
-                 discard_cleanups (old_chain1);
-                 add_aexpr (collect, aexpr);
-
-                 /* take care of the registers */
-                 if (areqs.reg_mask_len > 0)
-                   {
-                     int ndx1;
-                     int ndx2;
+             if (0 == strncasecmp ("$reg", action_exp, 4))
+               {
+                 for (i = 0; i < NUM_REGS; i++)
+                   add_register (collect, i);
+                 action_exp = strchr (action_exp, ',');        /* more? */
+               }
+             else if (0 == strncasecmp ("$arg", action_exp, 4))
+               {
+                 add_local_symbols (collect,
+                                    t->address,
+                                    frame_reg,
+                                    frame_offset,
+                                    'A');
+                 action_exp = strchr (action_exp, ',');        /* more? */
+               }
+             else if (0 == strncasecmp ("$loc", action_exp, 4))
+               {
+                 add_local_symbols (collect,
+                                    t->address,
+                                    frame_reg,
+                                    frame_offset,
+                                    'L');
+                 action_exp = strchr (action_exp, ',');        /* more? */
+               }
+             else
+               {
+                 unsigned long addr, len;
+                 struct cleanup *old_chain = NULL;
+                 struct cleanup *old_chain1 = NULL;
+                 struct agent_reqs areqs;
+
+                 exp = parse_exp_1 (&action_exp, 
+                                    block_for_pc (t->address), 1);
+                 old_chain = make_cleanup (free_current_contents, &exp);

 
 

-                     for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
+                 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;
+
+                   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);
+                     break;
+
+                   case OP_VAR_VALUE:
+                     collect_symbol (collect,
+                                     exp->elts[2].symbol,
+                                     frame_reg,
+                                     frame_offset);
+                     break;
+
+                   default:    /* full-fledged expression */
+                     aexpr = gen_trace_for_expr (t->address, exp);
+
+                     old_chain1 = make_cleanup_free_agent_expr (aexpr);
+
+                     ax_reqs (aexpr, &areqs);
+                     if (areqs.flaw != agent_flaw_none)
+                       error ("malformed expression");
+
+                     if (areqs.min_height < 0)
+                       error ("gdb: Internal error: expression has min height < 0");
+                     if (areqs.max_height > 20)
+                       error ("expression too complicated, try simplifying");
+
+                     discard_cleanups (old_chain1);
+                     add_aexpr (collect, aexpr);
+
+                     /* take care of the registers */
+                     if (areqs.reg_mask_len > 0)

                        {
                        {

-                         QUIT;         /* allow user to bail out with ^C */
-                         if (areqs.reg_mask[ndx1] != 0)
+                         int ndx1;
+                         int ndx2;
+
+                         for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)

                            {
                            {

-                             /* assume chars have 8 bits */
-                             for (ndx2 = 0; ndx2 < 8; ndx2++)
-                               if (areqs.reg_mask[ndx1] & (1 << ndx2))
-                                 /* it's used -- record it */
-                                 add_register (collect, ndx1 * 8 + ndx2);
+                             QUIT;     /* allow user to bail out with ^C */
+                             if (areqs.reg_mask[ndx1] != 0)
+                               {
+                                 /* assume chars have 8 bits */
+                                 for (ndx2 = 0; ndx2 < 8; ndx2++)
+                                   if (areqs.reg_mask[ndx1] & (1 << ndx2))
+                                     /* it's used -- record it */
+                                     add_register (collect, ndx1 * 8 + ndx2);
+                               }

                            }
                        }
                            }
                        }

-                   }
-                 break;
-               }       /* switch */
-               do_cleanups (old_chain);
-             }         /* do */
-         } while (action_exp && *action_exp++ == ',');
-       }               /* if */
+                     break;
+                   }           /* switch */
+                 do_cleanups (old_chain);
+               }               /* do */
+           }
+         while (action_exp && *action_exp++ == ',');
+       }                       /* if */

       else if (cmd->function.cfunc == while_stepping_pseudocommand)
        {
          collect = &stepping_list;
       else if (cmd->function.cfunc == while_stepping_pseudocommand)
        {
          collect = &stepping_list;


@@ -1579,26 +1633,24 @@ encode_actions (t, tdp_actions, stepping_actions)
          if (collect == &stepping_list)        /* end stepping actions */
            collect = &tracepoint_list;
          else
          if (collect == &stepping_list)        /* end stepping actions */
            collect = &tracepoint_list;
          else

-           break;                      /* end tracepoint actions */
+           break;              /* end tracepoint actions */

        }
        }

-    }                  /* for */
-  memrange_sortmerge (&tracepoint_list); 
-  memrange_sortmerge (&stepping_list); 
+    }                          /* for */
+  memrange_sortmerge (&tracepoint_list);
+  memrange_sortmerge (&stepping_list);

 
 

-  *tdp_actions      = stringify_collection_list (&tracepoint_list, &tdp_buff);
-  *stepping_actions = stringify_collection_list (&stepping_list,   &step_buff);
+  *tdp_actions = stringify_collection_list (&tracepoint_list, tdp_buff);
+  *stepping_actions = stringify_collection_list (&stepping_list, step_buff);

 }
 
 static void
 }
 
 static void

-add_aexpr(collect, aexpr)
-     struct collection_list *collect;
-     struct agent_expr *aexpr;
+add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)

 {
   if (collect->next_aexpr_elt >= collect->aexpr_listsize)
     {
       collect->aexpr_list =
        xrealloc (collect->aexpr_list,
 {
   if (collect->next_aexpr_elt >= collect->aexpr_listsize)
     {
       collect->aexpr_list =
        xrealloc (collect->aexpr_list,

-                 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
+               2 * collect->aexpr_listsize * sizeof (struct agent_expr *));

       collect->aexpr_listsize *= 2;
     }
   collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
       collect->aexpr_listsize *= 2;
     }
   collect->aexpr_list[collect->next_aexpr_elt] = aexpr;


@@ -1624,43 +1676,43 @@ remote_set_transparent_ranges (void)
   int anysecs = 0;
 
   if (!exec_bfd)
   int anysecs = 0;
 
   if (!exec_bfd)

-    return;            /* no information to give. */
+    return;                    /* no information to give. */

 
   strcpy (target_buf, "QTro");
   for (s = exec_bfd->sections; s; s = s->next)
     {
 
   strcpy (target_buf, "QTro");
   for (s = exec_bfd->sections; s; s = s->next)
     {

-      char tmp[40];
+      char tmp1[40], tmp2[40];

 
 

-      if ((s->flags & SEC_LOAD)     == 0 ||
-       /* (s->flags & SEC_CODE)     == 0 || */
+      if ((s->flags & SEC_LOAD) == 0 ||
+      /* (s->flags & SEC_CODE)     == 0 || */

          (s->flags & SEC_READONLY) == 0)
        continue;
 
       anysecs = 1;
          (s->flags & SEC_READONLY) == 0)
        continue;
 
       anysecs = 1;

-      lma  = s->lma;
+      lma = s->lma;

       size = bfd_get_section_size_before_reloc (s);
       size = bfd_get_section_size_before_reloc (s);

-      sprintf (tmp, ":%x,%x", lma, lma + size);
-      strcat (target_buf, tmp);
+      sprintf_vma (tmp1, lma);
+      sprintf_vma (tmp2, lma + size);
+      sprintf (target_buf + strlen (target_buf), 
+              ":%s,%s", tmp1, tmp2);

     }
   if (anysecs)
     {
       putpkt (target_buf);
     }
   if (anysecs)
     {
       putpkt (target_buf);

-      getpkt (target_buf, 0);
+      getpkt (target_buf, sizeof (target_buf), 0);

     }
 }
 
 /* tstart command:
     }
 }
 
 /* tstart command:

- 
+

    Tell target to clear any previous trace experiment.
    Walk the list of tracepoints, and send them (and their actions)
    to the target.  If no errors, 
    Tell target to start a new trace experiment.  */
 
 static void
    Tell target to clear any previous trace experiment.
    Walk the list of tracepoints, and send them (and their actions)
    to the target.  If no errors, 
    Tell target to start a new trace experiment.  */
 
 static void

-trace_start_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM MOSTLY_IMPLEMENTED */
+trace_start_command (char *args, int from_tty)
+{                              /* STUB_COMM MOSTLY_IMPLEMENTED */

   struct tracepoint *t;
   char buf[2048];
   char **tdp_actions;
   struct tracepoint *t;
   char buf[2048];
   char **tdp_actions;


@@ -1668,86 +1720,90 @@ trace_start_command (args, from_tty)
   int ndx;
   struct cleanup *old_chain = NULL;
 
   int ndx;
   struct cleanup *old_chain = NULL;
 

-  dont_repeat ();      /* like "run", dangerous to repeat accidentally */
-  
+  dont_repeat ();              /* like "run", dangerous to repeat accidentally */
+

   if (target_is_remote ())
     {
       putpkt ("QTinit");
   if (target_is_remote ())
     {
       putpkt ("QTinit");

-      remote_get_noisy_reply (target_buf);
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));

       if (strcmp (target_buf, "OK"))
        error ("Target does not support this command.");
 
       ALL_TRACEPOINTS (t)
       if (strcmp (target_buf, "OK"))
        error ("Target does not support this command.");
 
       ALL_TRACEPOINTS (t)

-       {
-         int ss_count;         /* if actions include singlestepping */
-         int disable_mask;     /* ??? */
-         int enable_mask;      /* ??? */
-
-         sprintf (buf, "QTDP:%x:%x:%c:%x:%x", t->number, t->address, 
-                  t->enabled == enabled ? 'E' : 'D', 
-                  t->step_count, t->pass_count);
-
-         if (t->actions)
-           strcat (buf, "-");
-         putpkt (buf);
-         remote_get_noisy_reply (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, tdp_actions);
-             (void) make_cleanup (free_actions_list, stepping_actions);
+      {
+       char tmp[40];

 
 

-             /* 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:%x:%s%c",
-                              t->number, t->address,
-                              tdp_actions[ndx],
-                              ((tdp_actions[ndx+1] || stepping_actions)
-                               ? '-' : 0));
-                     putpkt (buf);
-                     remote_get_noisy_reply (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:%x:%s%s%s",
-                              t->number, t->address,
-                              ((ndx == 0) ? "S" : ""),
-                              stepping_actions[ndx],
-                              (stepping_actions[ndx+1] ? "-" : ""));
-                     putpkt (buf);
-                     remote_get_noisy_reply (target_buf);
-                     if (strcmp (target_buf, "OK"))
-                       error ("Error on target while setting tracepoints.");
-                   }
-               }
+       sprintf_vma (tmp, t->address);
+       sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* address */
+                t->enabled == enabled ? 'E' : 'D',
+                t->step_count, t->pass_count);

 
 

-             do_cleanups (old_chain);
-           }
-       }
+       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.");
+                 }
+             }
+
+           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);
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));

       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 (-1);

       trace_running_p = 1;
       trace_running_p = 1;

+      if (trace_start_stop_hook)
+       trace_start_stop_hook (1, from_tty);
+

     }
   else
     error ("Trace can only be run on remote targets.");
     }
   else
     error ("Trace can only be run on remote targets.");


@@ -1755,17 +1811,17 @@ trace_start_command (args, from_tty)
 
 /* tstop command */
 static void
 
 /* tstop command */
 static void

-trace_stop_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM IS_IMPLEMENTED */
+trace_stop_command (char *args, int from_tty)
+{                              /* STUB_COMM IS_IMPLEMENTED */

   if (target_is_remote ())
     {
       putpkt ("QTStop");
   if (target_is_remote ())
     {
       putpkt ("QTStop");

-      remote_get_noisy_reply (target_buf);
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));

       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;

+      if (trace_start_stop_hook)
+       trace_start_stop_hook (0, from_tty);

     }
   else
     error ("Trace can only be run on remote targets.");
     }
   else
     error ("Trace can only be run on remote targets.");


@@ -1775,14 +1831,12 @@ unsigned long trace_running_p;
 
 /* tstatus command */
 static void
 
 /* tstatus command */
 static void

-trace_status_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM IS_IMPLEMENTED */
+trace_status_command (char *args, int from_tty)
+{                              /* STUB_COMM IS_IMPLEMENTED */

   if (target_is_remote ())
     {
       putpkt ("qTStatus");
   if (target_is_remote ())
     {
       putpkt ("qTStatus");

-      remote_get_noisy_reply (target_buf);
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));

 
       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'))


@@ -1797,9 +1851,9 @@ trace_status_command (args, 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 (msg, from_tty)
-     char *msg;
-     int from_tty;
+finish_tfind_command (char *msg,
+                     long sizeof_msg,
+                     int from_tty)

 {
   int target_frameno = -1, target_tracept = -1;
   CORE_ADDR old_frame_addr;
 {
   int target_frameno = -1, target_tracept = -1;
   CORE_ADDR old_frame_addr;


@@ -1807,63 +1861,64 @@ finish_tfind_command (msg, from_tty)
   char *reply;
 
   old_frame_addr = FRAME_FP (get_current_frame ());
   char *reply;
 
   old_frame_addr = FRAME_FP (get_current_frame ());

-  old_func       = find_pc_function (read_pc ());
+  old_func = find_pc_function (read_pc ());

 
   putpkt (msg);
 
   putpkt (msg);

-  reply = remote_get_noisy_reply (msg);
+  reply = remote_get_noisy_reply (msg, sizeof_msg);

 
   while (reply && *reply)
 
   while (reply && *reply)

-    switch (*reply) {
-    case 'F':
-      if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1)
-       { 
-         /* A request for a non-existant trace frame has failed.
-            Our response will be different, depending on FROM_TTY:
-
-            If FROM_TTY is true, meaning that this command was 
-            typed interactively by the user, then give an error
-            and DO NOT change the state of traceframe_number etc.
-
-            However if FROM_TTY is false, meaning that we're either
-            in a script, a loop, or a user-defined command, then 
-            DON'T give an error, but DO change the state of
-            traceframe_number etc. to invalid.
-
-            The rationalle is that if you typed the command, you
-            might just have committed a typo or something, and you'd
-            like to NOT lose your current debugging state.  However
-            if you're in a user-defined command or especially in a
-            loop, then you need a way to detect that the command
-            failed WITHOUT aborting.  This allows you to write
-            scripts that search thru the trace buffer until the end,
-            and then continue on to do something else.  */
-
-         if (from_tty)
-           error ("Target failed to find requested trace frame.");
-         else
-           {
-             if (info_verbose)
-               printf_filtered ("End of trace buffer.\n");
-             /* The following will not recurse, since it's special-cased */
-             trace_find_command ("-1", from_tty);
-             reply = NULL;     /* break out of loop, 
+    switch (*reply)
+      {
+      case 'F':
+       if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1)
+         {
+           /* A request for a non-existant trace frame has failed.
+              Our response will be different, depending on FROM_TTY:
+
+              If FROM_TTY is true, meaning that this command was 
+              typed interactively by the user, then give an error
+              and DO NOT change the state of traceframe_number etc.
+
+              However if FROM_TTY is false, meaning that we're either
+              in a script, a loop, or a user-defined command, then 
+              DON'T give an error, but DO change the state of
+              traceframe_number etc. to invalid.
+
+              The rationalle is that if you typed the command, you
+              might just have committed a typo or something, and you'd
+              like to NOT lose your current debugging state.  However
+              if you're in a user-defined command or especially in a
+              loop, then you need a way to detect that the command
+              failed WITHOUT aborting.  This allows you to write
+              scripts that search thru the trace buffer until the end,
+              and then continue on to do something else.  */
+
+           if (from_tty)
+             error ("Target failed to find requested trace frame.");
+           else
+             {
+               if (info_verbose)
+                 printf_filtered ("End of trace buffer.\n");
+               /* The following will not recurse, since it's special-cased */
+               trace_find_command ("-1", from_tty);
+               reply = NULL;   /* break out of loop, 

                                   (avoid recursive nonsense) */
                                   (avoid recursive nonsense) */

-           }
-       }
-      break;
-    case 'T':
-      if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
-       error ("Target failed to find requested trace frame.");
-      break;
-    case 'O':  /* "OK"? */
-      if (reply[1] == 'K' && reply[2] == '\0')
-       reply += 2;
-      else
+             }
+         }
+       break;
+      case 'T':
+       if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
+         error ("Target failed to find requested trace frame.");
+       break;
+      case 'O':                /* "OK"? */
+       if (reply[1] == 'K' && reply[2] == '\0')
+         reply += 2;
+       else
+         error ("Bogus reply from target: %s", reply);
+       break;
+      default:

        error ("Bogus reply from target: %s", reply);
        error ("Bogus reply from target: %s", reply);

-      break;
-    default:
-      error ("Bogus reply from target: %s", reply);
-    }
+      }

 
   flush_cached_frames ();
   registers_changed ();
 
   flush_cached_frames ();
   registers_changed ();


@@ -1880,22 +1935,22 @@ finish_tfind_command (msg, from_tty)
       int source_only;
 
       /* NOTE: in immitation of the step command, try to determine
       int source_only;
 
       /* NOTE: in immitation of the step command, try to determine

-        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 ||
-         FRAME_FP (get_current_frame ()) == 0 ||
-         old_frame_addr == FRAME_FP (get_current_frame ())))
+         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 ||
+          FRAME_FP (get_current_frame ()) == 0 ||
+          old_frame_addr == FRAME_FP (get_current_frame ())))

        source_only = -1;
       else
        source_only = -1;
       else

-       source_only =  1;
+       source_only = 1;

 
       print_stack_frame (selected_frame, selected_frame_level, source_only);
       do_displays ();
 
       print_stack_frame (selected_frame, selected_frame_level, source_only);
       do_displays ();


@@ -1912,27 +1967,24 @@ finish_tfind_command (msg, from_tty)
    target does not give us a frame number or a tracepoint number).
    Instead of that, the target may send us a string containing
    any combination of:
    target does not give us a frame number or a tracepoint number).
    Instead of that, the target may send us a string containing
    any combination of:

-       F<hexnum>       (gives the selected frame number)
-       T<hexnum>       (gives the selected tracepoint number)
-   */
+   F<hexnum>    (gives the selected frame number)
+   T<hexnum>    (gives the selected tracepoint number)
+ */

 
 /* tfind command */
 static void
 
 /* tfind command */
 static void

-trace_find_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+trace_find_command (char *args, int from_tty)
+{                              /* STUB_COMM PART_IMPLEMENTED */

   /* this should only be called with a numeric argument */
   int frameno = -1;
   /* this should only be called with a numeric argument */
   int frameno = -1;

-  char *tmp;

 
   if (target_is_remote ())
     {
       if (trace_find_hook)
 
   if (target_is_remote ())
     {
       if (trace_find_hook)

-       trace_find_hook (args, from_tty);  
-      
+       trace_find_hook (args, from_tty);
+

       if (args == 0 || *args == 0)
       if (args == 0 || *args == 0)

-       { /* TFIND with no args means find NEXT trace frame. */
+       {                       /* TFIND with no args means find NEXT trace frame. */

          if (traceframe_number == -1)
            frameno = 0;        /* "next" is first one */
          else
          if (traceframe_number == -1)
            frameno = 0;        /* "next" is first one */
          else


@@ -1948,13 +2000,13 @@ trace_find_command (args, from_tty)
          frameno = traceframe_number - 1;
        }
       else
          frameno = traceframe_number - 1;
        }
       else

-       frameno = parse_and_eval_address (args);
+       frameno = parse_and_eval_long (args);

 
       if (frameno < -1)
        error ("invalid input (%d is less than zero)", frameno);
 
       sprintf (target_buf, "QTFrame:%x", frameno);
 
       if (frameno < -1)
        error ("invalid input (%d is less than zero)", frameno);
 
       sprintf (target_buf, "QTFrame:%x", frameno);

-      finish_tfind_command (target_buf, from_tty);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);

     }
   else
     error ("Trace can only be run on remote targets.");
     }
   else
     error ("Trace can only be run on remote targets.");


@@ -1962,39 +2014,31 @@ trace_find_command (args, from_tty)
 
 /* tfind end */
 static void
 
 /* tfind end */
 static void

-trace_find_end_command (args, from_tty)
-     char *args;
-     int from_tty;
+trace_find_end_command (char *args, int from_tty)

 {
   trace_find_command ("-1", from_tty);
 }
 
 /* tfind none */
 static void
 {
   trace_find_command ("-1", from_tty);
 }
 
 /* tfind none */
 static void

-trace_find_none_command (args, from_tty)
-     char *args;
-     int from_tty;
+trace_find_none_command (char *args, int from_tty)

 {
   trace_find_command ("-1", from_tty);
 }
 
 /* tfind start */
 static void
 {
   trace_find_command ("-1", from_tty);
 }
 
 /* tfind start */
 static void

-trace_find_start_command (args, from_tty)
-     char *args;
-     int from_tty;
+trace_find_start_command (char *args, int from_tty)

 {
   trace_find_command ("0", from_tty);
 }
 
 /* tfind pc command */
 static void
 {
   trace_find_command ("0", from_tty);
 }
 
 /* tfind pc command */
 static void

-trace_find_pc_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+trace_find_pc_command (char *args, int from_tty)
+{                              /* STUB_COMM PART_IMPLEMENTED */

   CORE_ADDR pc;
   CORE_ADDR pc;

-  char *tmp;
+  char tmp[40];

 
   if (target_is_remote ())
     {
 
   if (target_is_remote ())
     {


@@ -2003,8 +2047,9 @@ trace_find_pc_command (args, from_tty)
       else
        pc = parse_and_eval_address (args);
 
       else
        pc = parse_and_eval_address (args);
 

-      sprintf (target_buf, "QTFrame:pc:%x", pc);
-      finish_tfind_command (target_buf, from_tty);
+      sprintf_vma (tmp, pc);
+      sprintf (target_buf, "QTFrame:pc:%s", tmp);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);

     }
   else
     error ("Trace can only be run on remote targets.");
     }
   else
     error ("Trace can only be run on remote targets.");


@@ -2012,12 +2057,9 @@ trace_find_pc_command (args, from_tty)
 
 /* tfind tracepoint command */
 static void
 
 /* tfind tracepoint command */
 static void

-trace_find_tracepoint_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+trace_find_tracepoint_command (char *args, int from_tty)
+{                              /* STUB_COMM PART_IMPLEMENTED */

   int tdp;
   int tdp;

-  char buf[40], *tmp;

 
   if (target_is_remote ())
     {
 
   if (target_is_remote ())
     {


@@ -2027,33 +2069,31 @@ trace_find_tracepoint_command (args, from_tty)
        else
          tdp = tracepoint_number;      /* default is current TDP */
       else
        else
          tdp = tracepoint_number;      /* default is current TDP */
       else

-       tdp = parse_and_eval_address (args);
+       tdp = parse_and_eval_long (args);

 
       sprintf (target_buf, "QTFrame:tdp:%x", tdp);
 
       sprintf (target_buf, "QTFrame:tdp:%x", tdp);

-      finish_tfind_command (target_buf, from_tty);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);

     }
   else
     error ("Trace can only be run on remote targets.");
 }
 
 /* TFIND LINE command:
     }
   else
     error ("Trace can only be run on remote targets.");
 }
 
 /* TFIND LINE command:

- 
+

    This command will take a sourceline for argument, just like BREAK
    or TRACE (ie. anything that "decode_line_1" can handle).  
    This command will take a sourceline for argument, just like BREAK
    or TRACE (ie. anything that "decode_line_1" can handle).  

-   
+

    With no argument, this command will find the next trace frame 
    corresponding to a source line OTHER THAN THE CURRENT ONE.  */
 
 static void
    With no argument, this command will find the next trace frame 
    corresponding to a source line OTHER THAN THE CURRENT ONE.  */
 
 static void

-trace_find_line_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+trace_find_line_command (char *args, int from_tty)
+{                              /* STUB_COMM PART_IMPLEMENTED */

   static CORE_ADDR start_pc, end_pc;
   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
   static CORE_ADDR start_pc, end_pc;
   struct symtabs_and_lines sals;
   struct symtab_and_line sal;

-  char *tmp;

   struct cleanup *old_chain;
   struct cleanup *old_chain;

+  char   startpc_str[40], endpc_str[40];

 
   if (target_is_remote ())
     {
 
   if (target_is_remote ())
     {


@@ -2068,18 +2108,18 @@ trace_find_line_command (args, from_tty)
       else
        {
          sals = decode_line_spec (args, 1);
       else
        {
          sals = decode_line_spec (args, 1);

-         sal  = sals.sals[0];
+         sal = sals.sals[0];

        }
 
        }
 

-      old_chain = make_cleanup (free, sals.sals);
+      old_chain = make_cleanup (xfree, sals.sals);

       if (sal.symtab == 0)
        {
          printf_filtered ("TFIND: No line number information available");
          if (sal.pc != 0)
            {
              /* This is useful for "info line *0x7f34".  If we can't tell the
       if (sal.symtab == 0)
        {
          printf_filtered ("TFIND: No line number information available");
          if (sal.pc != 0)
            {
              /* This is useful for "info line *0x7f34".  If we can't tell the

-                user about a source line, at least let them have the symbolic
-                address.  */
+                user about a source line, at least let them have the symbolic
+                address.  */

              printf_filtered (" for address ");
              wrap_here ("  ");
              print_address (sal.pc, gdb_stdout);
              printf_filtered (" for address ");
              wrap_here ("  ");
              print_address (sal.pc, gdb_stdout);


@@ -2088,7 +2128,7 @@ trace_find_line_command (args, from_tty)
          else
            {
              printf_filtered (".\n");
          else
            {
              printf_filtered (".\n");

-             return;   /* no line, no PC; what can we do? */
+             return;           /* no line, no PC; what can we do? */

            }
        }
       else if (sal.line > 0
            }
        }
       else if (sal.line > 0


@@ -2120,104 +2160,107 @@ trace_find_line_command (args, from_tty)
        error ("Line number %d is out of range for \"%s\".\n",
               sal.line, sal.symtab->filename);
 
        error ("Line number %d is out of range for \"%s\".\n",
               sal.line, sal.symtab->filename);
 

+      sprintf_vma (startpc_str, start_pc);
+      sprintf_vma (endpc_str, end_pc - 1);

       if (args && *args)       /* find within range of stated line */
       if (args && *args)       /* find within range of stated line */

-       sprintf (target_buf, "QTFrame:range:%x:%x", start_pc, end_pc - 1);
+       sprintf (target_buf, "QTFrame:range:%s:%s", startpc_str, endpc_str);

       else                     /* find OUTSIDE OF range of CURRENT line */
       else                     /* find OUTSIDE OF range of CURRENT line */

-       sprintf (target_buf, "QTFrame:outside:%x:%x", start_pc, end_pc - 1);
-      finish_tfind_command (target_buf, from_tty);
+       sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);

       do_cleanups (old_chain);
     }
   else
       do_cleanups (old_chain);
     }
   else

-      error ("Trace can only be run on remote targets.");
+    error ("Trace can only be run on remote targets.");

 }
 
 /* tfind range command */
 static void
 }
 
 /* tfind range command */
 static void

-trace_find_range_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+trace_find_range_command (char *args, int from_tty)
+{

   static CORE_ADDR start, stop;
   static CORE_ADDR start, stop;

+  char start_str[40], stop_str[40];

   char *tmp;
 
   if (target_is_remote ())
     {
       if (args == 0 || *args == 0)
   char *tmp;
 
   if (target_is_remote ())
     {
       if (args == 0 || *args == 0)

-       { /* XXX FIXME: what should default behavior be? */
+       {               /* XXX FIXME: what should default behavior be? */

          printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
          return;
        }
 
          printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
          return;
        }
 

-      if (0 != (tmp = strchr (args, ',' )))
+      if (0 != (tmp = strchr (args, ',')))

        {
          *tmp++ = '\0';        /* terminate start address */
        {
          *tmp++ = '\0';        /* terminate start address */

-         while (isspace (*tmp))
+         while (isspace ((int) *tmp))

            tmp++;
          start = parse_and_eval_address (args);
            tmp++;
          start = parse_and_eval_address (args);

-         stop  = parse_and_eval_address (tmp);
+         stop = parse_and_eval_address (tmp);

        }
       else
        }
       else

-       { /* no explicit end address? */
+       {                       /* no explicit end address? */

          start = parse_and_eval_address (args);
          start = parse_and_eval_address (args);

-         stop  = start + 1; /* ??? */
+         stop = start + 1;     /* ??? */

        }
 
        }
 

-      sprintf (target_buf, "QTFrame:range:%x:%x", start, stop);
-      finish_tfind_command (target_buf, from_tty);
+      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);

     }
   else
     }
   else

-      error ("Trace can only be run on remote targets.");
+    error ("Trace can only be run on remote targets.");

 }
 
 /* tfind outside command */
 static void
 }
 
 /* tfind outside command */
 static void

-trace_find_outside_command (args, from_tty)
-     char *args;
-     int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+trace_find_outside_command (char *args, int from_tty)
+{

   CORE_ADDR start, stop;
   CORE_ADDR start, stop;

+  char start_str[40], stop_str[40];

   char *tmp;
 
   if (target_is_remote ())
     {
       if (args == 0 || *args == 0)
   char *tmp;
 
   if (target_is_remote ())
     {
       if (args == 0 || *args == 0)

-       { /* XXX FIXME: what should default behavior be? */
+       {               /* XXX FIXME: what should default behavior be? */

          printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
          return;
        }
 
          printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
          return;
        }
 

-      if (0 != (tmp = strchr (args, ',' )))
+      if (0 != (tmp = strchr (args, ',')))

        {
          *tmp++ = '\0';        /* terminate start address */
        {
          *tmp++ = '\0';        /* terminate start address */

-         while (isspace (*tmp))
+         while (isspace ((int) *tmp))

            tmp++;
          start = parse_and_eval_address (args);
            tmp++;
          start = parse_and_eval_address (args);

-         stop  = parse_and_eval_address (tmp);
+         stop = parse_and_eval_address (tmp);

        }
       else
        }
       else

-       { /* no explicit end address? */
+       {                       /* no explicit end address? */

          start = parse_and_eval_address (args);
          start = parse_and_eval_address (args);

-         stop  = start + 1; /* ??? */
+         stop = start + 1;     /* ??? */

        }
 
        }
 

-      sprintf (target_buf, "QTFrame:outside:%x:%x", start, stop);
-      finish_tfind_command (target_buf, from_tty);
+      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);

     }
   else
     }
   else

-      error ("Trace can only be run on remote targets.");
+    error ("Trace can only be run on remote targets.");

 }
 
 /* save-tracepoints command */
 static void
 }
 
 /* save-tracepoints command */
 static void

-tracepoint_save_command (args, from_tty)
-     char *args;
-     int from_tty;
+tracepoint_save_command (char *args, int from_tty)

 {
 {

-  struct tracepoint  *tp;
+  struct tracepoint *tp;

   struct action_line *line;
   FILE *fp;
   char *i1 = "    ", *i2 = "      ";
   char *indent, *actionline;
   struct action_line *line;
   FILE *fp;
   char *i1 = "    ", *i2 = "      ";
   char *indent, *actionline;

+  char tmp[40];

 
   if (args == 0 || *args == 0)
     error ("Argument required (file name in which to save tracepoints");
 
   if (args == 0 || *args == 0)
     error ("Argument required (file name in which to save tracepoints");


@@ -2232,42 +2275,45 @@ tracepoint_save_command (args, from_tty)
     error ("Unable to open file '%s' for saving tracepoints");
 
   ALL_TRACEPOINTS (tp)
     error ("Unable to open file '%s' for saving tracepoints");
 
   ALL_TRACEPOINTS (tp)

-    {
-      if (tp->addr_string)
-       fprintf (fp, "trace %s\n", tp->addr_string);
-      else
-       fprintf (fp, "trace *0x%x\n", tp->address);
+  {
+    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->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;
+    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(*actionline))
-               actionline++;
+           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->function.cfunc == while_stepping_pseudocommand)
-                   indent = i2;
-                 else if (cmd->function.cfunc == end_actions_pseudocommand)
-                   indent = i1;
-               }
-           }
-       }
-    }
+           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->function.cfunc == while_stepping_pseudocommand)
+                 indent = i2;
+               else if (cmd->function.cfunc == end_actions_pseudocommand)
+                 indent = i1;
+             }
+         }
+      }
+  }

   fclose (fp);
   if (from_tty)
     printf_filtered ("Tracepoints saved to file '%s'.\n", args);
   fclose (fp);
   if (from_tty)
     printf_filtered ("Tracepoints saved to file '%s'.\n", args);


@@ -2276,24 +2322,21 @@ tracepoint_save_command (args, from_tty)
 
 /* info scope command: list the locals for a scope.  */
 static void
 
 /* info scope command: list the locals for a scope.  */
 static void

-scope_info (args, from_tty)
-     char *args;
-     int from_tty;
+scope_info (char *args, int from_tty)

 {
 {

-  struct symtab_and_line sal;

   struct symtabs_and_lines sals;
   struct symbol *sym;
   struct minimal_symbol *msym;
   struct block *block;
   char **canonical, *symname, *save_args = args;
   struct symtabs_and_lines sals;
   struct symbol *sym;
   struct minimal_symbol *msym;
   struct block *block;
   char **canonical, *symname, *save_args = args;

-  int i, nsyms, count = 0;
+  int i, j, nsyms, count = 0;

 
   if (args == 0 || *args == 0)
     error ("requires an argument (function, line or *addr) to define a scope");
 
   sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
   if (sals.nelts == 0)
 
   if (args == 0 || *args == 0)
     error ("requires an argument (function, line or *addr) to define a scope");
 
   sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
   if (sals.nelts == 0)

-    return;            /* presumably decode_line_1 has already warned */
+    return;                    /* presumably decode_line_1 has already warned */

 
   /* Resolve line numbers to PC */
   resolve_sal_pc (&sals.sals[0]);
 
   /* Resolve line numbers to PC */
   resolve_sal_pc (&sals.sals[0]);


@@ -2301,107 +2344,108 @@ scope_info (args, from_tty)
 
   while (block != 0)
     {
 
   while (block != 0)
     {

-      QUIT;                            /* allow user to bail out with ^C */
+      QUIT;                    /* allow user to bail out with ^C */

       nsyms = BLOCK_NSYMS (block);
       for (i = 0; i < nsyms; i++)
        {
       nsyms = BLOCK_NSYMS (block);
       for (i = 0; i < nsyms; i++)
        {

-         QUIT;                         /* allow user to bail out with ^C */
+         QUIT;                 /* allow user to bail out with ^C */

          if (count == 0)
            printf_filtered ("Scope for %s:\n", save_args);
          count++;
          sym = BLOCK_SYM (block, i);
          symname = SYMBOL_NAME (sym);
          if (symname == NULL || *symname == '\0')
          if (count == 0)
            printf_filtered ("Scope for %s:\n", save_args);
          count++;
          sym = BLOCK_SYM (block, i);
          symname = SYMBOL_NAME (sym);
          if (symname == NULL || *symname == '\0')

-           continue;   /* probably botched, certainly useless */
+           continue;           /* probably botched, certainly useless */

 
          printf_filtered ("Symbol %s is ", symname);
 
          printf_filtered ("Symbol %s is ", symname);

-         switch (SYMBOL_CLASS (sym)) {
-         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 %d (0x%x)", 
-                            SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
-           break;
-         case LOC_CONST_BYTES:
-           printf_filtered ("constant bytes: ");
-           if (SYMBOL_TYPE (sym))
-             for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (sym)); i++)
-               fprintf_filtered (gdb_stdout, " %02x",
-                                 (unsigned) SYMBOL_VALUE_BYTES (sym) [i]);
-           break;
-         case LOC_STATIC:
-           printf_filtered ("in static storage at address ");
-           print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
-           break;
-         case LOC_REGISTER:
-           printf_filtered ("a local variable in register $%s",
-                            reg_names [SYMBOL_VALUE (sym)]);
-           break;
-         case LOC_ARG:
-         case LOC_LOCAL_ARG:
-           printf_filtered ("an argument at stack/frame offset %ld",
-                            SYMBOL_VALUE (sym));
-           break;
-         case LOC_LOCAL:
-           printf_filtered ("a local variable at frame offset %ld",
-                            SYMBOL_VALUE (sym));
-           break;
-         case LOC_REF_ARG:
-           printf_filtered ("a reference argument at offset %ld",
-                            SYMBOL_VALUE (sym));
-           break;
-         case LOC_REGPARM:
-           printf_filtered ("an argument in register $%s",
-                            reg_names[SYMBOL_VALUE (sym)]);
-           break;
-         case LOC_REGPARM_ADDR:
-           printf_filtered ("the address of an argument, in register $%s",
-                            reg_names[SYMBOL_VALUE (sym)]);
-           break;
-         case LOC_TYPEDEF:
-           printf_filtered ("a typedef.\n");
-           continue;
-         case LOC_LABEL:
-           printf_filtered ("a label at address ");
-           print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
-           break;
-         case LOC_BLOCK:
-           printf_filtered ("a function at address ");
-           print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
-                                  gdb_stdout);
-           break;
-         case LOC_BASEREG:
-           printf_filtered ("a variable at offset %d from register $%s",
-                            SYMBOL_VALUE (sym),
-                            reg_names [SYMBOL_BASEREG (sym)]);
-           break;
-         case LOC_BASEREG_ARG:
-           printf_filtered ("an argument at offset %d from register $%s",
-                            SYMBOL_VALUE (sym),
-                            reg_names [SYMBOL_BASEREG (sym)]);
-           break;
-         case LOC_UNRESOLVED:
-           msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
-           if (msym == NULL)
-             printf_filtered ("Unresolved Static");
-           else
-             {
-               printf_filtered ("static storage at address ");
-               print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1, 
-                                      gdb_stdout);
-             }
-           break;
-         case LOC_OPTIMIZED_OUT:
-           printf_filtered ("optimized out.\n");
-           continue;
-         }
+         switch (SYMBOL_CLASS (sym))
+           {
+           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 %ld (0x%lx)",
+                              SYMBOL_VALUE (sym), 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 ");
+             print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+             break;
+           case LOC_REGISTER:
+             printf_filtered ("a local variable in register $%s",
+                              REGISTER_NAME (SYMBOL_VALUE (sym)));
+             break;
+           case LOC_ARG:
+           case LOC_LOCAL_ARG:
+             printf_filtered ("an argument at stack/frame offset %ld",
+                              SYMBOL_VALUE (sym));
+             break;
+           case LOC_LOCAL:
+             printf_filtered ("a local variable at frame offset %ld",
+                              SYMBOL_VALUE (sym));
+             break;
+           case LOC_REF_ARG:
+             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",
+                              REGISTER_NAME (SYMBOL_VALUE (sym)));
+             break;
+           case LOC_TYPEDEF:
+             printf_filtered ("a typedef.\n");
+             continue;
+           case LOC_LABEL:
+             printf_filtered ("a label at address ");
+             print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+             break;
+           case LOC_BLOCK:
+             printf_filtered ("a function at address ");
+             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)));
+             break;
+           case LOC_UNRESOLVED:
+             msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+             if (msym == NULL)
+               printf_filtered ("Unresolved Static");
+             else
+               {
+                 printf_filtered ("static storage at address ");
+                 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
+                                        gdb_stdout);
+               }
+             break;
+           case LOC_OPTIMIZED_OUT:
+             printf_filtered ("optimized out.\n");
+             continue;
+           }

          if (SYMBOL_TYPE (sym))
          if (SYMBOL_TYPE (sym))

-           printf_filtered (", length %d.\n", 
-                            TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
+           printf_filtered (", length %d.\n",
+                          TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));

        }
       if (BLOCK_FUNCTION (block))
        break;
        }
       if (BLOCK_FUNCTION (block))
        break;


@@ -2415,24 +2459,22 @@ scope_info (args, from_tty)
 
 /* worker function (cleanup) */
 static void
 
 /* worker function (cleanup) */
 static void

-replace_comma (comma)
-     char *comma;
+replace_comma (void *data)

 {
 {

+  char *comma = data;

   *comma = ',';
 }
 
 /* tdump command */
 static void
   *comma = ',';
 }
 
 /* tdump command */
 static void

-trace_dump_command (args, from_tty)
-     char *args;
-     int from_tty;
+trace_dump_command (char *args, int from_tty)

 {
 {

-  struct tracepoint  *t;
+  struct tracepoint *t;

   struct action_line *action;
   struct action_line *action;

-  char               *action_exp, *next_comma;
-  struct cleanup     *old_cleanups;
-  int                 stepping_actions = 0;
-  int                 stepping_frame   = 0;
+  char *action_exp, *next_comma;
+  struct cleanup *old_cleanups;
+  int stepping_actions = 0;
+  int stepping_frame = 0;

 
   if (!target_is_remote ())
     {
 
   if (!target_is_remote ())
     {


@@ -2448,34 +2490,34 @@ trace_dump_command (args, from_tty)
 
   ALL_TRACEPOINTS (t)
     if (t->number == tracepoint_number)
 
   ALL_TRACEPOINTS (t)
     if (t->number == tracepoint_number)

-      break;
+    break;

 
   if (t == NULL)
 
   if (t == NULL)

-    error ("No known tracepoint matches 'current' tracepoint #%d.", 
+    error ("No known tracepoint matches 'current' tracepoint #%d.",

           tracepoint_number);
 
   old_cleanups = make_cleanup (null_cleanup, NULL);
 
           tracepoint_number);
 
   old_cleanups = make_cleanup (null_cleanup, NULL);
 

-  printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n", 
+  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.  */
 
                   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.  */
 

-  stepping_frame = (t->address != read_pc());
+  stepping_frame = (t->address != read_pc ());

 
   for (action = t->actions; action; action = action->next)
     {
       struct cmd_list_element *cmd;
 
 
   for (action = t->actions; action; action = action->next)
     {
       struct cmd_list_element *cmd;
 

-      QUIT;                            /* allow user to bail out with ^C */
+      QUIT;                    /* allow user to bail out with ^C */

       action_exp = action->action;
       action_exp = action->action;

-      while (isspace (*action_exp))
+      while (isspace ((int) *action_exp))

        action_exp++;
 
       /* The collection actions to be done while stepping are
        action_exp++;
 
       /* The collection actions to be done while stepping are

-        bracketed by the commands "while-stepping" and "end".  */
+         bracketed by the commands "while-stepping" and "end".  */

 
       if (*action_exp == '#')  /* comment line */
        continue;
 
       if (*action_exp == '#')  /* comment line */
        continue;


@@ -2497,36 +2539,38 @@ trace_dump_command (args, from_tty)
             STEPPING_FRAME and STEPPING_ACTIONS should be equal.  */
          if (stepping_frame == stepping_actions)
            {
             STEPPING_FRAME and STEPPING_ACTIONS should be equal.  */
          if (stepping_frame == stepping_actions)
            {

-             do { /* repeat over a comma-separated list */
-               QUIT;           /* allow user to bail out with ^C */
-               if (*action_exp == ',')
-                 action_exp++;
-               while (isspace (*action_exp))
-                 action_exp++;
-
-               next_comma = strchr (action_exp, ',');
-
-               if      (0 == strncasecmp (action_exp, "$reg", 4))
-                 registers_info (NULL, from_tty);
-               else if (0 == strncasecmp (action_exp, "$loc", 4))
-                 locals_info (NULL, from_tty);
-               else if (0 == strncasecmp (action_exp, "$arg", 4))
-                 args_info (NULL, from_tty);
-               else
-                 { /* variable */
-                   if (next_comma)
-                     {
-                       make_cleanup (replace_comma, next_comma);
-                       *next_comma = '\0';
-                     }
-                   printf_filtered ("%s = ", action_exp);
-                   output_command (action_exp, from_tty);
-                   printf_filtered ("\n");
-                 }
-               if (next_comma)
-                 *next_comma = ',';
-               action_exp = next_comma;
-             } while (action_exp && *action_exp == ',');
+             do
+               {               /* repeat over a comma-separated list */
+                 QUIT;         /* allow user to bail out with ^C */
+                 if (*action_exp == ',')
+                   action_exp++;
+                 while (isspace ((int) *action_exp))
+                   action_exp++;
+
+                 next_comma = strchr (action_exp, ',');
+
+                 if (0 == strncasecmp (action_exp, "$reg", 4))
+                   registers_info (NULL, from_tty);
+                 else if (0 == strncasecmp (action_exp, "$loc", 4))
+                   locals_info (NULL, from_tty);
+                 else if (0 == strncasecmp (action_exp, "$arg", 4))
+                   args_info (NULL, from_tty);
+                 else
+                   {           /* variable */
+                     if (next_comma)
+                       {
+                         make_cleanup (replace_comma, next_comma);
+                         *next_comma = '\0';
+                       }
+                     printf_filtered ("%s = ", action_exp);
+                     output_command (action_exp, from_tty);
+                     printf_filtered ("\n");
+                   }
+                 if (next_comma)
+                   *next_comma = ',';
+                 action_exp = next_comma;
+               }
+             while (action_exp && *action_exp == ',');

            }
        }
     }
            }
        }
     }


@@ -2538,13 +2582,10 @@ trace_dump_command (args, from_tty)
  * "stolen" from sparc-stub.c
  */
 
  * "stolen" from sparc-stub.c
  */
 

-static const char hexchars[]="0123456789abcdef";
+static const char hexchars[] = "0123456789abcdef";

 
 static unsigned char *
 
 static unsigned char *

-mem2hex(mem, buf, count)
-     unsigned char *mem;
-     unsigned char *buf;
-     int count;
+mem2hex (unsigned char *mem, unsigned char *buf, int count)

 {
   unsigned char ch;
 
 {
   unsigned char ch;
 


@@ -2561,30 +2602,33 @@ mem2hex(mem, buf, count)
   return buf;
 }
 
   return buf;
 }
 

-int get_traceframe_number()
+int
+get_traceframe_number (void)

 {
 {

- return traceframe_number;
+  return traceframe_number;

 }
 
 
 /* module initialization */
 void
 }
 
 
 /* module initialization */
 void

-_initialize_tracepoint ()
+_initialize_tracepoint (void)

 {
 {

-  tracepoint_chain  = 0;
-  tracepoint_count  = 0;
+  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"), 
+  set_internalvar (lookup_internalvar ("tpnum"),

                   value_from_longest (builtin_type_int, (LONGEST) 0));
                   value_from_longest (builtin_type_int, (LONGEST) 0));

-  set_internalvar (lookup_internalvar ("trace_frame"), 
-                  value_from_longest (builtin_type_int, (LONGEST) -1));
+  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;

-      tracepoint_list.list = xmalloc 
+      tracepoint_list.list = xmalloc

        (tracepoint_list.listsize * sizeof (struct memrange));
     }
   if (tracepoint_list.aexpr_list == NULL)
        (tracepoint_list.listsize * sizeof (struct memrange));
     }
   if (tracepoint_list.aexpr_list == NULL)


@@ -2597,7 +2641,7 @@ _initialize_tracepoint ()
   if (stepping_list.list == NULL)
     {
       stepping_list.listsize = 128;
   if (stepping_list.list == NULL)
     {
       stepping_list.listsize = 128;

-      stepping_list.list = xmalloc 
+      stepping_list.list = xmalloc

        (stepping_list.listsize * sizeof (struct memrange));
     }
 
        (stepping_list.listsize * sizeof (struct memrange));
     }
 


@@ -2608,11 +2652,11 @@ _initialize_tracepoint ()
        (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
     }
 
        (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
     }
 

-  add_info ("scope", scope_info, 
+  add_info ("scope", scope_info,

            "List the variables local to a scope");
 
            "List the variables local to a scope");
 

-  add_cmd ("tracepoints", class_trace, NO_FUNCTION, 
-          "Tracing of program execution without stopping the program.", 
+  add_cmd ("tracepoints", class_trace, NO_FUNCTION,
+          "Tracing of program execution without stopping the program.",

           &cmdlist);
 
   add_info ("tracepoints", tracepoints_info,
           &cmdlist);
 
   add_info ("tracepoints", tracepoints_info,


@@ -2622,26 +2666,27 @@ last tracepoint set.");
 
   add_info_alias ("tp", "tracepoints", 1);
 
 
   add_info_alias ("tp", "tracepoints", 1);
 

-  add_com ("save-tracepoints", class_trace, tracepoint_save_command, 
-          "Save current tracepoint definitions as a script.\n\
+  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.");
 Use the 'source' command in another debug session to restore them.");

+  c->completer = filename_completer;

 
 

-  add_com ("tdump", class_trace, trace_dump_command, 
+  add_com ("tdump", class_trace, trace_dump_command,

           "Print everything collected at the current tracepoint.");
 
           "Print everything collected at the current tracepoint.");
 

-  add_prefix_cmd ("tfind",  class_trace, trace_find_command,
+  add_prefix_cmd ("tfind", class_trace, trace_find_command,

                  "Select a trace frame;\n\
 No argument means forward by one frame; '-' meand backward by one frame.",
                  &tfindlist, "tfind ", 1, &cmdlist);
 
   add_cmd ("outside", class_trace, trace_find_outside_command,
           "Select a trace frame whose PC is outside the given \
                  "Select a trace frame;\n\
 No argument means forward by one frame; '-' meand backward by one frame.",
                  &tfindlist, "tfind ", 1, &cmdlist);
 
   add_cmd ("outside", class_trace, trace_find_outside_command,
           "Select a trace frame whose PC is outside the given \

-range.\nUsage: tfind outside addr1, addr2", 
+range.\nUsage: tfind outside addr1, addr2",

           &tfindlist);
 
   add_cmd ("range", class_trace, trace_find_range_command,
           "Select a trace frame whose PC is in the given range.\n\
           &tfindlist);
 
   add_cmd ("range", class_trace, trace_find_range_command,
           "Select a trace frame whose PC is in the given range.\n\

-Usage: tfind range addr1,addr2", 
+Usage: tfind range addr1,addr2",

           &tfindlist);
 
   add_cmd ("line", class_trace, trace_find_line_command,
           &tfindlist);
 
   add_cmd ("line", class_trace, trace_find_line_command,


@@ -2674,16 +2719,16 @@ De-select any trace frame and resume 'live' debugging.",
           "Select the first trace frame in the trace buffer.",
           &tfindlist);
 
           "Select the first trace frame in the trace buffer.",
           &tfindlist);
 

-  add_com ("tstatus",  class_trace, trace_status_command,
+  add_com ("tstatus", class_trace, trace_status_command,

           "Display the status of the current trace data collection.");
 
           "Display the status of the current trace data collection.");
 

-  add_com ("tstop",  class_trace, trace_stop_command,
+  add_com ("tstop", class_trace, trace_stop_command,

           "Stop trace data collection.");
 
   add_com ("tstart", class_trace, trace_start_command,
           "Start trace data collection.");
 
           "Stop trace data collection.");
 
   add_com ("tstart", class_trace, trace_start_command,
           "Start trace data collection.");
 

-  add_com ("passcount", class_trace, trace_pass_command, 
+  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\
           "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\


@@ -2704,10 +2749,10 @@ one or more \"collect\" commands, to specify what to collect\n\
 while single-stepping.\n\n\
 Note: this command can only be used in a tracepoint \"actions\" list.");
 
 while single-stepping.\n\n\
 Note: this command can only be used in a tracepoint \"actions\" list.");
 

-  add_com_alias ("ws",         "while-stepping", class_alias, 0);
-  add_com_alias ("stepping",   "while-stepping", class_alias, 0);
+  add_com_alias ("ws", "while-stepping", class_alias, 0);
+  add_com_alias ("stepping", "while-stepping", class_alias, 0);

 
 

-  add_com ("collect", class_trace, collect_pseudocommand, 
+  add_com ("collect", class_trace, collect_pseudocommand,

           "Specify one or more data items to be collected at a tracepoint.\n\
 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
 collect all data (variables, registers) referenced by that expression.\n\
           "Specify one or more data items to be collected at a tracepoint.\n\
 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
 collect all data (variables, registers) referenced by that expression.\n\


@@ -2723,34 +2768,34 @@ 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, 
+  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);
 
           "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, 
+  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);
 
           "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, 
+  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);
 
           "Enable specified tracepoints.\n\
 Arguments are tracepoint numbers, separated by spaces.\n\
 No argument means enable all tracepoints.",
           &enablelist);
 

-  add_com ("trace", class_trace, trace_command,
-          "Set a tracepoint at a specified line or function or address.\n\
+  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.");
 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.");

+  c->completer = 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 ("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);
 }
   add_com_alias ("trac", "trace", class_alias, 1);
 }

-