gdb/tracepoint.c

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