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