gdb/tracepoint.c

   1 /* Tracing functionality for remote targets in custom GDB protocol
   2    Copyright 1997 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "frame.h"
  23 #include "tracepoint.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "gdbcmd.h"
  27 #include "value.h"
  28 #include "target.h"
  29 #include "language.h"
  30 #include "gdb_string.h"
  31
  32 #include "ax.h"
  33 #include "ax-gdb.h"
  34
  35 /* readline include files */
  36 #include "readline.h"
  37 #include "history.h"
  38
  39 /* readline defines this.  */
  40 #undef savestring
  41
  42 #ifdef HAVE_UNISTD_H
  43 #include <unistd.h>
  44 #endif
  45
  46 /* maximum length of an agent aexpression.
  47    this accounts for the fact that packets are limited to 400 bytes
  48    (which includes everything -- including the checksum), and assumes
  49    the worst case of maximum length for each of the pieces of a
  50    continuation packet.
  51
  52    NOTE: expressions get mem2hex'ed otherwise this would be twice as
  53    large.  (400 - 31)/2 == 184 */
  54 #define MAX_AGENT_EXPR_LEN      184
  55
  56
  57 extern int info_verbose;
  58 extern void (*readline_begin_hook) PARAMS ((char *, ...));
  59 extern char * (*readline_hook) PARAMS ((char *));
  60 extern void (*readline_end_hook) PARAMS ((void));
  61 extern void x_command PARAMS ((char *, int));
  62 extern int addressprint;                /* Print machine addresses? */
  63
  64 /* If this definition isn't overridden by the header files, assume
  65    that isatty and fileno exist on this system.  */
  66 #ifndef ISATTY
  67 #define ISATTY(FP)      (isatty (fileno (FP)))
  68 #endif
  69
  70 /*
  71    Tracepoint.c:
  72
  73    This module defines the following debugger commands:
  74    trace            : set a tracepoint on a function, line, or address.
  75    info trace       : list all debugger-defined tracepoints.
  76    delete trace     : delete one or more tracepoints.
  77    enable trace     : enable one or more tracepoints.
  78    disable trace    : disable one or more tracepoints.
  79    actions          : specify actions to be taken at a tracepoint.
  80    passcount        : specify a pass count for a tracepoint.
  81    tstart           : start a trace experiment.
  82    tstop            : stop a trace experiment.
  83    tstatus          : query the status of a trace experiment.
  84    tfind            : find a trace frame in the trace buffer.
  85    tdump            : print everything collected at the current tracepoint.
  86    save-tracepoints : write tracepoint setup into a file.
  87
  88    This module defines the following user-visible debugger variables:
  89    $trace_frame : sequence number of trace frame currently being debugged.
  90    $trace_line  : source line of trace frame currently being debugged.
  91    $trace_file  : source file of trace frame currently being debugged.
  92    $tracepoint  : tracepoint number of trace frame currently being debugged.
  93    */
  94
  95
  96 /* ======= Important global variables: ======= */
  97
  98 /* Chain of all tracepoints defined.  */
  99 struct tracepoint *tracepoint_chain;
 100
 101 /* Number of last tracepoint made.  */
 102 static int tracepoint_count;
 103
 104 /* Number of last traceframe collected.  */
 105 static int traceframe_number;
 106
 107 /* Tracepoint for last traceframe collected.  */
 108 static int tracepoint_number;
 109
 110 /* Symbol for function for last traceframe collected */
 111 static struct symbol *traceframe_fun;
 112
 113 /* Symtab and line for last traceframe collected */
 114 static struct symtab_and_line traceframe_sal;
 115
 116 /* Tracing command lists */
 117 static struct cmd_list_element *tfindlist;
 118
 119 /* ======= Important command functions: ======= */
 120 static void trace_command                 PARAMS ((char *, int));
 121 static void tracepoints_info              PARAMS ((char *, int));
 122 static void delete_trace_command          PARAMS ((char *, int));
 123 static void enable_trace_command          PARAMS ((char *, int));
 124 static void disable_trace_command         PARAMS ((char *, int));
 125 static void trace_pass_command            PARAMS ((char *, int));
 126 static void trace_actions_command         PARAMS ((char *, int));
 127 static void trace_start_command           PARAMS ((char *, int));
 128 static void trace_stop_command            PARAMS ((char *, int));
 129 static void trace_status_command          PARAMS ((char *, int));
 130 static void trace_find_command            PARAMS ((char *, int));
 131 static void trace_find_pc_command         PARAMS ((char *, int));
 132 static void trace_find_tracepoint_command PARAMS ((char *, int));
 133 static void trace_find_line_command       PARAMS ((char *, int));
 134 static void trace_find_range_command      PARAMS ((char *, int));
 135 static void trace_find_outside_command    PARAMS ((char *, int));
 136 static void tracepoint_save_command       PARAMS ((char *, int));
 137 static void trace_dump_command            PARAMS ((char *, int));
 138
 139 /* support routines */
 140 static void trace_mention                 PARAMS ((struct tracepoint *));
 141
 142 struct collection_list;
 143 static void add_aexpr PARAMS ((struct collection_list *, struct agent_expr *));
 144 static unsigned char *mem2hex(unsigned char *, unsigned char *, int);
 145
 146 /* Utility: returns true if "target remote" */
 147 static int
 148 target_is_remote ()
 149 {
 150   if (current_target.to_shortname &&
 151       strcmp (current_target.to_shortname, "remote") == 0)
 152     return 1;
 153   else
 154     return 0;
 155 }
 156
 157 /* Utility: generate error from an incoming stub packet.  */
 158 static void
 159 trace_error (buf)
 160      char *buf;
 161 {
 162   if (*buf++ != 'E')
 163     return;                     /* not an error msg */
 164   switch (*buf)
 165     {
 166     case '1':                   /* malformed packet error */
 167       if (*++buf == '0')        /*   general case: */
 168         error ("tracepoint.c: error in outgoing packet.");
 169       else
 170         error ("tracepoint.c: error in outgoing packet at field #%d.",
 171                strtol (buf, NULL, 16));
 172     case '2':
 173       error ("trace API error 0x%s.", ++buf);
 174     default:
 175       error ("Target returns error code '%s'.", buf);
 176     }
 177 }
 178
 179 /* Utility: wait for reply from stub, while accepting "O" packets */
 180 static char *
 181 remote_get_noisy_reply (buf)
 182      char *buf;
 183 {
 184   do    /* loop on reply from remote stub */
 185     {
 186       QUIT;                             /* allow user to bail out with ^C */
 187       getpkt (buf, 0);
 188       if (buf[0] == 0)
 189         error ("Target does not support this command.");
 190       else if (buf[0] == 'E')
 191         trace_error (buf);
 192       else if (buf[0] == 'O' &&
 193                buf[1] != 'K')
 194         remote_console_output (buf + 1);        /* 'O' message from stub */
 195       else
 196         return buf;                             /* here's the actual reply */
 197     } while (1);
 198 }
 199
 200 /* Set tracepoint count to NUM.  */
 201 static void
 202 set_tracepoint_count (num)
 203      int num;
 204 {
 205   tracepoint_count = num;
 206   set_internalvar (lookup_internalvar ("tpnum"),
 207                    value_from_longest (builtin_type_int, (LONGEST) num));
 208 }
 209
 210 /* Set traceframe number to NUM.  */
 211 static void
 212 set_traceframe_num (num)
 213      int num;
 214 {
 215   traceframe_number = num;
 216   set_internalvar (lookup_internalvar ("trace_frame"),
 217                    value_from_longest (builtin_type_int, (LONGEST) num));
 218 }
 219
 220 /* Set tracepoint number to NUM.  */
 221 static void
 222 set_tracepoint_num (num)
 223      int num;
 224 {
 225   tracepoint_number = num;
 226   set_internalvar (lookup_internalvar ("tracepoint"),
 227                    value_from_longest (builtin_type_int, (LONGEST) num));
 228 }
 229
 230 /* Set externally visible debug variables for querying/printing
 231    the traceframe context (line, function, file) */
 232
 233 static void
 234 set_traceframe_context (trace_pc)
 235      CORE_ADDR trace_pc;
 236 {
 237   static struct type *func_string, *file_string;
 238   static struct type *func_range,  *file_range;
 239   static value_ptr    func_val,     file_val;
 240   static struct type *charstar;
 241   int len;
 242
 243   if (charstar == (struct type *) NULL)
 244     charstar = lookup_pointer_type (builtin_type_char);
 245
 246   if (trace_pc == -1)   /* cease debugging any trace buffers */
 247     {
 248       traceframe_fun = 0;
 249       traceframe_sal.pc = traceframe_sal.line = 0;
 250       traceframe_sal.symtab = NULL;
 251       set_internalvar (lookup_internalvar ("trace_func"),
 252                        value_from_longest (charstar, (LONGEST) 0));
 253       set_internalvar (lookup_internalvar ("trace_file"),
 254                        value_from_longest (charstar, (LONGEST) 0));
 255       set_internalvar (lookup_internalvar ("trace_line"),
 256                        value_from_longest (builtin_type_int, (LONGEST) -1));
 257       return;
 258     }
 259
 260   /* save as globals for internal use */
 261   traceframe_sal = find_pc_line (trace_pc, 0);
 262   traceframe_fun = find_pc_function (trace_pc);
 263
 264   /* save linenumber as "$trace_line", a debugger variable visible to users */
 265   set_internalvar (lookup_internalvar ("trace_line"),
 266                    value_from_longest (builtin_type_int,
 267                                        (LONGEST) traceframe_sal.line));
 268
 269   /* save func name as "$trace_func", a debugger variable visible to users */
 270   if (traceframe_fun == NULL ||
 271       SYMBOL_NAME (traceframe_fun) == NULL)
 272     set_internalvar (lookup_internalvar ("trace_func"),
 273                      value_from_longest (charstar, (LONGEST) 0));
 274   else
 275     {
 276       len = strlen (SYMBOL_NAME (traceframe_fun));
 277       func_range  = create_range_type (func_range,
 278                                        builtin_type_int, 0, len - 1);
 279       func_string = create_array_type (func_string,
 280                                        builtin_type_char, func_range);
 281       func_val = allocate_value (func_string);
 282       VALUE_TYPE (func_val) = func_string;
 283       memcpy (VALUE_CONTENTS_RAW (func_val),
 284               SYMBOL_NAME (traceframe_fun),
 285               len);
 286       func_val->modifiable = 0;
 287       set_internalvar (lookup_internalvar ("trace_func"), func_val);
 288     }
 289
 290   /* save file name as "$trace_file", a debugger variable visible to users */
 291   if (traceframe_sal.symtab == NULL ||
 292       traceframe_sal.symtab->filename == NULL)
 293     set_internalvar (lookup_internalvar ("trace_file"),
 294                      value_from_longest (charstar, (LONGEST) 0));
 295   else
 296     {
 297       len = strlen (traceframe_sal.symtab->filename);
 298       file_range  = create_range_type (file_range,
 299                                        builtin_type_int, 0, len - 1);
 300       file_string = create_array_type (file_string,
 301                                        builtin_type_char, file_range);
 302       file_val = allocate_value (file_string);
 303       VALUE_TYPE (file_val) = file_string;
 304       memcpy (VALUE_CONTENTS_RAW (file_val),
 305               traceframe_sal.symtab->filename,
 306               len);
 307       file_val->modifiable = 0;
 308       set_internalvar (lookup_internalvar ("trace_file"), file_val);
 309     }
 310 }
 311
 312 /* Low level routine to set a tracepoint.
 313    Returns the tracepoint object so caller can set other things.
 314    Does not set the tracepoint number!
 315    Does not print anything.
 316
 317    ==> This routine should not be called if there is a chance of later
 318    error(); otherwise it leaves a bogus tracepoint on the chain.  Validate
 319    your arguments BEFORE calling this routine!  */
 320
 321 static struct tracepoint *
 322 set_raw_tracepoint (sal)
 323      struct symtab_and_line sal;
 324 {
 325   register struct tracepoint *t, *tc;
 326   struct cleanup *old_chain;
 327
 328   t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
 329   old_chain = make_cleanup (free, t);
 330   memset (t, 0, sizeof (*t));
 331   t->address = sal.pc;
 332   if (sal.symtab == NULL)
 333     t->source_file = NULL;
 334   else
 335     {
 336       if (sal.symtab->dirname == NULL)
 337         {
 338           t->source_file = (char *) xmalloc (strlen (sal.symtab->filename) + 1);
 339           strcpy (t->source_file, sal.symtab->filename);
 340         }
 341       else
 342         {
 343           char *p;
 344
 345           t->source_file = (char *) xmalloc (strlen (sal.symtab->filename) +
 346                                              strlen (sal.symtab->dirname) + 2);
 347
 348           strcpy (t->source_file, sal.symtab->dirname);
 349           p = t->source_file;
 350           while (*p)
 351             p++;
 352           if (*(--p) != '/')            /* Will this work on Windows? */
 353             strcat (t->source_file, "/");
 354           strcat (t->source_file, sal.symtab->filename);
 355         }
 356     }
 357
 358   t->language = current_language->la_language;
 359   t->input_radix = input_radix;
 360   t->line_number = sal.line;
 361   t->enabled     = enabled;
 362   t->next        = 0;
 363   t->step_count  = 0;
 364   t->pass_count  = 0;
 365   t->addr_string = NULL;
 366
 367   /* Add this tracepoint to the end of the chain
 368      so that a list of tracepoints will come out in order
 369      of increasing numbers.  */
 370
 371   tc = tracepoint_chain;
 372   if (tc == 0)
 373     tracepoint_chain = t;
 374   else
 375     {
 376       while (tc->next)
 377         tc = tc->next;
 378       tc->next = t;
 379     }
 380   discard_cleanups (old_chain);
 381   return t;
 382 }
 383
 384 /* Set a tracepoint according to ARG (function, linenum or *address) */
 385 static void
 386 trace_command (arg, from_tty)
 387      char *arg;
 388      int from_tty;
 389 {
 390   char **canonical = (char **)NULL;
 391   struct symtabs_and_lines sals;
 392   struct symtab_and_line sal;
 393   struct tracepoint *t;
 394   char *addr_start = 0, *addr_end = 0;
 395   int i;
 396
 397   if (!arg || !*arg)
 398     error ("trace command requires an argument");
 399
 400   if (from_tty && info_verbose)
 401     printf_filtered ("TRACE %s\n", arg);
 402
 403   addr_start = arg;
 404   sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, &canonical);
 405   addr_end   = arg;
 406   if (! sals.nelts)
 407     return;     /* ??? Presumably decode_line_1 has already warned? */
 408
 409   /* Resolve all line numbers to PC's */
 410   for (i = 0; i < sals.nelts; i++)
 411     resolve_sal_pc (&sals.sals[i]);
 412
 413   /* Now set all the tracepoints.  */
 414   for (i = 0; i < sals.nelts; i++)
 415     {
 416       sal = sals.sals[i];
 417
 418       t = set_raw_tracepoint (sal);
 419       set_tracepoint_count (tracepoint_count + 1);
 420       t->number = tracepoint_count;
 421
 422       /* If a canonical line spec is needed use that instead of the
 423          command string.  */
 424       if (canonical != (char **)NULL && canonical[i] != NULL)
 425         t->addr_string = canonical[i];
 426       else if (addr_start)
 427         t->addr_string = savestring (addr_start, addr_end - addr_start);
 428
 429       trace_mention (t);
 430
 431       /* Let the UI know of any additions */
 432       if (create_tracepoint_hook)
 433         create_tracepoint_hook (t);
 434     }
 435
 436   if (sals.nelts > 1)
 437     {
 438       printf_filtered ("Multiple tracepoints were set.\n");
 439       printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
 440     }
 441 }
 442
 443 /* Tell the user we have just set a tracepoint TP. */
 444
 445 static void
 446 trace_mention (tp)
 447      struct tracepoint *tp;
 448 {
 449   printf_filtered ("Tracepoint %d", tp->number);
 450
 451   if (addressprint || (tp->source_file == NULL))
 452     {
 453       printf_filtered (" at ");
 454       print_address_numeric (tp->address, 1, gdb_stdout);
 455     }
 456   if (tp->source_file)
 457     printf_filtered (": file %s, line %d.",
 458                      tp->source_file, tp->line_number);
 459
 460   printf_filtered ("\n");
 461 }
 462
 463 /* Print information on tracepoint number TPNUM_EXP, or all if omitted.  */
 464
 465 static void
 466 tracepoints_info (tpnum_exp, from_tty)
 467      char *tpnum_exp;
 468      int from_tty;
 469 {
 470   struct tracepoint *t;
 471   struct action_line *action;
 472   int found_a_tracepoint = 0;
 473   char wrap_indent[80];
 474   struct symbol *sym;
 475   int tpnum = -1;
 476
 477   if (tpnum_exp)
 478     tpnum = parse_and_eval_address (tpnum_exp);
 479
 480   ALL_TRACEPOINTS (t)
 481     if (tpnum == -1 || tpnum == t->number)
 482       {
 483         extern int addressprint;        /* print machine addresses? */
 484
 485         if (!found_a_tracepoint++)
 486           {
 487             printf_filtered ("Num Enb ");
 488             if (addressprint)
 489               printf_filtered ("Address    ");
 490             printf_filtered ("PassC StepC What\n");
 491           }
 492         strcpy (wrap_indent, "                           ");
 493         if (addressprint)
 494           strcat (wrap_indent, "           ");
 495
 496         printf_filtered ("%-3d %-3s ", t->number,
 497                          t->enabled == enabled ? "y" : "n");
 498         if (addressprint)
 499           printf_filtered ("%s ",
 500                            local_hex_string_custom ((unsigned long) t->address,
 501                                                     "08l"));
 502         printf_filtered ("%-5d %-5d ", t->pass_count, t->step_count);
 503
 504         if (t->source_file)
 505           {
 506             sym = find_pc_function (t->address);
 507             if (sym)
 508               {
 509                 fputs_filtered ("in ", gdb_stdout);
 510                 fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
 511                 wrap_here (wrap_indent);
 512                 fputs_filtered (" at ", gdb_stdout);
 513               }
 514             fputs_filtered (t->source_file, gdb_stdout);
 515             printf_filtered (":%d", t->line_number);
 516           }
 517         else
 518           print_address_symbolic (t->address, gdb_stdout, demangle, " ");
 519
 520         printf_filtered ("\n");
 521         if (t->actions)
 522           {
 523             printf_filtered ("  Actions for tracepoint %d: \n", t->number);
 524             for (action = t->actions; action; action = action->next)
 525               {
 526                 printf_filtered ("\t%s\n", action->action);
 527               }
 528           }
 529       }
 530   if (!found_a_tracepoint)
 531     {
 532       if (tpnum == -1)
 533         printf_filtered ("No tracepoints.\n");
 534       else
 535         printf_filtered ("No tracepoint number %d.\n", tpnum);
 536     }
 537 }
 538
 539 /* Optimization: the code to parse an enable, disable, or delete TP command
 540    is virtually identical except for whether it performs an enable, disable,
 541    or delete.  Therefore I've combined them into one function with an opcode.
 542    */
 543 enum tracepoint_opcode
 544 {
 545   enable,
 546   disable,
 547   delete
 548 };
 549
 550 /* This function implements enable, disable and delete. */
 551 static void
 552 tracepoint_operation (t, from_tty, opcode)
 553      struct tracepoint *t;
 554      int from_tty;
 555      enum tracepoint_opcode opcode;
 556 {
 557   struct tracepoint *t2;
 558
 559   switch (opcode) {
 560   case enable:
 561     t->enabled = enabled;
 562     if (modify_tracepoint_hook)
 563       modify_tracepoint_hook (t);
 564     break;
 565   case disable:
 566     t->enabled = disabled;
 567     if (modify_tracepoint_hook)
 568       modify_tracepoint_hook (t);
 569     break;
 570   case delete:
 571     if (tracepoint_chain == t)
 572       tracepoint_chain = t->next;
 573
 574     ALL_TRACEPOINTS (t2)
 575       if (t2->next == t)
 576         {
 577           t2->next = t->next;
 578           break;
 579         }
 580
 581     /* Let the UI know of any deletions */
 582     if (delete_tracepoint_hook)
 583       delete_tracepoint_hook (t);
 584
 585     if (t->addr_string)
 586       free (t->addr_string);
 587     if (t->source_file)
 588       free (t->source_file);
 589     if (t->actions)
 590       free_actions (t);
 591
 592     free (t);
 593     break;
 594   }
 595 }
 596
 597 /* Utility: parse a tracepoint number and look it up in the list.  */
 598 struct tracepoint *
 599 get_tracepoint_by_number (arg)
 600      char **arg;
 601 {
 602   struct tracepoint *t;
 603   char *end, *copy;
 604   value_ptr val;
 605   int tpnum;
 606
 607   if (arg == 0)
 608     error ("Bad tracepoint argument");
 609
 610   if (*arg == 0 || **arg == 0)  /* empty arg means refer to last tp */
 611     tpnum = tracepoint_count;
 612   else if (**arg == '$')        /* handle convenience variable */
 613     {
 614       /* Make a copy of the name, so we can null-terminate it
 615          to pass to lookup_internalvar().  */
 616       end = *arg + 1;
 617       while (isalnum(*end) || *end == '_')
 618         end++;
 619       copy = (char *) alloca (end - *arg);
 620       strncpy (copy, *arg + 1, (end - *arg - 1));
 621       copy[end - *arg - 1] = '\0';
 622       *arg = end;
 623
 624       val = value_of_internalvar (lookup_internalvar (copy));
 625       if (TYPE_CODE( VALUE_TYPE (val)) != TYPE_CODE_INT)
 626         error ("Convenience variable must have integral type.");
 627       tpnum = (int) value_as_long (val);
 628     }
 629   else          /* handle tracepoint number */
 630     {
 631       tpnum = strtol (*arg, arg, 0);
 632       if (tpnum == 0)           /* possible strtol failure */
 633         while (**arg && !isspace (**arg))
 634           (*arg)++;             /* advance to next white space, if any */
 635     }
 636   ALL_TRACEPOINTS (t)
 637     if (t->number == tpnum)
 638       {
 639         return t;
 640       }
 641   printf_unfiltered ("No tracepoint number %d.\n", tpnum);
 642   return NULL;
 643 }
 644
 645 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
 646 static void
 647 map_args_over_tracepoints (args, from_tty, opcode)
 648      char *args;
 649      int from_tty;
 650      enum tracepoint_opcode opcode;
 651 {
 652   struct tracepoint *t, *tmp;
 653   int tpnum;
 654   char *cp;
 655
 656   if (args == 0 || *args == 0)  /* do them all */
 657     ALL_TRACEPOINTS_SAFE (t, tmp)
 658       tracepoint_operation (t, from_tty, opcode);
 659   else
 660     while (*args)
 661       {
 662         QUIT;           /* give user option to bail out with ^C */
 663         if (t = get_tracepoint_by_number (&args))
 664           tracepoint_operation (t, from_tty, opcode);
 665         while (*args == ' ' || *args == '\t')
 666           args++;
 667       }
 668 }
 669
 670 /* The 'enable trace' command enables tracepoints.  Not supported by all targets.  */
 671 static void
 672 enable_trace_command (args, from_tty)
 673      char *args;
 674      int from_tty;
 675 {
 676   dont_repeat ();
 677   map_args_over_tracepoints (args, from_tty, enable);
 678 }
 679
 680 /* The 'disable trace' command enables tracepoints.  Not supported by all targets.  */
 681 static void
 682 disable_trace_command (args, from_tty)
 683      char *args;
 684      int from_tty;
 685 {
 686   dont_repeat ();
 687   map_args_over_tracepoints (args, from_tty, disable);
 688 }
 689
 690 /* Remove a tracepoint (or all if no argument) */
 691 static void
 692 delete_trace_command (args, from_tty)
 693      char *args;
 694      int from_tty;
 695 {
 696   dont_repeat ();
 697   if (!args || !*args)          /* No args implies all tracepoints; */
 698     if (from_tty)               /* confirm only if from_tty... */
 699       if (tracepoint_chain)     /* and if there are tracepoints to delete! */
 700         if (!query ("Delete all tracepoints? "))
 701           return;
 702
 703   map_args_over_tracepoints (args, from_tty, delete);
 704 }
 705
 706 /* Set passcount for tracepoint.
 707
 708    First command argument is passcount, second is tracepoint number.
 709    If tracepoint number omitted, apply to most recently defined.
 710    Also accepts special argument "all".  */
 711
 712 static void
 713 trace_pass_command (args, from_tty)
 714      char *args;
 715      int from_tty;
 716 {
 717   struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
 718   unsigned long count;
 719
 720   if (args == 0 || *args == 0)
 721     error ("PASS command requires an argument (count + optional TP num)");
 722
 723   count = strtoul (args, &args, 10);    /* count comes first, then TP num */
 724
 725   while (*args && isspace (*args))
 726     args++;
 727
 728   if (*args && strncasecmp (args, "all", 3) == 0)
 729     args += 3;  /* skip special argument "all" */
 730   else
 731     t1 = get_tracepoint_by_number (&args);
 732
 733   if (*args)
 734     error ("Junk at end of arguments.");
 735
 736   if (t1 == NULL)
 737     return;     /* error, bad tracepoint number */
 738
 739   ALL_TRACEPOINTS (t2)
 740     if (t1 == (struct tracepoint *) -1 || t1 == t2)
 741       {
 742         t2->pass_count = count;
 743         if (modify_tracepoint_hook)
 744           modify_tracepoint_hook (t2);
 745         if (from_tty)
 746           printf_filtered ("Setting tracepoint %d's passcount to %d\n",
 747                            t2->number, count);
 748       }
 749 }
 750
 751 /* ACTIONS functions: */
 752
 753 /* Prototypes for action-parsing utility commands  */
 754 static void  read_actions PARAMS((struct tracepoint *));
 755 static char *parse_and_eval_memrange PARAMS ((char *,
 756                                               CORE_ADDR,
 757                                               long *,
 758                                               bfd_signed_vma *,
 759                                               long *));
 760
 761 /* The three functions:
 762         collect_pseudocommand,
 763         while_stepping_pseudocommand, and
 764         end_actions_pseudocommand
 765    are placeholders for "commands" that are actually ONLY to be used
 766    within a tracepoint action list.  If the actual function is ever called,
 767    it means that somebody issued the "command" at the top level,
 768    which is always an error.  */
 769
 770 static void
 771 end_actions_pseudocommand (args, from_tty)
 772      char *args;
 773      int from_tty;
 774 {
 775   error ("This command cannot be used at the top level.");
 776 }
 777
 778 static void
 779 while_stepping_pseudocommand (args, from_tty)
 780      char *args;
 781      int from_tty;
 782 {
 783   error ("This command can only be used in a tracepoint actions list.");
 784 }
 785
 786 static void
 787 collect_pseudocommand (args, from_tty)
 788      char *args;
 789      int from_tty;
 790 {
 791   error ("This command can only be used in a tracepoint actions list.");
 792 }
 793
 794 /* Enter a list of actions for a tracepoint.  */
 795 static void
 796 trace_actions_command (args, from_tty)
 797      char *args;
 798      int from_tty;
 799 {
 800   struct tracepoint *t;
 801   char *actions;
 802   char tmpbuf[128];
 803   char *end_msg = "End with a line saying just \"end\".";
 804
 805   if (t = get_tracepoint_by_number (&args))
 806     {
 807       sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
 808                t->number);
 809
 810       if (from_tty)
 811         {
 812           if (readline_begin_hook)
 813             (*readline_begin_hook) ("%s  %s\n", tmpbuf, end_msg);
 814           else if (input_from_terminal_p ())
 815             printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
 816         }
 817
 818       free_actions (t);
 819       t->step_count = 0;        /* read_actions may set this */
 820       read_actions (t);
 821
 822       if (readline_end_hook)
 823         (*readline_end_hook) ();
 824
 825       /* tracepoints_changed () */
 826     }
 827   /* else error, just return; */
 828 }
 829
 830 /* worker function */
 831 static void
 832 read_actions (t)
 833      struct tracepoint *t;
 834 {
 835   char *line;
 836   char *prompt1 = "> ", *prompt2 = "  > ";
 837   char *prompt = prompt1;
 838   enum actionline_type linetype;
 839   extern FILE *instream;
 840   struct action_line *next = NULL, *temp;
 841   struct cleanup *old_chain;
 842
 843   /* Control-C quits instantly if typed while in this loop
 844      since it should not wait until the user types a newline.  */
 845   immediate_quit++;
 846 #ifdef STOP_SIGNAL
 847   if (job_control)
 848     signal (STOP_SIGNAL, stop_sig);
 849 #endif
 850   old_chain = make_cleanup (free_actions, (void *) t);
 851   while (1)
 852     {
 853       /* Make sure that all output has been output.  Some machines may let
 854          you get away with leaving out some of the gdb_flush, but not all.  */
 855       wrap_here ("");
 856       gdb_flush (gdb_stdout);
 857       gdb_flush (gdb_stderr);
 858
 859       if (readline_hook && instream == NULL)
 860         line = (*readline_hook) (prompt);
 861       else if (instream == stdin && ISATTY (instream))
 862         {
 863           line = readline (prompt);
 864           if (line && *line)            /* add it to command history */
 865             add_history (line);
 866         }
 867       else
 868         line = gdb_readline (0);
 869
 870       linetype = validate_actionline (&line, t);
 871       if (linetype == BADLINE)
 872         continue;       /* already warned -- collect another line */
 873
 874       temp = xmalloc (sizeof (struct action_line));
 875       temp->next = NULL;
 876       temp->action = line;
 877
 878       if (next == NULL)         /* first action for this tracepoint? */
 879         t->actions = next = temp;
 880       else
 881         {
 882           next->next = temp;
 883           next = temp;
 884         }
 885
 886       if (linetype == STEPPING) /* begin "while-stepping" */
 887         if (prompt == prompt2)
 888           {
 889             warning ("Already processing 'while-stepping'");
 890             continue;
 891           }
 892         else
 893           prompt = prompt2;     /* change prompt for stepping actions */
 894       else if (linetype == END)
 895         if (prompt == prompt2)
 896           {
 897             prompt = prompt1;   /* end of single-stepping actions */
 898           }
 899         else
 900           { /* end of actions */
 901             if (t->actions->next == NULL)
 902               {
 903                 /* an "end" all by itself with no other actions means
 904                    this tracepoint has no actions.  Discard empty list. */
 905                 free_actions (t);
 906               }
 907             break;
 908           }
 909     }
 910 #ifdef STOP_SIGNAL
 911   if (job_control)
 912     signal (STOP_SIGNAL, SIG_DFL);
 913 #endif
 914   immediate_quit = 0;
 915   discard_cleanups (old_chain);
 916 }
 917
 918 /* worker function */
 919 enum actionline_type
 920 validate_actionline (line, t)
 921      char **line;
 922      struct tracepoint *t;
 923 {
 924   struct cmd_list_element *c;
 925   struct expression *exp = NULL;
 926   value_ptr temp, temp2;
 927   struct cleanup *old_chain = NULL;
 928   char *p;
 929
 930   for (p = *line; isspace (*p); )
 931     p++;
 932
 933   /* symbol lookup etc. */
 934   if (*p == '\0')       /* empty line: just prompt for another line. */
 935     return BADLINE;
 936
 937   if (*p == '#')        /* comment line */
 938     return GENERIC;
 939
 940   c = lookup_cmd (&p, cmdlist, "", -1, 1);
 941   if (c == 0)
 942     {
 943       warning ("'%s' is not an action that I know, or is ambiguous.", p);
 944       return BADLINE;
 945     }
 946
 947   if (c->function.cfunc == collect_pseudocommand)
 948     {
 949       struct agent_expr *aexpr;
 950       struct agent_reqs areqs;
 951
 952       do {                      /* repeat over a comma-separated list */
 953         QUIT;                   /* allow user to bail out with ^C */
 954         while (isspace (*p))
 955           p++;
 956
 957         if (*p == '$')                  /* look for special pseudo-symbols */
 958           {
 959             long typecode, size;
 960             bfd_signed_vma offset;
 961
 962             if ((0 == strncasecmp ("reg", p + 1, 3)) ||
 963                 (0 == strncasecmp ("arg", p + 1, 3)) ||
 964                 (0 == strncasecmp ("loc", p + 1, 3)))
 965               {
 966                 p = strchr (p, ',');
 967                 continue;
 968               }
 969             /* else fall thru, treat p as an expression and parse it! */
 970           }
 971         exp   = parse_exp_1 (&p, block_for_pc (t->address), 1);
 972         old_chain = make_cleanup (free_current_contents, &exp);
 973
 974         if (exp->elts[0].opcode == OP_VAR_VALUE)
 975           if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
 976             {
 977               warning ("%s is constant (value %d): will not be collected.",
 978                        SYMBOL_NAME (exp->elts[2].symbol),
 979                        SYMBOL_VALUE (exp->elts[2].symbol));
 980               return BADLINE;
 981             }
 982           else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
 983             {
 984               warning ("%s is optimized away and cannot be collected.",
 985                        SYMBOL_NAME (exp->elts[2].symbol));
 986               return BADLINE;
 987             }
 988
 989         /* we have something to collect, make sure that the expr to
 990            bytecode translator can handle it and that it's not too long */
 991         aexpr = gen_trace_for_expr(exp);
 992         (void) make_cleanup (free_agent_expr, aexpr);
 993
 994         if (aexpr->len > MAX_AGENT_EXPR_LEN)
 995           error ("expression too complicated, try simplifying");
 996
 997         ax_reqs(aexpr, &areqs);
 998         (void) make_cleanup (free, areqs.reg_mask);
 999
1000         if (areqs.flaw != agent_flaw_none)
1001           error ("malformed expression");
1002
1003         if (areqs.min_height < 0)
1004           error ("gdb: Internal error: expression has min height < 0");
1005
1006         if (areqs.max_height > 20)
1007           error ("expression too complicated, try simplifying");
1008
1009         do_cleanups (old_chain);
1010       } while (p && *p++ == ',');
1011       return GENERIC;
1012     }
1013   else if (c->function.cfunc == while_stepping_pseudocommand)
1014     {
1015       char *steparg;    /* in case warning is necessary */
1016
1017       while (isspace (*p))
1018         p++;
1019       steparg = p;
1020
1021       if (*p == '\0' ||
1022           (t->step_count = strtol (p, &p, 0)) == 0)
1023         {
1024           warning ("bad step-count: command ignored.", *line);
1025           return BADLINE;
1026         }
1027       return STEPPING;
1028     }
1029   else if (c->function.cfunc == end_actions_pseudocommand)
1030     return END;
1031   else
1032     {
1033       warning ("'%s' is not a supported tracepoint action.", *line);
1034       return BADLINE;
1035     }
1036 }
1037
1038 /* worker function */
1039 void
1040 free_actions (t)
1041      struct tracepoint *t;
1042 {
1043   struct action_line *line, *next;
1044
1045   for (line = t->actions; line; line = next)
1046     {
1047       next = line->next;
1048       if (line->action)
1049         free (line->action);
1050       free (line);
1051     }
1052   t->actions = NULL;
1053 }
1054
1055 struct memrange {
1056   int type;             /* 0 for absolute memory range, else basereg number */
1057   bfd_signed_vma start;
1058   bfd_signed_vma end;
1059 };
1060
1061 struct collection_list {
1062   unsigned char regs_mask[8];   /* room for up to 256 regs */
1063   long listsize;
1064   long next_memrange;
1065   struct memrange *list;
1066   long aexpr_listsize;          /* size of array pointed to by expr_list elt */
1067   long next_aexpr_elt;
1068   struct agent_expr **aexpr_list;
1069
1070 } tracepoint_list, stepping_list;
1071
1072 /* MEMRANGE functions: */
1073
1074 static int memrange_cmp PARAMS ((const void *, const void *));
1075
1076 /* compare memranges for qsort */
1077 static int
1078 memrange_cmp (va, vb)
1079      const void *va;
1080      const void *vb;
1081 {
1082   const struct memrange *a = va, *b = vb;
1083
1084   if (a->type < b->type)
1085     return -1;
1086   if (a->type > b->type)
1087     return  1;
1088   if (a->type == 0)
1089     {
1090       if ((bfd_vma) a->start  < (bfd_vma) b->start)  return -1;
1091       if ((bfd_vma) a->start  > (bfd_vma) b->start)  return  1;
1092     }
1093   else
1094     {
1095       if (a->start  < b->start)
1096         return -1;
1097       if (a->start  > b->start)
1098         return  1;
1099     }
1100   return 0;
1101 }
1102
1103 /* Sort the memrange list using qsort, and merge adjacent memranges */
1104 static void
1105 memrange_sortmerge (memranges)
1106      struct collection_list *memranges;
1107 {
1108   int a, b;
1109
1110   qsort (memranges->list, memranges->next_memrange,
1111          sizeof (struct memrange), memrange_cmp);
1112   if (memranges->next_memrange > 0)
1113     {
1114       for (a = 0, b = 1; b < memranges->next_memrange; b++)
1115         {
1116           if (memranges->list[a].type == memranges->list[b].type &&
1117               memranges->list[b].start - memranges->list[a].end <=
1118               MAX_REGISTER_VIRTUAL_SIZE)
1119             {
1120               /* memrange b starts before memrange a ends; merge them.  */
1121               if (memranges->list[b].end > memranges->list[a].end)
1122                 memranges->list[a].end = memranges->list[b].end;
1123               continue;         /* next b, same a */
1124             }
1125           a++;                  /* next a */
1126           if (a != b)
1127             memcpy (&memranges->list[a], &memranges->list[b],
1128                     sizeof (struct memrange));
1129         }
1130       memranges->next_memrange = a + 1;
1131     }
1132 }
1133
1134 /* Add a register to a collection list */
1135 void
1136 add_register (collection, regno)
1137      struct collection_list *collection;
1138      unsigned long regno;
1139 {
1140   if (info_verbose)
1141     printf_filtered ("collect register %d\n", regno);
1142   if (regno > (8 * sizeof (collection->regs_mask)))
1143     error ("Internal: register number %d too large for tracepoint",
1144            regno);
1145   collection->regs_mask [regno / 8] |= 1 << (regno  % 8);
1146 }
1147
1148 /* Add a memrange to a collection list */
1149 static void
1150 add_memrange (memranges, type, base, len)
1151      struct collection_list *memranges;
1152      int type;
1153      bfd_signed_vma base;
1154      unsigned long len;
1155 {
1156   if (info_verbose)
1157     printf_filtered ("(%d,0x%x,%d)\n", type, base, len);
1158   /* type: 0 == memory, n == basereg */
1159   memranges->list[memranges->next_memrange].type  = type;
1160   /* base: addr if memory, offset if reg relative. */
1161   memranges->list[memranges->next_memrange].start = base;
1162   /* len: we actually save end (base + len) for convenience */
1163   memranges->list[memranges->next_memrange].end   = base + len;
1164   memranges->next_memrange++;
1165   if (memranges->next_memrange >= memranges->listsize)
1166     {
1167       memranges->listsize *= 2;
1168       memranges->list = xrealloc (memranges->list,
1169                                   memranges->listsize);
1170     }
1171
1172   if (type != -1)       /* better collect the base register! */
1173     add_register (memranges, type);
1174 }
1175
1176 /* Add a symbol to a collection list */
1177 static void
1178 collect_symbol (collect, sym)
1179      struct collection_list *collect;
1180      struct symbol *sym;
1181 {
1182   unsigned long  len;
1183   unsigned long  reg;
1184   bfd_signed_vma offset;
1185
1186   len  = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
1187   switch (SYMBOL_CLASS (sym)) {
1188   default:
1189     printf_filtered ("%s: don't know symbol class %d\n",
1190                      SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
1191     break;
1192   case LOC_CONST:
1193     printf_filtered ("%s is constant, value is %d: will not be collected.\n",
1194                      SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
1195     break;
1196   case LOC_STATIC:
1197     offset = SYMBOL_VALUE_ADDRESS (sym);
1198     if (info_verbose)
1199       printf_filtered ("LOC_STATIC %s: collect %d bytes at 0x%08x\n",
1200                        SYMBOL_NAME (sym), len, offset);
1201     add_memrange (collect, -1, offset, len);    /* 0 == memory */
1202     break;
1203   case LOC_REGISTER:
1204   case LOC_REGPARM:
1205     reg = SYMBOL_VALUE (sym);
1206     if (info_verbose)
1207       printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
1208     add_register (collect, reg);
1209     break;
1210   case LOC_REF_ARG:
1211     printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1212     printf_filtered ("       (will not collect %s)\n",
1213                      SYMBOL_NAME (sym));
1214     break;
1215   case LOC_ARG:
1216     offset = SYMBOL_VALUE (sym);
1217     reg = FP_REGNUM;
1218     if (info_verbose)
1219       {
1220         printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
1221                          SYMBOL_NAME (sym), len);
1222         printf_filtered (" %d from frame ptr reg %d\n", offset, reg);
1223       }
1224     add_memrange (collect, reg, offset, len);
1225     break;
1226   case LOC_REGPARM_ADDR:
1227     reg = SYMBOL_VALUE (sym);
1228     offset = 0;
1229     if (info_verbose)
1230       {
1231         printf_filtered ("LOC_REGPARM_ADDR %s: Collect %d bytes at offset",
1232                          SYMBOL_NAME (sym), len);
1233         printf_filtered (" %d from reg %d\n", offset, reg);
1234       }
1235     add_memrange (collect, reg, offset, len);
1236     break;
1237   case LOC_LOCAL:
1238   case LOC_LOCAL_ARG:
1239     offset = SYMBOL_VALUE (sym);
1240     reg = FP_REGNUM;
1241     if (info_verbose)
1242       {
1243         printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
1244                          SYMBOL_NAME (sym), len);
1245         printf_filtered (" %d from frame ptr reg %d\n", offset, reg);
1246       }
1247     add_memrange (collect, reg, offset, len);
1248     break;
1249   case LOC_BASEREG:
1250   case LOC_BASEREG_ARG:
1251     reg = SYMBOL_BASEREG (sym);
1252     offset  = SYMBOL_VALUE (sym);
1253     if (info_verbose)
1254       {
1255         printf_filtered ("LOC_BASEREG %s: collect %d bytes at offset %d from basereg %d\n",
1256                          SYMBOL_NAME (sym), len, offset, reg);
1257       }
1258     add_memrange (collect, reg, offset, len);
1259     break;
1260   case LOC_UNRESOLVED:
1261     printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
1262     break;
1263   case LOC_OPTIMIZED_OUT:
1264     printf_filtered ("%s has been optimized out of existance.\n",
1265                      SYMBOL_NAME (sym));
1266     break;
1267   }
1268 }
1269
1270 /* Add all locals (or args) symbols to collection list */
1271 static void
1272 add_local_symbols (collect, pc, type)
1273      struct collection_list *collect;
1274      CORE_ADDR pc;
1275      int type;
1276 {
1277   struct symbol *sym;
1278   struct block  *block;
1279   int i, nsyms, count = 0;
1280
1281   block = block_for_pc (pc);
1282   while (block != 0)
1283     {
1284       QUIT;                             /* allow user to bail out with ^C */
1285       nsyms = BLOCK_NSYMS (block);
1286       for (i = 0; i < nsyms; i++)
1287         {
1288           sym = BLOCK_SYM (block, i);
1289           switch (SYMBOL_CLASS (sym)) {
1290           case LOC_LOCAL:
1291           case LOC_STATIC:
1292           case LOC_REGISTER:
1293           case LOC_BASEREG:
1294             if (type == 'L')    /* collecting Locals */
1295               {
1296                 count++;
1297                 collect_symbol (collect, sym);
1298               }
1299             break;
1300           case LOC_ARG:
1301           case LOC_LOCAL_ARG:
1302           case LOC_REF_ARG:
1303           case LOC_REGPARM:
1304           case LOC_REGPARM_ADDR:
1305           case LOC_BASEREG_ARG:
1306             if (type == 'A')    /* collecting Arguments */
1307               {
1308                 count++;
1309                 collect_symbol (collect, sym);
1310               }
1311           }
1312         }
1313       if (BLOCK_FUNCTION (block))
1314         break;
1315       else
1316         block = BLOCK_SUPERBLOCK (block);
1317     }
1318   if (count == 0)
1319     warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
1320 }
1321
1322 /* worker function */
1323 static void
1324 clear_collection_list (list)
1325      struct collection_list *list;
1326 {
1327   int ndx;
1328
1329   list->next_memrange = 0;
1330   for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1331     {
1332       free_agent_expr(list->aexpr_list[ndx]);
1333       list->aexpr_list[ndx] = NULL;
1334     }
1335   list->next_aexpr_elt = 0;
1336   memset (list->regs_mask, 0, sizeof (list->regs_mask));
1337 }
1338
1339 /* reduce a collection list to string form (for gdb protocol) */
1340 static char **
1341 stringify_collection_list (list, string)
1342      struct collection_list *list;
1343      char *string;
1344 {
1345   char temp_buf[2048];
1346   int count;
1347   int ndx = 0;
1348   char *(*str_list)[];
1349   char *end;
1350   long  i;
1351
1352   count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1353   str_list = (char *(*)[])xmalloc(count * sizeof (char *));
1354
1355   for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1356     if (list->regs_mask[i] != 0)        /* skip leading zeroes in regs_mask */
1357       break;
1358   if (list->regs_mask[i] != 0)  /* prepare to send regs_mask to the stub */
1359     {
1360       if (info_verbose)
1361         printf_filtered ("\nCollecting registers (mask): 0x");
1362       end = temp_buf;
1363       *end++='R';
1364       for (; i >= 0; i--)
1365         {
1366           QUIT;                         /* allow user to bail out with ^C */
1367           if (info_verbose)
1368             printf_filtered ("%02X", list->regs_mask[i]);
1369           sprintf (end,  "%02X", list->regs_mask[i]);
1370           end += 2;
1371         }
1372       (*str_list)[ndx] = savestring(temp_buf, end - temp_buf);
1373       ndx++;
1374     }
1375   if (info_verbose)
1376     printf_filtered ("\n");
1377   if (list->next_memrange > 0 && info_verbose)
1378     printf_filtered ("Collecting memranges: \n");
1379   for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1380     {
1381       QUIT;                     /* allow user to bail out with ^C */
1382       if (info_verbose)
1383         printf_filtered ("(%d, 0x%x, %d)\n",
1384                          list->list[i].type,
1385                          list->list[i].start,
1386                          list->list[i].end - list->list[i].start);
1387       if (count + 27 > MAX_AGENT_EXPR_LEN)
1388         {
1389           (*str_list)[ndx] = savestring(temp_buf, count);
1390           ndx++;
1391           count = 0;
1392           end = temp_buf;
1393         }
1394       sprintf (end, "M%X,%X,%X",
1395                list->list[i].type,
1396                list->list[i].start,
1397                list->list[i].end - list->list[i].start);
1398       count += strlen (end);
1399       end += strlen (end);
1400     }
1401
1402   for (i = 0; i < list->next_aexpr_elt; i++)
1403     {
1404       QUIT;                     /* allow user to bail out with ^C */
1405       if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1406         {
1407           (*str_list)[ndx] = savestring(temp_buf, count);
1408           ndx++;
1409           count = 0;
1410           end = temp_buf;
1411         }
1412       sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1413       end += 10;                /* 'X' + 8 hex digits + ',' */
1414       count += 10;
1415
1416       end = mem2hex(list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
1417       count += 2 * list->aexpr_list[i]->len;
1418     }
1419
1420   if (count != 0)
1421     {
1422       (*str_list)[ndx] = savestring(temp_buf, count);
1423       ndx++;
1424       count = 0;
1425       end = temp_buf;
1426     }
1427   (*str_list)[ndx] = NULL;
1428
1429   if (ndx == 0)
1430     return NULL;
1431   else
1432     return *str_list;
1433 }
1434
1435 void
1436 free_actions_list(actions_list)
1437      char **actions_list;
1438 {
1439   int ndx;
1440
1441   if (actions_list == 0)
1442     return;
1443
1444   for (ndx = 0; actions_list[ndx]; ndx++)
1445     free(actions_list[ndx]);
1446
1447   free(actions_list);
1448 }
1449
1450 /* render all actions into gdb protocol */
1451 static void
1452 encode_actions (t, tdp_actions, stepping_actions)
1453      struct tracepoint  *t;
1454      char              ***tdp_actions;
1455      char              ***stepping_actions;
1456 {
1457   static char        tdp_buff[2048], step_buff[2048];
1458   char               *action_exp;
1459   struct expression  *exp = NULL;
1460   struct action_line *action;
1461   bfd_signed_vma      offset;
1462   long                i;
1463   value_ptr           tempval;
1464   struct collection_list  *collect;
1465   struct cmd_list_element *cmd;
1466   struct agent_expr *aexpr;
1467
1468   clear_collection_list (&tracepoint_list);
1469   clear_collection_list (&stepping_list);
1470   collect = &tracepoint_list;
1471
1472   *tdp_actions = NULL;
1473   *stepping_actions = NULL;
1474
1475   for (action = t->actions; action; action = action->next)
1476     {
1477       QUIT;                     /* allow user to bail out with ^C */
1478       action_exp = action->action;
1479       while (isspace (*action_exp))
1480         action_exp++;
1481
1482       if (*action_exp == '#')   /* comment line */
1483         return;
1484
1485       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1486       if (cmd == 0)
1487         error ("Bad action list item: %s", action_exp);
1488
1489       if (cmd->function.cfunc == collect_pseudocommand)
1490         {
1491           do {  /* repeat over a comma-separated list */
1492             QUIT;               /* allow user to bail out with ^C */
1493             while (isspace (*action_exp))
1494               action_exp++;
1495
1496             if (0 == strncasecmp ("$reg", action_exp, 4))
1497               {
1498                 for (i = 0; i < NUM_REGS; i++)
1499                   add_register (collect, i);
1500                 action_exp = strchr (action_exp, ','); /* more? */
1501               }
1502             else if (0 == strncasecmp ("$arg", action_exp, 4))
1503               {
1504                 add_local_symbols (collect, t->address, 'A');
1505                 action_exp = strchr (action_exp, ','); /* more? */
1506               }
1507             else if (0 == strncasecmp ("$loc", action_exp, 4))
1508               {
1509                 add_local_symbols (collect, t->address, 'L');
1510                 action_exp = strchr (action_exp, ','); /* more? */
1511               }
1512             else
1513               {
1514                 unsigned long addr, len;
1515                 struct cleanup *old_chain = NULL;
1516                 struct cleanup *old_chain1 = NULL;
1517                 struct agent_reqs areqs;
1518
1519                 exp = parse_exp_1 (&action_exp, block_for_pc (t->address), 1);
1520                 old_chain = make_cleanup (free_current_contents, &exp);
1521
1522                 switch (exp->elts[0].opcode) {
1523                 case OP_REGISTER:
1524                   i = exp->elts[1].longconst;
1525                   if (info_verbose)
1526                     printf_filtered ("OP_REGISTER: ");
1527                   add_register (collect, i);
1528                   break;
1529
1530                 case UNOP_MEMVAL:
1531                   /* safe because we know it's a simple expression */
1532                   tempval = evaluate_expression (exp);
1533                   addr = VALUE_ADDRESS (tempval) + VALUE_OFFSET (tempval);
1534                   len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1535                   add_memrange (collect, -1, addr, len);
1536                   break;
1537
1538                 case OP_VAR_VALUE:
1539                   collect_symbol (collect, exp->elts[2].symbol);
1540                   break;
1541
1542                 default:        /* full-fledged expression */
1543                   aexpr = gen_trace_for_expr (exp);
1544
1545                   old_chain1 = make_cleanup (free_agent_expr, aexpr);
1546
1547                   ax_reqs (aexpr, &areqs);
1548                   if (areqs.flaw != agent_flaw_none)
1549                     error ("malformed expression");
1550
1551                   if (areqs.min_height < 0)
1552                     error ("gdb: Internal error: expression has min height < 0");
1553                   if (areqs.max_height > 20)
1554                     error ("expression too complicated, try simplifying");
1555
1556                   discard_cleanups (old_chain1);
1557                   add_aexpr (collect, aexpr);
1558
1559                   /* take care of the registers */
1560                   if (areqs.reg_mask_len > 0)
1561                     {
1562                       int ndx1;
1563                       int ndx2;
1564
1565                       for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1566                         {
1567                           QUIT;         /* allow user to bail out with ^C */
1568                           if (areqs.reg_mask[ndx1] != 0)
1569                             {
1570                               /* assume chars have 8 bits */
1571                               for (ndx2 = 0; ndx2 < 8; ndx2++)
1572                                 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1573                                   /* it's used -- record it */
1574                                   add_register (collect, ndx1 * 8 + ndx2);
1575                             }
1576                         }
1577                     }
1578                   break;
1579                 }       /* switch */
1580                 do_cleanups (old_chain);
1581               }         /* do */
1582           } while (action_exp && *action_exp++ == ',');
1583         }               /* if */
1584       else if (cmd->function.cfunc == while_stepping_pseudocommand)
1585         {
1586           collect = &stepping_list;
1587         }
1588       else if (cmd->function.cfunc == end_actions_pseudocommand)
1589         {
1590           if (collect == &stepping_list)        /* end stepping actions */
1591             collect = &tracepoint_list;
1592           else
1593             break;                      /* end tracepoint actions */
1594         }
1595     }                   /* for */
1596   memrange_sortmerge (&tracepoint_list);
1597   memrange_sortmerge (&stepping_list);
1598
1599   *tdp_actions      = stringify_collection_list (&tracepoint_list, &tdp_buff);
1600   *stepping_actions = stringify_collection_list (&stepping_list,   &step_buff);
1601 }
1602
1603 static void
1604 add_aexpr(collect, aexpr)
1605      struct collection_list *collect;
1606      struct agent_expr *aexpr;
1607 {
1608   if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1609     {
1610       collect->aexpr_list =
1611         xrealloc (collect->aexpr_list,
1612                   2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1613       collect->aexpr_listsize *= 2;
1614     }
1615   collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1616   collect->next_aexpr_elt++;
1617 }
1618
1619 static char target_buf[2048];
1620
1621 /* Set "transparent" memory ranges
1622
1623    Allow trace mechanism to treat text-like sections
1624    (and perhaps all read-only sections) transparently,
1625    i.e. don't reject memory requests from these address ranges
1626    just because they haven't been collected.  */
1627
1628 static void
1629 remote_set_transparent_ranges (void)
1630 {
1631   extern bfd *exec_bfd;
1632   asection *s;
1633   bfd_size_type size;
1634   bfd_vma lma;
1635   int anysecs = 0;
1636
1637   if (!exec_bfd)
1638     return;             /* no information to give. */
1639
1640   strcpy (target_buf, "QTro");
1641   for (s = exec_bfd->sections; s; s = s->next)
1642     {
1643       char tmp[40];
1644
1645       if ((s->flags & SEC_LOAD)     == 0 ||
1646        /* (s->flags & SEC_CODE)     == 0 || */
1647           (s->flags & SEC_READONLY) == 0)
1648         continue;
1649
1650       anysecs = 1;
1651       lma  = s->lma;
1652       size = bfd_get_section_size_before_reloc (s);
1653       sprintf (tmp, ":%x,%x", lma, lma + size);
1654       strcat (target_buf, tmp);
1655     }
1656   if (anysecs)
1657     {
1658       putpkt (target_buf);
1659       getpkt (target_buf, 0);
1660     }
1661 }
1662
1663 /* tstart command:
1664
1665    Tell target to clear any previous trace experiment.
1666    Walk the list of tracepoints, and send them (and their actions)
1667    to the target.  If no errors,
1668    Tell target to start a new trace experiment.  */
1669
1670 static void
1671 trace_start_command (args, from_tty)
1672      char *args;
1673      int from_tty;
1674 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1675   struct tracepoint *t;
1676   char buf[2048];
1677   char **tdp_actions;
1678   char **stepping_actions;
1679   int ndx;
1680   struct cleanup *old_chain = NULL;
1681
1682   dont_repeat ();       /* like "run", dangerous to repeat accidentally */
1683
1684   if (target_is_remote ())
1685     {
1686       putpkt ("QTinit");
1687       remote_get_noisy_reply (target_buf);
1688       if (strcmp (target_buf, "OK"))
1689         error ("Target does not support this command.");
1690
1691       ALL_TRACEPOINTS (t)
1692         {
1693           int ss_count;         /* if actions include singlestepping */
1694           int disable_mask;     /* ??? */
1695           int enable_mask;      /* ??? */
1696
1697           sprintf (buf, "QTDP:%x:%x:%c:%x:%x", t->number, t->address,
1698                    t->enabled == enabled ? 'E' : 'D',
1699                    t->step_count, t->pass_count);
1700
1701           if (t->actions)
1702             strcat (buf, "-");
1703           putpkt (buf);
1704           remote_get_noisy_reply (target_buf);
1705           if (strcmp (target_buf, "OK"))
1706             error ("Target does not support tracepoints.");
1707
1708           if (t->actions)
1709             {
1710               encode_actions (t, &tdp_actions, &stepping_actions);
1711               old_chain = make_cleanup (free_actions_list, tdp_actions);
1712               (void) make_cleanup (free_actions_list, stepping_actions);
1713
1714               /* do_single_steps (t); */
1715               if (tdp_actions)
1716                 {
1717                   for (ndx = 0; tdp_actions[ndx]; ndx++)
1718                     {
1719                       QUIT;             /* allow user to bail out with ^C */
1720                       sprintf (buf, "QTDP:-%x:%x:%s%c",
1721                                t->number, t->address,
1722                                tdp_actions[ndx],
1723                                ((tdp_actions[ndx+1] || stepping_actions)
1724                                 ? '-' : 0));
1725                       putpkt (buf);
1726                       remote_get_noisy_reply (target_buf);
1727                       if (strcmp (target_buf, "OK"))
1728                         error ("Error on target while setting tracepoints.");
1729                     }
1730                 }
1731               if (stepping_actions)
1732                 {
1733                   for (ndx = 0; stepping_actions[ndx]; ndx++)
1734                     {
1735                       QUIT;             /* allow user to bail out with ^C */
1736                       sprintf (buf, "QTDP:-%x:%x:%s%s%s",
1737                                t->number, t->address,
1738                                ((ndx == 0) ? "S" : ""),
1739                                stepping_actions[ndx],
1740                                (stepping_actions[ndx+1] ? "-" : ""));
1741                       putpkt (buf);
1742                       remote_get_noisy_reply (target_buf);
1743                       if (strcmp (target_buf, "OK"))
1744                         error ("Error on target while setting tracepoints.");
1745                     }
1746                 }
1747
1748               do_cleanups (old_chain);
1749             }
1750         }
1751       /* Tell target to treat text-like sections as transparent */
1752       remote_set_transparent_ranges ();
1753       /* Now insert traps and begin collecting data */
1754       putpkt ("QTStart");
1755       remote_get_noisy_reply (target_buf);
1756       if (strcmp (target_buf, "OK"))
1757         error ("Bogus reply from target: %s", target_buf);
1758       set_traceframe_num (-1);  /* all old traceframes invalidated */
1759       set_tracepoint_num (-1);
1760       set_traceframe_context(-1);
1761       trace_running_p = 1;
1762     }
1763   else
1764     error ("Trace can only be run on remote targets.");
1765 }
1766
1767 /* tstop command */
1768 static void
1769 trace_stop_command (args, from_tty)
1770      char *args;
1771      int from_tty;
1772 { /* STUB_COMM IS_IMPLEMENTED */
1773   if (target_is_remote ())
1774     {
1775       putpkt ("QTStop");
1776       remote_get_noisy_reply (target_buf);
1777       if (strcmp (target_buf, "OK"))
1778         error ("Bogus reply from target: %s", target_buf);
1779       trace_running_p = 0;
1780     }
1781   else
1782     error ("Trace can only be run on remote targets.");
1783 }
1784
1785 unsigned long trace_running_p;
1786
1787 /* tstatus command */
1788 static void
1789 trace_status_command (args, from_tty)
1790      char *args;
1791      int from_tty;
1792 { /* STUB_COMM IS_IMPLEMENTED */
1793   if (target_is_remote ())
1794     {
1795       putpkt ("qTStatus");
1796       remote_get_noisy_reply (target_buf);
1797
1798       if (target_buf[0] != 'T' ||
1799           (target_buf[1] != '0' && target_buf[1] != '1'))
1800         error ("Bogus reply from target: %s", target_buf);
1801
1802       /* exported for use by the GUI */
1803       trace_running_p = (target_buf[1] == '1');
1804     }
1805   else
1806     error ("Trace can only be run on remote targets.");
1807 }
1808
1809 /* Worker function for the various flavors of the tfind command */
1810 static void
1811 finish_tfind_command (msg, from_tty)
1812      char *msg;
1813      int from_tty;
1814 {
1815   int target_frameno = -1, target_tracept = -1;
1816   CORE_ADDR old_frame_addr;
1817   struct symbol *old_func;
1818   char *reply;
1819
1820   old_frame_addr = FRAME_FP (get_current_frame ());
1821   old_func       = find_pc_function (read_pc ());
1822
1823   putpkt (msg);
1824   reply = remote_get_noisy_reply (msg);
1825
1826   while (reply && *reply)
1827     switch (*reply) {
1828     case 'F':
1829       if ((target_frameno = strtol (++reply, &reply, 16)) == -1)
1830         {
1831           /* A request for a non-existant trace frame has failed.
1832              Our response will be different, depending on FROM_TTY:
1833
1834              If FROM_TTY is true, meaning that this command was
1835              typed interactively by the user, then give an error
1836              and DO NOT change the state of traceframe_number etc.
1837
1838              However if FROM_TTY is false, meaning that we're either
1839              in a script, a loop, or a user-defined command, then
1840              DON'T give an error, but DO change the state of
1841              traceframe_number etc. to invalid.
1842
1843              The rationalle is that if you typed the command, you
1844              might just have committed a typo or something, and you'd
1845              like to NOT lose your current debugging state.  However
1846              if you're in a user-defined command or especially in a
1847              loop, then you need a way to detect that the command
1848              failed WITHOUT aborting.  This allows you to write
1849              scripts that search thru the trace buffer until the end,
1850              and then continue on to do something else.  */
1851
1852           if (from_tty)
1853             error ("Target failed to find requested trace frame.");
1854           else
1855             {
1856               if (info_verbose)
1857                 printf_filtered ("End of trace buffer.\n");
1858               /* The following will not recurse, since it's special-cased */
1859               trace_find_command ("-1", from_tty);
1860               reply = NULL;     /* break out of loop,
1861                                    (avoid recursive nonsense) */
1862             }
1863         }
1864       break;
1865     case 'T':
1866       if ((target_tracept = strtol (++reply, &reply, 16)) == -1)
1867         error ("Target failed to find requested trace frame.");
1868       break;
1869     case 'O':   /* "OK"? */
1870       if (reply[1] == 'K' && reply[2] == '\0')
1871         reply += 2;
1872       else
1873         error ("Bogus reply from target: %s", reply);
1874       break;
1875     default:
1876       error ("Bogus reply from target: %s", reply);
1877     }
1878
1879   flush_cached_frames ();
1880   registers_changed ();
1881   select_frame (get_current_frame (), 0);
1882   set_traceframe_num (target_frameno);
1883   set_tracepoint_num (target_tracept);
1884   if (target_frameno == -1)
1885     set_traceframe_context (-1);
1886   else
1887     set_traceframe_context (read_pc ());
1888
1889   if (from_tty)
1890     {
1891       int source_only;
1892
1893       /* NOTE: in immitation of the step command, try to determine
1894          whether we have made a transition from one function to another.
1895          If so, we'll print the "stack frame" (ie. the new function and
1896          it's arguments) -- otherwise we'll just show the new source line.
1897
1898          This determination is made by checking (1) whether the current
1899          function has changed, and (2) whether the current FP has changed.
1900          Hack: if the FP wasn't collected, either at the current or the
1901          previous frame, assume that the FP has NOT changed.  */
1902
1903       if (old_func       == find_pc_function (read_pc ()) &&
1904          (old_frame_addr == 0 ||
1905           FRAME_FP (get_current_frame ()) == 0 ||
1906           old_frame_addr == FRAME_FP (get_current_frame ())))
1907         source_only = -1;
1908       else
1909         source_only =  1;
1910
1911       print_stack_frame (selected_frame, selected_frame_level, source_only);
1912       do_displays ();
1913     }
1914 }
1915
1916 /* trace_find_command takes a trace frame number n,
1917    sends "QTFrame:<n>" to the target,
1918    and accepts a reply that may contain several optional pieces
1919    of information: a frame number, a tracepoint number, and an
1920    indication of whether this is a trap frame or a stepping frame.
1921
1922    The minimal response is just "OK" (which indicates that the
1923    target does not give us a frame number or a tracepoint number).
1924    Instead of that, the target may send us a string containing
1925    any combination of:
1926         F<hexnum>       (gives the selected frame number)
1927         T<hexnum>       (gives the selected tracepoint number)
1928    */
1929
1930 /* tfind command */
1931 static void
1932 trace_find_command (args, from_tty)
1933      char *args;
1934      int from_tty;
1935 { /* STUB_COMM PART_IMPLEMENTED */
1936   /* this should only be called with a numeric argument */
1937   int frameno = -1;
1938   int target_frameno = -1, target_tracept = -1, target_stepfrm = 0;
1939   char *tmp;
1940
1941   if (target_is_remote ())
1942     {
1943       if (args == 0 || *args == 0)
1944         { /* TFIND with no args means find NEXT trace frame. */
1945           if (traceframe_number == -1)
1946             frameno = 0;        /* "next" is first one */
1947           else
1948             frameno = traceframe_number + 1;
1949         }
1950       else if (0 == strcmp (args, "-"))
1951         {
1952           if (traceframe_number == -1)
1953             error ("not debugging trace buffer");
1954           else if (from_tty && traceframe_number == 0)
1955             error ("already at start of trace buffer");
1956
1957           frameno = traceframe_number - 1;
1958         }
1959       else
1960         frameno = parse_and_eval_address (args);
1961
1962       if (frameno < -1)
1963         error ("invalid input (%d is less than zero)", frameno);
1964
1965       sprintf (target_buf, "QTFrame:%x", frameno);
1966       finish_tfind_command (target_buf, from_tty);
1967     }
1968   else
1969     error ("Trace can only be run on remote targets.");
1970 }
1971
1972 /* tfind end */
1973 static void
1974 trace_find_end_command (args, from_tty)
1975      char *args;
1976      int from_tty;
1977 {
1978   trace_find_command ("-1", from_tty);
1979 }
1980
1981 /* tfind none */
1982 static void
1983 trace_find_none_command (args, from_tty)
1984      char *args;
1985      int from_tty;
1986 {
1987   trace_find_command ("-1", from_tty);
1988 }
1989
1990 /* tfind start */
1991 static void
1992 trace_find_start_command (args, from_tty)
1993      char *args;
1994      int from_tty;
1995 {
1996   trace_find_command ("0", from_tty);
1997 }
1998
1999 /* tfind pc command */
2000 static void
2001 trace_find_pc_command (args, from_tty)
2002      char *args;
2003      int from_tty;
2004 { /* STUB_COMM PART_IMPLEMENTED */
2005   CORE_ADDR pc;
2006   int target_frameno;
2007   char *tmp;
2008
2009   if (target_is_remote ())
2010     {
2011       if (args == 0 || *args == 0)
2012         pc = read_pc ();        /* default is current pc */
2013       else
2014         pc = parse_and_eval_address (args);
2015
2016       sprintf (target_buf, "QTFrame:pc:%x", pc);
2017       finish_tfind_command (target_buf, from_tty);
2018     }
2019   else
2020     error ("Trace can only be run on remote targets.");
2021 }
2022
2023 /* tfind tracepoint command */
2024 static void
2025 trace_find_tracepoint_command (args, from_tty)
2026      char *args;
2027      int from_tty;
2028 { /* STUB_COMM PART_IMPLEMENTED */
2029   int target_frameno, tdp;
2030   char buf[40], *tmp;
2031
2032   if (target_is_remote ())
2033     {
2034       if (args == 0 || *args == 0)
2035         if (tracepoint_number == -1)
2036           error ("No current tracepoint -- please supply an argument.");
2037         else
2038           tdp = tracepoint_number;      /* default is current TDP */
2039       else
2040         tdp = parse_and_eval_address (args);
2041
2042       sprintf (target_buf, "QTFrame:tdp:%x", tdp);
2043       finish_tfind_command (target_buf, from_tty);
2044     }
2045   else
2046     error ("Trace can only be run on remote targets.");
2047 }
2048
2049 /* TFIND LINE command:
2050
2051    This command will take a sourceline for argument, just like BREAK
2052    or TRACE (ie. anything that "decode_line_1" can handle).
2053
2054    With no argument, this command will find the next trace frame
2055    corresponding to a source line OTHER THAN THE CURRENT ONE.  */
2056
2057 static void
2058 trace_find_line_command (args, from_tty)
2059      char *args;
2060      int from_tty;
2061 { /* STUB_COMM PART_IMPLEMENTED */
2062   static CORE_ADDR start_pc, end_pc;
2063   struct symtabs_and_lines sals;
2064   struct symtab_and_line sal;
2065   int target_frameno;
2066   char *tmp;
2067   struct cleanup *old_chain;
2068
2069   if (target_is_remote ())
2070     {
2071       if (args == 0 || *args == 0)
2072         {
2073           sal = find_pc_line ((get_current_frame ())->pc, 0);
2074           sals.nelts = 1;
2075           sals.sals = (struct symtab_and_line *)
2076             xmalloc (sizeof (struct symtab_and_line));
2077           sals.sals[0] = sal;
2078         }
2079       else
2080         {
2081           sals = decode_line_spec (args, 1);
2082           sal  = sals.sals[0];
2083         }
2084
2085       old_chain = make_cleanup (free, sals.sals);
2086       if (sal.symtab == 0)
2087         {
2088           printf_filtered ("TFIND: No line number information available");
2089           if (sal.pc != 0)
2090             {
2091               /* This is useful for "info line *0x7f34".  If we can't tell the
2092                  user about a source line, at least let them have the symbolic
2093                  address.  */
2094               printf_filtered (" for address ");
2095               wrap_here ("  ");
2096               print_address (sal.pc, gdb_stdout);
2097               printf_filtered (";\n -- will attempt to find by PC. \n");
2098             }
2099           else
2100             {
2101               printf_filtered (".\n");
2102               return;   /* no line, no PC; what can we do? */
2103             }
2104         }
2105       else if (sal.line > 0
2106                && find_line_pc_range (sal, &start_pc, &end_pc))
2107         {
2108           if (start_pc == end_pc)
2109             {
2110               printf_filtered ("Line %d of \"%s\"",
2111                                sal.line, sal.symtab->filename);
2112               wrap_here ("  ");
2113               printf_filtered (" is at address ");
2114               print_address (start_pc, gdb_stdout);
2115               wrap_here ("  ");
2116               printf_filtered (" but contains no code.\n");
2117               sal = find_pc_line (start_pc, 0);
2118               if (sal.line > 0 &&
2119                   find_line_pc_range (sal, &start_pc, &end_pc) &&
2120                   start_pc != end_pc)
2121                 printf_filtered ("Attempting to find line %d instead.\n",
2122                                  sal.line);
2123               else
2124                 error ("Cannot find a good line.");
2125             }
2126         }
2127       else
2128         /* Is there any case in which we get here, and have an address
2129            which the user would want to see?  If we have debugging symbols
2130            and no line numbers?  */
2131         error ("Line number %d is out of range for \"%s\".\n",
2132                sal.line, sal.symtab->filename);
2133
2134       if (args && *args)        /* find within range of stated line */
2135         sprintf (target_buf, "QTFrame:range:%x:%x", start_pc, end_pc - 1);
2136       else                      /* find OUTSIDE OF range of CURRENT line */
2137         sprintf (target_buf, "QTFrame:outside:%x:%x", start_pc, end_pc - 1);
2138       finish_tfind_command (target_buf, from_tty);
2139       do_cleanups (old_chain);
2140     }
2141   else
2142       error ("Trace can only be run on remote targets.");
2143 }
2144
2145 /* tfind range command */
2146 static void
2147 trace_find_range_command (args, from_tty)
2148      char *args;
2149      int from_tty;
2150 { /* STUB_COMM PART_IMPLEMENTED */
2151   static CORE_ADDR start, stop;
2152   int target_frameno;
2153   char *tmp;
2154
2155   if (target_is_remote ())
2156     {
2157       if (args == 0 || *args == 0)
2158         { /* XXX FIXME: what should default behavior be? */
2159           printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2160           return;
2161         }
2162
2163       if (0 != (tmp = strchr (args, ',' )))
2164         {
2165           *tmp++ = '\0';        /* terminate start address */
2166           while (isspace (*tmp))
2167             tmp++;
2168           start = parse_and_eval_address (args);
2169           stop  = parse_and_eval_address (tmp);
2170         }
2171       else
2172         { /* no explicit end address? */
2173           start = parse_and_eval_address (args);
2174           stop  = start + 1; /* ??? */
2175         }
2176
2177       sprintf (target_buf, "QTFrame:range:%x:%x", start, stop);
2178       finish_tfind_command (target_buf, from_tty);
2179     }
2180   else
2181       error ("Trace can only be run on remote targets.");
2182 }
2183
2184 /* tfind outside command */
2185 static void
2186 trace_find_outside_command (args, from_tty)
2187      char *args;
2188      int from_tty;
2189 { /* STUB_COMM PART_IMPLEMENTED */
2190   CORE_ADDR start, stop;
2191   int target_frameno;
2192   char *tmp;
2193
2194   if (target_is_remote ())
2195     {
2196       if (args == 0 || *args == 0)
2197         { /* XXX FIXME: what should default behavior be? */
2198           printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2199           return;
2200         }
2201
2202       if (0 != (tmp = strchr (args, ',' )))
2203         {
2204           *tmp++ = '\0';        /* terminate start address */
2205           while (isspace (*tmp))
2206             tmp++;
2207           start = parse_and_eval_address (args);
2208           stop  = parse_and_eval_address (tmp);
2209         }
2210       else
2211         { /* no explicit end address? */
2212           start = parse_and_eval_address (args);
2213           stop  = start + 1; /* ??? */
2214         }
2215
2216       sprintf (target_buf, "QTFrame:outside:%x:%x", start, stop);
2217       finish_tfind_command (target_buf, from_tty);
2218     }
2219   else
2220       error ("Trace can only be run on remote targets.");
2221 }
2222
2223 /* save-tracepoints command */
2224 static void
2225 tracepoint_save_command (args, from_tty)
2226      char *args;
2227      int from_tty;
2228 {
2229   struct tracepoint  *tp;
2230   struct action_line *line;
2231   FILE *fp;
2232   char *i1 = "    ", *i2 = "      ";
2233   char *indent, *actionline;
2234
2235   if (args == 0 || *args == 0)
2236     error ("Argument required (file name in which to save tracepoints");
2237
2238   if (tracepoint_chain == 0)
2239     {
2240       warning ("save-tracepoints: no tracepoints to save.\n");
2241       return;
2242     }
2243
2244   if (!(fp = fopen (args, "w")))
2245     error ("Unable to open file '%s' for saving tracepoints");
2246
2247   ALL_TRACEPOINTS (tp)
2248     {
2249       if (tp->addr_string)
2250         fprintf (fp, "trace %s\n", tp->addr_string);
2251       else
2252         fprintf (fp, "trace *0x%x\n", tp->address);
2253
2254       if (tp->pass_count)
2255         fprintf (fp, "  passcount %d\n", tp->pass_count);
2256
2257       if (tp->actions)
2258         {
2259           fprintf (fp, "  actions\n");
2260           indent = i1;
2261           for (line = tp->actions; line; line = line->next)
2262             {
2263               struct cmd_list_element *cmd;
2264
2265               QUIT;                     /* allow user to bail out with ^C */
2266               actionline = line->action;
2267               while (isspace(*actionline))
2268                 actionline++;
2269
2270               fprintf (fp, "%s%s\n", indent, actionline);
2271               if (*actionline != '#')   /* skip for comment lines */
2272                 {
2273                   cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
2274                   if (cmd == 0)
2275                     error ("Bad action list item: %s", actionline);
2276                   if (cmd->function.cfunc == while_stepping_pseudocommand)
2277                     indent = i2;
2278                   else if (cmd->function.cfunc == end_actions_pseudocommand)
2279                     indent = i1;
2280                 }
2281             }
2282         }
2283     }
2284   fclose (fp);
2285   if (from_tty)
2286     printf_filtered ("Tracepoints saved to file '%s'.\n", args);
2287   return;
2288 }
2289
2290 /* info scope command: list the locals for a scope.  */
2291 static void
2292 scope_info (args, from_tty)
2293      char *args;
2294      int from_tty;
2295 {
2296   struct symtab_and_line sal;
2297   struct symtabs_and_lines sals;
2298   struct symbol *sym;
2299   struct minimal_symbol *msym;
2300   struct block *block;
2301   char **canonical, *symname, *save_args = args;
2302   int i, nsyms, count = 0;
2303
2304   if (args == 0 || *args == 0)
2305     error ("requires an argument (function, line or *addr) to define a scope");
2306
2307   sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
2308   if (sals.nelts == 0)
2309     return;             /* presumably decode_line_1 has already warned */
2310
2311   /* Resolve line numbers to PC */
2312   resolve_sal_pc (&sals.sals[0]);
2313   block = block_for_pc (sals.sals[0].pc);
2314
2315   while (block != 0)
2316     {
2317       QUIT;                             /* allow user to bail out with ^C */
2318       nsyms = BLOCK_NSYMS (block);
2319       for (i = 0; i < nsyms; i++)
2320         {
2321           QUIT;                         /* allow user to bail out with ^C */
2322           if (count == 0)
2323             printf_filtered ("Scope for %s:\n", save_args);
2324           count++;
2325           sym = BLOCK_SYM (block, i);
2326           symname = SYMBOL_NAME (sym);
2327           if (symname == NULL || *symname == '\0')
2328             continue;   /* probably botched, certainly useless */
2329
2330           printf_filtered ("Symbol %s is ", symname);
2331           switch (SYMBOL_CLASS (sym)) {
2332           default:
2333           case LOC_UNDEF:               /* messed up symbol? */
2334             printf_filtered ("a bogus symbol, class %d.\n",
2335                              SYMBOL_CLASS (sym));
2336             count--;                    /* don't count this one */
2337             continue;
2338           case LOC_CONST:
2339             printf_filtered ("a constant with value %d (0x%x)",
2340                              SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2341             break;
2342           case LOC_CONST_BYTES:
2343             printf_filtered ("constant bytes: ");
2344             if (SYMBOL_TYPE (sym))
2345               for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (sym)); i++)
2346                 fprintf_filtered (gdb_stdout, " %02x",
2347                                   (unsigned) SYMBOL_VALUE_BYTES (sym) [i]);
2348             break;
2349           case LOC_STATIC:
2350             printf_filtered ("in static storage at address ");
2351             print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2352             break;
2353           case LOC_REGISTER:
2354             printf_filtered ("a local variable in register $%s",
2355                              reg_names [SYMBOL_VALUE (sym)]);
2356             break;
2357           case LOC_ARG:
2358           case LOC_LOCAL_ARG:
2359             printf_filtered ("an argument at stack/frame offset %ld",
2360                              SYMBOL_VALUE (sym));
2361             break;
2362           case LOC_LOCAL:
2363             printf_filtered ("a local variable at frame offset %ld",
2364                              SYMBOL_VALUE (sym));
2365             break;
2366           case LOC_REF_ARG:
2367             printf_filtered ("a reference argument at offset %ld",
2368                              SYMBOL_VALUE (sym));
2369             break;
2370           case LOC_REGPARM:
2371             printf_filtered ("an argument in register $%s",
2372                              reg_names[SYMBOL_VALUE (sym)]);
2373             break;
2374           case LOC_REGPARM_ADDR:
2375             printf_filtered ("the address of an argument, in register $%s",
2376                              reg_names[SYMBOL_VALUE (sym)]);
2377             break;
2378           case LOC_TYPEDEF:
2379             printf_filtered ("a typedef.\n");
2380             continue;
2381           case LOC_LABEL:
2382             printf_filtered ("a label at address ");
2383             print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2384             break;
2385           case LOC_BLOCK:
2386             printf_filtered ("a function at address ");
2387             print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
2388                                    gdb_stdout);
2389             break;
2390           case LOC_BASEREG:
2391             printf_filtered ("a variable at offset %d from register $%s",
2392                              SYMBOL_VALUE (sym),
2393                              reg_names [SYMBOL_BASEREG (sym)]);
2394             break;
2395           case LOC_BASEREG_ARG:
2396             printf_filtered ("an argument at offset %d from register $%s",
2397                              SYMBOL_VALUE (sym),
2398                              reg_names [SYMBOL_BASEREG (sym)]);
2399             break;
2400           case LOC_UNRESOLVED:
2401             msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
2402             if (msym == NULL)
2403               printf_filtered ("Unresolved Static");
2404             else
2405               {
2406                 printf_filtered ("static storage at address ");
2407                 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
2408                                        gdb_stdout);
2409               }
2410             break;
2411           case LOC_OPTIMIZED_OUT:
2412             printf_filtered ("optimized out.\n");
2413             continue;
2414           }
2415           if (SYMBOL_TYPE (sym))
2416             printf_filtered (", length %d.\n",
2417                              TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2418         }
2419       if (BLOCK_FUNCTION (block))
2420         break;
2421       else
2422         block = BLOCK_SUPERBLOCK (block);
2423     }
2424   if (count <= 0)
2425     printf_filtered ("Scope for %s contains no locals or arguments.\n",
2426                      save_args);
2427 }
2428
2429 /* worker function (cleanup) */
2430 static void
2431 replace_comma (comma)
2432      char *comma;
2433 {
2434   *comma = ',';
2435 }
2436
2437 /* tdump command */
2438 static void
2439 trace_dump_command (args, from_tty)
2440      char *args;
2441      int from_tty;
2442 {
2443   struct tracepoint  *t;
2444   struct action_line *action;
2445   char               *action_exp, *next_comma;
2446   struct cleanup     *old_cleanups;
2447   int                 stepping_actions = 0;
2448   int                 stepping_frame   = 0;
2449
2450   if (!target_is_remote ())
2451     {
2452       error ("Trace can only be run on remote targets.");
2453       return;
2454     }
2455
2456   if (tracepoint_number == -1)
2457     {
2458       warning ("No current trace frame.");
2459       return;
2460     }
2461
2462   ALL_TRACEPOINTS (t)
2463     if (t->number == tracepoint_number)
2464       break;
2465
2466   if (t == NULL)
2467     error ("No known tracepoint matches 'current' tracepoint #%d.",
2468            tracepoint_number);
2469
2470   old_cleanups = make_cleanup (null_cleanup, NULL);
2471
2472   printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2473                    tracepoint_number, traceframe_number);
2474
2475   /* The current frame is a trap frame if the frame PC is equal
2476      to the tracepoint PC.  If not, then the current frame was
2477      collected during single-stepping.  */
2478
2479   stepping_frame = (t->address != read_pc());
2480
2481   for (action = t->actions; action; action = action->next)
2482     {
2483       struct cmd_list_element *cmd;
2484
2485       QUIT;                             /* allow user to bail out with ^C */
2486       action_exp = action->action;
2487       while (isspace (*action_exp))
2488         action_exp++;
2489
2490       /* The collection actions to be done while stepping are
2491          bracketed by the commands "while-stepping" and "end".  */
2492
2493       if (*action_exp == '#')   /* comment line */
2494         continue;
2495
2496       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2497       if (cmd == 0)
2498         error ("Bad action list item: %s", action_exp);
2499
2500       if (cmd->function.cfunc == while_stepping_pseudocommand)
2501         stepping_actions = 1;
2502       else if (cmd->function.cfunc == end_actions_pseudocommand)
2503         stepping_actions = 0;
2504       else if (cmd->function.cfunc == collect_pseudocommand)
2505         {
2506           /* Display the collected data.
2507              For the trap frame, display only what was collected at the trap.
2508              Likewise for stepping frames, display only what was collected
2509              while stepping.  This means that the two boolean variables,
2510              STEPPING_FRAME and STEPPING_ACTIONS should be equal.  */
2511           if (stepping_frame == stepping_actions)
2512             {
2513               do { /* repeat over a comma-separated list */
2514                 QUIT;           /* allow user to bail out with ^C */
2515                 if (*action_exp == ',')
2516                   action_exp++;
2517                 while (isspace (*action_exp))
2518                   action_exp++;
2519
2520                 next_comma = strchr (action_exp, ',');
2521
2522                 if      (0 == strncasecmp (action_exp, "$reg", 4))
2523                   registers_info (NULL, from_tty);
2524                 else if (0 == strncasecmp (action_exp, "$loc", 4))
2525                   locals_info (NULL, from_tty);
2526                 else if (0 == strncasecmp (action_exp, "$arg", 4))
2527                   args_info (NULL, from_tty);
2528                 else
2529                   { /* variable */
2530                     if (next_comma)
2531                       {
2532                         make_cleanup (replace_comma, next_comma);
2533                         *next_comma = '\0';
2534                       }
2535                     printf_filtered ("%s = ", action_exp);
2536                     output_command (action_exp, from_tty);
2537                     printf_filtered ("\n");
2538                   }
2539                 if (next_comma)
2540                   *next_comma = ',';
2541                 action_exp = next_comma;
2542               } while (action_exp && *action_exp == ',');
2543             }
2544         }
2545     }
2546   discard_cleanups (old_cleanups);
2547 }
2548
2549 /* Convert the memory pointed to by mem into hex, placing result in buf.
2550  * Return a pointer to the last char put in buf (null)
2551  * "stolen" from sparc-stub.c
2552  */
2553
2554 static const char hexchars[]="0123456789abcdef";
2555
2556 static unsigned char *
2557 mem2hex(mem, buf, count)
2558      unsigned char *mem;
2559      unsigned char *buf;
2560      int count;
2561 {
2562   unsigned char ch;
2563
2564   while (count-- > 0)
2565     {
2566       ch = *mem++;
2567
2568       *buf++ = hexchars[ch >> 4];
2569       *buf++ = hexchars[ch & 0xf];
2570     }
2571
2572   *buf = 0;
2573
2574   return buf;
2575 }
2576
2577 int get_traceframe_number()
2578 {
2579  return traceframe_number;
2580 }
2581
2582
2583 /* module initialization */
2584 void
2585 _initialize_tracepoint ()
2586 {
2587   tracepoint_chain  = 0;
2588   tracepoint_count  = 0;
2589   traceframe_number = -1;
2590   tracepoint_number = -1;
2591
2592   set_internalvar (lookup_internalvar ("tpnum"),
2593                    value_from_longest (builtin_type_int, (LONGEST) 0));
2594   set_internalvar (lookup_internalvar ("trace_frame"),
2595                    value_from_longest (builtin_type_int, (LONGEST) -1));
2596
2597   if (tracepoint_list.list == NULL)
2598     {
2599       tracepoint_list.listsize = 128;
2600       tracepoint_list.list = xmalloc
2601         (tracepoint_list.listsize * sizeof (struct memrange));
2602     }
2603   if (tracepoint_list.aexpr_list == NULL)
2604     {
2605       tracepoint_list.aexpr_listsize = 128;
2606       tracepoint_list.aexpr_list = xmalloc
2607         (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
2608     }
2609
2610   if (stepping_list.list == NULL)
2611     {
2612       stepping_list.listsize = 128;
2613       stepping_list.list = xmalloc
2614         (stepping_list.listsize * sizeof (struct memrange));
2615     }
2616
2617   if (stepping_list.aexpr_list == NULL)
2618     {
2619       stepping_list.aexpr_listsize = 128;
2620       stepping_list.aexpr_list = xmalloc
2621         (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
2622     }
2623
2624   add_info ("scope", scope_info,
2625             "List the variables local to a scope");
2626
2627   add_cmd ("tracepoints", class_trace, NO_FUNCTION,
2628            "Tracing of program execution without stopping the program.",
2629            &cmdlist);
2630
2631   add_info ("tracepoints", tracepoints_info,
2632             "Status of tracepoints, or tracepoint number NUMBER.\n\
2633 Convenience variable \"$tpnum\" contains the number of the\n\
2634 last tracepoint set.");
2635
2636   add_info_alias ("tp", "tracepoints", 1);
2637
2638   add_com ("save-tracepoints", class_trace, tracepoint_save_command,
2639            "Save current tracepoint definitions as a script.\n\
2640 Use the 'source' command in another debug session to restore them.");
2641
2642   add_com ("tdump", class_trace, trace_dump_command,
2643            "Print everything collected at the current tracepoint.");
2644
2645   add_prefix_cmd ("tfind",  class_trace, trace_find_command,
2646                   "Select a trace frame;\n\
2647 No argument means forward by one frame; '-' meand backward by one frame.",
2648                   &tfindlist, "tfind ", 1, &cmdlist);
2649
2650   add_cmd ("outside", class_trace, trace_find_outside_command,
2651            "Select a trace frame whose PC is outside the given \
2652 range.\nUsage: tfind outside addr1, addr2",
2653            &tfindlist);
2654
2655   add_cmd ("range", class_trace, trace_find_range_command,
2656            "Select a trace frame whose PC is in the given range.\n\
2657 Usage: tfind range addr1,addr2",
2658            &tfindlist);
2659
2660   add_cmd ("line", class_trace, trace_find_line_command,
2661            "Select a trace frame by source line.\n\
2662 Argument can be a line number (with optional source file), \n\
2663 a function name, or '*' followed by an address.\n\
2664 Default argument is 'the next source line that was traced'.",
2665            &tfindlist);
2666
2667   add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command,
2668            "Select a trace frame by tracepoint number.\n\
2669 Default is the tracepoint for the current trace frame.",
2670            &tfindlist);
2671
2672   add_cmd ("pc", class_trace, trace_find_pc_command,
2673            "Select a trace frame by PC.\n\
2674 Default is the current PC, or the PC of the current trace frame.",
2675            &tfindlist);
2676
2677   add_cmd ("end", class_trace, trace_find_end_command,
2678            "Synonym for 'none'.\n\
2679 De-select any trace frame and resume 'live' debugging.",
2680            &tfindlist);
2681
2682   add_cmd ("none", class_trace, trace_find_none_command,
2683            "De-select any trace frame and resume 'live' debugging.",
2684            &tfindlist);
2685
2686   add_cmd ("start", class_trace, trace_find_start_command,
2687            "Select the first trace frame in the trace buffer.",
2688            &tfindlist);
2689
2690   add_com ("tstatus",  class_trace, trace_status_command,
2691            "Display the status of the current trace data collection.");
2692
2693   add_com ("tstop",  class_trace, trace_stop_command,
2694            "Stop trace data collection.");
2695
2696   add_com ("tstart", class_trace, trace_start_command,
2697            "Start trace data collection.");
2698
2699   add_com ("passcount", class_trace, trace_pass_command,
2700            "Set the passcount for a tracepoint.\n\
2701 The trace will end when the tracepoint has been passed 'count' times.\n\
2702 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2703 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2704
2705   add_com ("end", class_trace, end_actions_pseudocommand,
2706            "Ends a list of commands or actions.\n\
2707 Several GDB commands allow you to enter a list of commands or actions.\n\
2708 Entering \"end\" on a line by itself is the normal way to terminate\n\
2709 such a list.\n\n\
2710 Note: the \"end\" command cannot be used at the gdb prompt.");
2711
2712   add_com ("while-stepping", class_trace, while_stepping_pseudocommand,
2713            "Specify single-stepping behavior at a tracepoint.\n\
2714 Argument is number of instructions to trace in single-step mode\n\
2715 following the tracepoint.  This command is normally followed by\n\
2716 one or more \"collect\" commands, to specify what to collect\n\
2717 while single-stepping.\n\n\
2718 Note: this command can only be used in a tracepoint \"actions\" list.");
2719
2720   add_com_alias ("ws",         "while-stepping", class_alias, 0);
2721   add_com_alias ("stepping",   "while-stepping", class_alias, 0);
2722
2723   add_com ("collect", class_trace, collect_pseudocommand,
2724            "Specify one or more data items to be collected at a tracepoint.\n\
2725 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
2726 collect all data (variables, registers) referenced by that expression.\n\
2727 Also accepts the following special arguments:\n\
2728     $regs   -- all registers.\n\
2729     $args   -- all function arguments.\n\
2730     $locals -- all variables local to the block/function scope.\n\
2731 Note: this command can only be used in a tracepoint \"actions\" list.");
2732
2733   add_com ("actions", class_trace, trace_actions_command,
2734            "Specify the actions to be taken at a tracepoint.\n\
2735 Tracepoint actions may include collecting of specified data, \n\
2736 single-stepping, or enabling/disabling other tracepoints, \n\
2737 depending on target's capabilities.");
2738
2739   add_cmd ("tracepoints", class_trace, delete_trace_command,
2740            "Delete specified tracepoints.\n\
2741 Arguments are tracepoint numbers, separated by spaces.\n\
2742 No argument means delete all tracepoints.",
2743            &deletelist);
2744
2745   add_cmd ("tracepoints", class_trace, disable_trace_command,
2746            "Disable specified tracepoints.\n\
2747 Arguments are tracepoint numbers, separated by spaces.\n\
2748 No argument means disable all tracepoints.",
2749            &disablelist);
2750
2751   add_cmd ("tracepoints", class_trace, enable_trace_command,
2752            "Enable specified tracepoints.\n\
2753 Arguments are tracepoint numbers, separated by spaces.\n\
2754 No argument means enable all tracepoints.",
2755            &enablelist);
2756
2757   add_com ("trace", class_trace, trace_command,
2758            "Set a tracepoint at a specified line or function or address.\n\
2759 Argument may be a line number, function name, or '*' plus an address.\n\
2760 For a line number or function, trace at the start of its code.\n\
2761 If an address is specified, trace at that exact address.\n\n\
2762 Do \"help tracepoints\" for info on other tracepoint commands.");
2763
2764   add_com_alias ("tp",   "trace", class_alias, 0);
2765   add_com_alias ("tr",   "trace", class_alias, 1);
2766   add_com_alias ("tra",  "trace", class_alias, 1);
2767   add_com_alias ("trac", "trace", class_alias, 1);
2768 }
2769