gdb/tracepoint.c

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