contrib/gdb/gdb/tracepoint.c

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