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