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
1800   if ((int) ts->traceframe_count != -1)
1801     ui_out_field_int (uiout, "frames", ts->traceframe_count);
1802   if ((int) ts->buffer_size != -1)
1803     ui_out_field_int (uiout, "buffer-size",  (int) ts->buffer_size);
1804   if ((int) ts->buffer_free != -1)
1805     ui_out_field_int (uiout, "buffer-free",  (int) ts->buffer_free);
1806 }
1807
1808 /* This function handles the details of what to do about an ongoing
1809    tracing run if the user has asked to detach or otherwise disconnect
1810    from the target.  */
1811 void
1812 disconnect_tracing (int from_tty)
1813 {
1814   /* It can happen that the target that was tracing went away on its
1815      own, and we didn't notice.  Get a status update, and if the
1816      current target doesn't even do tracing, then assume it's not
1817      running anymore.  */
1818   if (target_get_trace_status (current_trace_status ()) < 0)
1819     current_trace_status ()->running = 0;
1820
1821   /* If running interactively, give the user the option to cancel and
1822      then decide what to do differently with the run.  Scripts are
1823      just going to disconnect and let the target deal with it,
1824      according to how it's been instructed previously via
1825      disconnected-tracing.  */
1826   if (current_trace_status ()->running && from_tty)
1827     {
1828       if (current_trace_status ()->disconnected_tracing)
1829         {
1830           if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1831             error (_("Not confirmed."));
1832         }
1833       else
1834         {
1835           if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1836             error (_("Not confirmed."));
1837         }
1838     }
1839
1840   /* Also we want to be out of tfind mode, otherwise things can get
1841      confusing upon reconnection.  Just use these calls instead of
1842      full tfind_1 behavior because we're in the middle of detaching,
1843      and there's no point to updating current stack frame etc.  */
1844   set_traceframe_number (-1);
1845   set_traceframe_context (NULL);
1846 }
1847
1848 /* Worker function for the various flavors of the tfind command.  */
1849 void
1850 tfind_1 (enum trace_find_type type, int num,
1851          ULONGEST addr1, ULONGEST addr2,
1852          int from_tty)
1853 {
1854   int target_frameno = -1, target_tracept = -1;
1855   struct frame_id old_frame_id;
1856   char *reply;
1857   struct breakpoint *tp;
1858
1859   old_frame_id = get_frame_id (get_current_frame ());
1860
1861   target_frameno = target_trace_find (type, num, addr1, addr2,
1862                                       &target_tracept);
1863
1864   if (type == tfind_number
1865       && num == -1
1866       && target_frameno == -1)
1867     {
1868       /* We told the target to get out of tfind mode, and it did.  */
1869     }
1870   else if (target_frameno == -1)
1871     {
1872       /* A request for a non-existant trace frame has failed.
1873          Our response will be different, depending on FROM_TTY:
1874
1875          If FROM_TTY is true, meaning that this command was
1876          typed interactively by the user, then give an error
1877          and DO NOT change the state of traceframe_number etc.
1878
1879          However if FROM_TTY is false, meaning that we're either
1880          in a script, a loop, or a user-defined command, then
1881          DON'T give an error, but DO change the state of
1882          traceframe_number etc. to invalid.
1883
1884          The rationalle is that if you typed the command, you
1885          might just have committed a typo or something, and you'd
1886          like to NOT lose your current debugging state.  However
1887          if you're in a user-defined command or especially in a
1888          loop, then you need a way to detect that the command
1889          failed WITHOUT aborting.  This allows you to write
1890          scripts that search thru the trace buffer until the end,
1891          and then continue on to do something else.  */
1892
1893       if (from_tty)
1894         error (_("Target failed to find requested trace frame."));
1895       else
1896         {
1897           if (info_verbose)
1898             printf_filtered ("End of trace buffer.\n");
1899 #if 0 /* dubious now? */
1900           /* The following will not recurse, since it's
1901              special-cased.  */
1902           trace_find_command ("-1", from_tty);
1903 #endif
1904         }
1905     }
1906
1907   tp = get_tracepoint_by_number_on_target (target_tracept);
1908
1909   reinit_frame_cache ();
1910   registers_changed ();
1911   target_dcache_invalidate ();
1912   set_traceframe_num (target_frameno);
1913   set_tracepoint_num (tp ? tp->number : target_tracept);
1914   if (target_frameno == -1)
1915     set_traceframe_context (NULL);
1916   else
1917     set_traceframe_context (get_current_frame ());
1918
1919   if (traceframe_number >= 0)
1920     {
1921       /* Use different branches for MI and CLI to make CLI messages
1922          i18n-eable.  */
1923       if (ui_out_is_mi_like_p (uiout))
1924         {
1925           ui_out_field_string (uiout, "found", "1");
1926           ui_out_field_int (uiout, "tracepoint", tracepoint_number);
1927           ui_out_field_int (uiout, "traceframe", traceframe_number);
1928         }
1929       else
1930         {
1931           printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1932                              traceframe_number, tracepoint_number);
1933         }
1934     }
1935   else
1936     {
1937       if (ui_out_is_mi_like_p (uiout))
1938         ui_out_field_string (uiout, "found", "0");
1939       else
1940         printf_unfiltered (_("No trace frame found"));
1941     }
1942
1943   /* If we're in nonstop mode and getting out of looking at trace
1944      frames, there won't be any current frame to go back to and
1945      display.  */
1946   if (from_tty
1947       && (has_stack_frames () || traceframe_number >= 0))
1948     {
1949       enum print_what print_what;
1950
1951       /* NOTE: in immitation of the step command, try to determine
1952          whether we have made a transition from one function to
1953          another.  If so, we'll print the "stack frame" (ie. the new
1954          function and it's arguments) -- otherwise we'll just show the
1955          new source line.  */
1956
1957       if (frame_id_eq (old_frame_id,
1958                        get_frame_id (get_current_frame ())))
1959         print_what = SRC_LINE;
1960       else
1961         print_what = SRC_AND_LOC;
1962
1963       print_stack_frame (get_selected_frame (NULL), 1, print_what);
1964       do_displays ();
1965     }
1966 }
1967
1968 /* trace_find_command takes a trace frame number n,
1969    sends "QTFrame:<n>" to the target,
1970    and accepts a reply that may contain several optional pieces
1971    of information: a frame number, a tracepoint number, and an
1972    indication of whether this is a trap frame or a stepping frame.
1973
1974    The minimal response is just "OK" (which indicates that the
1975    target does not give us a frame number or a tracepoint number).
1976    Instead of that, the target may send us a string containing
1977    any combination of:
1978    F<hexnum>    (gives the selected frame number)
1979    T<hexnum>    (gives the selected tracepoint number)
1980  */
1981
1982 /* tfind command */
1983 static void
1984 trace_find_command (char *args, int from_tty)
1985 { /* this should only be called with a numeric argument */
1986   int frameno = -1;
1987
1988   if (current_trace_status ()->running && !current_trace_status ()->from_file)
1989     error ("May not look at trace frames while trace is running.");
1990
1991   if (args == 0 || *args == 0)
1992     { /* TFIND with no args means find NEXT trace frame.  */
1993       if (traceframe_number == -1)
1994         frameno = 0;    /* "next" is first one */
1995         else
1996         frameno = traceframe_number + 1;
1997     }
1998   else if (0 == strcmp (args, "-"))
1999     {
2000       if (traceframe_number == -1)
2001         error (_("not debugging trace buffer"));
2002       else if (from_tty && traceframe_number == 0)
2003         error (_("already at start of trace buffer"));
2004
2005       frameno = traceframe_number - 1;
2006       }
2007   /* A hack to work around eval's need for fp to have been collected.  */
2008   else if (0 == strcmp (args, "-1"))
2009     frameno = -1;
2010   else
2011     frameno = parse_and_eval_long (args);
2012
2013   if (frameno < -1)
2014     error (_("invalid input (%d is less than zero)"), frameno);
2015
2016   tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2017 }
2018
2019 /* tfind end */
2020 static void
2021 trace_find_end_command (char *args, int from_tty)
2022 {
2023   trace_find_command ("-1", from_tty);
2024 }
2025
2026 /* tfind none */
2027 static void
2028 trace_find_none_command (char *args, int from_tty)
2029 {
2030   trace_find_command ("-1", from_tty);
2031 }
2032
2033 /* tfind start */
2034 static void
2035 trace_find_start_command (char *args, int from_tty)
2036 {
2037   trace_find_command ("0", from_tty);
2038 }
2039
2040 /* tfind pc command */
2041 static void
2042 trace_find_pc_command (char *args, int from_tty)
2043 {
2044   CORE_ADDR pc;
2045   char tmp[40];
2046
2047   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2048     error ("May not look at trace frames while trace is running.");
2049
2050   if (args == 0 || *args == 0)
2051     pc = regcache_read_pc (get_current_regcache ());
2052   else
2053     pc = parse_and_eval_address (args);
2054
2055   tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2056 }
2057
2058 /* tfind tracepoint command */
2059 static void
2060 trace_find_tracepoint_command (char *args, int from_tty)
2061 {
2062   int tdp;
2063   struct breakpoint *tp;
2064
2065   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2066     error ("May not look at trace frames while trace is running.");
2067
2068   if (args == 0 || *args == 0)
2069     {
2070       if (tracepoint_number == -1)
2071         error (_("No current tracepoint -- please supply an argument."));
2072       else
2073         tdp = tracepoint_number;        /* default is current TDP */
2074     }
2075   else
2076     tdp = parse_and_eval_long (args);
2077
2078   /* If we have the tracepoint on hand, use the number that the
2079      target knows about (which may be different if we disconnected
2080      and reconnected).  */
2081   tp = get_tracepoint (tdp);
2082   if (tp)
2083     tdp = tp->number_on_target;
2084
2085   tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2086 }
2087
2088 /* TFIND LINE command:
2089
2090    This command will take a sourceline for argument, just like BREAK
2091    or TRACE (ie. anything that "decode_line_1" can handle).
2092
2093    With no argument, this command will find the next trace frame
2094    corresponding to a source line OTHER THAN THE CURRENT ONE.  */
2095
2096 static void
2097 trace_find_line_command (char *args, int from_tty)
2098 {
2099   static CORE_ADDR start_pc, end_pc;
2100   struct symtabs_and_lines sals;
2101   struct symtab_and_line sal;
2102   struct cleanup *old_chain;
2103   char   startpc_str[40], endpc_str[40];
2104
2105   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2106     error ("May not look at trace frames while trace is running.");
2107
2108   if (args == 0 || *args == 0)
2109     {
2110       sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2111       sals.nelts = 1;
2112       sals.sals = (struct symtab_and_line *)
2113         xmalloc (sizeof (struct symtab_and_line));
2114       sals.sals[0] = sal;
2115     }
2116   else
2117     {
2118       sals = decode_line_spec (args, 1);
2119       sal = sals.sals[0];
2120     }
2121
2122   old_chain = make_cleanup (xfree, sals.sals);
2123   if (sal.symtab == 0)
2124     error (_("No line number information available."));
2125
2126   if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2127     {
2128       if (start_pc == end_pc)
2129         {
2130           printf_filtered ("Line %d of \"%s\"",
2131                            sal.line, sal.symtab->filename);
2132           wrap_here ("  ");
2133           printf_filtered (" is at address ");
2134           print_address (get_current_arch (), start_pc, gdb_stdout);
2135           wrap_here ("  ");
2136           printf_filtered (" but contains no code.\n");
2137           sal = find_pc_line (start_pc, 0);
2138           if (sal.line > 0
2139               && find_line_pc_range (sal, &start_pc, &end_pc)
2140               && start_pc != end_pc)
2141             printf_filtered ("Attempting to find line %d instead.\n",
2142                              sal.line);
2143           else
2144             error (_("Cannot find a good line."));
2145         }
2146       }
2147     else
2148     /* Is there any case in which we get here, and have an address
2149        which the user would want to see?  If we have debugging
2150        symbols and no line numbers?  */
2151     error (_("Line number %d is out of range for \"%s\"."),
2152            sal.line, sal.symtab->filename);
2153
2154   /* Find within range of stated line.  */
2155   if (args && *args)
2156     tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2157   else
2158     tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2159   do_cleanups (old_chain);
2160 }
2161
2162 /* tfind range command */
2163 static void
2164 trace_find_range_command (char *args, int from_tty)
2165 {
2166   static CORE_ADDR start, stop;
2167   char start_str[40], stop_str[40];
2168   char *tmp;
2169
2170   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2171     error ("May not look at trace frames while trace is running.");
2172
2173   if (args == 0 || *args == 0)
2174     { /* XXX FIXME: what should default behavior be?  */
2175       printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2176       return;
2177     }
2178
2179   if (0 != (tmp = strchr (args, ',')))
2180     {
2181       *tmp++ = '\0';    /* terminate start address */
2182       while (isspace ((int) *tmp))
2183         tmp++;
2184       start = parse_and_eval_address (args);
2185       stop = parse_and_eval_address (tmp);
2186     }
2187   else
2188     {                   /* no explicit end address? */
2189       start = parse_and_eval_address (args);
2190       stop = start + 1; /* ??? */
2191     }
2192
2193   tfind_1 (tfind_range, 0, start, stop, from_tty);
2194 }
2195
2196 /* tfind outside command */
2197 static void
2198 trace_find_outside_command (char *args, int from_tty)
2199 {
2200   CORE_ADDR start, stop;
2201   char start_str[40], stop_str[40];
2202   char *tmp;
2203
2204   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2205     error ("May not look at trace frames while trace is running.");
2206
2207   if (args == 0 || *args == 0)
2208     { /* XXX FIXME: what should default behavior be? */
2209       printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2210       return;
2211     }
2212
2213   if (0 != (tmp = strchr (args, ',')))
2214     {
2215       *tmp++ = '\0';    /* terminate start address */
2216       while (isspace ((int) *tmp))
2217         tmp++;
2218       start = parse_and_eval_address (args);
2219       stop = parse_and_eval_address (tmp);
2220     }
2221   else
2222     {                   /* no explicit end address? */
2223       start = parse_and_eval_address (args);
2224       stop = start + 1; /* ??? */
2225     }
2226
2227   tfind_1 (tfind_outside, 0, start, stop, from_tty);
2228 }
2229
2230 /* info scope command: list the locals for a scope.  */
2231 static void
2232 scope_info (char *args, int from_tty)
2233 {
2234   struct symtabs_and_lines sals;
2235   struct symbol *sym;
2236   struct minimal_symbol *msym;
2237   struct block *block;
2238   char **canonical, *symname, *save_args = args;
2239   struct dict_iterator iter;
2240   int j, count = 0;
2241   struct gdbarch *gdbarch;
2242   int regno;
2243
2244   if (args == 0 || *args == 0)
2245     error (_("requires an argument (function, line or *addr) to define a scope"));
2246
2247   sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2248   if (sals.nelts == 0)
2249     return;             /* presumably decode_line_1 has already warned */
2250
2251   /* Resolve line numbers to PC */
2252   resolve_sal_pc (&sals.sals[0]);
2253   block = block_for_pc (sals.sals[0].pc);
2254
2255   while (block != 0)
2256     {
2257       QUIT;                     /* allow user to bail out with ^C */
2258       ALL_BLOCK_SYMBOLS (block, iter, sym)
2259         {
2260           QUIT;                 /* allow user to bail out with ^C */
2261           if (count == 0)
2262             printf_filtered ("Scope for %s:\n", save_args);
2263           count++;
2264
2265           symname = SYMBOL_PRINT_NAME (sym);
2266           if (symname == NULL || *symname == '\0')
2267             continue;           /* probably botched, certainly useless */
2268
2269           gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2270
2271           printf_filtered ("Symbol %s is ", symname);
2272           switch (SYMBOL_CLASS (sym))
2273             {
2274             default:
2275             case LOC_UNDEF:     /* messed up symbol? */
2276               printf_filtered ("a bogus symbol, class %d.\n",
2277                                SYMBOL_CLASS (sym));
2278               count--;          /* don't count this one */
2279               continue;
2280             case LOC_CONST:
2281               printf_filtered ("a constant with value %ld (0x%lx)",
2282                                SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2283               break;
2284             case LOC_CONST_BYTES:
2285               printf_filtered ("constant bytes: ");
2286               if (SYMBOL_TYPE (sym))
2287                 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2288                   fprintf_filtered (gdb_stdout, " %02x",
2289                                     (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2290               break;
2291             case LOC_STATIC:
2292               printf_filtered ("in static storage at address ");
2293               printf_filtered ("%s", paddress (gdbarch,
2294                                                SYMBOL_VALUE_ADDRESS (sym)));
2295               break;
2296             case LOC_REGISTER:
2297               /* GDBARCH is the architecture associated with the objfile
2298                  the symbol is defined in; the target architecture may be
2299                  different, and may provide additional registers.  However,
2300                  we do not know the target architecture at this point.
2301                  We assume the objfile architecture will contain all the
2302                  standard registers that occur in debug info in that
2303                  objfile.  */
2304               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2305
2306               if (SYMBOL_IS_ARGUMENT (sym))
2307                 printf_filtered ("an argument in register $%s",
2308                                  gdbarch_register_name (gdbarch, regno));
2309               else
2310                 printf_filtered ("a local variable in register $%s",
2311                                  gdbarch_register_name (gdbarch, regno));
2312               break;
2313             case LOC_ARG:
2314               printf_filtered ("an argument at stack/frame offset %ld",
2315                                SYMBOL_VALUE (sym));
2316               break;
2317             case LOC_LOCAL:
2318               printf_filtered ("a local variable at frame offset %ld",
2319                                SYMBOL_VALUE (sym));
2320               break;
2321             case LOC_REF_ARG:
2322               printf_filtered ("a reference argument at offset %ld",
2323                                SYMBOL_VALUE (sym));
2324               break;
2325             case LOC_REGPARM_ADDR:
2326               /* Note comment at LOC_REGISTER.  */
2327               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2328               printf_filtered ("the address of an argument, in register $%s",
2329                                gdbarch_register_name (gdbarch, regno));
2330               break;
2331             case LOC_TYPEDEF:
2332               printf_filtered ("a typedef.\n");
2333               continue;
2334             case LOC_LABEL:
2335               printf_filtered ("a label at address ");
2336               printf_filtered ("%s", paddress (gdbarch,
2337                                                SYMBOL_VALUE_ADDRESS (sym)));
2338               break;
2339             case LOC_BLOCK:
2340               printf_filtered ("a function at address ");
2341               printf_filtered ("%s",
2342                 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2343               break;
2344             case LOC_UNRESOLVED:
2345               msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2346                                             NULL, NULL);
2347               if (msym == NULL)
2348                 printf_filtered ("Unresolved Static");
2349               else
2350                 {
2351                   printf_filtered ("static storage at address ");
2352                   printf_filtered ("%s",
2353                     paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2354                 }
2355               break;
2356             case LOC_OPTIMIZED_OUT:
2357               printf_filtered ("optimized out.\n");
2358               continue;
2359             case LOC_COMPUTED:
2360               SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
2361               break;
2362             }
2363           if (SYMBOL_TYPE (sym))
2364             printf_filtered (", length %d.\n",
2365                              TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2366         }
2367       if (BLOCK_FUNCTION (block))
2368         break;
2369       else
2370         block = BLOCK_SUPERBLOCK (block);
2371     }
2372   if (count <= 0)
2373     printf_filtered ("Scope for %s contains no locals or arguments.\n",
2374                      save_args);
2375 }
2376
2377 /* worker function (cleanup) */
2378 static void
2379 replace_comma (void *data)
2380 {
2381   char *comma = data;
2382   *comma = ',';
2383 }
2384
2385
2386 /* Helper for trace_dump_command.  Dump the action list starting at
2387    ACTION.  STEPPING_ACTIONS is true if we're iterating over the
2388    actions of the body of a while-stepping action.  STEPPING_FRAME is
2389    set if the current traceframe was determined to be a while-stepping
2390    traceframe.  */
2391
2392 static void
2393 trace_dump_actions (struct command_line *action,
2394                     int stepping_actions, int stepping_frame,
2395                     int from_tty)
2396 {
2397   char *action_exp, *next_comma;
2398
2399   for (; action != NULL; action = action->next)
2400     {
2401       struct cmd_list_element *cmd;
2402
2403       QUIT;                     /* allow user to bail out with ^C */
2404       action_exp = action->line;
2405       while (isspace ((int) *action_exp))
2406         action_exp++;
2407
2408       /* The collection actions to be done while stepping are
2409          bracketed by the commands "while-stepping" and "end".  */
2410
2411       if (*action_exp == '#')   /* comment line */
2412         continue;
2413
2414       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2415       if (cmd == 0)
2416         error (_("Bad action list item: %s"), action_exp);
2417
2418       if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2419         {
2420           int i;
2421
2422           for (i = 0; i < action->body_count; ++i)
2423             trace_dump_actions (action->body_list[i],
2424                                 1, stepping_frame, from_tty);
2425         }
2426       else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2427         {
2428           /* Display the collected data.
2429              For the trap frame, display only what was collected at
2430              the trap.  Likewise for stepping frames, display only
2431              what was collected while stepping.  This means that the
2432              two boolean variables, STEPPING_FRAME and
2433              STEPPING_ACTIONS should be equal.  */
2434           if (stepping_frame == stepping_actions)
2435             {
2436               do
2437                 {               /* repeat over a comma-separated list */
2438                   QUIT;         /* allow user to bail out with ^C */
2439                   if (*action_exp == ',')
2440                     action_exp++;
2441                   while (isspace ((int) *action_exp))
2442                     action_exp++;
2443
2444                   next_comma = strchr (action_exp, ',');
2445
2446                   if (0 == strncasecmp (action_exp, "$reg", 4))
2447                     registers_info (NULL, from_tty);
2448                   else if (0 == strncasecmp (action_exp, "$loc", 4))
2449                     locals_info (NULL, from_tty);
2450                   else if (0 == strncasecmp (action_exp, "$arg", 4))
2451                     args_info (NULL, from_tty);
2452                   else
2453                     {           /* variable */
2454                       if (next_comma)
2455                         {
2456                           make_cleanup (replace_comma, next_comma);
2457                           *next_comma = '\0';
2458                         }
2459                       printf_filtered ("%s = ", action_exp);
2460                       output_command (action_exp, from_tty);
2461                       printf_filtered ("\n");
2462                     }
2463                   if (next_comma)
2464                     *next_comma = ',';
2465                   action_exp = next_comma;
2466                 }
2467               while (action_exp && *action_exp == ',');
2468             }
2469         }
2470     }
2471 }
2472
2473 /* The tdump command.  */
2474
2475 static void
2476 trace_dump_command (char *args, int from_tty)
2477 {
2478   struct regcache *regcache;
2479   struct breakpoint *t;
2480   int stepping_frame = 0;
2481   struct bp_location *loc;
2482
2483   if (tracepoint_number == -1)
2484     {
2485       warning (_("No current trace frame."));
2486       return;
2487     }
2488
2489   t = get_tracepoint (tracepoint_number);
2490
2491   if (t == NULL)
2492     error (_("No known tracepoint matches 'current' tracepoint #%d."),
2493            tracepoint_number);
2494
2495   printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2496                    tracepoint_number, traceframe_number);
2497
2498   /* The current frame is a trap frame if the frame PC is equal
2499      to the tracepoint PC.  If not, then the current frame was
2500      collected during single-stepping.  */
2501
2502   regcache = get_current_regcache ();
2503
2504   /* If the traceframe's address matches any of the tracepoint's
2505      locations, assume it is a direct hit rather than a while-stepping
2506      frame.  (FIXME this is not reliable, should record each frame's
2507      type.)  */
2508   stepping_frame = 1;
2509   for (loc = t->loc; loc; loc = loc->next)
2510     if (loc->address == regcache_read_pc (regcache))
2511       stepping_frame = 0;
2512
2513   trace_dump_actions (breakpoint_commands (t), 0, stepping_frame, from_tty);
2514 }
2515
2516 /* Encode a piece of a tracepoint's source-level definition in a form
2517    that is suitable for both protocol and saving in files.  */
2518 /* This version does not do multiple encodes for long strings; it should
2519    return an offset to the next piece to encode.  FIXME  */
2520
2521 extern int
2522 encode_source_string (int tpnum, ULONGEST addr,
2523                       char *srctype, char *src, char *buf, int buf_size)
2524 {
2525   if (80 + strlen (srctype) > buf_size)
2526     error (_("Buffer too small for source encoding"));
2527   sprintf (buf, "%x:%s:%s:%x:%x:",
2528            tpnum, phex_nz (addr, sizeof (addr)), srctype, 0, (int) strlen (src));
2529   if (strlen (buf) + strlen (src) * 2 >= buf_size)
2530     error (_("Source string too long for buffer"));
2531   bin2hex (src, buf + strlen (buf), 0);
2532   return -1;
2533 }
2534
2535 extern int trace_regblock_size;
2536
2537 /* Save tracepoint data to file named FILENAME.  If TARGET_DOES_SAVE is
2538    non-zero, the save is performed on the target, otherwise GDB obtains all
2539    trace data and saves it locally.  */
2540
2541 void
2542 trace_save (const char *filename, int target_does_save)
2543 {
2544   struct cleanup *cleanup;
2545   char *pathname;
2546   struct trace_status *ts = current_trace_status ();
2547   int err, status;
2548   FILE *fp;
2549   struct uploaded_tp *uploaded_tps = NULL, *utp;
2550   struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2551   int a;
2552   char *act;
2553   LONGEST gotten = 0;
2554   ULONGEST offset = 0;
2555 #define MAX_TRACE_UPLOAD 2000
2556   gdb_byte buf[MAX_TRACE_UPLOAD];
2557   int written;
2558
2559   /* If the target is to save the data to a file on its own, then just
2560      send the command and be done with it.  */
2561   if (target_does_save)
2562     {
2563       err = target_save_trace_data (filename);
2564       if (err < 0)
2565         error (_("Target failed to save trace data to '%s'."),
2566                filename);
2567       return;
2568     }
2569
2570   /* Get the trace status first before opening the file, so if the
2571      target is losing, we can get out without touching files.  */
2572   status = target_get_trace_status (ts);
2573
2574   pathname = tilde_expand (filename);
2575   cleanup = make_cleanup (xfree, pathname);
2576
2577   fp = fopen (pathname, "w");
2578   if (!fp)
2579     error (_("Unable to open file '%s' for saving trace data (%s)"),
2580            filename, safe_strerror (errno));
2581   make_cleanup_fclose (fp);
2582
2583   /* Write a file header, with a high-bit-set char to indicate a
2584      binary file, plus a hint as what this file is, and a version
2585      number in case of future needs.  */
2586   written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2587   if (written < 1)
2588     perror_with_name (pathname);
2589
2590   /* Write descriptive info.  */
2591
2592   /* Write out the size of a register block.  */
2593   fprintf (fp, "R %x\n", trace_regblock_size);
2594
2595   /* Write out status of the tracing run (aka "tstatus" info).  */
2596   fprintf (fp, "status %c;%s",
2597            (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2598   if (ts->stop_reason == tracepoint_error)
2599     {
2600       char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2601       bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2602       fprintf (fp, ":%s", buf);
2603     }
2604   fprintf (fp, ":%x", ts->stopping_tracepoint);
2605   if (ts->traceframe_count >= 0)
2606     fprintf (fp, ";tframes:%x", ts->traceframe_count);
2607   if (ts->traceframes_created >= 0)
2608     fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2609   if (ts->buffer_free >= 0)
2610     fprintf (fp, ";tfree:%x", ts->buffer_free);
2611   if (ts->buffer_size >= 0)
2612     fprintf (fp, ";tsize:%x", ts->buffer_size);
2613   if (ts->disconnected_tracing)
2614     fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2615   if (ts->circular_buffer)
2616     fprintf (fp, ";circular:%x", ts->circular_buffer);
2617   fprintf (fp, "\n");
2618
2619   /* Note that we want to upload tracepoints and save those, rather
2620      than simply writing out the local ones, because the user may have
2621      changed tracepoints in GDB in preparation for a future tracing
2622      run, or maybe just mass-deleted all types of breakpoints as part
2623      of cleaning up.  So as not to contaminate the session, leave the
2624      data in its uploaded form, don't make into real tracepoints.  */
2625
2626   /* Get trace state variables first, they may be checked when parsing
2627      uploaded commands.  */
2628
2629   target_upload_trace_state_variables (&uploaded_tsvs);
2630
2631   for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2632     {
2633       char *buf = "";
2634
2635       if (utsv->name)
2636         {
2637           buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2638           bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2639         }
2640
2641       fprintf (fp, "tsv %x:%s:%x:%s\n",
2642                utsv->number, phex_nz (utsv->initial_value, 8),
2643                utsv->builtin, buf);
2644
2645       if (utsv->name)
2646         xfree (buf);
2647     }
2648
2649   free_uploaded_tsvs (&uploaded_tsvs);
2650
2651   target_upload_tracepoints (&uploaded_tps);
2652
2653   for (utp = uploaded_tps; utp; utp = utp->next)
2654     {
2655       fprintf (fp, "tp T%x:%s:%c:%x:%x",
2656                utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2657                (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2658       if (utp->type == bp_fast_tracepoint)
2659         fprintf (fp, ":F%x", utp->orig_size);
2660       if (utp->cond)
2661         fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2662                  utp->cond);
2663       fprintf (fp, "\n");
2664       for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2665         fprintf (fp, "tp A%x:%s:%s\n",
2666                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2667       for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2668         fprintf (fp, "tp S%x:%s:%s\n",
2669                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2670       if (utp->at_string)
2671         {
2672           encode_source_string (utp->number, utp->addr,
2673                                 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2674           fprintf (fp, "tp Z%s\n", buf);
2675         }
2676       if (utp->cond_string)
2677         {
2678           encode_source_string (utp->number, utp->addr,
2679                                 "cond", utp->cond_string, buf, MAX_TRACE_UPLOAD);
2680           fprintf (fp, "tp Z%s\n", buf);
2681         }
2682       for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2683         {
2684           encode_source_string (utp->number, utp->addr, "cmd", act,
2685                                 buf, MAX_TRACE_UPLOAD);
2686           fprintf (fp, "tp Z%s\n", buf);
2687         }
2688     }
2689
2690   free_uploaded_tps (&uploaded_tps);
2691
2692   /* Mark the end of the definition section.  */
2693   fprintf (fp, "\n");
2694
2695   /* Get and write the trace data proper.  We ask for big blocks, in
2696      the hopes of efficiency, but will take less if the target has
2697      packet size limitations or some such.  */
2698   while (1)
2699     {
2700       gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2701       if (gotten < 0)
2702         error (_("Failure to get requested trace buffer data"));
2703       /* No more data is forthcoming, we're done.  */
2704       if (gotten == 0)
2705         break;
2706       written = fwrite (buf, gotten, 1, fp);
2707       if (written < 1)
2708         perror_with_name (pathname);
2709       offset += gotten;
2710     }
2711
2712   /* Mark the end of trace data.  (We know that gotten is 0 at this point.)  */
2713   written = fwrite (&gotten, 4, 1, fp);
2714   if (written < 1)
2715     perror_with_name (pathname);
2716
2717   do_cleanups (cleanup);
2718 }
2719
2720 static void
2721 trace_save_command (char *args, int from_tty)
2722 {
2723   int target_does_save = 0;
2724   char **argv;
2725   char *filename = NULL;
2726   struct cleanup *back_to;
2727
2728   if (args == NULL)
2729     error_no_arg (_("file in which to save trace data"));
2730
2731   argv = gdb_buildargv (args);
2732   back_to = make_cleanup_freeargv (argv);
2733
2734   for (; *argv; ++argv)
2735     {
2736       if (strcmp (*argv, "-r") == 0)
2737         target_does_save = 1;
2738       else if (**argv == '-')
2739         error (_("unknown option `%s'"), *argv);
2740       else
2741         filename = *argv;
2742     }
2743
2744   if (!filename)
2745     error_no_arg (_("file in which to save trace data"));
2746
2747   trace_save (filename, target_does_save);
2748
2749   if (from_tty)
2750     printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2751
2752   do_cleanups (back_to);
2753 }
2754
2755 /* Tell the target what to do with an ongoing tracing run if GDB
2756    disconnects for some reason.  */
2757
2758 void
2759 send_disconnected_tracing_value (int value)
2760 {
2761   target_set_disconnected_tracing (value);
2762 }
2763
2764 static void
2765 set_disconnected_tracing (char *args, int from_tty,
2766                           struct cmd_list_element *c)
2767 {
2768   send_disconnected_tracing_value (disconnected_tracing);
2769 }
2770
2771 static void
2772 set_circular_trace_buffer (char *args, int from_tty,
2773                            struct cmd_list_element *c)
2774 {
2775   target_set_circular_trace_buffer (circular_trace_buffer);
2776 }
2777
2778 /* Convert the memory pointed to by mem into hex, placing result in buf.
2779  * Return a pointer to the last char put in buf (null)
2780  * "stolen" from sparc-stub.c
2781  */
2782
2783 static const char hexchars[] = "0123456789abcdef";
2784
2785 static char *
2786 mem2hex (gdb_byte *mem, char *buf, int count)
2787 {
2788   gdb_byte ch;
2789
2790   while (count-- > 0)
2791     {
2792       ch = *mem++;
2793
2794       *buf++ = hexchars[ch >> 4];
2795       *buf++ = hexchars[ch & 0xf];
2796     }
2797
2798   *buf = 0;
2799
2800   return buf;
2801 }
2802
2803 int
2804 get_traceframe_number (void)
2805 {
2806   return traceframe_number;
2807 }
2808
2809 /* Make the traceframe NUM be the current trace frame.  Does nothing
2810    if NUM is already current.  */
2811
2812 void
2813 set_traceframe_number (int num)
2814 {
2815   int newnum;
2816
2817   if (traceframe_number == num)
2818     {
2819       /* Nothing to do.  */
2820       return;
2821     }
2822
2823   newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2824
2825   if (newnum != num)
2826     warning (_("could not change traceframe"));
2827
2828   traceframe_number = newnum;
2829
2830   /* Changing the traceframe changes our view of registers and of the
2831      frame chain.  */
2832   registers_changed ();
2833 }
2834
2835 /* A cleanup used when switching away and back from tfind mode.  */
2836
2837 struct current_traceframe_cleanup
2838 {
2839   /* The traceframe we were inspecting.  */
2840   int traceframe_number;
2841 };
2842
2843 static void
2844 do_restore_current_traceframe_cleanup (void *arg)
2845 {
2846   struct current_traceframe_cleanup *old = arg;
2847
2848   set_traceframe_number (old->traceframe_number);
2849 }
2850
2851 static void
2852 restore_current_traceframe_cleanup_dtor (void *arg)
2853 {
2854   struct current_traceframe_cleanup *old = arg;
2855
2856   xfree (old);
2857 }
2858
2859 struct cleanup *
2860 make_cleanup_restore_current_traceframe (void)
2861 {
2862   struct current_traceframe_cleanup *old;
2863
2864   old = xmalloc (sizeof (struct current_traceframe_cleanup));
2865   old->traceframe_number = traceframe_number;
2866
2867   return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
2868                             restore_current_traceframe_cleanup_dtor);
2869 }
2870
2871 /* Given a number and address, return an uploaded tracepoint with that
2872    number, creating if necessary.  */
2873
2874 struct uploaded_tp *
2875 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2876 {
2877   struct uploaded_tp *utp;
2878
2879   for (utp = *utpp; utp; utp = utp->next)
2880     if (utp->number == num && utp->addr == addr)
2881       return utp;
2882   utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2883   memset (utp, 0, sizeof (struct uploaded_tp));
2884   utp->number = num;
2885   utp->addr = addr;
2886   utp->actions = NULL;
2887   utp->step_actions = NULL;
2888   utp->cmd_strings = NULL;
2889   utp->next = *utpp;
2890   *utpp = utp;
2891   return utp;
2892 }
2893
2894 static void
2895 free_uploaded_tps (struct uploaded_tp **utpp)
2896 {
2897   struct uploaded_tp *next_one;
2898
2899   while (*utpp)
2900     {
2901       next_one = (*utpp)->next;
2902       xfree (*utpp);
2903       *utpp = next_one;
2904     }
2905 }
2906
2907 /* Given a number and address, return an uploaded tracepoint with that
2908    number, creating if necessary.  */
2909
2910 struct uploaded_tsv *
2911 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2912 {
2913   struct uploaded_tsv *utsv;
2914
2915   for (utsv = *utsvp; utsv; utsv = utsv->next)
2916     if (utsv->number == num)
2917       return utsv;
2918   utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
2919   memset (utsv, 0, sizeof (struct uploaded_tsv));
2920   utsv->number = num;
2921   utsv->next = *utsvp;
2922   *utsvp = utsv;
2923   return utsv;
2924 }
2925
2926 static void
2927 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
2928 {
2929   struct uploaded_tsv *next_one;
2930
2931   while (*utsvp)
2932     {
2933       next_one = (*utsvp)->next;
2934       xfree (*utsvp);
2935       *utsvp = next_one;
2936     }
2937 }
2938
2939 /* Look for an existing tracepoint that seems similar enough to the
2940    uploaded one.  Enablement isn't compared, because the user can
2941    toggle that freely, and may have done so in anticipation of the
2942    next trace run.  */
2943
2944 struct breakpoint *
2945 find_matching_tracepoint (struct uploaded_tp *utp)
2946 {
2947   VEC(breakpoint_p) *tp_vec = all_tracepoints ();
2948   int ix;
2949   struct breakpoint *t;
2950   struct bp_location *loc;
2951
2952   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2953     {
2954       if (t->type == utp->type
2955           && t->step_count == utp->step
2956           && t->pass_count == utp->pass
2957           /* FIXME also test conditionals and actions */
2958           )
2959         {
2960           /* Scan the locations for an address match.  */
2961           for (loc = t->loc; loc; loc = loc->next)
2962             {
2963               if (loc->address == utp->addr)
2964                 return t;
2965             }
2966         }
2967     }
2968   return NULL;
2969 }
2970
2971 /* Given a list of tracepoints uploaded from a target, attempt to
2972    match them up with existing tracepoints, and create new ones if not
2973    found.  */
2974
2975 void
2976 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
2977 {
2978   struct uploaded_tp *utp;
2979   struct breakpoint *t;
2980
2981   /* Look for GDB tracepoints that match up with our uploaded versions.  */
2982   for (utp = *uploaded_tps; utp; utp = utp->next)
2983     {
2984       t = find_matching_tracepoint (utp);
2985       if (t)
2986         printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2987                          t->number, utp->number, paddress (get_current_arch (), utp->addr));
2988       else
2989         {
2990           t = create_tracepoint_from_upload (utp);
2991           if (t)
2992             printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2993                              t->number, utp->number, paddress (get_current_arch (), utp->addr));
2994           else
2995             printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2996                              utp->number, paddress (get_current_arch (), utp->addr));
2997         }
2998       /* Whether found or created, record the number used by the
2999          target, to help with mapping target tracepoints back to their
3000          counterparts here.  */
3001       if (t)
3002         t->number_on_target = utp->number;
3003     }
3004
3005   free_uploaded_tps (uploaded_tps);
3006 }
3007
3008 /* Trace state variables don't have much to identify them beyond their
3009    name, so just use that to detect matches.  */
3010
3011 struct trace_state_variable *
3012 find_matching_tsv (struct uploaded_tsv *utsv)
3013 {
3014   if (!utsv->name)
3015     return NULL;
3016
3017   return find_trace_state_variable (utsv->name);
3018 }
3019
3020 struct trace_state_variable *
3021 create_tsv_from_upload (struct uploaded_tsv *utsv)
3022 {
3023   const char *namebase;
3024   char buf[20];
3025   int try_num = 0;
3026   struct trace_state_variable *tsv;
3027
3028   if (utsv->name)
3029     {
3030       namebase = utsv->name;
3031       sprintf (buf, "%s", namebase);
3032     }
3033   else
3034     {
3035       namebase = "__tsv";
3036       sprintf (buf, "%s_%d", namebase, try_num++);
3037     }
3038
3039   /* Fish for a name that is not in use.  */
3040   /* (should check against all internal vars?) */
3041   while (find_trace_state_variable (buf))
3042     sprintf (buf, "%s_%d", namebase, try_num++);
3043
3044   /* We have an available name, create the variable.  */
3045   tsv = create_trace_state_variable (xstrdup (buf));
3046   tsv->initial_value = utsv->initial_value;
3047   tsv->builtin = utsv->builtin;
3048
3049   return tsv;
3050 }
3051
3052 /* Given a list of uploaded trace state variables, try to match them
3053    up with existing variables, or create additional ones.  */
3054
3055 void
3056 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3057 {
3058   int ix;
3059   struct uploaded_tsv *utsv;
3060   struct trace_state_variable *tsv;
3061   int highest;
3062
3063   /* Most likely some numbers will have to be reassigned as part of
3064      the merge, so clear them all in anticipation.  */
3065   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3066     tsv->number = 0;
3067
3068   for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3069     {
3070       tsv = find_matching_tsv (utsv);
3071       if (tsv)
3072         printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3073                          tsv->name, utsv->number);
3074       else
3075         {
3076           tsv = create_tsv_from_upload (utsv);
3077           printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3078                            tsv->name, utsv->number);
3079         }
3080       /* Give precedence to numberings that come from the target.  */
3081       if (tsv)
3082         tsv->number = utsv->number;
3083     }
3084
3085   /* Renumber everything that didn't get a target-assigned number.  */
3086   highest = 0;
3087   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3088     if (tsv->number > highest)
3089       highest = tsv->number;
3090
3091   ++highest;
3092   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3093     if (tsv->number == 0)
3094       tsv->number = highest++;
3095
3096   free_uploaded_tsvs (uploaded_tsvs);
3097 }
3098
3099 /* target tfile command */
3100
3101 struct target_ops tfile_ops;
3102
3103 /* Fill in tfile_ops with its defined operations and properties.  */
3104
3105 #define TRACE_HEADER_SIZE 8
3106
3107 char *trace_filename;
3108 int trace_fd = -1;
3109 off_t trace_frames_offset;
3110 off_t cur_offset;
3111 int cur_data_size;
3112 int trace_regblock_size;
3113
3114 static void tfile_interp_line (char *line,
3115                                struct uploaded_tp **utpp,
3116                                struct uploaded_tsv **utsvp);
3117
3118 static void
3119 tfile_open (char *filename, int from_tty)
3120 {
3121   char *temp;
3122   struct cleanup *old_chain;
3123   int flags;
3124   int scratch_chan;
3125   char header[TRACE_HEADER_SIZE];
3126   char linebuf[1000]; /* should be max remote packet size or so */
3127   char byte;
3128   int bytes, i, gotten;
3129   struct trace_status *ts;
3130   struct uploaded_tp *uploaded_tps = NULL;
3131   struct uploaded_tsv *uploaded_tsvs = NULL;
3132
3133   target_preopen (from_tty);
3134   if (!filename)
3135     error (_("No trace file specified."));
3136
3137   filename = tilde_expand (filename);
3138   if (!IS_ABSOLUTE_PATH(filename))
3139     {
3140       temp = concat (current_directory, "/", filename, (char *)NULL);
3141       xfree (filename);
3142       filename = temp;
3143     }
3144
3145   old_chain = make_cleanup (xfree, filename);
3146
3147   flags = O_BINARY | O_LARGEFILE;
3148   flags |= O_RDONLY;
3149   scratch_chan = open (filename, flags, 0);
3150   if (scratch_chan < 0)
3151     perror_with_name (filename);
3152
3153   /* Looks semi-reasonable.  Toss the old trace file and work on the new.  */
3154
3155   discard_cleanups (old_chain); /* Don't free filename any more */
3156   unpush_target (&tfile_ops);
3157
3158   push_target (&tfile_ops);
3159
3160   trace_filename = xstrdup (filename);
3161   trace_fd = scratch_chan;
3162
3163   bytes = 0;
3164   /* Read the file header and test for validity.  */
3165   gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
3166   if (gotten < 0)
3167     perror_with_name (trace_filename);
3168   else if (gotten < TRACE_HEADER_SIZE)
3169     error (_("Premature end of file while reading trace file"));
3170
3171   bytes += TRACE_HEADER_SIZE;
3172   if (!(header[0] == 0x7f
3173         && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3174     error (_("File is not a valid trace file."));
3175
3176   trace_regblock_size = 0;
3177   ts = current_trace_status ();
3178   /* We know we're working with a file.  */
3179   ts->from_file = 1;
3180   /* Set defaults in case there is no status line.  */
3181   ts->running_known = 0;
3182   ts->stop_reason = trace_stop_reason_unknown;
3183   ts->traceframe_count = -1;
3184   ts->buffer_free = 0;
3185   ts->disconnected_tracing = 0;
3186   ts->circular_buffer = 0;
3187
3188   /* Read through a section of newline-terminated lines that
3189      define things like tracepoints.  */
3190   i = 0;
3191   while (1)
3192     {
3193       gotten = read (trace_fd, &byte, 1);
3194       if (gotten < 0)
3195         perror_with_name (trace_filename);
3196       else if (gotten < 1)
3197         error (_("Premature end of file while reading trace file"));
3198
3199       ++bytes;
3200       if (byte == '\n')
3201         {
3202           /* Empty line marks end of the definition section.  */
3203           if (i == 0)
3204             break;
3205           linebuf[i] = '\0';
3206           i = 0;
3207           tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3208         }
3209       else
3210         linebuf[i++] = byte;
3211       if (i >= 1000)
3212         error (_("Excessively long lines in trace file"));
3213     }
3214
3215   /* Add the file's tracepoints and variables into the current mix.  */
3216
3217   /* Get trace state variables first, they may be checked when parsing
3218      uploaded commands.  */
3219   merge_uploaded_trace_state_variables (&uploaded_tsvs);
3220
3221   merge_uploaded_tracepoints (&uploaded_tps);
3222
3223   /* Record the starting offset of the binary trace data.  */
3224   trace_frames_offset = bytes;
3225
3226   /* If we don't have a blocksize, we can't interpret the
3227      traceframes.  */
3228   if (trace_regblock_size == 0)
3229     error (_("No register block size recorded in trace file"));
3230   if (ts->traceframe_count <= 0)
3231     {
3232       warning ("No traceframes present in this file.");
3233       return;
3234     }
3235
3236 #define TFILE_PID (1)
3237   inferior_appeared (current_inferior (), TFILE_PID);
3238   inferior_ptid = pid_to_ptid (TFILE_PID);
3239   add_thread_silent (inferior_ptid);
3240
3241   post_create_inferior (&tfile_ops, from_tty);
3242
3243 #if 0
3244   /* FIXME this will get defined in MI patch submission */
3245   tfind_1 (tfind_number, 0, 0, 0, 0);
3246 #endif
3247 }
3248
3249 /* Interpret the given line from the definitions part of the trace
3250    file.  */
3251
3252 static void
3253 tfile_interp_line (char *line,
3254                    struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3255 {
3256   char *p = line;
3257
3258   if (strncmp (p, "R ", strlen ("R ")) == 0)
3259     {
3260       p += strlen ("R ");
3261       trace_regblock_size = strtol (p, &p, 16);
3262     }
3263   else if (strncmp (p, "status ", strlen ("status ")) == 0)
3264     {
3265       p += strlen ("status ");
3266       parse_trace_status (p, current_trace_status ());
3267     }
3268   else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3269     {
3270       p += strlen ("tp ");
3271       parse_tracepoint_definition (p, utpp);
3272     }
3273   else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3274     {
3275       p += strlen ("tsv ");
3276       parse_tsv_definition (p, utsvp);
3277     }
3278   else
3279     warning ("Ignoring trace file definition \"%s\"", line);
3280 }
3281
3282 /* Parse the part of trace status syntax that is shared between
3283    the remote protocol and the trace file reader.  */
3284
3285 extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
3286
3287 void
3288 parse_trace_status (char *line, struct trace_status *ts)
3289 {
3290   char *p = line, *p1, *p2, *p_temp;
3291   ULONGEST val;
3292
3293   ts->running_known = 1;
3294   ts->running = (*p++ == '1');
3295   ts->stop_reason = trace_stop_reason_unknown;
3296   xfree (ts->error_desc);
3297   ts->error_desc = NULL;
3298   ts->traceframe_count = -1;
3299   ts->traceframes_created = -1;
3300   ts->buffer_free = -1;
3301   ts->buffer_size = -1;
3302   ts->disconnected_tracing = 0;
3303   ts->circular_buffer = 0;
3304
3305   while (*p++)
3306     {
3307       p1 = strchr (p, ':');
3308       if (p1 == NULL)
3309         error (_("Malformed trace status, at %s\n\
3310 Status line: '%s'\n"), p, line);
3311       if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3312         {
3313           p = unpack_varlen_hex (++p1, &val);
3314           ts->stop_reason = trace_buffer_full;
3315         }
3316       else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3317         {
3318           p = unpack_varlen_hex (++p1, &val);
3319           ts->stop_reason = trace_never_run;
3320         }
3321       else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0)
3322         {
3323           p = unpack_varlen_hex (++p1, &val);
3324           ts->stop_reason = tracepoint_passcount;
3325           ts->stopping_tracepoint = val;
3326         }
3327       else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3328         {
3329           p = unpack_varlen_hex (++p1, &val);
3330           ts->stop_reason = tstop_command;
3331         }
3332       else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3333         {
3334           p = unpack_varlen_hex (++p1, &val);
3335           ts->stop_reason = trace_disconnected;
3336         }
3337       else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3338         {
3339           p2 = strchr (++p1, ':');
3340           if (p2 != p1)
3341             {
3342               int end;
3343
3344               ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3345               end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3346               ts->error_desc[end] = '\0';
3347             }
3348           else
3349             ts->error_desc = xstrdup ("");
3350
3351           p = unpack_varlen_hex (++p2, &val);
3352           ts->stopping_tracepoint = val;
3353           ts->stop_reason = tracepoint_error;
3354         }
3355       else if (strncmp (p, "tframes", p1 - p) == 0)
3356         {
3357           p = unpack_varlen_hex (++p1, &val);
3358           ts->traceframe_count = val;
3359         }
3360       else if (strncmp (p, "tcreated", p1 - p) == 0)
3361         {
3362           p = unpack_varlen_hex (++p1, &val);
3363           ts->traceframes_created = val;
3364         }
3365       else if (strncmp (p, "tfree", p1 - p) == 0)
3366         {
3367           p = unpack_varlen_hex (++p1, &val);
3368           ts->buffer_free = val;
3369         }
3370       else if (strncmp (p, "tsize", p1 - p) == 0)
3371         {
3372           p = unpack_varlen_hex (++p1, &val);
3373           ts->buffer_size = val;
3374         }
3375       else if (strncmp (p, "disconn", p1 - p) == 0)
3376         {
3377           p = unpack_varlen_hex (++p1, &val);
3378           ts->disconnected_tracing = val;
3379         }
3380       else if (strncmp (p, "circular", p1 - p) == 0)
3381         {
3382           p = unpack_varlen_hex (++p1, &val);
3383           ts->circular_buffer = val;
3384         }
3385       else
3386         {
3387           /* Silently skip unknown optional info.  */
3388           p_temp = strchr (p1 + 1, ';');
3389           if (p_temp)
3390             p = p_temp;
3391           else
3392             /* Must be at the end.  */
3393             break;
3394         }
3395     }
3396 }
3397
3398 /* Given a line of text defining a part of a tracepoint, parse it into
3399    an "uploaded tracepoint".  */
3400
3401 void
3402 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3403 {
3404   char *p;
3405   char piece;
3406   ULONGEST num, addr, step, pass, orig_size, xlen, start;
3407   int enabled, i, end;
3408   enum bptype type;
3409   char *cond, *srctype, *src, *buf;
3410   struct uploaded_tp *utp = NULL;
3411
3412   p = line;
3413   /* Both tracepoint and action definitions start with the same number
3414      and address sequence.  */
3415   piece = *p++;
3416   p = unpack_varlen_hex (p, &num);
3417   p++;  /* skip a colon */
3418   p = unpack_varlen_hex (p, &addr);
3419   p++;  /* skip a colon */
3420   if (piece == 'T')
3421     {
3422       enabled = (*p++ == 'E');
3423       p++;  /* skip a colon */
3424       p = unpack_varlen_hex (p, &step);
3425       p++;  /* skip a colon */
3426       p = unpack_varlen_hex (p, &pass);
3427       type = bp_tracepoint;
3428       cond = NULL;
3429       /* Thumb through optional fields.  */
3430       while (*p == ':')
3431         {
3432           p++;  /* skip a colon */
3433           if (*p == 'F')
3434             {
3435               type = bp_fast_tracepoint;
3436               p++;
3437               p = unpack_varlen_hex (p, &orig_size);
3438             }
3439           else if (*p == 'X')
3440             {
3441               p++;
3442               p = unpack_varlen_hex (p, &xlen);
3443               p++;  /* skip a comma */
3444               cond = (char *) xmalloc (2 * xlen + 1);
3445               strncpy (cond, p, 2 * xlen);
3446               cond[2 * xlen] = '\0';
3447               p += 2 * xlen;
3448             }
3449           else
3450             warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p);
3451         }
3452       utp = get_uploaded_tp (num, addr, utpp);
3453       utp->type = type;
3454       utp->enabled = enabled;
3455       utp->step = step;
3456       utp->pass = pass;
3457       utp->cond = cond;
3458     }
3459   else if (piece == 'A')
3460     {
3461       utp = get_uploaded_tp (num, addr, utpp);
3462       VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3463     }
3464   else if (piece == 'S')
3465     {
3466       utp = get_uploaded_tp (num, addr, utpp);
3467       VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3468     }
3469   else if (piece == 'Z')
3470     {
3471       /* Parse a chunk of source form definition.  */
3472       utp = get_uploaded_tp (num, addr, utpp);
3473       srctype = p;
3474       p = strchr (p, ':');
3475       p++;  /* skip a colon */
3476       p = unpack_varlen_hex (p, &start);
3477       p++;  /* skip a colon */
3478       p = unpack_varlen_hex (p, &xlen);
3479       p++;  /* skip a colon */
3480
3481       buf = alloca (strlen (line));
3482
3483       end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3484       buf[end] = '\0';
3485
3486       if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3487         utp->at_string = xstrdup (buf);
3488       else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3489         utp->cond_string = xstrdup (buf);
3490       else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3491         VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3492     }
3493   else
3494     {
3495       /* Don't error out, the target might be sending us optional
3496          info that we don't care about.  */
3497       warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3498     }
3499 }
3500
3501 /* Convert a textual description of a trace state variable into an
3502    uploaded object.  */
3503
3504 void
3505 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3506 {
3507   char *p, *buf;
3508   ULONGEST num, initval, builtin;
3509   int end;
3510   struct uploaded_tsv *utsv = NULL;
3511
3512   buf = alloca (strlen (line));
3513
3514   p = line;
3515   p = unpack_varlen_hex (p, &num);
3516   p++; /* skip a colon */
3517   p = unpack_varlen_hex (p, &initval);
3518   p++; /* skip a colon */
3519   p = unpack_varlen_hex (p, &builtin);
3520   p++; /* skip a colon */
3521   end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3522   buf[end] = '\0';
3523
3524   utsv = get_uploaded_tsv (num, utsvp);
3525   utsv->initial_value = initval;
3526   utsv->builtin = builtin;
3527   utsv->name = xstrdup (buf);
3528 }
3529
3530 /* Close the trace file and generally clean up.  */
3531
3532 static void
3533 tfile_close (int quitting)
3534 {
3535   int pid;
3536
3537   if (trace_fd < 0)
3538     return;
3539
3540   pid = ptid_get_pid (inferior_ptid);
3541   inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff */
3542   exit_inferior_silent (pid);
3543
3544   close (trace_fd);
3545   trace_fd = -1;
3546   if (trace_filename)
3547     xfree (trace_filename);
3548 }
3549
3550 static void
3551 tfile_files_info (struct target_ops *t)
3552 {
3553   /* (it would be useful to mention the name of the file) */
3554   printf_filtered ("Looking at a trace file.\n");
3555 }
3556
3557 /* The trace status for a file is that tracing can never be run.  */
3558
3559 static int
3560 tfile_get_trace_status (struct trace_status *ts)
3561 {
3562   /* Other bits of trace status were collected as part of opening the
3563      trace files, so nothing to do here.  */
3564
3565   return -1;
3566 }
3567
3568 /* Given the position of a traceframe in the file, figure out what
3569    address the frame was collected at.  This would normally be the
3570    value of a collected PC register, but if not available, we
3571    improvise.  */
3572
3573 static ULONGEST
3574 tfile_get_traceframe_address (off_t tframe_offset)
3575 {
3576   ULONGEST addr = 0;
3577   short tpnum;
3578   struct breakpoint *tp;
3579   off_t saved_offset = cur_offset;
3580   int gotten;
3581
3582   /* FIXME dig pc out of collected registers */
3583
3584   /* Fall back to using tracepoint address.  */
3585   lseek (trace_fd, tframe_offset, SEEK_SET);
3586   gotten = read (trace_fd, &tpnum, 2);
3587   if (gotten < 0)
3588     perror_with_name (trace_filename);
3589   else if (gotten < 2)
3590     error (_("Premature end of file while reading trace file"));
3591
3592   tp = get_tracepoint_by_number_on_target (tpnum);
3593   /* FIXME this is a poor heuristic if multiple locations */
3594   if (tp && tp->loc)
3595     addr = tp->loc->address;
3596
3597   /* Restore our seek position.  */
3598   cur_offset = saved_offset;
3599   lseek (trace_fd, cur_offset, SEEK_SET);
3600   return addr;
3601 }
3602
3603 /* Given a type of search and some parameters, scan the collection of
3604    traceframes in the file looking for a match.  When found, return
3605    both the traceframe and tracepoint number, otherwise -1 for
3606    each.  */
3607
3608 static int
3609 tfile_trace_find (enum trace_find_type type, int num,
3610                   ULONGEST addr1, ULONGEST addr2, int *tpp)
3611 {
3612   short tpnum;
3613   int tfnum = 0, found = 0, gotten;
3614   int data_size;
3615   struct breakpoint *tp;
3616   off_t offset, tframe_offset;
3617   ULONGEST tfaddr;
3618
3619   lseek (trace_fd, trace_frames_offset, SEEK_SET);
3620   offset = trace_frames_offset;
3621   while (1)
3622     {
3623       tframe_offset = offset;
3624       gotten = read (trace_fd, &tpnum, 2);
3625       if (gotten < 0)
3626         perror_with_name (trace_filename);
3627       else if (gotten < 2)
3628         error (_("Premature end of file while reading trace file"));
3629       offset += 2;
3630       if (tpnum == 0)
3631         break;
3632       gotten = read (trace_fd, &data_size, 4);
3633       if (gotten < 0)
3634         perror_with_name (trace_filename);
3635       else if (gotten < 4)
3636         error (_("Premature end of file while reading trace file"));
3637       offset += 4;
3638       switch (type)
3639         {
3640         case tfind_number:
3641           if (tfnum == num)
3642             found = 1;
3643           break;
3644         case tfind_pc:
3645           tfaddr = tfile_get_traceframe_address (tframe_offset);
3646           if (tfaddr == addr1)
3647             found = 1;
3648           break;
3649         case tfind_tp:
3650           tp = get_tracepoint (num);
3651           if (tp && tpnum == tp->number_on_target)
3652             found = 1;
3653           break;
3654         case tfind_range:
3655           tfaddr = tfile_get_traceframe_address (tframe_offset);
3656           if (addr1 <= tfaddr && tfaddr <= addr2)
3657             found = 1;
3658           break;
3659         case tfind_outside:
3660           tfaddr = tfile_get_traceframe_address (tframe_offset);
3661           if (!(addr1 <= tfaddr && tfaddr <= addr2))
3662             found = 1;
3663           break;
3664         default:
3665           internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3666         }
3667       if (found)
3668         {
3669           if (tpp)
3670             *tpp = tpnum;
3671           cur_offset = offset;
3672           cur_data_size = data_size;
3673           return tfnum;
3674         }
3675       /* Skip past the traceframe's data.  */
3676       lseek (trace_fd, data_size, SEEK_CUR);
3677       offset += data_size;
3678       /* Update our own count of traceframes.  */
3679       ++tfnum;
3680     }
3681   /* Did not find what we were looking for.  */
3682   if (tpp)
3683     *tpp = -1;
3684   return -1;
3685 }
3686
3687 /* Look for a block of saved registers in the traceframe, and get the
3688    requested register from it.  */
3689
3690 static void
3691 tfile_fetch_registers (struct target_ops *ops,
3692                        struct regcache *regcache, int regno)
3693 {
3694   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3695   char block_type;
3696   int i, pos, offset, regn, regsize, gotten, pc_regno;
3697   unsigned short mlen;
3698   char *regs;
3699
3700   /* An uninitialized reg size says we're not going to be
3701      successful at getting register blocks.  */
3702   if (!trace_regblock_size)
3703     return;
3704
3705   regs = alloca (trace_regblock_size);
3706
3707   lseek (trace_fd, cur_offset, SEEK_SET);
3708   pos = 0;
3709   while (pos < cur_data_size)
3710     {
3711       gotten = read (trace_fd, &block_type, 1);
3712       if (gotten < 0)
3713         perror_with_name (trace_filename);
3714       else if (gotten < 1)
3715         error (_("Premature end of file while reading trace file"));
3716
3717       ++pos;
3718       switch (block_type)
3719         {
3720         case 'R':
3721           gotten = read (trace_fd, regs, trace_regblock_size);
3722           if (gotten < 0)
3723             perror_with_name (trace_filename);
3724           else if (gotten < trace_regblock_size)
3725             error (_("Premature end of file while reading trace file"));
3726
3727           /* Assume the block is laid out in GDB register number order,
3728              each register with the size that it has in GDB.  */
3729           offset = 0;
3730           for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3731             {
3732               regsize = register_size (gdbarch, regn);
3733               /* Make sure we stay within block bounds.  */
3734               if (offset + regsize >= trace_regblock_size)
3735                 break;
3736               if (!regcache_valid_p (regcache, regn))
3737                 {
3738                   if (regno == regn)
3739                     {
3740                       regcache_raw_supply (regcache, regno, regs + offset);
3741                       break;
3742                     }
3743                   else if (regno == -1)
3744                     {
3745                       regcache_raw_supply (regcache, regn, regs + offset);
3746                     }
3747                 }
3748               offset += regsize;
3749             }
3750           return;
3751         case 'M':
3752           lseek (trace_fd, 8, SEEK_CUR);
3753           gotten = read (trace_fd, &mlen, 2);
3754           if (gotten < 0)
3755             perror_with_name (trace_filename);
3756           else if (gotten < 2)
3757             error (_("Premature end of file while reading trace file"));
3758           lseek (trace_fd, mlen, SEEK_CUR);
3759           pos += (8 + 2 + mlen);
3760           break;
3761         case 'V':
3762           lseek (trace_fd, 4 + 8, SEEK_CUR);
3763           pos += (4 + 8);
3764           break;
3765         default:
3766           error ("Unknown block type '%c' (0x%x) in trace frame",
3767                  block_type, block_type);
3768           break;
3769         }
3770     }
3771
3772   /* We get here if no register data has been found.  Although we
3773      don't like making up numbers, GDB has all manner of troubles when
3774      the target says some register is not available.  Filling in with
3775      zeroes is a reasonable fallback.  */
3776   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3777     regcache_raw_supply (regcache, regn, NULL);
3778
3779   /* We can often usefully guess that the PC is going to be the same
3780      as the address of the tracepoint.  */
3781   pc_regno = gdbarch_pc_regnum (gdbarch);
3782   if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
3783     {
3784       struct breakpoint *tp = get_tracepoint (tracepoint_number);
3785
3786       if (tp && tp->loc)
3787         {
3788           /* But don't try to guess if tracepoint is multi-location...  */
3789           if (tp->loc->next)
3790             {
3791               warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3792                        tp->number);
3793               return;
3794             }
3795           /* ... or does while-stepping.  */
3796           if (tp->step_count > 0)
3797             {
3798               warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3799                        tp->number);
3800               return;
3801             }
3802
3803           store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
3804                                   gdbarch_byte_order (gdbarch),
3805                                   tp->loc->address);
3806           regcache_raw_supply (regcache, pc_regno, regs);
3807         }
3808     }
3809 }
3810
3811 static LONGEST
3812 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3813                     const char *annex, gdb_byte *readbuf,
3814                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3815 {
3816   char block_type;
3817   int pos, gotten;
3818   ULONGEST maddr, amt;
3819   unsigned short mlen;
3820
3821   /* We're only doing regular memory for now.  */
3822   if (object != TARGET_OBJECT_MEMORY)
3823     return -1;
3824
3825   if (readbuf == NULL)
3826     error ("tfile_xfer_partial: trace file is read-only");
3827
3828   lseek (trace_fd, cur_offset, SEEK_SET);
3829   pos = 0;
3830   while (pos < cur_data_size)
3831     {
3832       gotten = read (trace_fd, &block_type, 1);
3833       if (gotten < 0)
3834         perror_with_name (trace_filename);
3835       else if (gotten < 1)
3836         error (_("Premature end of file while reading trace file"));
3837       ++pos;
3838       switch (block_type)
3839         {
3840         case 'R':
3841           lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3842           pos += trace_regblock_size;
3843           break;
3844         case 'M':
3845           gotten = read (trace_fd, &maddr, 8);
3846           if (gotten < 0)
3847             perror_with_name (trace_filename);
3848           else if (gotten < 8)
3849             error (_("Premature end of file while reading trace file"));
3850
3851           gotten = read (trace_fd, &mlen, 2);
3852           if (gotten < 0)
3853             perror_with_name (trace_filename);
3854           else if (gotten < 2)
3855             error (_("Premature end of file while reading trace file"));
3856           /* If the block includes the first part of the desired
3857              range, return as much it has; GDB will re-request the
3858              remainder, which might be in a different block of this
3859              trace frame.  */
3860           if (maddr <= offset && offset < (maddr + mlen))
3861             {
3862               amt = (maddr + mlen) - offset;
3863               if (amt > len)
3864                 amt = len;
3865
3866               read (trace_fd, readbuf, amt);
3867               return amt;
3868             }
3869           lseek (trace_fd, mlen, SEEK_CUR);
3870           pos += (8 + 2 + mlen);
3871           break;
3872         case 'V':
3873           lseek (trace_fd, 4 + 8, SEEK_CUR);
3874           pos += (4 + 8);
3875           break;
3876         default:
3877           error ("Unknown block type '%c' (0x%x) in traceframe",
3878                  block_type, block_type);
3879           break;
3880         }
3881     }
3882
3883   /* It's unduly pedantic to refuse to look at the executable for
3884      read-only pieces; so do the equivalent of readonly regions aka
3885      QTro packet.  */
3886   /* FIXME account for relocation at some point */
3887   if (exec_bfd)
3888     {
3889       asection *s;
3890       bfd_size_type size;
3891       bfd_vma lma;
3892
3893       for (s = exec_bfd->sections; s; s = s->next)
3894         {
3895           if ((s->flags & SEC_LOAD) == 0 ||
3896               (s->flags & SEC_READONLY) == 0)
3897             continue;
3898
3899           lma = s->lma;
3900           size = bfd_get_section_size (s);
3901           if (lma <= offset && offset < (lma + size))
3902             {
3903               amt = (lma + size) - offset;
3904               if (amt > len)
3905                 amt = len;
3906
3907               amt = bfd_get_section_contents (exec_bfd, s,
3908                                               readbuf, offset - lma, amt);
3909               return amt;
3910             }
3911         }
3912     }
3913
3914   /* Indicate failure to find the requested memory block.  */
3915   return -1;
3916 }
3917
3918 /* Iterate through the blocks of a trace frame, looking for a 'V'
3919    block with a matching tsv number.  */
3920
3921 static int
3922 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
3923 {
3924   char block_type;
3925   int pos, vnum, gotten;
3926   unsigned short mlen;
3927
3928   lseek (trace_fd, cur_offset, SEEK_SET);
3929   pos = 0;
3930   while (pos < cur_data_size)
3931     {
3932       gotten = read (trace_fd, &block_type, 1);
3933       if (gotten < 0)
3934         perror_with_name (trace_filename);
3935       else if (gotten < 1)
3936         error (_("Premature end of file while reading trace file"));
3937       ++pos;
3938       switch (block_type)
3939         {
3940         case 'R':
3941           lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3942           pos += trace_regblock_size;
3943           break;
3944         case 'M':
3945           lseek (trace_fd, 8, SEEK_CUR);
3946           gotten = read (trace_fd, &mlen, 2);
3947           if (gotten < 0)
3948             perror_with_name (trace_filename);
3949           else if (gotten < 2)
3950             error (_("Premature end of file while reading trace file"));
3951           lseek (trace_fd, mlen, SEEK_CUR);
3952           pos += (8 + 2 + mlen);
3953           break;
3954         case 'V':
3955           gotten = read (trace_fd, &vnum, 4);
3956           if (gotten < 0)
3957             perror_with_name (trace_filename);
3958           else if (gotten < 4)
3959             error (_("Premature end of file while reading trace file"));
3960           if (tsvnum == vnum)
3961             {
3962               gotten = read (trace_fd, val, 8);
3963               if (gotten < 0)
3964                 perror_with_name (trace_filename);
3965               else if (gotten < 8)
3966                 error (_("Premature end of file while reading trace file"));
3967               return 1;
3968             }
3969           lseek (trace_fd, 8, SEEK_CUR);
3970           pos += (4 + 8);
3971           break;
3972         default:
3973           error ("Unknown block type '%c' (0x%x) in traceframe",
3974                  block_type, block_type);
3975           break;
3976         }
3977     }
3978   /* Didn't find anything.  */
3979   return 0;
3980 }
3981
3982 static int
3983 tfile_has_all_memory (struct target_ops *ops)
3984 {
3985   return 1;
3986 }
3987
3988 static int
3989 tfile_has_memory (struct target_ops *ops)
3990 {
3991   return 1;
3992 }
3993
3994 static int
3995 tfile_has_stack (struct target_ops *ops)
3996 {
3997   return 1;
3998 }
3999
4000 static int
4001 tfile_has_registers (struct target_ops *ops)
4002 {
4003   return 1;
4004 }
4005
4006 static void
4007 init_tfile_ops (void)
4008 {
4009   tfile_ops.to_shortname = "tfile";
4010   tfile_ops.to_longname = "Local trace dump file";
4011   tfile_ops.to_doc =
4012     "Use a trace file as a target.  Specify the filename of the trace file.";
4013   tfile_ops.to_open = tfile_open;
4014   tfile_ops.to_close = tfile_close;
4015   tfile_ops.to_fetch_registers = tfile_fetch_registers;
4016   tfile_ops.to_xfer_partial = tfile_xfer_partial;
4017   tfile_ops.to_files_info = tfile_files_info;
4018   tfile_ops.to_get_trace_status = tfile_get_trace_status;
4019   tfile_ops.to_trace_find = tfile_trace_find;
4020   tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value;
4021   /* core_stratum might seem more logical, but GDB doesn't like having
4022      more than one core_stratum vector.  */
4023   tfile_ops.to_stratum = process_stratum;
4024   tfile_ops.to_has_all_memory = tfile_has_all_memory;
4025   tfile_ops.to_has_memory = tfile_has_memory;
4026   tfile_ops.to_has_stack = tfile_has_stack;
4027   tfile_ops.to_has_registers = tfile_has_registers;
4028   tfile_ops.to_magic = OPS_MAGIC;
4029 }
4030
4031 /* module initialization */
4032 void
4033 _initialize_tracepoint (void)
4034 {
4035   struct cmd_list_element *c;
4036
4037   traceframe_number = -1;
4038   tracepoint_number = -1;
4039
4040   if (tracepoint_list.list == NULL)
4041     {
4042       tracepoint_list.listsize = 128;
4043       tracepoint_list.list = xmalloc
4044         (tracepoint_list.listsize * sizeof (struct memrange));
4045     }
4046   if (tracepoint_list.aexpr_list == NULL)
4047     {
4048       tracepoint_list.aexpr_listsize = 128;
4049       tracepoint_list.aexpr_list = xmalloc
4050         (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4051     }
4052
4053   if (stepping_list.list == NULL)
4054     {
4055       stepping_list.listsize = 128;
4056       stepping_list.list = xmalloc
4057         (stepping_list.listsize * sizeof (struct memrange));
4058     }
4059
4060   if (stepping_list.aexpr_list == NULL)
4061     {
4062       stepping_list.aexpr_listsize = 128;
4063       stepping_list.aexpr_list = xmalloc
4064         (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4065     }
4066
4067   add_info ("scope", scope_info,
4068             _("List the variables local to a scope"));
4069
4070   add_cmd ("tracepoints", class_trace, NULL,
4071            _("Tracing of program execution without stopping the program."),
4072            &cmdlist);
4073
4074   add_com ("tdump", class_trace, trace_dump_command,
4075            _("Print everything collected at the current tracepoint."));
4076
4077   add_com ("tsave", class_trace, trace_save_command, _("\
4078 Save the trace data to a file.\n\
4079 Use the '-r' option to direct the target to save directly to the file,\n\
4080 using its own filesystem."));
4081
4082   c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4083 Define a trace state variable.\n\
4084 Argument is a $-prefixed name, optionally followed\n\
4085 by '=' and an expression that sets the initial value\n\
4086 at the start of tracing."));
4087   set_cmd_completer (c, expression_completer);
4088
4089   add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4090 Delete one or more trace state variables.\n\
4091 Arguments are the names of the variables to delete.\n\
4092 If no arguments are supplied, delete all variables."), &deletelist);
4093   /* FIXME add a trace variable completer */
4094
4095   add_info ("tvariables", tvariables_info, _("\
4096 Status of trace state variables and their values.\n\
4097 "));
4098
4099   add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4100 Select a trace frame;\n\
4101 No argument means forward by one frame; '-' means backward by one frame."),
4102                   &tfindlist, "tfind ", 1, &cmdlist);
4103
4104   add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4105 Select a trace frame whose PC is outside the given range (exclusive).\n\
4106 Usage: tfind outside addr1, addr2"),
4107            &tfindlist);
4108
4109   add_cmd ("range", class_trace, trace_find_range_command, _("\
4110 Select a trace frame whose PC is in the given range (inclusive).\n\
4111 Usage: tfind range addr1,addr2"),
4112            &tfindlist);
4113
4114   add_cmd ("line", class_trace, trace_find_line_command, _("\
4115 Select a trace frame by source line.\n\
4116 Argument can be a line number (with optional source file), \n\
4117 a function name, or '*' followed by an address.\n\
4118 Default argument is 'the next source line that was traced'."),
4119            &tfindlist);
4120
4121   add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4122 Select a trace frame by tracepoint number.\n\
4123 Default is the tracepoint for the current trace frame."),
4124            &tfindlist);
4125
4126   add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4127 Select a trace frame by PC.\n\
4128 Default is the current PC, or the PC of the current trace frame."),
4129            &tfindlist);
4130
4131   add_cmd ("end", class_trace, trace_find_end_command, _("\
4132 Synonym for 'none'.\n\
4133 De-select any trace frame and resume 'live' debugging."),
4134            &tfindlist);
4135
4136   add_cmd ("none", class_trace, trace_find_none_command,
4137            _("De-select any trace frame and resume 'live' debugging."),
4138            &tfindlist);
4139
4140   add_cmd ("start", class_trace, trace_find_start_command,
4141            _("Select the first trace frame in the trace buffer."),
4142            &tfindlist);
4143
4144   add_com ("tstatus", class_trace, trace_status_command,
4145            _("Display the status of the current trace data collection."));
4146
4147   add_com ("tstop", class_trace, trace_stop_command,
4148            _("Stop trace data collection."));
4149
4150   add_com ("tstart", class_trace, trace_start_command,
4151            _("Start trace data collection."));
4152
4153   add_com ("end", class_trace, end_actions_pseudocommand, _("\
4154 Ends a list of commands or actions.\n\
4155 Several GDB commands allow you to enter a list of commands or actions.\n\
4156 Entering \"end\" on a line by itself is the normal way to terminate\n\
4157 such a list.\n\n\
4158 Note: the \"end\" command cannot be used at the gdb prompt."));
4159
4160   add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4161 Specify single-stepping behavior at a tracepoint.\n\
4162 Argument is number of instructions to trace in single-step mode\n\
4163 following the tracepoint.  This command is normally followed by\n\
4164 one or more \"collect\" commands, to specify what to collect\n\
4165 while single-stepping.\n\n\
4166 Note: this command can only be used in a tracepoint \"actions\" list."));
4167
4168   add_com_alias ("ws", "while-stepping", class_alias, 0);
4169   add_com_alias ("stepping", "while-stepping", class_alias, 0);
4170
4171   add_com ("collect", class_trace, collect_pseudocommand, _("\
4172 Specify one or more data items to be collected at a tracepoint.\n\
4173 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
4174 collect all data (variables, registers) referenced by that expression.\n\
4175 Also accepts the following special arguments:\n\
4176     $regs   -- all registers.\n\
4177     $args   -- all function arguments.\n\
4178     $locals -- all variables local to the block/function scope.\n\
4179 Note: this command can only be used in a tracepoint \"actions\" list."));
4180
4181   add_com ("teval", class_trace, teval_pseudocommand, _("\
4182 Specify one or more expressions to be evaluated at a tracepoint.\n\
4183 Accepts a comma-separated list of (one or more) expressions.\n\
4184 The result of each evaluation will be discarded.\n\
4185 Note: this command can only be used in a tracepoint \"actions\" list."));
4186
4187   add_com ("actions", class_trace, trace_actions_command, _("\
4188 Specify the actions to be taken at a tracepoint.\n\
4189 Tracepoint actions may include collecting of specified data, \n\
4190 single-stepping, or enabling/disabling other tracepoints, \n\
4191 depending on target's capabilities."));
4192
4193   default_collect = xstrdup ("");
4194   add_setshow_string_cmd ("default-collect", class_trace,
4195                           &default_collect, _("\
4196 Set the list of expressions to collect by default"), _("\
4197 Show the list of expressions to collect by default"), NULL,
4198                           NULL, NULL,
4199                           &setlist, &showlist);
4200
4201   add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4202                            &disconnected_tracing, _("\
4203 Set whether tracing continues after GDB disconnects."), _("\
4204 Show whether tracing continues after GDB disconnects."), _("\
4205 Use this to continue a tracing run even if GDB disconnects\n\
4206 or detaches from the target.  You can reconnect later and look at\n\
4207 trace data collected in the meantime."),
4208                            set_disconnected_tracing,
4209                            NULL,
4210                            &setlist,
4211                            &showlist);
4212
4213   add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4214                            &circular_trace_buffer, _("\
4215 Set target's use of circular trace buffer."), _("\
4216 Show target's use of circular trace buffer."), _("\
4217 Use this to make the trace buffer into a circular buffer,\n\
4218 which will discard traceframes (oldest first) instead of filling\n\
4219 up and stopping the trace run."),
4220                            set_circular_trace_buffer,
4221                            NULL,
4222                            &setlist,
4223                            &showlist);
4224
4225   init_tfile_ops ();
4226
4227   add_target (&tfile_ops);
4228 }