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