gdb/tracepoint.c

   1 /* Tracing functionality for remote targets in custom GDB protocol
   2
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   4    2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "arch-utils.h"
  23 #include "symtab.h"
  24 #include "frame.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "gdbcmd.h"
  28 #include "value.h"
  29 #include "target.h"
  30 #include "language.h"
  31 #include "gdb_string.h"
  32 #include "inferior.h"
  33 #include "breakpoint.h"
  34 #include "tracepoint.h"
  35 #include "linespec.h"
  36 #include "regcache.h"
  37 #include "completer.h"
  38 #include "block.h"
  39 #include "dictionary.h"
  40 #include "observer.h"
  41 #include "user-regs.h"
  42 #include "valprint.h"
  43 #include "gdbcore.h"
  44 #include "objfiles.h"
  45 #include "filenames.h"
  46 #include "gdbthread.h"
  47 #include "stack.h"
  48 #include "gdbcore.h"
  49
  50 #include "ax.h"
  51 #include "ax-gdb.h"
  52
  53 /* readline include files */
  54 #include "readline/readline.h"
  55 #include "readline/history.h"
  56
  57 /* readline defines this.  */
  58 #undef savestring
  59
  60 #ifdef HAVE_UNISTD_H
  61 #include <unistd.h>
  62 #endif
  63
  64 #ifndef O_LARGEFILE
  65 #define O_LARGEFILE 0
  66 #endif
  67
  68 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
  69 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
  70
  71 extern void stop_tracing ();
  72
  73 /* Maximum length of an agent aexpression.
  74    This accounts for the fact that packets are limited to 400 bytes
  75    (which includes everything -- including the checksum), and assumes
  76    the worst case of maximum length for each of the pieces of a
  77    continuation packet.
  78
  79    NOTE: expressions get mem2hex'ed otherwise this would be twice as
  80    large.  (400 - 31)/2 == 184 */
  81 #define MAX_AGENT_EXPR_LEN      184
  82
  83 /* A hook used to notify the UI of tracepoint operations.  */
  84
  85 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
  86 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
  87
  88 extern void (*deprecated_readline_begin_hook) (char *, ...);
  89 extern char *(*deprecated_readline_hook) (char *);
  90 extern void (*deprecated_readline_end_hook) (void);
  91
  92 /* GDB commands implemented in other modules:
  93  */
  94
  95 extern void output_command (char *, int);
  96
  97 /*
  98    Tracepoint.c:
  99
 100    This module defines the following debugger commands:
 101    trace            : set a tracepoint on a function, line, or address.
 102    info trace       : list all debugger-defined tracepoints.
 103    delete trace     : delete one or more tracepoints.
 104    enable trace     : enable one or more tracepoints.
 105    disable trace    : disable one or more tracepoints.
 106    actions          : specify actions to be taken at a tracepoint.
 107    passcount        : specify a pass count for a tracepoint.
 108    tstart           : start a trace experiment.
 109    tstop            : stop a trace experiment.
 110    tstatus          : query the status of a trace experiment.
 111    tfind            : find a trace frame in the trace buffer.
 112    tdump            : print everything collected at the current tracepoint.
 113    save-tracepoints : write tracepoint setup into a file.
 114
 115    This module defines the following user-visible debugger variables:
 116    $trace_frame : sequence number of trace frame currently being debugged.
 117    $trace_line  : source line of trace frame currently being debugged.
 118    $trace_file  : source file of trace frame currently being debugged.
 119    $tracepoint  : tracepoint number of trace frame currently being debugged.
 120  */
 121
 122
 123 /* ======= Important global variables: ======= */
 124
 125 /* The list of all trace state variables.  We don't retain pointers to
 126    any of these for any reason - API is by name or number only - so it
 127    works to have a vector of objects.  */
 128
 129 typedef struct trace_state_variable tsv_s;
 130 DEF_VEC_O(tsv_s);
 131
 132 static VEC(tsv_s) *tvariables;
 133
 134 /* The next integer to assign to a variable.  */
 135
 136 static int next_tsv_number = 1;
 137
 138 /* Number of last traceframe collected.  */
 139 static int traceframe_number;
 140
 141 /* Tracepoint for last traceframe collected.  */
 142 static int tracepoint_number;
 143
 144 /* Symbol for function for last traceframe collected */
 145 static struct symbol *traceframe_fun;
 146
 147 /* Symtab and line for last traceframe collected */
 148 static struct symtab_and_line traceframe_sal;
 149
 150 /* Tracing command lists */
 151 static struct cmd_list_element *tfindlist;
 152
 153 /* List of expressions to collect by default at each tracepoint hit.  */
 154 char *default_collect = "";
 155
 156 static int disconnected_tracing;
 157
 158 /* This variable controls whether we ask the target for a linear or
 159    circular trace buffer.  */
 160
 161 static int circular_trace_buffer;
 162
 163 /* ======= Important command functions: ======= */
 164 static void trace_actions_command (char *, int);
 165 static void trace_start_command (char *, int);
 166 static void trace_stop_command (char *, int);
 167 static void trace_status_command (char *, int);
 168 static void trace_find_command (char *, int);
 169 static void trace_find_pc_command (char *, int);
 170 static void trace_find_tracepoint_command (char *, int);
 171 static void trace_find_line_command (char *, int);
 172 static void trace_find_range_command (char *, int);
 173 static void trace_find_outside_command (char *, int);
 174 static void trace_dump_command (char *, int);
 175
 176 /* support routines */
 177
 178 struct collection_list;
 179 static void add_aexpr (struct collection_list *, struct agent_expr *);
 180 static char *mem2hex (gdb_byte *, char *, int);
 181 static void add_register (struct collection_list *collection,
 182                           unsigned int regno);
 183
 184 extern void send_disconnected_tracing_value (int value);
 185
 186 static void free_uploaded_tps (struct uploaded_tp **utpp);
 187 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
 188
 189
 190 extern void _initialize_tracepoint (void);
 191
 192 static struct trace_status trace_status;
 193
 194 char *stop_reason_names[] = {
 195   "tunknown",
 196   "tnotrun",
 197   "tstop",
 198   "tfull",
 199   "tdisconnected",
 200   "tpasscount",
 201   "terror"
 202 };
 203
 204 struct trace_status *
 205 current_trace_status ()
 206 {
 207   return &trace_status;
 208 }
 209
 210 /* Set traceframe number to NUM.  */
 211 static void
 212 set_traceframe_num (int num)
 213 {
 214   traceframe_number = num;
 215   set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
 216 }
 217
 218 /* Set tracepoint number to NUM.  */
 219 static void
 220 set_tracepoint_num (int num)
 221 {
 222   tracepoint_number = num;
 223   set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
 224 }
 225
 226 /* Set externally visible debug variables for querying/printing
 227    the traceframe context (line, function, file) */
 228
 229 static void
 230 set_traceframe_context (struct frame_info *trace_frame)
 231 {
 232   CORE_ADDR trace_pc;
 233
 234   if (trace_frame == NULL)              /* Cease debugging any trace buffers.  */
 235     {
 236       traceframe_fun = 0;
 237       traceframe_sal.pc = traceframe_sal.line = 0;
 238       traceframe_sal.symtab = NULL;
 239       clear_internalvar (lookup_internalvar ("trace_func"));
 240       clear_internalvar (lookup_internalvar ("trace_file"));
 241       set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
 242       return;
 243     }
 244
 245   /* Save as globals for internal use.  */
 246   trace_pc = get_frame_pc (trace_frame);
 247   traceframe_sal = find_pc_line (trace_pc, 0);
 248   traceframe_fun = find_pc_function (trace_pc);
 249
 250   /* Save linenumber as "$trace_line", a debugger variable visible to
 251      users.  */
 252   set_internalvar_integer (lookup_internalvar ("trace_line"),
 253                            traceframe_sal.line);
 254
 255   /* Save func name as "$trace_func", a debugger variable visible to
 256      users.  */
 257   if (traceframe_fun == NULL
 258       || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
 259     clear_internalvar (lookup_internalvar ("trace_func"));
 260   else
 261     set_internalvar_string (lookup_internalvar ("trace_func"),
 262                             SYMBOL_LINKAGE_NAME (traceframe_fun));
 263
 264   /* Save file name as "$trace_file", a debugger variable visible to
 265      users.  */
 266   if (traceframe_sal.symtab == NULL
 267       || traceframe_sal.symtab->filename == NULL)
 268     clear_internalvar (lookup_internalvar ("trace_file"));
 269   else
 270     set_internalvar_string (lookup_internalvar ("trace_file"),
 271                             traceframe_sal.symtab->filename);
 272 }
 273
 274 /* Create a new trace state variable with the given name.  */
 275
 276 struct trace_state_variable *
 277 create_trace_state_variable (const char *name)
 278 {
 279   struct trace_state_variable tsv;
 280
 281   memset (&tsv, 0, sizeof (tsv));
 282   tsv.name = xstrdup (name);
 283   tsv.number = next_tsv_number++;
 284   return VEC_safe_push (tsv_s, tvariables, &tsv);
 285 }
 286
 287 /* Look for a trace state variable of the given name.  */
 288
 289 struct trace_state_variable *
 290 find_trace_state_variable (const char *name)
 291 {
 292   struct trace_state_variable *tsv;
 293   int ix;
 294
 295   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 296     if (strcmp (name, tsv->name) == 0)
 297       return tsv;
 298
 299   return NULL;
 300 }
 301
 302 void
 303 delete_trace_state_variable (const char *name)
 304 {
 305   struct trace_state_variable *tsv;
 306   int ix;
 307
 308   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 309     if (strcmp (name, tsv->name) == 0)
 310       {
 311         xfree ((void *)tsv->name);
 312         VEC_unordered_remove (tsv_s, tvariables, ix);
 313         return;
 314       }
 315
 316   warning (_("No trace variable named \"$%s\", not deleting"), name);
 317 }
 318
 319 /* The 'tvariable' command collects a name and optional expression to
 320    evaluate into an initial value.  */
 321
 322 void
 323 trace_variable_command (char *args, int from_tty)
 324 {
 325   struct expression *expr;
 326   struct cleanup *old_chain;
 327   struct internalvar *intvar = NULL;
 328   LONGEST initval = 0;
 329   struct trace_state_variable *tsv;
 330
 331   if (!args || !*args)
 332     error_no_arg (_("trace state variable name"));
 333
 334   /* All the possible valid arguments are expressions.  */
 335   expr = parse_expression (args);
 336   old_chain = make_cleanup (free_current_contents, &expr);
 337
 338   if (expr->nelts == 0)
 339     error (_("No expression?"));
 340
 341   /* Only allow two syntaxes; "$name" and "$name=value".  */
 342   if (expr->elts[0].opcode == OP_INTERNALVAR)
 343     {
 344       intvar = expr->elts[1].internalvar;
 345     }
 346   else if (expr->elts[0].opcode == BINOP_ASSIGN
 347            && expr->elts[1].opcode == OP_INTERNALVAR)
 348     {
 349       intvar = expr->elts[2].internalvar;
 350       initval = value_as_long (evaluate_subexpression_type (expr, 4));
 351     }
 352   else
 353     error (_("Syntax must be $NAME [ = EXPR ]"));
 354
 355   if (!intvar)
 356     error (_("No name given"));
 357
 358   if (strlen (internalvar_name (intvar)) <= 0)
 359     error (_("Must supply a non-empty variable name"));
 360
 361   /* If the variable already exists, just change its initial value.  */
 362   tsv = find_trace_state_variable (internalvar_name (intvar));
 363   if (tsv)
 364     {
 365       tsv->initial_value = initval;
 366       printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
 367                        tsv->name, plongest (tsv->initial_value));
 368       do_cleanups (old_chain);
 369       return;
 370     }
 371
 372   /* Create a new variable.  */
 373   tsv = create_trace_state_variable (internalvar_name (intvar));
 374   tsv->initial_value = initval;
 375
 376   printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
 377                    tsv->name, plongest (tsv->initial_value));
 378
 379   do_cleanups (old_chain);
 380 }
 381
 382 void
 383 delete_trace_variable_command (char *args, int from_tty)
 384 {
 385   int i, ix;
 386   char **argv;
 387   struct cleanup *back_to;
 388   struct trace_state_variable *tsv;
 389
 390   if (args == NULL)
 391     {
 392       if (query (_("Delete all trace state variables? ")))
 393         VEC_free (tsv_s, tvariables);
 394       dont_repeat ();
 395       return;
 396     }
 397
 398   argv = gdb_buildargv (args);
 399   back_to = make_cleanup_freeargv (argv);
 400
 401   for (i = 0; argv[i] != NULL; i++)
 402     {
 403       if (*argv[i] == '$')
 404         delete_trace_state_variable (argv[i] + 1);
 405       else
 406         warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[i]);
 407     }
 408
 409   do_cleanups (back_to);
 410
 411   dont_repeat ();
 412 }
 413
 414 void
 415 tvariables_info_1 (void)
 416 {
 417   struct trace_state_variable *tsv;
 418   int ix;
 419   int count = 0;
 420   struct cleanup *back_to;
 421
 422   if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
 423     {
 424       printf_filtered (_("No trace state variables.\n"));
 425       return;
 426     }
 427
 428   /* Try to acquire values from the target.  */
 429   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
 430     tsv->value_known = target_get_trace_state_variable_value (tsv->number,
 431                                                               &(tsv->value));
 432
 433   back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
 434                                                  count, "trace-variables");
 435   ui_out_table_header (uiout, 15, ui_left, "name", "Name");
 436   ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
 437   ui_out_table_header (uiout, 11, ui_left, "current", "Current");
 438
 439   ui_out_table_body (uiout);
 440
 441   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 442     {
 443       struct cleanup *back_to2;
 444       char *c;
 445       char *name;
 446
 447       back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
 448
 449       name = concat ("$", tsv->name, NULL);
 450       make_cleanup (xfree, name);
 451       ui_out_field_string (uiout, "name", name);
 452       ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
 453
 454       if (tsv->value_known)
 455         c = plongest (tsv->value);
 456       else if (ui_out_is_mi_like_p (uiout))
 457         /* For MI, we prefer not to use magic string constants, but rather
 458            omit the field completely.  The difference between unknown and
 459            undefined does not seem important enough to represent.  */
 460         c = NULL;
 461       else if (current_trace_status ()->running || traceframe_number >= 0)
 462         /* The value is/was defined, but we don't have it.  */
 463         c = "<unknown>";
 464       else
 465         /* It is not meaningful to ask about the value.  */
 466         c = "<undefined>";
 467       if (c)
 468         ui_out_field_string (uiout, "current", c);
 469       ui_out_text (uiout, "\n");
 470
 471       do_cleanups (back_to2);
 472     }
 473
 474   do_cleanups (back_to);
 475 }
 476
 477 /* List all the trace state variables.  */
 478
 479 static void
 480 tvariables_info (char *args, int from_tty)
 481 {
 482   tvariables_info_1 ();
 483 }
 484
 485 /* Stash definitions of tsvs into the given file.  */
 486
 487 void
 488 save_trace_state_variables (struct ui_file *fp)
 489 {
 490   struct trace_state_variable *tsv;
 491   int ix;
 492
 493   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 494     {
 495       fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
 496       if (tsv->initial_value)
 497         fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
 498       fprintf_unfiltered (fp, "\n");
 499     }
 500 }
 501
 502 /* ACTIONS functions: */
 503
 504 /* The three functions:
 505    collect_pseudocommand,
 506    while_stepping_pseudocommand, and
 507    end_actions_pseudocommand
 508    are placeholders for "commands" that are actually ONLY to be used
 509    within a tracepoint action list.  If the actual function is ever called,
 510    it means that somebody issued the "command" at the top level,
 511    which is always an error.  */
 512
 513 void
 514 end_actions_pseudocommand (char *args, int from_tty)
 515 {
 516   error (_("This command cannot be used at the top level."));
 517 }
 518
 519 void
 520 while_stepping_pseudocommand (char *args, int from_tty)
 521 {
 522   error (_("This command can only be used in a tracepoint actions list."));
 523 }
 524
 525 static void
 526 collect_pseudocommand (char *args, int from_tty)
 527 {
 528   error (_("This command can only be used in a tracepoint actions list."));
 529 }
 530
 531 static void
 532 teval_pseudocommand (char *args, int from_tty)
 533 {
 534   error (_("This command can only be used in a tracepoint actions list."));
 535 }
 536
 537 /* Enter a list of actions for a tracepoint.  */
 538 static void
 539 trace_actions_command (char *args, int from_tty)
 540 {
 541   struct breakpoint *t;
 542   struct command_line *l;
 543
 544   t = get_tracepoint_by_number (&args, 0, 1);
 545   if (t)
 546     {
 547       char *tmpbuf =
 548         xstrprintf ("Enter actions for tracepoint %d, one per line.",
 549                     t->number);
 550       struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
 551
 552       l = read_command_lines (tmpbuf, from_tty, 1, check_tracepoint_command, t);
 553       do_cleanups (cleanups);
 554       breakpoint_set_commands (t, l);
 555     }
 556   /* else just return */
 557 }
 558
 559 /* Report the results of checking the agent expression, as errors or
 560    internal errors.  */
 561
 562 static void
 563 report_agent_reqs_errors (struct agent_expr *aexpr, struct agent_reqs *areqs)
 564 {
 565   /* All of the "flaws" are serious bytecode generation issues that
 566      should never occur.  */
 567   if (areqs->flaw != agent_flaw_none)
 568     internal_error (__FILE__, __LINE__, _("expression is malformed"));
 569
 570   /* If analysis shows a stack underflow, GDB must have done something
 571      badly wrong in its bytecode generation.  */
 572   if (areqs->min_height < 0)
 573     internal_error (__FILE__, __LINE__,
 574                     _("expression has min height < 0"));
 575
 576   /* Issue this error if the stack is predicted to get too deep.  The
 577      limit is rather arbitrary; a better scheme might be for the
 578      target to report how much stack it will have available.  The
 579      depth roughly corresponds to parenthesization, so a limit of 20
 580      amounts to 20 levels of expression nesting, which is actually
 581      a pretty big hairy expression.  */
 582   if (areqs->max_height > 20)
 583     error (_("Expression is too complicated."));
 584 }
 585
 586 /* worker function */
 587 void
 588 validate_actionline (char **line, struct breakpoint *t)
 589 {
 590   struct cmd_list_element *c;
 591   struct expression *exp = NULL;
 592   struct cleanup *old_chain = NULL;
 593   char *p, *tmp_p;
 594   struct bp_location *loc;
 595   struct agent_expr *aexpr;
 596   struct agent_reqs areqs;
 597
 598   /* if EOF is typed, *line is NULL */
 599   if (*line == NULL)
 600     return;
 601
 602   for (p = *line; isspace ((int) *p);)
 603     p++;
 604
 605   /* Symbol lookup etc.  */
 606   if (*p == '\0')       /* empty line: just prompt for another line.  */
 607     return;
 608
 609   if (*p == '#')                /* comment line */
 610     return;
 611
 612   c = lookup_cmd (&p, cmdlist, "", -1, 1);
 613   if (c == 0)
 614     error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
 615
 616   if (cmd_cfunc_eq (c, collect_pseudocommand))
 617     {
 618       do
 619         {                       /* repeat over a comma-separated list */
 620           QUIT;                 /* allow user to bail out with ^C */
 621           while (isspace ((int) *p))
 622             p++;
 623
 624           if (*p == '$')        /* look for special pseudo-symbols */
 625             {
 626               if ((0 == strncasecmp ("reg", p + 1, 3)) ||
 627                   (0 == strncasecmp ("arg", p + 1, 3)) ||
 628                   (0 == strncasecmp ("loc", p + 1, 3)))
 629                 {
 630                   p = strchr (p, ',');
 631                   continue;
 632                 }
 633               /* else fall thru, treat p as an expression and parse it!  */
 634             }
 635           tmp_p = p;
 636           for (loc = t->loc; loc; loc = loc->next)
 637             {
 638               p = tmp_p;
 639               exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
 640               old_chain = make_cleanup (free_current_contents, &exp);
 641
 642               if (exp->elts[0].opcode == OP_VAR_VALUE)
 643                 {
 644                   if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
 645                     {
 646                       error (_("constant `%s' (value %ld) will not be collected."),
 647                              SYMBOL_PRINT_NAME (exp->elts[2].symbol),
 648                              SYMBOL_VALUE (exp->elts[2].symbol));
 649                     }
 650                   else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
 651                     {
 652                       error (_("`%s' is optimized away and cannot be collected."),
 653                              SYMBOL_PRINT_NAME (exp->elts[2].symbol));
 654                     }
 655                 }
 656
 657               /* We have something to collect, make sure that the expr to
 658                  bytecode translator can handle it and that it's not too
 659                  long.  */
 660               aexpr = gen_trace_for_expr (loc->address, exp);
 661               make_cleanup_free_agent_expr (aexpr);
 662
 663               if (aexpr->len > MAX_AGENT_EXPR_LEN)
 664                 error (_("Expression is too complicated."));
 665
 666               ax_reqs (aexpr, &areqs);
 667               (void) make_cleanup (xfree, areqs.reg_mask);
 668
 669               report_agent_reqs_errors (aexpr, &areqs);
 670
 671               do_cleanups (old_chain);
 672             }
 673         }
 674       while (p && *p++ == ',');
 675     }
 676
 677   else if (cmd_cfunc_eq (c, teval_pseudocommand))
 678     {
 679       do
 680         {                       /* repeat over a comma-separated list */
 681           QUIT;                 /* allow user to bail out with ^C */
 682           while (isspace ((int) *p))
 683             p++;
 684
 685           tmp_p = p;
 686           for (loc = t->loc; loc; loc = loc->next)
 687             {
 688               p = tmp_p;
 689               /* Only expressions are allowed for this action.  */
 690               exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
 691               old_chain = make_cleanup (free_current_contents, &exp);
 692
 693               /* We have something to evaluate, make sure that the expr to
 694                  bytecode translator can handle it and that it's not too
 695                  long.  */
 696               aexpr = gen_eval_for_expr (loc->address, exp);
 697               make_cleanup_free_agent_expr (aexpr);
 698
 699               if (aexpr->len > MAX_AGENT_EXPR_LEN)
 700                 error (_("Expression is too complicated."));
 701
 702               ax_reqs (aexpr, &areqs);
 703               (void) make_cleanup (xfree, areqs.reg_mask);
 704
 705               report_agent_reqs_errors (aexpr, &areqs);
 706
 707               do_cleanups (old_chain);
 708             }
 709         }
 710       while (p && *p++ == ',');
 711     }
 712
 713   else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
 714     {
 715       char *steparg;            /* in case warning is necessary */
 716
 717       while (isspace ((int) *p))
 718         p++;
 719       steparg = p;
 720
 721       if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
 722         error (_("while-stepping step count `%s' is malformed."), *line);
 723     }
 724
 725   else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
 726     ;
 727
 728   else
 729     error (_("`%s' is not a supported tracepoint action."), *line);
 730 }
 731
 732 enum {
 733   memrange_absolute = -1
 734 };
 735
 736 struct memrange
 737 {
 738   int type;             /* memrange_absolute for absolute memory range,
 739                            else basereg number */
 740   bfd_signed_vma start;
 741   bfd_signed_vma end;
 742 };
 743
 744 struct collection_list
 745   {
 746     unsigned char regs_mask[32];        /* room for up to 256 regs */
 747     long listsize;
 748     long next_memrange;
 749     struct memrange *list;
 750     long aexpr_listsize;        /* size of array pointed to by expr_list elt */
 751     long next_aexpr_elt;
 752     struct agent_expr **aexpr_list;
 753
 754   }
 755 tracepoint_list, stepping_list;
 756
 757 /* MEMRANGE functions: */
 758
 759 static int memrange_cmp (const void *, const void *);
 760
 761 /* compare memranges for qsort */
 762 static int
 763 memrange_cmp (const void *va, const void *vb)
 764 {
 765   const struct memrange *a = va, *b = vb;
 766
 767   if (a->type < b->type)
 768     return -1;
 769   if (a->type > b->type)
 770     return 1;
 771   if (a->type == memrange_absolute)
 772     {
 773       if ((bfd_vma) a->start < (bfd_vma) b->start)
 774         return -1;
 775       if ((bfd_vma) a->start > (bfd_vma) b->start)
 776         return 1;
 777     }
 778   else
 779     {
 780       if (a->start < b->start)
 781         return -1;
 782       if (a->start > b->start)
 783         return 1;
 784     }
 785   return 0;
 786 }
 787
 788 /* Sort the memrange list using qsort, and merge adjacent memranges.  */
 789 static void
 790 memrange_sortmerge (struct collection_list *memranges)
 791 {
 792   int a, b;
 793
 794   qsort (memranges->list, memranges->next_memrange,
 795          sizeof (struct memrange), memrange_cmp);
 796   if (memranges->next_memrange > 0)
 797     {
 798       for (a = 0, b = 1; b < memranges->next_memrange; b++)
 799         {
 800           if (memranges->list[a].type == memranges->list[b].type &&
 801               memranges->list[b].start - memranges->list[a].end <=
 802               MAX_REGISTER_SIZE)
 803             {
 804               /* memrange b starts before memrange a ends; merge them.  */
 805               if (memranges->list[b].end > memranges->list[a].end)
 806                 memranges->list[a].end = memranges->list[b].end;
 807               continue;         /* next b, same a */
 808             }
 809           a++;                  /* next a */
 810           if (a != b)
 811             memcpy (&memranges->list[a], &memranges->list[b],
 812                     sizeof (struct memrange));
 813         }
 814       memranges->next_memrange = a + 1;
 815     }
 816 }
 817
 818 /* Add a register to a collection list.  */
 819 static void
 820 add_register (struct collection_list *collection, unsigned int regno)
 821 {
 822   if (info_verbose)
 823     printf_filtered ("collect register %d\n", regno);
 824   if (regno >= (8 * sizeof (collection->regs_mask)))
 825     error (_("Internal: register number %d too large for tracepoint"),
 826            regno);
 827   collection->regs_mask[regno / 8] |= 1 << (regno % 8);
 828 }
 829
 830 /* Add a memrange to a collection list */
 831 static void
 832 add_memrange (struct collection_list *memranges,
 833               int type, bfd_signed_vma base,
 834               unsigned long len)
 835 {
 836   if (info_verbose)
 837     {
 838       printf_filtered ("(%d,", type);
 839       printf_vma (base);
 840       printf_filtered (",%ld)\n", len);
 841     }
 842
 843   /* type: memrange_absolute == memory, other n == basereg */
 844   memranges->list[memranges->next_memrange].type = type;
 845   /* base: addr if memory, offset if reg relative.  */
 846   memranges->list[memranges->next_memrange].start = base;
 847   /* len: we actually save end (base + len) for convenience */
 848   memranges->list[memranges->next_memrange].end = base + len;
 849   memranges->next_memrange++;
 850   if (memranges->next_memrange >= memranges->listsize)
 851     {
 852       memranges->listsize *= 2;
 853       memranges->list = xrealloc (memranges->list,
 854                                   memranges->listsize);
 855     }
 856
 857   if (type != memrange_absolute)                /* Better collect the base register!  */
 858     add_register (memranges, type);
 859 }
 860
 861 /* Add a symbol to a collection list.  */
 862 static void
 863 collect_symbol (struct collection_list *collect,
 864                 struct symbol *sym,
 865                 struct gdbarch *gdbarch,
 866                 long frame_regno, long frame_offset,
 867                 CORE_ADDR scope)
 868 {
 869   unsigned long len;
 870   unsigned int reg;
 871   bfd_signed_vma offset;
 872   int treat_as_expr = 0;
 873
 874   len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
 875   switch (SYMBOL_CLASS (sym))
 876     {
 877     default:
 878       printf_filtered ("%s: don't know symbol class %d\n",
 879                        SYMBOL_PRINT_NAME (sym),
 880                        SYMBOL_CLASS (sym));
 881       break;
 882     case LOC_CONST:
 883       printf_filtered ("constant %s (value %ld) will not be collected.\n",
 884                        SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
 885       break;
 886     case LOC_STATIC:
 887       offset = SYMBOL_VALUE_ADDRESS (sym);
 888       if (info_verbose)
 889         {
 890           char tmp[40];
 891
 892           sprintf_vma (tmp, offset);
 893           printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
 894                            SYMBOL_PRINT_NAME (sym), len,
 895                            tmp /* address */);
 896         }
 897       /* A struct may be a C++ class with static fields, go to general
 898          expression handling.  */
 899       if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
 900         treat_as_expr = 1;
 901       else
 902         add_memrange (collect, memrange_absolute, offset, len);
 903       break;
 904     case LOC_REGISTER:
 905       reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
 906       if (info_verbose)
 907         printf_filtered ("LOC_REG[parm] %s: ",
 908                          SYMBOL_PRINT_NAME (sym));
 909       add_register (collect, reg);
 910       /* Check for doubles stored in two registers.  */
 911       /* FIXME: how about larger types stored in 3 or more regs?  */
 912       if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
 913           len > register_size (gdbarch, reg))
 914         add_register (collect, reg + 1);
 915       break;
 916     case LOC_REF_ARG:
 917       printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
 918       printf_filtered ("       (will not collect %s)\n",
 919                        SYMBOL_PRINT_NAME (sym));
 920       break;
 921     case LOC_ARG:
 922       reg = frame_regno;
 923       offset = frame_offset + SYMBOL_VALUE (sym);
 924       if (info_verbose)
 925         {
 926           printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
 927                            SYMBOL_PRINT_NAME (sym), len);
 928           printf_vma (offset);
 929           printf_filtered (" from frame ptr reg %d\n", reg);
 930         }
 931       add_memrange (collect, reg, offset, len);
 932       break;
 933     case LOC_REGPARM_ADDR:
 934       reg = SYMBOL_VALUE (sym);
 935       offset = 0;
 936       if (info_verbose)
 937         {
 938           printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
 939                            SYMBOL_PRINT_NAME (sym), len);
 940           printf_vma (offset);
 941           printf_filtered (" from reg %d\n", reg);
 942         }
 943       add_memrange (collect, reg, offset, len);
 944       break;
 945     case LOC_LOCAL:
 946       reg = frame_regno;
 947       offset = frame_offset + SYMBOL_VALUE (sym);
 948       if (info_verbose)
 949         {
 950           printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
 951                            SYMBOL_PRINT_NAME (sym), len);
 952           printf_vma (offset);
 953           printf_filtered (" from frame ptr reg %d\n", reg);
 954         }
 955       add_memrange (collect, reg, offset, len);
 956       break;
 957
 958     case LOC_UNRESOLVED:
 959       treat_as_expr = 1;
 960       break;
 961
 962     case LOC_OPTIMIZED_OUT:
 963       printf_filtered ("%s has been optimized out of existence.\n",
 964                        SYMBOL_PRINT_NAME (sym));
 965       break;
 966
 967     case LOC_COMPUTED:
 968       treat_as_expr = 1;
 969       break;
 970     }
 971
 972   /* Expressions are the most general case.  */
 973   if (treat_as_expr)
 974     {
 975       struct agent_expr *aexpr;
 976       struct cleanup *old_chain1 = NULL;
 977       struct agent_reqs areqs;
 978
 979       aexpr = gen_trace_for_var (scope, gdbarch, sym);
 980
 981       /* It can happen that the symbol is recorded as a computed
 982          location, but it's been optimized away and doesn't actually
 983          have a location expression.  */
 984       if (!aexpr)
 985         {
 986           printf_filtered ("%s has been optimized out of existence.\n",
 987                            SYMBOL_PRINT_NAME (sym));
 988           return;
 989         }
 990
 991       old_chain1 = make_cleanup_free_agent_expr (aexpr);
 992
 993       ax_reqs (aexpr, &areqs);
 994
 995       report_agent_reqs_errors (aexpr, &areqs);
 996
 997       discard_cleanups (old_chain1);
 998       add_aexpr (collect, aexpr);
 999
1000       /* take care of the registers */
1001       if (areqs.reg_mask_len > 0)
1002         {
1003           int ndx1, ndx2;
1004
1005           for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1006             {
1007               QUIT;     /* allow user to bail out with ^C */
1008               if (areqs.reg_mask[ndx1] != 0)
1009                 {
1010                   /* assume chars have 8 bits */
1011                   for (ndx2 = 0; ndx2 < 8; ndx2++)
1012                     if (areqs.reg_mask[ndx1] & (1 << ndx2))
1013                       /* it's used -- record it */
1014                       add_register (collect, ndx1 * 8 + ndx2);
1015                 }
1016             }
1017         }
1018     }
1019 }
1020
1021 /* Data to be passed around in the calls to the locals and args
1022    iterators.  */
1023
1024 struct add_local_symbols_data
1025 {
1026   struct collection_list *collect;
1027   struct gdbarch *gdbarch;
1028   CORE_ADDR pc;
1029   long frame_regno;
1030   long frame_offset;
1031   int count;
1032 };
1033
1034 /* The callback for the locals and args iterators  */
1035
1036 static void
1037 do_collect_symbol (const char *print_name,
1038                    struct symbol *sym,
1039                    void *cb_data)
1040 {
1041   struct add_local_symbols_data *p = cb_data;
1042
1043   collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1044                   p->frame_offset, p->pc);
1045   p->count++;
1046 }
1047
1048 /* Add all locals (or args) symbols to collection list */
1049 static void
1050 add_local_symbols (struct collection_list *collect,
1051                    struct gdbarch *gdbarch, CORE_ADDR pc,
1052                    long frame_regno, long frame_offset, int type)
1053 {
1054   struct block *block;
1055   struct add_local_symbols_data cb_data;
1056
1057   cb_data.collect = collect;
1058   cb_data.gdbarch = gdbarch;
1059   cb_data.pc = pc;
1060   cb_data.frame_regno = frame_regno;
1061   cb_data.frame_offset = frame_offset;
1062   cb_data.count = 0;
1063
1064   if (type == 'L')
1065     {
1066       block = block_for_pc (pc);
1067       if (block == NULL)
1068         {
1069           warning (_("Can't collect locals; "
1070                      "no symbol table info available.\n"));
1071           return;
1072         }
1073
1074       iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1075       if (cb_data.count == 0)
1076         warning (_("No locals found in scope."));
1077     }
1078   else
1079     {
1080       pc = get_pc_function_start (pc);
1081       block = block_for_pc (pc);
1082       if (block == NULL)
1083         {
1084           warning (_("Can't collect args; no symbol table info available.\n"));
1085           return;
1086         }
1087
1088       iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1089       if (cb_data.count == 0)
1090         warning (_("No args found in scope."));
1091     }
1092 }
1093
1094 /* worker function */
1095 static void
1096 clear_collection_list (struct collection_list *list)
1097 {
1098   int ndx;
1099
1100   list->next_memrange = 0;
1101   for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1102     {
1103       free_agent_expr (list->aexpr_list[ndx]);
1104       list->aexpr_list[ndx] = NULL;
1105     }
1106   list->next_aexpr_elt = 0;
1107   memset (list->regs_mask, 0, sizeof (list->regs_mask));
1108 }
1109
1110 /* reduce a collection list to string form (for gdb protocol) */
1111 static char **
1112 stringify_collection_list (struct collection_list *list, char *string)
1113 {
1114   char temp_buf[2048];
1115   char tmp2[40];
1116   int count;
1117   int ndx = 0;
1118   char *(*str_list)[];
1119   char *end;
1120   long i;
1121
1122   count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1123   str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1124
1125   for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1126     if (list->regs_mask[i] != 0)        /* skip leading zeroes in regs_mask */
1127       break;
1128   if (list->regs_mask[i] != 0)  /* prepare to send regs_mask to the stub */
1129     {
1130       if (info_verbose)
1131         printf_filtered ("\nCollecting registers (mask): 0x");
1132       end = temp_buf;
1133       *end++ = 'R';
1134       for (; i >= 0; i--)
1135         {
1136           QUIT;                 /* allow user to bail out with ^C */
1137           if (info_verbose)
1138             printf_filtered ("%02X", list->regs_mask[i]);
1139           sprintf (end, "%02X", list->regs_mask[i]);
1140           end += 2;
1141         }
1142       (*str_list)[ndx] = xstrdup (temp_buf);
1143       ndx++;
1144     }
1145   if (info_verbose)
1146     printf_filtered ("\n");
1147   if (list->next_memrange > 0 && info_verbose)
1148     printf_filtered ("Collecting memranges: \n");
1149   for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1150     {
1151       QUIT;                     /* allow user to bail out with ^C */
1152       sprintf_vma (tmp2, list->list[i].start);
1153       if (info_verbose)
1154         {
1155           printf_filtered ("(%d, %s, %ld)\n",
1156                            list->list[i].type,
1157                            tmp2,
1158                            (long) (list->list[i].end - list->list[i].start));
1159         }
1160       if (count + 27 > MAX_AGENT_EXPR_LEN)
1161         {
1162           (*str_list)[ndx] = savestring (temp_buf, count);
1163           ndx++;
1164           count = 0;
1165           end = temp_buf;
1166         }
1167
1168       {
1169         bfd_signed_vma length = list->list[i].end - list->list[i].start;
1170
1171         /* The "%X" conversion specifier expects an unsigned argument,
1172            so passing -1 (memrange_absolute) to it directly gives you
1173            "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1174            Special-case it.  */
1175         if (list->list[i].type == memrange_absolute)
1176           sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1177         else
1178           sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1179       }
1180
1181       count += strlen (end);
1182       end = temp_buf + count;
1183     }
1184
1185   for (i = 0; i < list->next_aexpr_elt; i++)
1186     {
1187       QUIT;                     /* allow user to bail out with ^C */
1188       if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1189         {
1190           (*str_list)[ndx] = savestring (temp_buf, count);
1191           ndx++;
1192           count = 0;
1193           end = temp_buf;
1194         }
1195       sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1196       end += 10;                /* 'X' + 8 hex digits + ',' */
1197       count += 10;
1198
1199       end = mem2hex (list->aexpr_list[i]->buf,
1200                      end, list->aexpr_list[i]->len);
1201       count += 2 * list->aexpr_list[i]->len;
1202     }
1203
1204   if (count != 0)
1205     {
1206       (*str_list)[ndx] = savestring (temp_buf, count);
1207       ndx++;
1208       count = 0;
1209       end = temp_buf;
1210     }
1211   (*str_list)[ndx] = NULL;
1212
1213   if (ndx == 0)
1214     {
1215       xfree (str_list);
1216       return NULL;
1217     }
1218   else
1219     return *str_list;
1220 }
1221
1222
1223 static void
1224 encode_actions_1 (struct command_line *action,
1225                   struct breakpoint *t,
1226                   struct bp_location *tloc,
1227                   int frame_reg,
1228                   LONGEST frame_offset,
1229                   struct collection_list *collect,
1230                   struct collection_list *stepping_list)
1231 {
1232   char *action_exp;
1233   struct expression *exp = NULL;
1234   struct command_line *actions;
1235   int i;
1236   struct value *tempval;
1237   struct cmd_list_element *cmd;
1238   struct agent_expr *aexpr;
1239
1240   for (; action; action = action->next)
1241     {
1242       QUIT;                     /* allow user to bail out with ^C */
1243       action_exp = action->line;
1244       while (isspace ((int) *action_exp))
1245         action_exp++;
1246
1247       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1248       if (cmd == 0)
1249         error (_("Bad action list item: %s"), action_exp);
1250
1251       if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1252         {
1253           do
1254             {                   /* repeat over a comma-separated list */
1255               QUIT;             /* allow user to bail out with ^C */
1256               while (isspace ((int) *action_exp))
1257                 action_exp++;
1258
1259               if (0 == strncasecmp ("$reg", action_exp, 4))
1260                 {
1261                   for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1262                     add_register (collect, i);
1263                   action_exp = strchr (action_exp, ',');        /* more? */
1264                 }
1265               else if (0 == strncasecmp ("$arg", action_exp, 4))
1266                 {
1267                   add_local_symbols (collect,
1268                                      t->gdbarch,
1269                                      tloc->address,
1270                                      frame_reg,
1271                                      frame_offset,
1272                                      'A');
1273                   action_exp = strchr (action_exp, ',');        /* more? */
1274                 }
1275               else if (0 == strncasecmp ("$loc", action_exp, 4))
1276                 {
1277                   add_local_symbols (collect,
1278                                      t->gdbarch,
1279                                      tloc->address,
1280                                      frame_reg,
1281                                      frame_offset,
1282                                      'L');
1283                   action_exp = strchr (action_exp, ',');        /* more? */
1284                 }
1285               else
1286                 {
1287                   unsigned long addr, len;
1288                   struct cleanup *old_chain = NULL;
1289                   struct cleanup *old_chain1 = NULL;
1290                   struct agent_reqs areqs;
1291
1292                   exp = parse_exp_1 (&action_exp,
1293                                      block_for_pc (tloc->address), 1);
1294                   old_chain = make_cleanup (free_current_contents, &exp);
1295
1296                   switch (exp->elts[0].opcode)
1297                     {
1298                     case OP_REGISTER:
1299                       {
1300                         const char *name = &exp->elts[2].string;
1301
1302                         i = user_reg_map_name_to_regnum (t->gdbarch,
1303                                                          name, strlen (name));
1304                         if (i == -1)
1305                           internal_error (__FILE__, __LINE__,
1306                                           _("Register $%s not available"),
1307                                           name);
1308                         if (info_verbose)
1309                           printf_filtered ("OP_REGISTER: ");
1310                         add_register (collect, i);
1311                         break;
1312                       }
1313
1314                     case UNOP_MEMVAL:
1315                       /* safe because we know it's a simple expression */
1316                       tempval = evaluate_expression (exp);
1317                       addr = value_address (tempval);
1318                       len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1319                       add_memrange (collect, memrange_absolute, addr, len);
1320                       break;
1321
1322                     case OP_VAR_VALUE:
1323                       collect_symbol (collect,
1324                                       exp->elts[2].symbol,
1325                                       t->gdbarch,
1326                                       frame_reg,
1327                                       frame_offset,
1328                                       tloc->address);
1329                       break;
1330
1331                     default:    /* full-fledged expression */
1332                       aexpr = gen_trace_for_expr (tloc->address, exp);
1333
1334                       old_chain1 = make_cleanup_free_agent_expr (aexpr);
1335
1336                       ax_reqs (aexpr, &areqs);
1337
1338                       report_agent_reqs_errors (aexpr, &areqs);
1339
1340                       discard_cleanups (old_chain1);
1341                       add_aexpr (collect, aexpr);
1342
1343                       /* take care of the registers */
1344                       if (areqs.reg_mask_len > 0)
1345                         {
1346                           int ndx1;
1347                           int ndx2;
1348
1349                           for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1350                             {
1351                               QUIT;     /* allow user to bail out with ^C */
1352                               if (areqs.reg_mask[ndx1] != 0)
1353                                 {
1354                                   /* assume chars have 8 bits */
1355                                   for (ndx2 = 0; ndx2 < 8; ndx2++)
1356                                     if (areqs.reg_mask[ndx1] & (1 << ndx2))
1357                                       /* it's used -- record it */
1358                                       add_register (collect,
1359                                                     ndx1 * 8 + ndx2);
1360                                 }
1361                             }
1362                         }
1363                       break;
1364                     }           /* switch */
1365                   do_cleanups (old_chain);
1366                 }               /* do */
1367             }
1368           while (action_exp && *action_exp++ == ',');
1369         }                       /* if */
1370       else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1371         {
1372           do
1373             {                   /* repeat over a comma-separated list */
1374               QUIT;             /* allow user to bail out with ^C */
1375               while (isspace ((int) *action_exp))
1376                 action_exp++;
1377
1378                 {
1379                   unsigned long addr, len;
1380                   struct cleanup *old_chain = NULL;
1381                   struct cleanup *old_chain1 = NULL;
1382                   struct agent_reqs areqs;
1383
1384                   exp = parse_exp_1 (&action_exp,
1385                                      block_for_pc (tloc->address), 1);
1386                   old_chain = make_cleanup (free_current_contents, &exp);
1387
1388                   aexpr = gen_eval_for_expr (tloc->address, exp);
1389                   old_chain1 = make_cleanup_free_agent_expr (aexpr);
1390
1391                   ax_reqs (aexpr, &areqs);
1392
1393                   report_agent_reqs_errors (aexpr, &areqs);
1394
1395                   discard_cleanups (old_chain1);
1396                   /* Even though we're not officially collecting, add
1397                      to the collect list anyway.  */
1398                   add_aexpr (collect, aexpr);
1399
1400                   do_cleanups (old_chain);
1401                 }               /* do */
1402             }
1403           while (action_exp && *action_exp++ == ',');
1404         }                       /* if */
1405       else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1406         {
1407           /* We check against nested while-stepping when setting
1408              breakpoint action, so no way to run into nested
1409              here.  */
1410           gdb_assert (stepping_list);
1411
1412           encode_actions_1 (action->body_list[0], t, tloc, frame_reg, frame_offset,
1413                             stepping_list, NULL);
1414         }
1415       else
1416         error (_("Invalid tracepoint command '%s'"), action->line);
1417     }                           /* for */
1418 }
1419
1420 /* Render all actions into gdb protocol.  */
1421 /*static*/ void
1422 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1423                 char ***tdp_actions, char ***stepping_actions)
1424 {
1425   static char tdp_buff[2048], step_buff[2048];
1426   char *default_collect_line = NULL;
1427   struct command_line *actions;
1428   struct command_line *default_collect_action = NULL;
1429   int frame_reg;
1430   LONGEST frame_offset;
1431   struct cleanup *back_to;
1432
1433   back_to = make_cleanup (null_cleanup, NULL);
1434
1435   clear_collection_list (&tracepoint_list);
1436   clear_collection_list (&stepping_list);
1437
1438   *tdp_actions = NULL;
1439   *stepping_actions = NULL;
1440
1441   gdbarch_virtual_frame_pointer (t->gdbarch,
1442                                  t->loc->address, &frame_reg, &frame_offset);
1443
1444   actions = breakpoint_commands (t);
1445
1446   /* If there are default expressions to collect, make up a collect
1447      action and prepend to the action list to encode.  Note that since
1448      validation is per-tracepoint (local var "xyz" might be valid for
1449      one tracepoint and not another, etc), we make up the action on
1450      the fly, and don't cache it.  */
1451   if (*default_collect)
1452     {
1453       char *line;
1454
1455       default_collect_line =  xstrprintf ("collect %s", default_collect);
1456       make_cleanup (xfree, default_collect_line);
1457
1458       line = default_collect_line;
1459       validate_actionline (&line, t);
1460
1461       default_collect_action = xmalloc (sizeof (struct command_line));
1462       make_cleanup (xfree, default_collect_action);
1463       default_collect_action->next = actions;
1464       default_collect_action->line = line;
1465       actions = default_collect_action;
1466     }
1467   encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1468                     &tracepoint_list, &stepping_list);
1469
1470   memrange_sortmerge (&tracepoint_list);
1471   memrange_sortmerge (&stepping_list);
1472
1473   *tdp_actions = stringify_collection_list (&tracepoint_list,
1474                                             tdp_buff);
1475   *stepping_actions = stringify_collection_list (&stepping_list,
1476                                                  step_buff);
1477
1478   do_cleanups (back_to);
1479 }
1480
1481 static void
1482 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1483 {
1484   if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1485     {
1486       collect->aexpr_list =
1487         xrealloc (collect->aexpr_list,
1488                 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1489       collect->aexpr_listsize *= 2;
1490     }
1491   collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1492   collect->next_aexpr_elt++;
1493 }
1494
1495
1496 void
1497 start_tracing (void)
1498 {
1499   char buf[2048];
1500   VEC(breakpoint_p) *tp_vec = NULL;
1501   int ix;
1502   struct breakpoint *t;
1503   struct trace_state_variable *tsv;
1504   int any_enabled = 0;
1505
1506   tp_vec = all_tracepoints ();
1507
1508   /* No point in tracing without any tracepoints... */
1509   if (VEC_length (breakpoint_p, tp_vec) == 0)
1510     {
1511       VEC_free (breakpoint_p, tp_vec);
1512       error (_("No tracepoints defined, not starting trace"));
1513     }
1514
1515   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1516     {
1517       if (t->enable_state == bp_enabled)
1518         {
1519           any_enabled = 1;
1520           break;
1521         }
1522     }
1523
1524   /* No point in tracing with only disabled tracepoints.  */
1525   if (!any_enabled)
1526     {
1527       VEC_free (breakpoint_p, tp_vec);
1528       error (_("No tracepoints enabled, not starting trace"));
1529     }
1530
1531   target_trace_init ();
1532
1533   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1534     {
1535       t->number_on_target = 0;
1536       target_download_tracepoint (t);
1537       t->number_on_target = t->number;
1538     }
1539   VEC_free (breakpoint_p, tp_vec);
1540
1541   /* Send down all the trace state variables too.  */
1542   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1543     {
1544       target_download_trace_state_variable (tsv);
1545     }
1546
1547   /* Tell target to treat text-like sections as transparent.  */
1548   target_trace_set_readonly_regions ();
1549   /* Set some mode flags.  */
1550   target_set_disconnected_tracing (disconnected_tracing);
1551   target_set_circular_trace_buffer (circular_trace_buffer);
1552
1553   /* Now insert traps and begin collecting data.  */
1554   target_trace_start ();
1555
1556   /* Reset our local state.  */
1557   set_traceframe_num (-1);
1558   set_tracepoint_num (-1);
1559   set_traceframe_context (NULL);
1560   current_trace_status()->running = 1;
1561 }
1562
1563 /* tstart command:
1564
1565    Tell target to clear any previous trace experiment.
1566    Walk the list of tracepoints, and send them (and their actions)
1567    to the target.  If no errors,
1568    Tell target to start a new trace experiment.  */
1569
1570 static void
1571 trace_start_command (char *args, int from_tty)
1572 {
1573   dont_repeat ();       /* Like "run", dangerous to repeat accidentally.  */
1574
1575   if (current_trace_status ()->running)
1576     {
1577       if (from_tty
1578           && !query (_("A trace is running already.  Start a new run? ")))
1579         error (_("New trace run not started."));
1580     }
1581
1582   start_tracing ();
1583 }
1584
1585 /* tstop command */
1586 static void
1587 trace_stop_command (char *args, int from_tty)
1588 {
1589   if (!current_trace_status ()->running)
1590     error (_("Trace is not running."));
1591
1592   stop_tracing ();
1593 }
1594
1595 void
1596 stop_tracing (void)
1597 {
1598   target_trace_stop ();
1599   /* should change in response to reply? */
1600   current_trace_status ()->running = 0;
1601 }
1602
1603 /* tstatus command */
1604 static void
1605 trace_status_command (char *args, int from_tty)
1606 {
1607   struct trace_status *ts = current_trace_status ();
1608   int status;
1609
1610   status = target_get_trace_status (ts);
1611
1612   if (status == -1)
1613     {
1614       if (ts->from_file)
1615         printf_filtered (_("Using a trace file.\n"));
1616       else
1617         {
1618           printf_filtered (_("Trace can not be run on this target.\n"));
1619           return;
1620         }
1621     }
1622
1623   if (!ts->running_known)
1624     {
1625       printf_filtered (_("Run/stop status is unknown.\n"));
1626     }
1627   else if (ts->running)
1628     {
1629       printf_filtered (_("Trace is running on the target.\n"));
1630     }
1631   else
1632     {
1633       switch (ts->stop_reason)
1634         {
1635         case trace_never_run:
1636           printf_filtered (_("No trace has been run on the target.\n"));
1637           break;
1638         case tstop_command:
1639           printf_filtered (_("Trace stopped by a tstop command.\n"));
1640           break;
1641         case trace_buffer_full:
1642           printf_filtered (_("Trace stopped because the buffer was full.\n"));
1643           break;
1644         case trace_disconnected:
1645           printf_filtered (_("Trace stopped because of disconnection.\n"));
1646           break;
1647         case tracepoint_passcount:
1648           printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1649                            ts->stopping_tracepoint);
1650           break;
1651         case tracepoint_error:
1652           if (ts->stopping_tracepoint)
1653             printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1654                              ts->error_desc, ts->stopping_tracepoint);
1655           else
1656             printf_filtered (_("Trace stopped by an error (%s).\n"),
1657                              ts->error_desc);
1658           break;
1659         case trace_stop_reason_unknown:
1660           printf_filtered (_("Trace stopped for an unknown reason.\n"));
1661           break;
1662         default:
1663           printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1664                            ts->stop_reason);
1665           break;
1666         }
1667     }
1668
1669   if (ts->traceframes_created >= 0
1670       && ts->traceframe_count != ts->traceframes_created)
1671     {
1672       printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1673                        ts->traceframe_count, ts->traceframes_created);
1674     }
1675   else if (ts->traceframe_count >= 0)
1676     {
1677       printf_filtered (_("Collected %d trace frames.\n"),
1678                        ts->traceframe_count);
1679     }
1680
1681   if (ts->buffer_free >= 0)
1682     {
1683       if (ts->buffer_size >= 0)
1684         {
1685           printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1686                            ts->buffer_free, ts->buffer_size);
1687           if (ts->buffer_size > 0)
1688             printf_filtered (_(" (%d%% full)"),
1689                              ((int) ((((long long) (ts->buffer_size
1690                                                     - ts->buffer_free)) * 100)
1691                                      / ts->buffer_size)));
1692           printf_filtered (_(".\n"));
1693         }
1694       else
1695         printf_filtered (_("Trace buffer has %d bytes free.\n"),
1696                          ts->buffer_free);
1697     }
1698
1699   if (ts->disconnected_tracing)
1700     printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1701   else
1702     printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1703
1704   if (ts->circular_buffer)
1705     printf_filtered (_("Trace buffer is circular.\n"));
1706
1707   /* Now report on what we're doing with tfind.  */
1708   if (traceframe_number >= 0)
1709     printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1710                      traceframe_number, tracepoint_number);
1711   else
1712     printf_filtered (_("Not looking at any trace frame.\n"));
1713 }
1714
1715 /* Report the trace status to uiout, in a way suitable for MI, and not
1716    suitable for CLI.  If ON_STOP is true, suppress a few fields that
1717    are not meaningful in the -trace-stop response.
1718
1719    The implementation is essentially parallel to trace_status_command, but
1720    merging them will result in unreadable code.  */
1721 void
1722 trace_status_mi (int on_stop)
1723 {
1724   struct trace_status *ts = current_trace_status ();
1725   int status;
1726   char *string_status;
1727
1728   status = target_get_trace_status (ts);
1729
1730   if (status == -1 && !ts->from_file)
1731     {
1732       ui_out_field_string (uiout, "supported", "0");
1733       return;
1734     }
1735
1736   if (ts->from_file)
1737     ui_out_field_string (uiout, "supported", "file");
1738   else if (!on_stop)
1739     ui_out_field_string (uiout, "supported", "1");
1740
1741   gdb_assert (ts->running_known);
1742
1743   if (ts->running)
1744     {
1745       ui_out_field_string (uiout, "running", "1");
1746
1747       /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1748          Given that the frontend gets the status either on -trace-stop, or from
1749          -trace-status after re-connection, it does not seem like this
1750          information is necessary for anything.  It is not necessary for either
1751          figuring the vital state of the target nor for navigation of trace
1752          frames.  If the frontend wants to show the current state is some
1753          configure dialog, it can request the value when such dialog is
1754          invoked by the user.  */
1755     }
1756   else
1757     {
1758       char *stop_reason = NULL;
1759       int stopping_tracepoint = -1;
1760
1761       if (!on_stop)
1762         ui_out_field_string (uiout, "running", "0");
1763
1764       if (ts->stop_reason != trace_stop_reason_unknown)
1765         {
1766           switch (ts->stop_reason)
1767             {
1768             case tstop_command:
1769               stop_reason = "request";
1770               break;
1771             case trace_buffer_full:
1772               stop_reason = "overflow";
1773               break;
1774             case trace_disconnected:
1775               stop_reason = "disconnection";
1776               break;
1777             case tracepoint_passcount:
1778               stop_reason = "passcount";
1779               stopping_tracepoint = ts->stopping_tracepoint;
1780               break;
1781             case tracepoint_error:
1782               stop_reason = "error";
1783               stopping_tracepoint = ts->stopping_tracepoint;
1784               break;
1785             }
1786
1787           if (stop_reason)
1788             {
1789               ui_out_field_string (uiout, "stop-reason", stop_reason);
1790               if (stopping_tracepoint != -1)
1791                 ui_out_field_int (uiout, "stopping-tracepoint",
1792                                   stopping_tracepoint);
1793               if (ts->stop_reason == tracepoint_error)
1794                 ui_out_field_string (uiout, "error-description",
1795                                      ts->error_desc);
1796             }
1797         }
1798     }
1799
1800   if (ts->traceframe_count != -1)
1801     ui_out_field_int (uiout, "frames", ts->traceframe_count);
1802   if (ts->traceframes_created != -1)
1803     ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1804   if (ts->buffer_size != -1)
1805     ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1806   if (ts->buffer_free != -1)
1807     ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1808
1809   ui_out_field_int (uiout, "disconnected",  ts->disconnected_tracing);
1810   ui_out_field_int (uiout, "circular",  ts->circular_buffer);
1811 }
1812
1813 /* This function handles the details of what to do about an ongoing
1814    tracing run if the user has asked to detach or otherwise disconnect
1815    from the target.  */
1816 void
1817 disconnect_tracing (int from_tty)
1818 {
1819   /* It can happen that the target that was tracing went away on its
1820      own, and we didn't notice.  Get a status update, and if the
1821      current target doesn't even do tracing, then assume it's not
1822      running anymore.  */
1823   if (target_get_trace_status (current_trace_status ()) < 0)
1824     current_trace_status ()->running = 0;
1825
1826   /* If running interactively, give the user the option to cancel and
1827      then decide what to do differently with the run.  Scripts are
1828      just going to disconnect and let the target deal with it,
1829      according to how it's been instructed previously via
1830      disconnected-tracing.  */
1831   if (current_trace_status ()->running && from_tty)
1832     {
1833       if (current_trace_status ()->disconnected_tracing)
1834         {
1835           if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1836             error (_("Not confirmed."));
1837         }
1838       else
1839         {
1840           if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1841             error (_("Not confirmed."));
1842         }
1843     }
1844
1845   /* Also we want to be out of tfind mode, otherwise things can get
1846      confusing upon reconnection.  Just use these calls instead of
1847      full tfind_1 behavior because we're in the middle of detaching,
1848      and there's no point to updating current stack frame etc.  */
1849   set_traceframe_number (-1);
1850   set_traceframe_context (NULL);
1851 }
1852
1853 /* Worker function for the various flavors of the tfind command.  */
1854 void
1855 tfind_1 (enum trace_find_type type, int num,
1856          ULONGEST addr1, ULONGEST addr2,
1857          int from_tty)
1858 {
1859   int target_frameno = -1, target_tracept = -1;
1860   struct frame_id old_frame_id = null_frame_id;
1861   char *reply;
1862   struct breakpoint *tp;
1863
1864   /* Only try to get the current stack frame if we have a chance of
1865      succeeding.  In particular, if we're trying to get a first trace
1866      frame while all threads are running, it's not going to succeed,
1867      so leave it with a default value and let the frame comparison
1868      below (correctly) decide to print out the source location of the
1869      trace frame.  */
1870   if (!(type == tfind_number && num == -1)
1871       && (has_stack_frames () || traceframe_number >= 0))
1872     old_frame_id = get_frame_id (get_current_frame ());
1873
1874   target_frameno = target_trace_find (type, num, addr1, addr2,
1875                                       &target_tracept);
1876
1877   if (type == tfind_number
1878       && num == -1
1879       && target_frameno == -1)
1880     {
1881       /* We told the target to get out of tfind mode, and it did.  */
1882     }
1883   else if (target_frameno == -1)
1884     {
1885       /* A request for a non-existent trace frame has failed.
1886          Our response will be different, depending on FROM_TTY:
1887
1888          If FROM_TTY is true, meaning that this command was
1889          typed interactively by the user, then give an error
1890          and DO NOT change the state of traceframe_number etc.
1891
1892          However if FROM_TTY is false, meaning that we're either
1893          in a script, a loop, or a user-defined command, then
1894          DON'T give an error, but DO change the state of
1895          traceframe_number etc. to invalid.
1896
1897          The rationalle is that if you typed the command, you
1898          might just have committed a typo or something, and you'd
1899          like to NOT lose your current debugging state.  However
1900          if you're in a user-defined command or especially in a
1901          loop, then you need a way to detect that the command
1902          failed WITHOUT aborting.  This allows you to write
1903          scripts that search thru the trace buffer until the end,
1904          and then continue on to do something else.  */
1905
1906       if (from_tty)
1907         error (_("Target failed to find requested trace frame."));
1908       else
1909         {
1910           if (info_verbose)
1911             printf_filtered ("End of trace buffer.\n");
1912 #if 0 /* dubious now? */
1913           /* The following will not recurse, since it's
1914              special-cased.  */
1915           trace_find_command ("-1", from_tty);
1916 #endif
1917         }
1918     }
1919
1920   tp = get_tracepoint_by_number_on_target (target_tracept);
1921
1922   reinit_frame_cache ();
1923   registers_changed ();
1924   target_dcache_invalidate ();
1925   set_traceframe_num (target_frameno);
1926   set_tracepoint_num (tp ? tp->number : target_tracept);
1927   if (target_frameno == -1)
1928     set_traceframe_context (NULL);
1929   else
1930     set_traceframe_context (get_current_frame ());
1931
1932   if (traceframe_number >= 0)
1933     {
1934       /* Use different branches for MI and CLI to make CLI messages
1935          i18n-eable.  */
1936       if (ui_out_is_mi_like_p (uiout))
1937         {
1938           ui_out_field_string (uiout, "found", "1");
1939           ui_out_field_int (uiout, "tracepoint", tracepoint_number);
1940           ui_out_field_int (uiout, "traceframe", traceframe_number);
1941         }
1942       else
1943         {
1944           printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1945                              traceframe_number, tracepoint_number);
1946         }
1947     }
1948   else
1949     {
1950       if (ui_out_is_mi_like_p (uiout))
1951         ui_out_field_string (uiout, "found", "0");
1952       else if (type == tfind_number && num == -1)
1953         printf_unfiltered (_("No longer looking at any trace frame\n"));
1954       else /* this case may never occur, check */
1955         printf_unfiltered (_("No trace frame found\n"));
1956     }
1957
1958   /* If we're in nonstop mode and getting out of looking at trace
1959      frames, there won't be any current frame to go back to and
1960      display.  */
1961   if (from_tty
1962       && (has_stack_frames () || traceframe_number >= 0))
1963     {
1964       enum print_what print_what;
1965
1966       /* NOTE: in imitation of the step command, try to determine
1967          whether we have made a transition from one function to
1968          another.  If so, we'll print the "stack frame" (ie. the new
1969          function and it's arguments) -- otherwise we'll just show the
1970          new source line.  */
1971
1972       if (frame_id_eq (old_frame_id,
1973                        get_frame_id (get_current_frame ())))
1974         print_what = SRC_LINE;
1975       else
1976         print_what = SRC_AND_LOC;
1977
1978       print_stack_frame (get_selected_frame (NULL), 1, print_what);
1979       do_displays ();
1980     }
1981 }
1982
1983 /* trace_find_command takes a trace frame number n,
1984    sends "QTFrame:<n>" to the target,
1985    and accepts a reply that may contain several optional pieces
1986    of information: a frame number, a tracepoint number, and an
1987    indication of whether this is a trap frame or a stepping frame.
1988
1989    The minimal response is just "OK" (which indicates that the
1990    target does not give us a frame number or a tracepoint number).
1991    Instead of that, the target may send us a string containing
1992    any combination of:
1993    F<hexnum>    (gives the selected frame number)
1994    T<hexnum>    (gives the selected tracepoint number)
1995  */
1996
1997 /* tfind command */
1998 static void
1999 trace_find_command (char *args, int from_tty)
2000 { /* this should only be called with a numeric argument */
2001   int frameno = -1;
2002
2003   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2004     error ("May not look at trace frames while trace is running.");
2005
2006   if (args == 0 || *args == 0)
2007     { /* TFIND with no args means find NEXT trace frame.  */
2008       if (traceframe_number == -1)
2009         frameno = 0;    /* "next" is first one */
2010         else
2011         frameno = traceframe_number + 1;
2012     }
2013   else if (0 == strcmp (args, "-"))
2014     {
2015       if (traceframe_number == -1)
2016         error (_("not debugging trace buffer"));
2017       else if (from_tty && traceframe_number == 0)
2018         error (_("already at start of trace buffer"));
2019
2020       frameno = traceframe_number - 1;
2021       }
2022   /* A hack to work around eval's need for fp to have been collected.  */
2023   else if (0 == strcmp (args, "-1"))
2024     frameno = -1;
2025   else
2026     frameno = parse_and_eval_long (args);
2027
2028   if (frameno < -1)
2029     error (_("invalid input (%d is less than zero)"), frameno);
2030
2031   tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2032 }
2033
2034 /* tfind end */
2035 static void
2036 trace_find_end_command (char *args, int from_tty)
2037 {
2038   trace_find_command ("-1", from_tty);
2039 }
2040
2041 /* tfind none */
2042 static void
2043 trace_find_none_command (char *args, int from_tty)
2044 {
2045   trace_find_command ("-1", from_tty);
2046 }
2047
2048 /* tfind start */
2049 static void
2050 trace_find_start_command (char *args, int from_tty)
2051 {
2052   trace_find_command ("0", from_tty);
2053 }
2054
2055 /* tfind pc command */
2056 static void
2057 trace_find_pc_command (char *args, int from_tty)
2058 {
2059   CORE_ADDR pc;
2060   char tmp[40];
2061
2062   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2063     error ("May not look at trace frames while trace is running.");
2064
2065   if (args == 0 || *args == 0)
2066     pc = regcache_read_pc (get_current_regcache ());
2067   else
2068     pc = parse_and_eval_address (args);
2069
2070   tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2071 }
2072
2073 /* tfind tracepoint command */
2074 static void
2075 trace_find_tracepoint_command (char *args, int from_tty)
2076 {
2077   int tdp;
2078   struct breakpoint *tp;
2079
2080   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2081     error ("May not look at trace frames while trace is running.");
2082
2083   if (args == 0 || *args == 0)
2084     {
2085       if (tracepoint_number == -1)
2086         error (_("No current tracepoint -- please supply an argument."));
2087       else
2088         tdp = tracepoint_number;        /* default is current TDP */
2089     }
2090   else
2091     tdp = parse_and_eval_long (args);
2092
2093   /* If we have the tracepoint on hand, use the number that the
2094      target knows about (which may be different if we disconnected
2095      and reconnected).  */
2096   tp = get_tracepoint (tdp);
2097   if (tp)
2098     tdp = tp->number_on_target;
2099
2100   tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2101 }
2102
2103 /* TFIND LINE command:
2104
2105    This command will take a sourceline for argument, just like BREAK
2106    or TRACE (ie. anything that "decode_line_1" can handle).
2107
2108    With no argument, this command will find the next trace frame
2109    corresponding to a source line OTHER THAN THE CURRENT ONE.  */
2110
2111 static void
2112 trace_find_line_command (char *args, int from_tty)
2113 {
2114   static CORE_ADDR start_pc, end_pc;
2115   struct symtabs_and_lines sals;
2116   struct symtab_and_line sal;
2117   struct cleanup *old_chain;
2118   char   startpc_str[40], endpc_str[40];
2119
2120   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2121     error ("May not look at trace frames while trace is running.");
2122
2123   if (args == 0 || *args == 0)
2124     {
2125       sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2126       sals.nelts = 1;
2127       sals.sals = (struct symtab_and_line *)
2128         xmalloc (sizeof (struct symtab_and_line));
2129       sals.sals[0] = sal;
2130     }
2131   else
2132     {
2133       sals = decode_line_spec (args, 1);
2134       sal = sals.sals[0];
2135     }
2136
2137   old_chain = make_cleanup (xfree, sals.sals);
2138   if (sal.symtab == 0)
2139     error (_("No line number information available."));
2140
2141   if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2142     {
2143       if (start_pc == end_pc)
2144         {
2145           printf_filtered ("Line %d of \"%s\"",
2146                            sal.line, sal.symtab->filename);
2147           wrap_here ("  ");
2148           printf_filtered (" is at address ");
2149           print_address (get_current_arch (), start_pc, gdb_stdout);
2150           wrap_here ("  ");
2151           printf_filtered (" but contains no code.\n");
2152           sal = find_pc_line (start_pc, 0);
2153           if (sal.line > 0
2154               && find_line_pc_range (sal, &start_pc, &end_pc)
2155               && start_pc != end_pc)
2156             printf_filtered ("Attempting to find line %d instead.\n",
2157                              sal.line);
2158           else
2159             error (_("Cannot find a good line."));
2160         }
2161       }
2162     else
2163     /* Is there any case in which we get here, and have an address
2164        which the user would want to see?  If we have debugging
2165        symbols and no line numbers?  */
2166     error (_("Line number %d is out of range for \"%s\"."),
2167            sal.line, sal.symtab->filename);
2168
2169   /* Find within range of stated line.  */
2170   if (args && *args)
2171     tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2172   else
2173     tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2174   do_cleanups (old_chain);
2175 }
2176
2177 /* tfind range command */
2178 static void
2179 trace_find_range_command (char *args, int from_tty)
2180 {
2181   static CORE_ADDR start, stop;
2182   char start_str[40], stop_str[40];
2183   char *tmp;
2184
2185   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2186     error ("May not look at trace frames while trace is running.");
2187
2188   if (args == 0 || *args == 0)
2189     { /* XXX FIXME: what should default behavior be?  */
2190       printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2191       return;
2192     }
2193
2194   if (0 != (tmp = strchr (args, ',')))
2195     {
2196       *tmp++ = '\0';    /* terminate start address */
2197       while (isspace ((int) *tmp))
2198         tmp++;
2199       start = parse_and_eval_address (args);
2200       stop = parse_and_eval_address (tmp);
2201     }
2202   else
2203     {                   /* no explicit end address? */
2204       start = parse_and_eval_address (args);
2205       stop = start + 1; /* ??? */
2206     }
2207
2208   tfind_1 (tfind_range, 0, start, stop, from_tty);
2209 }
2210
2211 /* tfind outside command */
2212 static void
2213 trace_find_outside_command (char *args, int from_tty)
2214 {
2215   CORE_ADDR start, stop;
2216   char start_str[40], stop_str[40];
2217   char *tmp;
2218
2219   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2220     error ("May not look at trace frames while trace is running.");
2221
2222   if (args == 0 || *args == 0)
2223     { /* XXX FIXME: what should default behavior be? */
2224       printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2225       return;
2226     }
2227
2228   if (0 != (tmp = strchr (args, ',')))
2229     {
2230       *tmp++ = '\0';    /* terminate start address */
2231       while (isspace ((int) *tmp))
2232         tmp++;
2233       start = parse_and_eval_address (args);
2234       stop = parse_and_eval_address (tmp);
2235     }
2236   else
2237     {                   /* no explicit end address? */
2238       start = parse_and_eval_address (args);
2239       stop = start + 1; /* ??? */
2240     }
2241
2242   tfind_1 (tfind_outside, 0, start, stop, from_tty);
2243 }
2244
2245 /* info scope command: list the locals for a scope.  */
2246 static void
2247 scope_info (char *args, int from_tty)
2248 {
2249   struct symtabs_and_lines sals;
2250   struct symbol *sym;
2251   struct minimal_symbol *msym;
2252   struct block *block;
2253   char **canonical, *symname, *save_args = args;
2254   struct dict_iterator iter;
2255   int j, count = 0;
2256   struct gdbarch *gdbarch;
2257   int regno;
2258
2259   if (args == 0 || *args == 0)
2260     error (_("requires an argument (function, line or *addr) to define a scope"));
2261
2262   sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2263   if (sals.nelts == 0)
2264     return;             /* presumably decode_line_1 has already warned */
2265
2266   /* Resolve line numbers to PC */
2267   resolve_sal_pc (&sals.sals[0]);
2268   block = block_for_pc (sals.sals[0].pc);
2269
2270   while (block != 0)
2271     {
2272       QUIT;                     /* allow user to bail out with ^C */
2273       ALL_BLOCK_SYMBOLS (block, iter, sym)
2274         {
2275           QUIT;                 /* allow user to bail out with ^C */
2276           if (count == 0)
2277             printf_filtered ("Scope for %s:\n", save_args);
2278           count++;
2279
2280           symname = SYMBOL_PRINT_NAME (sym);
2281           if (symname == NULL || *symname == '\0')
2282             continue;           /* probably botched, certainly useless */
2283
2284           gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2285
2286           printf_filtered ("Symbol %s is ", symname);
2287           switch (SYMBOL_CLASS (sym))
2288             {
2289             default:
2290             case LOC_UNDEF:     /* messed up symbol? */
2291               printf_filtered ("a bogus symbol, class %d.\n",
2292                                SYMBOL_CLASS (sym));
2293               count--;          /* don't count this one */
2294               continue;
2295             case LOC_CONST:
2296               printf_filtered ("a constant with value %ld (0x%lx)",
2297                                SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2298               break;
2299             case LOC_CONST_BYTES:
2300               printf_filtered ("constant bytes: ");
2301               if (SYMBOL_TYPE (sym))
2302                 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2303                   fprintf_filtered (gdb_stdout, " %02x",
2304                                     (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2305               break;
2306             case LOC_STATIC:
2307               printf_filtered ("in static storage at address ");
2308               printf_filtered ("%s", paddress (gdbarch,
2309                                                SYMBOL_VALUE_ADDRESS (sym)));
2310               break;
2311             case LOC_REGISTER:
2312               /* GDBARCH is the architecture associated with the objfile
2313                  the symbol is defined in; the target architecture may be
2314                  different, and may provide additional registers.  However,
2315                  we do not know the target architecture at this point.
2316                  We assume the objfile architecture will contain all the
2317                  standard registers that occur in debug info in that
2318                  objfile.  */
2319               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2320
2321               if (SYMBOL_IS_ARGUMENT (sym))
2322                 printf_filtered ("an argument in register $%s",
2323                                  gdbarch_register_name (gdbarch, regno));
2324               else
2325                 printf_filtered ("a local variable in register $%s",
2326                                  gdbarch_register_name (gdbarch, regno));
2327               break;
2328             case LOC_ARG:
2329               printf_filtered ("an argument at stack/frame offset %ld",
2330                                SYMBOL_VALUE (sym));
2331               break;
2332             case LOC_LOCAL:
2333               printf_filtered ("a local variable at frame offset %ld",
2334                                SYMBOL_VALUE (sym));
2335               break;
2336             case LOC_REF_ARG:
2337               printf_filtered ("a reference argument at offset %ld",
2338                                SYMBOL_VALUE (sym));
2339               break;
2340             case LOC_REGPARM_ADDR:
2341               /* Note comment at LOC_REGISTER.  */
2342               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2343               printf_filtered ("the address of an argument, in register $%s",
2344                                gdbarch_register_name (gdbarch, regno));
2345               break;
2346             case LOC_TYPEDEF:
2347               printf_filtered ("a typedef.\n");
2348               continue;
2349             case LOC_LABEL:
2350               printf_filtered ("a label at address ");
2351               printf_filtered ("%s", paddress (gdbarch,
2352                                                SYMBOL_VALUE_ADDRESS (sym)));
2353               break;
2354             case LOC_BLOCK:
2355               printf_filtered ("a function at address ");
2356               printf_filtered ("%s",
2357                 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2358               break;
2359             case LOC_UNRESOLVED:
2360               msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2361                                             NULL, NULL);
2362               if (msym == NULL)
2363                 printf_filtered ("Unresolved Static");
2364               else
2365                 {
2366                   printf_filtered ("static storage at address ");
2367                   printf_filtered ("%s",
2368                     paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2369                 }
2370               break;
2371             case LOC_OPTIMIZED_OUT:
2372               printf_filtered ("optimized out.\n");
2373               continue;
2374             case LOC_COMPUTED:
2375               SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2376                                                             BLOCK_START (block),
2377                                                             gdb_stdout);
2378               break;
2379             }
2380           if (SYMBOL_TYPE (sym))
2381             printf_filtered (", length %d.\n",
2382                              TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2383         }
2384       if (BLOCK_FUNCTION (block))
2385         break;
2386       else
2387         block = BLOCK_SUPERBLOCK (block);
2388     }
2389   if (count <= 0)
2390     printf_filtered ("Scope for %s contains no locals or arguments.\n",
2391                      save_args);
2392 }
2393
2394 /* worker function (cleanup) */
2395 static void
2396 replace_comma (void *data)
2397 {
2398   char *comma = data;
2399   *comma = ',';
2400 }
2401
2402
2403 /* Helper for trace_dump_command.  Dump the action list starting at
2404    ACTION.  STEPPING_ACTIONS is true if we're iterating over the
2405    actions of the body of a while-stepping action.  STEPPING_FRAME is
2406    set if the current traceframe was determined to be a while-stepping
2407    traceframe.  */
2408
2409 static void
2410 trace_dump_actions (struct command_line *action,
2411                     int stepping_actions, int stepping_frame,
2412                     int from_tty)
2413 {
2414   char *action_exp, *next_comma;
2415
2416   for (; action != NULL; action = action->next)
2417     {
2418       struct cmd_list_element *cmd;
2419
2420       QUIT;                     /* allow user to bail out with ^C */
2421       action_exp = action->line;
2422       while (isspace ((int) *action_exp))
2423         action_exp++;
2424
2425       /* The collection actions to be done while stepping are
2426          bracketed by the commands "while-stepping" and "end".  */
2427
2428       if (*action_exp == '#')   /* comment line */
2429         continue;
2430
2431       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2432       if (cmd == 0)
2433         error (_("Bad action list item: %s"), action_exp);
2434
2435       if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2436         {
2437           int i;
2438
2439           for (i = 0; i < action->body_count; ++i)
2440             trace_dump_actions (action->body_list[i],
2441                                 1, stepping_frame, from_tty);
2442         }
2443       else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2444         {
2445           /* Display the collected data.
2446              For the trap frame, display only what was collected at
2447              the trap.  Likewise for stepping frames, display only
2448              what was collected while stepping.  This means that the
2449              two boolean variables, STEPPING_FRAME and
2450              STEPPING_ACTIONS should be equal.  */
2451           if (stepping_frame == stepping_actions)
2452             {
2453               do
2454                 {               /* repeat over a comma-separated list */
2455                   QUIT;         /* allow user to bail out with ^C */
2456                   if (*action_exp == ',')
2457                     action_exp++;
2458                   while (isspace ((int) *action_exp))
2459                     action_exp++;
2460
2461                   next_comma = strchr (action_exp, ',');
2462
2463                   if (0 == strncasecmp (action_exp, "$reg", 4))
2464                     registers_info (NULL, from_tty);
2465                   else if (0 == strncasecmp (action_exp, "$loc", 4))
2466                     locals_info (NULL, from_tty);
2467                   else if (0 == strncasecmp (action_exp, "$arg", 4))
2468                     args_info (NULL, from_tty);
2469                   else
2470                     {           /* variable */
2471                       if (next_comma)
2472                         {
2473                           make_cleanup (replace_comma, next_comma);
2474                           *next_comma = '\0';
2475                         }
2476                       printf_filtered ("%s = ", action_exp);
2477                       output_command (action_exp, from_tty);
2478                       printf_filtered ("\n");
2479                     }
2480                   if (next_comma)
2481                     *next_comma = ',';
2482                   action_exp = next_comma;
2483                 }
2484               while (action_exp && *action_exp == ',');
2485             }
2486         }
2487     }
2488 }
2489
2490 /* The tdump command.  */
2491
2492 static void
2493 trace_dump_command (char *args, int from_tty)
2494 {
2495   struct regcache *regcache;
2496   struct breakpoint *t;
2497   int stepping_frame = 0;
2498   struct bp_location *loc;
2499   char *line, *default_collect_line = NULL;
2500   struct command_line *actions, *default_collect_action = NULL;
2501   struct cleanup *old_chain = NULL;
2502
2503   if (tracepoint_number == -1)
2504     {
2505       warning (_("No current trace frame."));
2506       return;
2507     }
2508
2509   t = get_tracepoint (tracepoint_number);
2510
2511   if (t == NULL)
2512     error (_("No known tracepoint matches 'current' tracepoint #%d."),
2513            tracepoint_number);
2514
2515   printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2516                    tracepoint_number, traceframe_number);
2517
2518   /* The current frame is a trap frame if the frame PC is equal
2519      to the tracepoint PC.  If not, then the current frame was
2520      collected during single-stepping.  */
2521
2522   regcache = get_current_regcache ();
2523
2524   /* If the traceframe's address matches any of the tracepoint's
2525      locations, assume it is a direct hit rather than a while-stepping
2526      frame.  (FIXME this is not reliable, should record each frame's
2527      type.)  */
2528   stepping_frame = 1;
2529   for (loc = t->loc; loc; loc = loc->next)
2530     if (loc->address == regcache_read_pc (regcache))
2531       stepping_frame = 0;
2532
2533   actions = breakpoint_commands (t);
2534
2535   /* If there is a default-collect list, make up a collect command,
2536      prepend to the tracepoint's commands, and pass the whole mess to
2537      the trace dump scanner.  We need to validate because
2538      default-collect might have been junked since the trace run.  */
2539   if (*default_collect)
2540     {
2541       default_collect_line = xstrprintf ("collect %s", default_collect);
2542       old_chain = make_cleanup (xfree, default_collect_line);
2543       line = default_collect_line;
2544       validate_actionline (&line, t);
2545       default_collect_action = xmalloc (sizeof (struct command_line));
2546       make_cleanup (xfree, default_collect_action);
2547       default_collect_action->next = actions;
2548       default_collect_action->line = line;
2549       actions = default_collect_action;
2550     }
2551
2552   trace_dump_actions (actions, 0, stepping_frame, from_tty);
2553
2554   if (*default_collect)
2555     do_cleanups (old_chain);
2556 }
2557
2558 /* Encode a piece of a tracepoint's source-level definition in a form
2559    that is suitable for both protocol and saving in files.  */
2560 /* This version does not do multiple encodes for long strings; it should
2561    return an offset to the next piece to encode.  FIXME  */
2562
2563 extern int
2564 encode_source_string (int tpnum, ULONGEST addr,
2565                       char *srctype, char *src, char *buf, int buf_size)
2566 {
2567   if (80 + strlen (srctype) > buf_size)
2568     error (_("Buffer too small for source encoding"));
2569   sprintf (buf, "%x:%s:%s:%x:%x:",
2570            tpnum, phex_nz (addr, sizeof (addr)), srctype, 0, (int) strlen (src));
2571   if (strlen (buf) + strlen (src) * 2 >= buf_size)
2572     error (_("Source string too long for buffer"));
2573   bin2hex (src, buf + strlen (buf), 0);
2574   return -1;
2575 }
2576
2577 extern int trace_regblock_size;
2578
2579 /* Save tracepoint data to file named FILENAME.  If TARGET_DOES_SAVE is
2580    non-zero, the save is performed on the target, otherwise GDB obtains all
2581    trace data and saves it locally.  */
2582
2583 void
2584 trace_save (const char *filename, int target_does_save)
2585 {
2586   struct cleanup *cleanup;
2587   char *pathname;
2588   struct trace_status *ts = current_trace_status ();
2589   int err, status;
2590   FILE *fp;
2591   struct uploaded_tp *uploaded_tps = NULL, *utp;
2592   struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2593   int a;
2594   char *act;
2595   LONGEST gotten = 0;
2596   ULONGEST offset = 0;
2597 #define MAX_TRACE_UPLOAD 2000
2598   gdb_byte buf[MAX_TRACE_UPLOAD];
2599   int written;
2600
2601   /* If the target is to save the data to a file on its own, then just
2602      send the command and be done with it.  */
2603   if (target_does_save)
2604     {
2605       err = target_save_trace_data (filename);
2606       if (err < 0)
2607         error (_("Target failed to save trace data to '%s'."),
2608                filename);
2609       return;
2610     }
2611
2612   /* Get the trace status first before opening the file, so if the
2613      target is losing, we can get out without touching files.  */
2614   status = target_get_trace_status (ts);
2615
2616   pathname = tilde_expand (filename);
2617   cleanup = make_cleanup (xfree, pathname);
2618
2619   fp = fopen (pathname, "w");
2620   if (!fp)
2621     error (_("Unable to open file '%s' for saving trace data (%s)"),
2622            filename, safe_strerror (errno));
2623   make_cleanup_fclose (fp);
2624
2625   /* Write a file header, with a high-bit-set char to indicate a
2626      binary file, plus a hint as what this file is, and a version
2627      number in case of future needs.  */
2628   written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2629   if (written < 1)
2630     perror_with_name (pathname);
2631
2632   /* Write descriptive info.  */
2633
2634   /* Write out the size of a register block.  */
2635   fprintf (fp, "R %x\n", trace_regblock_size);
2636
2637   /* Write out status of the tracing run (aka "tstatus" info).  */
2638   fprintf (fp, "status %c;%s",
2639            (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2640   if (ts->stop_reason == tracepoint_error)
2641     {
2642       char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2643       bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2644       fprintf (fp, ":%s", buf);
2645     }
2646   fprintf (fp, ":%x", ts->stopping_tracepoint);
2647   if (ts->traceframe_count >= 0)
2648     fprintf (fp, ";tframes:%x", ts->traceframe_count);
2649   if (ts->traceframes_created >= 0)
2650     fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2651   if (ts->buffer_free >= 0)
2652     fprintf (fp, ";tfree:%x", ts->buffer_free);
2653   if (ts->buffer_size >= 0)
2654     fprintf (fp, ";tsize:%x", ts->buffer_size);
2655   if (ts->disconnected_tracing)
2656     fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2657   if (ts->circular_buffer)
2658     fprintf (fp, ";circular:%x", ts->circular_buffer);
2659   fprintf (fp, "\n");
2660
2661   /* Note that we want to upload tracepoints and save those, rather
2662      than simply writing out the local ones, because the user may have
2663      changed tracepoints in GDB in preparation for a future tracing
2664      run, or maybe just mass-deleted all types of breakpoints as part
2665      of cleaning up.  So as not to contaminate the session, leave the
2666      data in its uploaded form, don't make into real tracepoints.  */
2667
2668   /* Get trace state variables first, they may be checked when parsing
2669      uploaded commands.  */
2670
2671   target_upload_trace_state_variables (&uploaded_tsvs);
2672
2673   for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2674     {
2675       char *buf = "";
2676
2677       if (utsv->name)
2678         {
2679           buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2680           bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2681         }
2682
2683       fprintf (fp, "tsv %x:%s:%x:%s\n",
2684                utsv->number, phex_nz (utsv->initial_value, 8),
2685                utsv->builtin, buf);
2686
2687       if (utsv->name)
2688         xfree (buf);
2689     }
2690
2691   free_uploaded_tsvs (&uploaded_tsvs);
2692
2693   target_upload_tracepoints (&uploaded_tps);
2694
2695   for (utp = uploaded_tps; utp; utp = utp->next)
2696     {
2697       fprintf (fp, "tp T%x:%s:%c:%x:%x",
2698                utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2699                (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2700       if (utp->type == bp_fast_tracepoint)
2701         fprintf (fp, ":F%x", utp->orig_size);
2702       if (utp->cond)
2703         fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2704                  utp->cond);
2705       fprintf (fp, "\n");
2706       for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2707         fprintf (fp, "tp A%x:%s:%s\n",
2708                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2709       for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2710         fprintf (fp, "tp S%x:%s:%s\n",
2711                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2712       if (utp->at_string)
2713         {
2714           encode_source_string (utp->number, utp->addr,
2715                                 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2716           fprintf (fp, "tp Z%s\n", buf);
2717         }
2718       if (utp->cond_string)
2719         {
2720           encode_source_string (utp->number, utp->addr,
2721                                 "cond", utp->cond_string, buf, MAX_TRACE_UPLOAD);
2722           fprintf (fp, "tp Z%s\n", buf);
2723         }
2724       for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2725         {
2726           encode_source_string (utp->number, utp->addr, "cmd", act,
2727                                 buf, MAX_TRACE_UPLOAD);
2728           fprintf (fp, "tp Z%s\n", buf);
2729         }
2730     }
2731
2732   free_uploaded_tps (&uploaded_tps);
2733
2734   /* Mark the end of the definition section.  */
2735   fprintf (fp, "\n");
2736
2737   /* Get and write the trace data proper.  We ask for big blocks, in
2738      the hopes of efficiency, but will take less if the target has
2739      packet size limitations or some such.  */
2740   while (1)
2741     {
2742       gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2743       if (gotten < 0)
2744         error (_("Failure to get requested trace buffer data"));
2745       /* No more data is forthcoming, we're done.  */
2746       if (gotten == 0)
2747         break;
2748       written = fwrite (buf, gotten, 1, fp);
2749       if (written < 1)
2750         perror_with_name (pathname);
2751       offset += gotten;
2752     }
2753
2754   /* Mark the end of trace data.  (We know that gotten is 0 at this point.)  */
2755   written = fwrite (&gotten, 4, 1, fp);
2756   if (written < 1)
2757     perror_with_name (pathname);
2758
2759   do_cleanups (cleanup);
2760 }
2761
2762 static void
2763 trace_save_command (char *args, int from_tty)
2764 {
2765   int target_does_save = 0;
2766   char **argv;
2767   char *filename = NULL;
2768   struct cleanup *back_to;
2769
2770   if (args == NULL)
2771     error_no_arg (_("file in which to save trace data"));
2772
2773   argv = gdb_buildargv (args);
2774   back_to = make_cleanup_freeargv (argv);
2775
2776   for (; *argv; ++argv)
2777     {
2778       if (strcmp (*argv, "-r") == 0)
2779         target_does_save = 1;
2780       else if (**argv == '-')
2781         error (_("unknown option `%s'"), *argv);
2782       else
2783         filename = *argv;
2784     }
2785
2786   if (!filename)
2787     error_no_arg (_("file in which to save trace data"));
2788
2789   trace_save (filename, target_does_save);
2790
2791   if (from_tty)
2792     printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2793
2794   do_cleanups (back_to);
2795 }
2796
2797 /* Tell the target what to do with an ongoing tracing run if GDB
2798    disconnects for some reason.  */
2799
2800 void
2801 send_disconnected_tracing_value (int value)
2802 {
2803   target_set_disconnected_tracing (value);
2804 }
2805
2806 static void
2807 set_disconnected_tracing (char *args, int from_tty,
2808                           struct cmd_list_element *c)
2809 {
2810   send_disconnected_tracing_value (disconnected_tracing);
2811 }
2812
2813 static void
2814 set_circular_trace_buffer (char *args, int from_tty,
2815                            struct cmd_list_element *c)
2816 {
2817   target_set_circular_trace_buffer (circular_trace_buffer);
2818 }
2819
2820 /* Convert the memory pointed to by mem into hex, placing result in buf.
2821  * Return a pointer to the last char put in buf (null)
2822  * "stolen" from sparc-stub.c
2823  */
2824
2825 static const char hexchars[] = "0123456789abcdef";
2826
2827 static char *
2828 mem2hex (gdb_byte *mem, char *buf, int count)
2829 {
2830   gdb_byte ch;
2831
2832   while (count-- > 0)
2833     {
2834       ch = *mem++;
2835
2836       *buf++ = hexchars[ch >> 4];
2837       *buf++ = hexchars[ch & 0xf];
2838     }
2839
2840   *buf = 0;
2841
2842   return buf;
2843 }
2844
2845 int
2846 get_traceframe_number (void)
2847 {
2848   return traceframe_number;
2849 }
2850
2851 /* Make the traceframe NUM be the current trace frame.  Does nothing
2852    if NUM is already current.  */
2853
2854 void
2855 set_traceframe_number (int num)
2856 {
2857   int newnum;
2858
2859   if (traceframe_number == num)
2860     {
2861       /* Nothing to do.  */
2862       return;
2863     }
2864
2865   newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2866
2867   if (newnum != num)
2868     warning (_("could not change traceframe"));
2869
2870   traceframe_number = newnum;
2871
2872   /* Changing the traceframe changes our view of registers and of the
2873      frame chain.  */
2874   registers_changed ();
2875 }
2876
2877 /* A cleanup used when switching away and back from tfind mode.  */
2878
2879 struct current_traceframe_cleanup
2880 {
2881   /* The traceframe we were inspecting.  */
2882   int traceframe_number;
2883 };
2884
2885 static void
2886 do_restore_current_traceframe_cleanup (void *arg)
2887 {
2888   struct current_traceframe_cleanup *old = arg;
2889
2890   set_traceframe_number (old->traceframe_number);
2891 }
2892
2893 static void
2894 restore_current_traceframe_cleanup_dtor (void *arg)
2895 {
2896   struct current_traceframe_cleanup *old = arg;
2897
2898   xfree (old);
2899 }
2900
2901 struct cleanup *
2902 make_cleanup_restore_current_traceframe (void)
2903 {
2904   struct current_traceframe_cleanup *old;
2905
2906   old = xmalloc (sizeof (struct current_traceframe_cleanup));
2907   old->traceframe_number = traceframe_number;
2908
2909   return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
2910                             restore_current_traceframe_cleanup_dtor);
2911 }
2912
2913 /* Given a number and address, return an uploaded tracepoint with that
2914    number, creating if necessary.  */
2915
2916 struct uploaded_tp *
2917 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2918 {
2919   struct uploaded_tp *utp;
2920
2921   for (utp = *utpp; utp; utp = utp->next)
2922     if (utp->number == num && utp->addr == addr)
2923       return utp;
2924   utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2925   memset (utp, 0, sizeof (struct uploaded_tp));
2926   utp->number = num;
2927   utp->addr = addr;
2928   utp->actions = NULL;
2929   utp->step_actions = NULL;
2930   utp->cmd_strings = NULL;
2931   utp->next = *utpp;
2932   *utpp = utp;
2933   return utp;
2934 }
2935
2936 static void
2937 free_uploaded_tps (struct uploaded_tp **utpp)
2938 {
2939   struct uploaded_tp *next_one;
2940
2941   while (*utpp)
2942     {
2943       next_one = (*utpp)->next;
2944       xfree (*utpp);
2945       *utpp = next_one;
2946     }
2947 }
2948
2949 /* Given a number and address, return an uploaded tracepoint with that
2950    number, creating if necessary.  */
2951
2952 struct uploaded_tsv *
2953 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2954 {
2955   struct uploaded_tsv *utsv;
2956
2957   for (utsv = *utsvp; utsv; utsv = utsv->next)
2958     if (utsv->number == num)
2959       return utsv;
2960   utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
2961   memset (utsv, 0, sizeof (struct uploaded_tsv));
2962   utsv->number = num;
2963   utsv->next = *utsvp;
2964   *utsvp = utsv;
2965   return utsv;
2966 }
2967
2968 static void
2969 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
2970 {
2971   struct uploaded_tsv *next_one;
2972
2973   while (*utsvp)
2974     {
2975       next_one = (*utsvp)->next;
2976       xfree (*utsvp);
2977       *utsvp = next_one;
2978     }
2979 }
2980
2981 /* Look for an existing tracepoint that seems similar enough to the
2982    uploaded one.  Enablement isn't compared, because the user can
2983    toggle that freely, and may have done so in anticipation of the
2984    next trace run.  */
2985
2986 struct breakpoint *
2987 find_matching_tracepoint (struct uploaded_tp *utp)
2988 {
2989   VEC(breakpoint_p) *tp_vec = all_tracepoints ();
2990   int ix;
2991   struct breakpoint *t;
2992   struct bp_location *loc;
2993
2994   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2995     {
2996       if (t->type == utp->type
2997           && t->step_count == utp->step
2998           && t->pass_count == utp->pass
2999           /* FIXME also test conditionals and actions */
3000           )
3001         {
3002           /* Scan the locations for an address match.  */
3003           for (loc = t->loc; loc; loc = loc->next)
3004             {
3005               if (loc->address == utp->addr)
3006                 return t;
3007             }
3008         }
3009     }
3010   return NULL;
3011 }
3012
3013 /* Given a list of tracepoints uploaded from a target, attempt to
3014    match them up with existing tracepoints, and create new ones if not
3015    found.  */
3016
3017 void
3018 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3019 {
3020   struct uploaded_tp *utp;
3021   struct breakpoint *t;
3022
3023   /* Look for GDB tracepoints that match up with our uploaded versions.  */
3024   for (utp = *uploaded_tps; utp; utp = utp->next)
3025     {
3026       t = find_matching_tracepoint (utp);
3027       if (t)
3028         printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3029                          t->number, utp->number, paddress (get_current_arch (), utp->addr));
3030       else
3031         {
3032           t = create_tracepoint_from_upload (utp);
3033           if (t)
3034             printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3035                              t->number, utp->number, paddress (get_current_arch (), utp->addr));
3036           else
3037             printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3038                              utp->number, paddress (get_current_arch (), utp->addr));
3039         }
3040       /* Whether found or created, record the number used by the
3041          target, to help with mapping target tracepoints back to their
3042          counterparts here.  */
3043       if (t)
3044         t->number_on_target = utp->number;
3045     }
3046
3047   free_uploaded_tps (uploaded_tps);
3048 }
3049
3050 /* Trace state variables don't have much to identify them beyond their
3051    name, so just use that to detect matches.  */
3052
3053 struct trace_state_variable *
3054 find_matching_tsv (struct uploaded_tsv *utsv)
3055 {
3056   if (!utsv->name)
3057     return NULL;
3058
3059   return find_trace_state_variable (utsv->name);
3060 }
3061
3062 struct trace_state_variable *
3063 create_tsv_from_upload (struct uploaded_tsv *utsv)
3064 {
3065   const char *namebase;
3066   char buf[20];
3067   int try_num = 0;
3068   struct trace_state_variable *tsv;
3069
3070   if (utsv->name)
3071     {
3072       namebase = utsv->name;
3073       sprintf (buf, "%s", namebase);
3074     }
3075   else
3076     {
3077       namebase = "__tsv";
3078       sprintf (buf, "%s_%d", namebase, try_num++);
3079     }
3080
3081   /* Fish for a name that is not in use.  */
3082   /* (should check against all internal vars?) */
3083   while (find_trace_state_variable (buf))
3084     sprintf (buf, "%s_%d", namebase, try_num++);
3085
3086   /* We have an available name, create the variable.  */
3087   tsv = create_trace_state_variable (xstrdup (buf));
3088   tsv->initial_value = utsv->initial_value;
3089   tsv->builtin = utsv->builtin;
3090
3091   return tsv;
3092 }
3093
3094 /* Given a list of uploaded trace state variables, try to match them
3095    up with existing variables, or create additional ones.  */
3096
3097 void
3098 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3099 {
3100   int ix;
3101   struct uploaded_tsv *utsv;
3102   struct trace_state_variable *tsv;
3103   int highest;
3104
3105   /* Most likely some numbers will have to be reassigned as part of
3106      the merge, so clear them all in anticipation.  */
3107   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3108     tsv->number = 0;
3109
3110   for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3111     {
3112       tsv = find_matching_tsv (utsv);
3113       if (tsv)
3114         printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3115                          tsv->name, utsv->number);
3116       else
3117         {
3118           tsv = create_tsv_from_upload (utsv);
3119           printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3120                            tsv->name, utsv->number);
3121         }
3122       /* Give precedence to numberings that come from the target.  */
3123       if (tsv)
3124         tsv->number = utsv->number;
3125     }
3126
3127   /* Renumber everything that didn't get a target-assigned number.  */
3128   highest = 0;
3129   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3130     if (tsv->number > highest)
3131       highest = tsv->number;
3132
3133   ++highest;
3134   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3135     if (tsv->number == 0)
3136       tsv->number = highest++;
3137
3138   free_uploaded_tsvs (uploaded_tsvs);
3139 }
3140
3141 /* target tfile command */
3142
3143 struct target_ops tfile_ops;
3144
3145 /* Fill in tfile_ops with its defined operations and properties.  */
3146
3147 #define TRACE_HEADER_SIZE 8
3148
3149 char *trace_filename;
3150 int trace_fd = -1;
3151 off_t trace_frames_offset;
3152 off_t cur_offset;
3153 int cur_data_size;
3154 int trace_regblock_size;
3155
3156 static void tfile_interp_line (char *line,
3157                                struct uploaded_tp **utpp,
3158                                struct uploaded_tsv **utsvp);
3159
3160 static void
3161 tfile_open (char *filename, int from_tty)
3162 {
3163   char *temp;
3164   struct cleanup *old_chain;
3165   int flags;
3166   int scratch_chan;
3167   char header[TRACE_HEADER_SIZE];
3168   char linebuf[1000]; /* should be max remote packet size or so */
3169   char byte;
3170   int bytes, i, gotten;
3171   struct trace_status *ts;
3172   struct uploaded_tp *uploaded_tps = NULL;
3173   struct uploaded_tsv *uploaded_tsvs = NULL;
3174
3175   target_preopen (from_tty);
3176   if (!filename)
3177     error (_("No trace file specified."));
3178
3179   filename = tilde_expand (filename);
3180   if (!IS_ABSOLUTE_PATH(filename))
3181     {
3182       temp = concat (current_directory, "/", filename, (char *)NULL);
3183       xfree (filename);
3184       filename = temp;
3185     }
3186
3187   old_chain = make_cleanup (xfree, filename);
3188
3189   flags = O_BINARY | O_LARGEFILE;
3190   flags |= O_RDONLY;
3191   scratch_chan = open (filename, flags, 0);
3192   if (scratch_chan < 0)
3193     perror_with_name (filename);
3194
3195   /* Looks semi-reasonable.  Toss the old trace file and work on the new.  */
3196
3197   discard_cleanups (old_chain); /* Don't free filename any more */
3198   unpush_target (&tfile_ops);
3199
3200   push_target (&tfile_ops);
3201
3202   trace_filename = xstrdup (filename);
3203   trace_fd = scratch_chan;
3204
3205   bytes = 0;
3206   /* Read the file header and test for validity.  */
3207   gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
3208   if (gotten < 0)
3209     perror_with_name (trace_filename);
3210   else if (gotten < TRACE_HEADER_SIZE)
3211     error (_("Premature end of file while reading trace file"));
3212
3213   bytes += TRACE_HEADER_SIZE;
3214   if (!(header[0] == 0x7f
3215         && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3216     error (_("File is not a valid trace file."));
3217
3218   trace_regblock_size = 0;
3219   ts = current_trace_status ();
3220   /* We know we're working with a file.  */
3221   ts->from_file = 1;
3222   /* Set defaults in case there is no status line.  */
3223   ts->running_known = 0;
3224   ts->stop_reason = trace_stop_reason_unknown;
3225   ts->traceframe_count = -1;
3226   ts->buffer_free = 0;
3227   ts->disconnected_tracing = 0;
3228   ts->circular_buffer = 0;
3229
3230   /* Read through a section of newline-terminated lines that
3231      define things like tracepoints.  */
3232   i = 0;
3233   while (1)
3234     {
3235       gotten = read (trace_fd, &byte, 1);
3236       if (gotten < 0)
3237         perror_with_name (trace_filename);
3238       else if (gotten < 1)
3239         error (_("Premature end of file while reading trace file"));
3240
3241       ++bytes;
3242       if (byte == '\n')
3243         {
3244           /* Empty line marks end of the definition section.  */
3245           if (i == 0)
3246             break;
3247           linebuf[i] = '\0';
3248           i = 0;
3249           tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3250         }
3251       else
3252         linebuf[i++] = byte;
3253       if (i >= 1000)
3254         error (_("Excessively long lines in trace file"));
3255     }
3256
3257   /* Add the file's tracepoints and variables into the current mix.  */
3258
3259   /* Get trace state variables first, they may be checked when parsing
3260      uploaded commands.  */
3261   merge_uploaded_trace_state_variables (&uploaded_tsvs);
3262
3263   merge_uploaded_tracepoints (&uploaded_tps);
3264
3265   /* Record the starting offset of the binary trace data.  */
3266   trace_frames_offset = bytes;
3267
3268   /* If we don't have a blocksize, we can't interpret the
3269      traceframes.  */
3270   if (trace_regblock_size == 0)
3271     error (_("No register block size recorded in trace file"));
3272   if (ts->traceframe_count <= 0)
3273     {
3274       warning ("No traceframes present in this file.");
3275       return;
3276     }
3277
3278 #define TFILE_PID (1)
3279   inferior_appeared (current_inferior (), TFILE_PID);
3280   inferior_ptid = pid_to_ptid (TFILE_PID);
3281   add_thread_silent (inferior_ptid);
3282
3283   post_create_inferior (&tfile_ops, from_tty);
3284
3285 #if 0
3286   /* FIXME this will get defined in MI patch submission */
3287   tfind_1 (tfind_number, 0, 0, 0, 0);
3288 #endif
3289 }
3290
3291 /* Interpret the given line from the definitions part of the trace
3292    file.  */
3293
3294 static void
3295 tfile_interp_line (char *line,
3296                    struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3297 {
3298   char *p = line;
3299
3300   if (strncmp (p, "R ", strlen ("R ")) == 0)
3301     {
3302       p += strlen ("R ");
3303       trace_regblock_size = strtol (p, &p, 16);
3304     }
3305   else if (strncmp (p, "status ", strlen ("status ")) == 0)
3306     {
3307       p += strlen ("status ");
3308       parse_trace_status (p, current_trace_status ());
3309     }
3310   else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3311     {
3312       p += strlen ("tp ");
3313       parse_tracepoint_definition (p, utpp);
3314     }
3315   else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3316     {
3317       p += strlen ("tsv ");
3318       parse_tsv_definition (p, utsvp);
3319     }
3320   else
3321     warning ("Ignoring trace file definition \"%s\"", line);
3322 }
3323
3324 /* Parse the part of trace status syntax that is shared between
3325    the remote protocol and the trace file reader.  */
3326
3327 extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
3328
3329 void
3330 parse_trace_status (char *line, struct trace_status *ts)
3331 {
3332   char *p = line, *p1, *p2, *p_temp;
3333   ULONGEST val;
3334
3335   ts->running_known = 1;
3336   ts->running = (*p++ == '1');
3337   ts->stop_reason = trace_stop_reason_unknown;
3338   xfree (ts->error_desc);
3339   ts->error_desc = NULL;
3340   ts->traceframe_count = -1;
3341   ts->traceframes_created = -1;
3342   ts->buffer_free = -1;
3343   ts->buffer_size = -1;
3344   ts->disconnected_tracing = 0;
3345   ts->circular_buffer = 0;
3346
3347   while (*p++)
3348     {
3349       p1 = strchr (p, ':');
3350       if (p1 == NULL)
3351         error (_("Malformed trace status, at %s\n\
3352 Status line: '%s'\n"), p, line);
3353       if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3354         {
3355           p = unpack_varlen_hex (++p1, &val);
3356           ts->stop_reason = trace_buffer_full;
3357         }
3358       else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3359         {
3360           p = unpack_varlen_hex (++p1, &val);
3361           ts->stop_reason = trace_never_run;
3362         }
3363       else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0)
3364         {
3365           p = unpack_varlen_hex (++p1, &val);
3366           ts->stop_reason = tracepoint_passcount;
3367           ts->stopping_tracepoint = val;
3368         }
3369       else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3370         {
3371           p = unpack_varlen_hex (++p1, &val);
3372           ts->stop_reason = tstop_command;
3373         }
3374       else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3375         {
3376           p = unpack_varlen_hex (++p1, &val);
3377           ts->stop_reason = trace_disconnected;
3378         }
3379       else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3380         {
3381           p2 = strchr (++p1, ':');
3382           if (p2 != p1)
3383             {
3384               int end;
3385
3386               ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3387               end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3388               ts->error_desc[end] = '\0';
3389             }
3390           else
3391             ts->error_desc = xstrdup ("");
3392
3393           p = unpack_varlen_hex (++p2, &val);
3394           ts->stopping_tracepoint = val;
3395           ts->stop_reason = tracepoint_error;
3396         }
3397       else if (strncmp (p, "tframes", p1 - p) == 0)
3398         {
3399           p = unpack_varlen_hex (++p1, &val);
3400           ts->traceframe_count = val;
3401         }
3402       else if (strncmp (p, "tcreated", p1 - p) == 0)
3403         {
3404           p = unpack_varlen_hex (++p1, &val);
3405           ts->traceframes_created = val;
3406         }
3407       else if (strncmp (p, "tfree", p1 - p) == 0)
3408         {
3409           p = unpack_varlen_hex (++p1, &val);
3410           ts->buffer_free = val;
3411         }
3412       else if (strncmp (p, "tsize", p1 - p) == 0)
3413         {
3414           p = unpack_varlen_hex (++p1, &val);
3415           ts->buffer_size = val;
3416         }
3417       else if (strncmp (p, "disconn", p1 - p) == 0)
3418         {
3419           p = unpack_varlen_hex (++p1, &val);
3420           ts->disconnected_tracing = val;
3421         }
3422       else if (strncmp (p, "circular", p1 - p) == 0)
3423         {
3424           p = unpack_varlen_hex (++p1, &val);
3425           ts->circular_buffer = val;
3426         }
3427       else
3428         {
3429           /* Silently skip unknown optional info.  */
3430           p_temp = strchr (p1 + 1, ';');
3431           if (p_temp)
3432             p = p_temp;
3433           else
3434             /* Must be at the end.  */
3435             break;
3436         }
3437     }
3438 }
3439
3440 /* Given a line of text defining a part of a tracepoint, parse it into
3441    an "uploaded tracepoint".  */
3442
3443 void
3444 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3445 {
3446   char *p;
3447   char piece;
3448   ULONGEST num, addr, step, pass, orig_size, xlen, start;
3449   int enabled, i, end;
3450   enum bptype type;
3451   char *cond, *srctype, *src, *buf;
3452   struct uploaded_tp *utp = NULL;
3453
3454   p = line;
3455   /* Both tracepoint and action definitions start with the same number
3456      and address sequence.  */
3457   piece = *p++;
3458   p = unpack_varlen_hex (p, &num);
3459   p++;  /* skip a colon */
3460   p = unpack_varlen_hex (p, &addr);
3461   p++;  /* skip a colon */
3462   if (piece == 'T')
3463     {
3464       enabled = (*p++ == 'E');
3465       p++;  /* skip a colon */
3466       p = unpack_varlen_hex (p, &step);
3467       p++;  /* skip a colon */
3468       p = unpack_varlen_hex (p, &pass);
3469       type = bp_tracepoint;
3470       cond = NULL;
3471       /* Thumb through optional fields.  */
3472       while (*p == ':')
3473         {
3474           p++;  /* skip a colon */
3475           if (*p == 'F')
3476             {
3477               type = bp_fast_tracepoint;
3478               p++;
3479               p = unpack_varlen_hex (p, &orig_size);
3480             }
3481           else if (*p == 'X')
3482             {
3483               p++;
3484               p = unpack_varlen_hex (p, &xlen);
3485               p++;  /* skip a comma */
3486               cond = (char *) xmalloc (2 * xlen + 1);
3487               strncpy (cond, p, 2 * xlen);
3488               cond[2 * xlen] = '\0';
3489               p += 2 * xlen;
3490             }
3491           else
3492             warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p);
3493         }
3494       utp = get_uploaded_tp (num, addr, utpp);
3495       utp->type = type;
3496       utp->enabled = enabled;
3497       utp->step = step;
3498       utp->pass = pass;
3499       utp->cond = cond;
3500     }
3501   else if (piece == 'A')
3502     {
3503       utp = get_uploaded_tp (num, addr, utpp);
3504       VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3505     }
3506   else if (piece == 'S')
3507     {
3508       utp = get_uploaded_tp (num, addr, utpp);
3509       VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3510     }
3511   else if (piece == 'Z')
3512     {
3513       /* Parse a chunk of source form definition.  */
3514       utp = get_uploaded_tp (num, addr, utpp);
3515       srctype = p;
3516       p = strchr (p, ':');
3517       p++;  /* skip a colon */
3518       p = unpack_varlen_hex (p, &start);
3519       p++;  /* skip a colon */
3520       p = unpack_varlen_hex (p, &xlen);
3521       p++;  /* skip a colon */
3522
3523       buf = alloca (strlen (line));
3524
3525       end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3526       buf[end] = '\0';
3527
3528       if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3529         utp->at_string = xstrdup (buf);
3530       else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3531         utp->cond_string = xstrdup (buf);
3532       else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3533         VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3534     }
3535   else
3536     {
3537       /* Don't error out, the target might be sending us optional
3538          info that we don't care about.  */
3539       warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3540     }
3541 }
3542
3543 /* Convert a textual description of a trace state variable into an
3544    uploaded object.  */
3545
3546 void
3547 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3548 {
3549   char *p, *buf;
3550   ULONGEST num, initval, builtin;
3551   int end;
3552   struct uploaded_tsv *utsv = NULL;
3553
3554   buf = alloca (strlen (line));
3555
3556   p = line;
3557   p = unpack_varlen_hex (p, &num);
3558   p++; /* skip a colon */
3559   p = unpack_varlen_hex (p, &initval);
3560   p++; /* skip a colon */
3561   p = unpack_varlen_hex (p, &builtin);
3562   p++; /* skip a colon */
3563   end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3564   buf[end] = '\0';
3565
3566   utsv = get_uploaded_tsv (num, utsvp);
3567   utsv->initial_value = initval;
3568   utsv->builtin = builtin;
3569   utsv->name = xstrdup (buf);
3570 }
3571
3572 /* Close the trace file and generally clean up.  */
3573
3574 static void
3575 tfile_close (int quitting)
3576 {
3577   int pid;
3578
3579   if (trace_fd < 0)
3580     return;
3581
3582   pid = ptid_get_pid (inferior_ptid);
3583   inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff */
3584   exit_inferior_silent (pid);
3585
3586   close (trace_fd);
3587   trace_fd = -1;
3588   if (trace_filename)
3589     xfree (trace_filename);
3590 }
3591
3592 static void
3593 tfile_files_info (struct target_ops *t)
3594 {
3595   /* (it would be useful to mention the name of the file) */
3596   printf_filtered ("Looking at a trace file.\n");
3597 }
3598
3599 /* The trace status for a file is that tracing can never be run.  */
3600
3601 static int
3602 tfile_get_trace_status (struct trace_status *ts)
3603 {
3604   /* Other bits of trace status were collected as part of opening the
3605      trace files, so nothing to do here.  */
3606
3607   return -1;
3608 }
3609
3610 /* Given the position of a traceframe in the file, figure out what
3611    address the frame was collected at.  This would normally be the
3612    value of a collected PC register, but if not available, we
3613    improvise.  */
3614
3615 static ULONGEST
3616 tfile_get_traceframe_address (off_t tframe_offset)
3617 {
3618   ULONGEST addr = 0;
3619   short tpnum;
3620   struct breakpoint *tp;
3621   off_t saved_offset = cur_offset;
3622   int gotten;
3623
3624   /* FIXME dig pc out of collected registers */
3625
3626   /* Fall back to using tracepoint address.  */
3627   lseek (trace_fd, tframe_offset, SEEK_SET);
3628   gotten = read (trace_fd, &tpnum, 2);
3629   if (gotten < 0)
3630     perror_with_name (trace_filename);
3631   else if (gotten < 2)
3632     error (_("Premature end of file while reading trace file"));
3633
3634   tp = get_tracepoint_by_number_on_target (tpnum);
3635   /* FIXME this is a poor heuristic if multiple locations */
3636   if (tp && tp->loc)
3637     addr = tp->loc->address;
3638
3639   /* Restore our seek position.  */
3640   cur_offset = saved_offset;
3641   lseek (trace_fd, cur_offset, SEEK_SET);
3642   return addr;
3643 }
3644
3645 /* Given a type of search and some parameters, scan the collection of
3646    traceframes in the file looking for a match.  When found, return
3647    both the traceframe and tracepoint number, otherwise -1 for
3648    each.  */
3649
3650 static int
3651 tfile_trace_find (enum trace_find_type type, int num,
3652                   ULONGEST addr1, ULONGEST addr2, int *tpp)
3653 {
3654   short tpnum;
3655   int tfnum = 0, found = 0, gotten;
3656   int data_size;
3657   struct breakpoint *tp;
3658   off_t offset, tframe_offset;
3659   ULONGEST tfaddr;
3660
3661   lseek (trace_fd, trace_frames_offset, SEEK_SET);
3662   offset = trace_frames_offset;
3663   while (1)
3664     {
3665       tframe_offset = offset;
3666       gotten = read (trace_fd, &tpnum, 2);
3667       if (gotten < 0)
3668         perror_with_name (trace_filename);
3669       else if (gotten < 2)
3670         error (_("Premature end of file while reading trace file"));
3671       offset += 2;
3672       if (tpnum == 0)
3673         break;
3674       gotten = read (trace_fd, &data_size, 4);
3675       if (gotten < 0)
3676         perror_with_name (trace_filename);
3677       else if (gotten < 4)
3678         error (_("Premature end of file while reading trace file"));
3679       offset += 4;
3680       switch (type)
3681         {
3682         case tfind_number:
3683           if (tfnum == num)
3684             found = 1;
3685           break;
3686         case tfind_pc:
3687           tfaddr = tfile_get_traceframe_address (tframe_offset);
3688           if (tfaddr == addr1)
3689             found = 1;
3690           break;
3691         case tfind_tp:
3692           tp = get_tracepoint (num);
3693           if (tp && tpnum == tp->number_on_target)
3694             found = 1;
3695           break;
3696         case tfind_range:
3697           tfaddr = tfile_get_traceframe_address (tframe_offset);
3698           if (addr1 <= tfaddr && tfaddr <= addr2)
3699             found = 1;
3700           break;
3701         case tfind_outside:
3702           tfaddr = tfile_get_traceframe_address (tframe_offset);
3703           if (!(addr1 <= tfaddr && tfaddr <= addr2))
3704             found = 1;
3705           break;
3706         default:
3707           internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3708         }
3709       if (found)
3710         {
3711           if (tpp)
3712             *tpp = tpnum;
3713           cur_offset = offset;
3714           cur_data_size = data_size;
3715           return tfnum;
3716         }
3717       /* Skip past the traceframe's data.  */
3718       lseek (trace_fd, data_size, SEEK_CUR);
3719       offset += data_size;
3720       /* Update our own count of traceframes.  */
3721       ++tfnum;
3722     }
3723   /* Did not find what we were looking for.  */
3724   if (tpp)
3725     *tpp = -1;
3726   return -1;
3727 }
3728
3729 /* Look for a block of saved registers in the traceframe, and get the
3730    requested register from it.  */
3731
3732 static void
3733 tfile_fetch_registers (struct target_ops *ops,
3734                        struct regcache *regcache, int regno)
3735 {
3736   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3737   char block_type;
3738   int i, pos, offset, regn, regsize, gotten, pc_regno;
3739   unsigned short mlen;
3740   char *regs;
3741
3742   /* An uninitialized reg size says we're not going to be
3743      successful at getting register blocks.  */
3744   if (!trace_regblock_size)
3745     return;
3746
3747   regs = alloca (trace_regblock_size);
3748
3749   lseek (trace_fd, cur_offset, SEEK_SET);
3750   pos = 0;
3751   while (pos < cur_data_size)
3752     {
3753       gotten = read (trace_fd, &block_type, 1);
3754       if (gotten < 0)
3755         perror_with_name (trace_filename);
3756       else if (gotten < 1)
3757         error (_("Premature end of file while reading trace file"));
3758
3759       ++pos;
3760       switch (block_type)
3761         {
3762         case 'R':
3763           gotten = read (trace_fd, regs, trace_regblock_size);
3764           if (gotten < 0)
3765             perror_with_name (trace_filename);
3766           else if (gotten < trace_regblock_size)
3767             error (_("Premature end of file while reading trace file"));
3768
3769           /* Assume the block is laid out in GDB register number order,
3770              each register with the size that it has in GDB.  */
3771           offset = 0;
3772           for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3773             {
3774               regsize = register_size (gdbarch, regn);
3775               /* Make sure we stay within block bounds.  */
3776               if (offset + regsize >= trace_regblock_size)
3777                 break;
3778               if (!regcache_valid_p (regcache, regn))
3779                 {
3780                   if (regno == regn)
3781                     {
3782                       regcache_raw_supply (regcache, regno, regs + offset);
3783                       break;
3784                     }
3785                   else if (regno == -1)
3786                     {
3787                       regcache_raw_supply (regcache, regn, regs + offset);
3788                     }
3789                 }
3790               offset += regsize;
3791             }
3792           return;
3793         case 'M':
3794           lseek (trace_fd, 8, SEEK_CUR);
3795           gotten = read (trace_fd, &mlen, 2);
3796           if (gotten < 0)
3797             perror_with_name (trace_filename);
3798           else if (gotten < 2)
3799             error (_("Premature end of file while reading trace file"));
3800           lseek (trace_fd, mlen, SEEK_CUR);
3801           pos += (8 + 2 + mlen);
3802           break;
3803         case 'V':
3804           lseek (trace_fd, 4 + 8, SEEK_CUR);
3805           pos += (4 + 8);
3806           break;
3807         default:
3808           error ("Unknown block type '%c' (0x%x) in trace frame",
3809                  block_type, block_type);
3810           break;
3811         }
3812     }
3813
3814   /* We get here if no register data has been found.  Although we
3815      don't like making up numbers, GDB has all manner of troubles when
3816      the target says some register is not available.  Filling in with
3817      zeroes is a reasonable fallback.  */
3818   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3819     regcache_raw_supply (regcache, regn, NULL);
3820
3821   /* We can often usefully guess that the PC is going to be the same
3822      as the address of the tracepoint.  */
3823   pc_regno = gdbarch_pc_regnum (gdbarch);
3824   if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
3825     {
3826       struct breakpoint *tp = get_tracepoint (tracepoint_number);
3827
3828       if (tp && tp->loc)
3829         {
3830           /* But don't try to guess if tracepoint is multi-location...  */
3831           if (tp->loc->next)
3832             {
3833               warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3834                        tp->number);
3835               return;
3836             }
3837           /* ... or does while-stepping.  */
3838           if (tp->step_count > 0)
3839             {
3840               warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3841                        tp->number);
3842               return;
3843             }
3844
3845           store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
3846                                   gdbarch_byte_order (gdbarch),
3847                                   tp->loc->address);
3848           regcache_raw_supply (regcache, pc_regno, regs);
3849         }
3850     }
3851 }
3852
3853 static LONGEST
3854 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3855                     const char *annex, gdb_byte *readbuf,
3856                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3857 {
3858   char block_type;
3859   int pos, gotten;
3860   ULONGEST maddr, amt;
3861   unsigned short mlen;
3862
3863   /* We're only doing regular memory for now.  */
3864   if (object != TARGET_OBJECT_MEMORY)
3865     return -1;
3866
3867   if (readbuf == NULL)
3868     error ("tfile_xfer_partial: trace file is read-only");
3869
3870   lseek (trace_fd, cur_offset, SEEK_SET);
3871   pos = 0;
3872   while (pos < cur_data_size)
3873     {
3874       gotten = read (trace_fd, &block_type, 1);
3875       if (gotten < 0)
3876         perror_with_name (trace_filename);
3877       else if (gotten < 1)
3878         error (_("Premature end of file while reading trace file"));
3879       ++pos;
3880       switch (block_type)
3881         {
3882         case 'R':
3883           lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3884           pos += trace_regblock_size;
3885           break;
3886         case 'M':
3887           gotten = read (trace_fd, &maddr, 8);
3888           if (gotten < 0)
3889             perror_with_name (trace_filename);
3890           else if (gotten < 8)
3891             error (_("Premature end of file while reading trace file"));
3892
3893           gotten = read (trace_fd, &mlen, 2);
3894           if (gotten < 0)
3895             perror_with_name (trace_filename);
3896           else if (gotten < 2)
3897             error (_("Premature end of file while reading trace file"));
3898           /* If the block includes the first part of the desired
3899              range, return as much it has; GDB will re-request the
3900              remainder, which might be in a different block of this
3901              trace frame.  */
3902           if (maddr <= offset && offset < (maddr + mlen))
3903             {
3904               amt = (maddr + mlen) - offset;
3905               if (amt > len)
3906                 amt = len;
3907
3908               gotten = read (trace_fd, readbuf, amt);
3909               if (gotten < 0)
3910                 perror_with_name (trace_filename);
3911               /* While it's acceptable to return less than was
3912                  originally asked for, it's not acceptable to return
3913                  less than what this block claims to contain.  */
3914               else if (gotten < amt)
3915                 error (_("Premature end of file while reading trace file"));
3916               return amt;
3917             }
3918           lseek (trace_fd, mlen, SEEK_CUR);
3919           pos += (8 + 2 + mlen);
3920           break;
3921         case 'V':
3922           lseek (trace_fd, 4 + 8, SEEK_CUR);
3923           pos += (4 + 8);
3924           break;
3925         default:
3926           error ("Unknown block type '%c' (0x%x) in traceframe",
3927                  block_type, block_type);
3928           break;
3929         }
3930     }
3931
3932   /* It's unduly pedantic to refuse to look at the executable for
3933      read-only pieces; so do the equivalent of readonly regions aka
3934      QTro packet.  */
3935   /* FIXME account for relocation at some point */
3936   if (exec_bfd)
3937     {
3938       asection *s;
3939       bfd_size_type size;
3940       bfd_vma lma;
3941
3942       for (s = exec_bfd->sections; s; s = s->next)
3943         {
3944           if ((s->flags & SEC_LOAD) == 0 ||
3945               (s->flags & SEC_READONLY) == 0)
3946             continue;
3947
3948           lma = s->lma;
3949           size = bfd_get_section_size (s);
3950           if (lma <= offset && offset < (lma + size))
3951             {
3952               amt = (lma + size) - offset;
3953               if (amt > len)
3954                 amt = len;
3955
3956               amt = bfd_get_section_contents (exec_bfd, s,
3957                                               readbuf, offset - lma, amt);
3958               return amt;
3959             }
3960         }
3961     }
3962
3963   /* Indicate failure to find the requested memory block.  */
3964   return -1;
3965 }
3966
3967 /* Iterate through the blocks of a trace frame, looking for a 'V'
3968    block with a matching tsv number.  */
3969
3970 static int
3971 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
3972 {
3973   char block_type;
3974   int pos, vnum, gotten;
3975   unsigned short mlen;
3976
3977   lseek (trace_fd, cur_offset, SEEK_SET);
3978   pos = 0;
3979   while (pos < cur_data_size)
3980     {
3981       gotten = read (trace_fd, &block_type, 1);
3982       if (gotten < 0)
3983         perror_with_name (trace_filename);
3984       else if (gotten < 1)
3985         error (_("Premature end of file while reading trace file"));
3986       ++pos;
3987       switch (block_type)
3988         {
3989         case 'R':
3990           lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3991           pos += trace_regblock_size;
3992           break;
3993         case 'M':
3994           lseek (trace_fd, 8, SEEK_CUR);
3995           gotten = read (trace_fd, &mlen, 2);
3996           if (gotten < 0)
3997             perror_with_name (trace_filename);
3998           else if (gotten < 2)
3999             error (_("Premature end of file while reading trace file"));
4000           lseek (trace_fd, mlen, SEEK_CUR);
4001           pos += (8 + 2 + mlen);
4002           break;
4003         case 'V':
4004           gotten = read (trace_fd, &vnum, 4);
4005           if (gotten < 0)
4006             perror_with_name (trace_filename);
4007           else if (gotten < 4)
4008             error (_("Premature end of file while reading trace file"));
4009           if (tsvnum == vnum)
4010             {
4011               gotten = read (trace_fd, val, 8);
4012               if (gotten < 0)
4013                 perror_with_name (trace_filename);
4014               else if (gotten < 8)
4015                 error (_("Premature end of file while reading trace file"));
4016               return 1;
4017             }
4018           lseek (trace_fd, 8, SEEK_CUR);
4019           pos += (4 + 8);
4020           break;
4021         default:
4022           error ("Unknown block type '%c' (0x%x) in traceframe",
4023                  block_type, block_type);
4024           break;
4025         }
4026     }
4027   /* Didn't find anything.  */
4028   return 0;
4029 }
4030
4031 static int
4032 tfile_has_all_memory (struct target_ops *ops)
4033 {
4034   return 1;
4035 }
4036
4037 static int
4038 tfile_has_memory (struct target_ops *ops)
4039 {
4040   return 1;
4041 }
4042
4043 static int
4044 tfile_has_stack (struct target_ops *ops)
4045 {
4046   return 1;
4047 }
4048
4049 static int
4050 tfile_has_registers (struct target_ops *ops)
4051 {
4052   return 1;
4053 }
4054
4055 static void
4056 init_tfile_ops (void)
4057 {
4058   tfile_ops.to_shortname = "tfile";
4059   tfile_ops.to_longname = "Local trace dump file";
4060   tfile_ops.to_doc =
4061     "Use a trace file as a target.  Specify the filename of the trace file.";
4062   tfile_ops.to_open = tfile_open;
4063   tfile_ops.to_close = tfile_close;
4064   tfile_ops.to_fetch_registers = tfile_fetch_registers;
4065   tfile_ops.to_xfer_partial = tfile_xfer_partial;
4066   tfile_ops.to_files_info = tfile_files_info;
4067   tfile_ops.to_get_trace_status = tfile_get_trace_status;
4068   tfile_ops.to_trace_find = tfile_trace_find;
4069   tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value;
4070   /* core_stratum might seem more logical, but GDB doesn't like having
4071      more than one core_stratum vector.  */
4072   tfile_ops.to_stratum = process_stratum;
4073   tfile_ops.to_has_all_memory = tfile_has_all_memory;
4074   tfile_ops.to_has_memory = tfile_has_memory;
4075   tfile_ops.to_has_stack = tfile_has_stack;
4076   tfile_ops.to_has_registers = tfile_has_registers;
4077   tfile_ops.to_magic = OPS_MAGIC;
4078 }
4079
4080 /* module initialization */
4081 void
4082 _initialize_tracepoint (void)
4083 {
4084   struct cmd_list_element *c;
4085
4086   traceframe_number = -1;
4087   tracepoint_number = -1;
4088
4089   if (tracepoint_list.list == NULL)
4090     {
4091       tracepoint_list.listsize = 128;
4092       tracepoint_list.list = xmalloc
4093         (tracepoint_list.listsize * sizeof (struct memrange));
4094     }
4095   if (tracepoint_list.aexpr_list == NULL)
4096     {
4097       tracepoint_list.aexpr_listsize = 128;
4098       tracepoint_list.aexpr_list = xmalloc
4099         (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4100     }
4101
4102   if (stepping_list.list == NULL)
4103     {
4104       stepping_list.listsize = 128;
4105       stepping_list.list = xmalloc
4106         (stepping_list.listsize * sizeof (struct memrange));
4107     }
4108
4109   if (stepping_list.aexpr_list == NULL)
4110     {
4111       stepping_list.aexpr_listsize = 128;
4112       stepping_list.aexpr_list = xmalloc
4113         (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4114     }
4115
4116   add_info ("scope", scope_info,
4117             _("List the variables local to a scope"));
4118
4119   add_cmd ("tracepoints", class_trace, NULL,
4120            _("Tracing of program execution without stopping the program."),
4121            &cmdlist);
4122
4123   add_com ("tdump", class_trace, trace_dump_command,
4124            _("Print everything collected at the current tracepoint."));
4125
4126   add_com ("tsave", class_trace, trace_save_command, _("\
4127 Save the trace data to a file.\n\
4128 Use the '-r' option to direct the target to save directly to the file,\n\
4129 using its own filesystem."));
4130
4131   c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4132 Define a trace state variable.\n\
4133 Argument is a $-prefixed name, optionally followed\n\
4134 by '=' and an expression that sets the initial value\n\
4135 at the start of tracing."));
4136   set_cmd_completer (c, expression_completer);
4137
4138   add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4139 Delete one or more trace state variables.\n\
4140 Arguments are the names of the variables to delete.\n\
4141 If no arguments are supplied, delete all variables."), &deletelist);
4142   /* FIXME add a trace variable completer */
4143
4144   add_info ("tvariables", tvariables_info, _("\
4145 Status of trace state variables and their values.\n\
4146 "));
4147
4148   add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4149 Select a trace frame;\n\
4150 No argument means forward by one frame; '-' means backward by one frame."),
4151                   &tfindlist, "tfind ", 1, &cmdlist);
4152
4153   add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4154 Select a trace frame whose PC is outside the given range (exclusive).\n\
4155 Usage: tfind outside addr1, addr2"),
4156            &tfindlist);
4157
4158   add_cmd ("range", class_trace, trace_find_range_command, _("\
4159 Select a trace frame whose PC is in the given range (inclusive).\n\
4160 Usage: tfind range addr1,addr2"),
4161            &tfindlist);
4162
4163   add_cmd ("line", class_trace, trace_find_line_command, _("\
4164 Select a trace frame by source line.\n\
4165 Argument can be a line number (with optional source file), \n\
4166 a function name, or '*' followed by an address.\n\
4167 Default argument is 'the next source line that was traced'."),
4168            &tfindlist);
4169
4170   add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4171 Select a trace frame by tracepoint number.\n\
4172 Default is the tracepoint for the current trace frame."),
4173            &tfindlist);
4174
4175   add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4176 Select a trace frame by PC.\n\
4177 Default is the current PC, or the PC of the current trace frame."),
4178            &tfindlist);
4179
4180   add_cmd ("end", class_trace, trace_find_end_command, _("\
4181 Synonym for 'none'.\n\
4182 De-select any trace frame and resume 'live' debugging."),
4183            &tfindlist);
4184
4185   add_cmd ("none", class_trace, trace_find_none_command,
4186            _("De-select any trace frame and resume 'live' debugging."),
4187            &tfindlist);
4188
4189   add_cmd ("start", class_trace, trace_find_start_command,
4190            _("Select the first trace frame in the trace buffer."),
4191            &tfindlist);
4192
4193   add_com ("tstatus", class_trace, trace_status_command,
4194            _("Display the status of the current trace data collection."));
4195
4196   add_com ("tstop", class_trace, trace_stop_command,
4197            _("Stop trace data collection."));
4198
4199   add_com ("tstart", class_trace, trace_start_command,
4200            _("Start trace data collection."));
4201
4202   add_com ("end", class_trace, end_actions_pseudocommand, _("\
4203 Ends a list of commands or actions.\n\
4204 Several GDB commands allow you to enter a list of commands or actions.\n\
4205 Entering \"end\" on a line by itself is the normal way to terminate\n\
4206 such a list.\n\n\
4207 Note: the \"end\" command cannot be used at the gdb prompt."));
4208
4209   add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4210 Specify single-stepping behavior at a tracepoint.\n\
4211 Argument is number of instructions to trace in single-step mode\n\
4212 following the tracepoint.  This command is normally followed by\n\
4213 one or more \"collect\" commands, to specify what to collect\n\
4214 while single-stepping.\n\n\
4215 Note: this command can only be used in a tracepoint \"actions\" list."));
4216
4217   add_com_alias ("ws", "while-stepping", class_alias, 0);
4218   add_com_alias ("stepping", "while-stepping", class_alias, 0);
4219
4220   add_com ("collect", class_trace, collect_pseudocommand, _("\
4221 Specify one or more data items to be collected at a tracepoint.\n\
4222 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
4223 collect all data (variables, registers) referenced by that expression.\n\
4224 Also accepts the following special arguments:\n\
4225     $regs   -- all registers.\n\
4226     $args   -- all function arguments.\n\
4227     $locals -- all variables local to the block/function scope.\n\
4228 Note: this command can only be used in a tracepoint \"actions\" list."));
4229
4230   add_com ("teval", class_trace, teval_pseudocommand, _("\
4231 Specify one or more expressions to be evaluated at a tracepoint.\n\
4232 Accepts a comma-separated list of (one or more) expressions.\n\
4233 The result of each evaluation will be discarded.\n\
4234 Note: this command can only be used in a tracepoint \"actions\" list."));
4235
4236   add_com ("actions", class_trace, trace_actions_command, _("\
4237 Specify the actions to be taken at a tracepoint.\n\
4238 Tracepoint actions may include collecting of specified data, \n\
4239 single-stepping, or enabling/disabling other tracepoints, \n\
4240 depending on target's capabilities."));
4241
4242   default_collect = xstrdup ("");
4243   add_setshow_string_cmd ("default-collect", class_trace,
4244                           &default_collect, _("\
4245 Set the list of expressions to collect by default"), _("\
4246 Show the list of expressions to collect by default"), NULL,
4247                           NULL, NULL,
4248                           &setlist, &showlist);
4249
4250   add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4251                            &disconnected_tracing, _("\
4252 Set whether tracing continues after GDB disconnects."), _("\
4253 Show whether tracing continues after GDB disconnects."), _("\
4254 Use this to continue a tracing run even if GDB disconnects\n\
4255 or detaches from the target.  You can reconnect later and look at\n\
4256 trace data collected in the meantime."),
4257                            set_disconnected_tracing,
4258                            NULL,
4259                            &setlist,
4260                            &showlist);
4261
4262   add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4263                            &circular_trace_buffer, _("\
4264 Set target's use of circular trace buffer."), _("\
4265 Show target's use of circular trace buffer."), _("\
4266 Use this to make the trace buffer into a circular buffer,\n\
4267 which will discard traceframes (oldest first) instead of filling\n\
4268 up and stopping the trace run."),
4269                            set_circular_trace_buffer,
4270                            NULL,
4271                            &setlist,
4272                            &showlist);
4273
4274   init_tfile_ops ();
4275
4276   add_target (&tfile_ops);
4277 }