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_spec (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 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 char *trace_filename;
3623 int trace_fd = -1;
3624 off_t trace_frames_offset;
3625 off_t cur_offset;
3626 int cur_traceframe_number;
3627 int cur_data_size;
3628 int trace_regblock_size;
3629
3630 static void tfile_interp_line (char *line,
3631                                struct uploaded_tp **utpp,
3632                                struct uploaded_tsv **utsvp);
3633
3634 /* Read SIZE bytes into READBUF from the trace frame, starting at
3635    TRACE_FD's current position.  Note that this call `read'
3636    underneath, hence it advances the file's seek position.  Throws an
3637    error if the `read' syscall fails, or less than SIZE bytes are
3638    read.  */
3639
3640 static void
3641 tfile_read (gdb_byte *readbuf, int size)
3642 {
3643   int gotten;
3644
3645   gotten = read (trace_fd, readbuf, size);
3646   if (gotten < 0)
3647     perror_with_name (trace_filename);
3648   else if (gotten < size)
3649     error (_("Premature end of file while reading trace file"));
3650 }
3651
3652 static void
3653 tfile_open (char *filename, int from_tty)
3654 {
3655   volatile struct gdb_exception ex;
3656   char *temp;
3657   struct cleanup *old_chain;
3658   int flags;
3659   int scratch_chan;
3660   char header[TRACE_HEADER_SIZE];
3661   char linebuf[1000]; /* Should be max remote packet size or so.  */
3662   char byte;
3663   int bytes, i;
3664   struct trace_status *ts;
3665   struct uploaded_tp *uploaded_tps = NULL;
3666   struct uploaded_tsv *uploaded_tsvs = NULL;
3667
3668   target_preopen (from_tty);
3669   if (!filename)
3670     error (_("No trace file specified."));
3671
3672   filename = tilde_expand (filename);
3673   if (!IS_ABSOLUTE_PATH(filename))
3674     {
3675       temp = concat (current_directory, "/", filename, (char *) NULL);
3676       xfree (filename);
3677       filename = temp;
3678     }
3679
3680   old_chain = make_cleanup (xfree, filename);
3681
3682   flags = O_BINARY | O_LARGEFILE;
3683   flags |= O_RDONLY;
3684   scratch_chan = open (filename, flags, 0);
3685   if (scratch_chan < 0)
3686     perror_with_name (filename);
3687
3688   /* Looks semi-reasonable.  Toss the old trace file and work on the new.  */
3689
3690   discard_cleanups (old_chain); /* Don't free filename any more.  */
3691   unpush_target (&tfile_ops);
3692
3693   trace_filename = xstrdup (filename);
3694   trace_fd = scratch_chan;
3695
3696   bytes = 0;
3697   /* Read the file header and test for validity.  */
3698   tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3699
3700   bytes += TRACE_HEADER_SIZE;
3701   if (!(header[0] == 0x7f
3702         && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3703     error (_("File is not a valid trace file."));
3704
3705   push_target (&tfile_ops);
3706
3707   trace_regblock_size = 0;
3708   ts = current_trace_status ();
3709   /* We know we're working with a file.  */
3710   ts->from_file = 1;
3711   /* Set defaults in case there is no status line.  */
3712   ts->running_known = 0;
3713   ts->stop_reason = trace_stop_reason_unknown;
3714   ts->traceframe_count = -1;
3715   ts->buffer_free = 0;
3716   ts->disconnected_tracing = 0;
3717   ts->circular_buffer = 0;
3718
3719   cur_traceframe_number = -1;
3720
3721   TRY_CATCH (ex, RETURN_MASK_ALL)
3722     {
3723       /* Read through a section of newline-terminated lines that
3724          define things like tracepoints.  */
3725       i = 0;
3726       while (1)
3727         {
3728           tfile_read (&byte, 1);
3729
3730           ++bytes;
3731           if (byte == '\n')
3732             {
3733               /* Empty line marks end of the definition section.  */
3734               if (i == 0)
3735                 break;
3736               linebuf[i] = '\0';
3737               i = 0;
3738               tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3739             }
3740           else
3741             linebuf[i++] = byte;
3742           if (i >= 1000)
3743             error (_("Excessively long lines in trace file"));
3744         }
3745
3746       /* Record the starting offset of the binary trace data.  */
3747       trace_frames_offset = bytes;
3748
3749       /* If we don't have a blocksize, we can't interpret the
3750          traceframes.  */
3751       if (trace_regblock_size == 0)
3752         error (_("No register block size recorded in trace file"));
3753     }
3754   if (ex.reason < 0)
3755     {
3756       /* Pop the partially set up target.  */
3757       pop_target ();
3758       throw_exception (ex);
3759     }
3760
3761   inferior_appeared (current_inferior (), TFILE_PID);
3762   inferior_ptid = pid_to_ptid (TFILE_PID);
3763   add_thread_silent (inferior_ptid);
3764
3765   if (ts->traceframe_count <= 0)
3766     warning (_("No traceframes present in this file."));
3767
3768   /* Add the file's tracepoints and variables into the current mix.  */
3769
3770   /* Get trace state variables first, they may be checked when parsing
3771      uploaded commands.  */
3772   merge_uploaded_trace_state_variables (&uploaded_tsvs);
3773
3774   merge_uploaded_tracepoints (&uploaded_tps);
3775
3776   post_create_inferior (&tfile_ops, from_tty);
3777 }
3778
3779 /* Interpret the given line from the definitions part of the trace
3780    file.  */
3781
3782 static void
3783 tfile_interp_line (char *line,
3784                    struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3785 {
3786   char *p = line;
3787
3788   if (strncmp (p, "R ", strlen ("R ")) == 0)
3789     {
3790       p += strlen ("R ");
3791       trace_regblock_size = strtol (p, &p, 16);
3792     }
3793   else if (strncmp (p, "status ", strlen ("status ")) == 0)
3794     {
3795       p += strlen ("status ");
3796       parse_trace_status (p, current_trace_status ());
3797     }
3798   else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3799     {
3800       p += strlen ("tp ");
3801       parse_tracepoint_definition (p, utpp);
3802     }
3803   else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3804     {
3805       p += strlen ("tsv ");
3806       parse_tsv_definition (p, utsvp);
3807     }
3808   else
3809     warning (_("Ignoring trace file definition \"%s\""), line);
3810 }
3811
3812 /* Parse the part of trace status syntax that is shared between
3813    the remote protocol and the trace file reader.  */
3814
3815 void
3816 parse_trace_status (char *line, struct trace_status *ts)
3817 {
3818   char *p = line, *p1, *p2, *p3, *p_temp;
3819   int end;
3820   ULONGEST val;
3821
3822   ts->running_known = 1;
3823   ts->running = (*p++ == '1');
3824   ts->stop_reason = trace_stop_reason_unknown;
3825   xfree (ts->stop_desc);
3826   ts->stop_desc = NULL;
3827   ts->traceframe_count = -1;
3828   ts->traceframes_created = -1;
3829   ts->buffer_free = -1;
3830   ts->buffer_size = -1;
3831   ts->disconnected_tracing = 0;
3832   ts->circular_buffer = 0;
3833   xfree (ts->user_name);
3834   ts->user_name = NULL;
3835   xfree (ts->notes);
3836   ts->notes = NULL;
3837   ts->start_time = ts->stop_time = 0;
3838
3839   while (*p++)
3840     {
3841       p1 = strchr (p, ':');
3842       if (p1 == NULL)
3843         error (_("Malformed trace status, at %s\n\
3844 Status line: '%s'\n"), p, line);
3845       p3 = strchr (p, ';');
3846       if (p3 == NULL)
3847         p3 = p + strlen (p);
3848       if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3849         {
3850           p = unpack_varlen_hex (++p1, &val);
3851           ts->stop_reason = trace_buffer_full;
3852         }
3853       else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3854         {
3855           p = unpack_varlen_hex (++p1, &val);
3856           ts->stop_reason = trace_never_run;
3857         }
3858       else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3859                         p1 - p) == 0)
3860         {
3861           p = unpack_varlen_hex (++p1, &val);
3862           ts->stop_reason = tracepoint_passcount;
3863           ts->stopping_tracepoint = val;
3864         }
3865       else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3866         {
3867           p2 = strchr (++p1, ':');
3868           if (!p2 || p2 > p3)
3869             {
3870               /*older style*/
3871               p2 = p1;
3872             }
3873           else if (p2 != p1)
3874             {
3875               ts->stop_desc = xmalloc (strlen (line));
3876               end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
3877               ts->stop_desc[end] = '\0';
3878             }
3879           else
3880             ts->stop_desc = xstrdup ("");
3881
3882           p = unpack_varlen_hex (++p2, &val);
3883           ts->stop_reason = tstop_command;
3884         }
3885       else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3886         {
3887           p = unpack_varlen_hex (++p1, &val);
3888           ts->stop_reason = trace_disconnected;
3889         }
3890       else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3891         {
3892           p2 = strchr (++p1, ':');
3893           if (p2 != p1)
3894             {
3895               ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
3896               end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
3897               ts->stop_desc[end] = '\0';
3898             }
3899           else
3900             ts->stop_desc = xstrdup ("");
3901
3902           p = unpack_varlen_hex (++p2, &val);
3903           ts->stopping_tracepoint = val;
3904           ts->stop_reason = tracepoint_error;
3905         }
3906       else if (strncmp (p, "tframes", p1 - p) == 0)
3907         {
3908           p = unpack_varlen_hex (++p1, &val);
3909           ts->traceframe_count = val;
3910         }
3911       else if (strncmp (p, "tcreated", p1 - p) == 0)
3912         {
3913           p = unpack_varlen_hex (++p1, &val);
3914           ts->traceframes_created = val;
3915         }
3916       else if (strncmp (p, "tfree", p1 - p) == 0)
3917         {
3918           p = unpack_varlen_hex (++p1, &val);
3919           ts->buffer_free = val;
3920         }
3921       else if (strncmp (p, "tsize", p1 - p) == 0)
3922         {
3923           p = unpack_varlen_hex (++p1, &val);
3924           ts->buffer_size = val;
3925         }
3926       else if (strncmp (p, "disconn", p1 - p) == 0)
3927         {
3928           p = unpack_varlen_hex (++p1, &val);
3929           ts->disconnected_tracing = val;
3930         }
3931       else if (strncmp (p, "circular", p1 - p) == 0)
3932         {
3933           p = unpack_varlen_hex (++p1, &val);
3934           ts->circular_buffer = val;
3935         }
3936       else if (strncmp (p, "starttime", p1 - p) == 0)
3937         {
3938           p = unpack_varlen_hex (++p1, &val);
3939           ts->start_time = val;
3940         }
3941       else if (strncmp (p, "stoptime", p1 - p) == 0)
3942         {
3943           p = unpack_varlen_hex (++p1, &val);
3944           ts->stop_time = val;
3945         }
3946       else if (strncmp (p, "username", p1 - p) == 0)
3947         {
3948           ++p1;
3949           ts->user_name = xmalloc (strlen (p) / 2);
3950           end = hex2bin (p1, ts->user_name, (p3 - p1)  / 2);
3951           ts->user_name[end] = '\0';
3952           p = p3;
3953         }
3954       else if (strncmp (p, "notes", p1 - p) == 0)
3955         {
3956           ++p1;
3957           ts->notes = xmalloc (strlen (p) / 2);
3958           end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
3959           ts->notes[end] = '\0';
3960           p = p3;
3961         }
3962       else
3963         {
3964           /* Silently skip unknown optional info.  */
3965           p_temp = strchr (p1 + 1, ';');
3966           if (p_temp)
3967             p = p_temp;
3968           else
3969             /* Must be at the end.  */
3970             break;
3971         }
3972     }
3973 }
3974
3975 void
3976 parse_tracepoint_status (char *p, struct breakpoint *bp,
3977                          struct uploaded_tp *utp)
3978 {
3979   ULONGEST uval;
3980   struct tracepoint *tp = (struct tracepoint *) bp;
3981
3982   p = unpack_varlen_hex (p, &uval);
3983   if (tp)
3984     tp->base.hit_count += uval;
3985   else
3986     utp->hit_count += uval;
3987   p = unpack_varlen_hex (p + 1, &uval);
3988   if (tp)
3989     tp->traceframe_usage += uval;
3990   else
3991     utp->traceframe_usage += uval;
3992   /* Ignore any extra, allowing for future extensions.  */
3993 }
3994
3995 /* Given a line of text defining a part of a tracepoint, parse it into
3996    an "uploaded tracepoint".  */
3997
3998 void
3999 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4000 {
4001   char *p;
4002   char piece;
4003   ULONGEST num, addr, step, pass, orig_size, xlen, start;
4004   int enabled, end;
4005   enum bptype type;
4006   char *cond, *srctype, *buf;
4007   struct uploaded_tp *utp = NULL;
4008
4009   p = line;
4010   /* Both tracepoint and action definitions start with the same number
4011      and address sequence.  */
4012   piece = *p++;
4013   p = unpack_varlen_hex (p, &num);
4014   p++;  /* skip a colon */
4015   p = unpack_varlen_hex (p, &addr);
4016   p++;  /* skip a colon */
4017   if (piece == 'T')
4018     {
4019       enabled = (*p++ == 'E');
4020       p++;  /* skip a colon */
4021       p = unpack_varlen_hex (p, &step);
4022       p++;  /* skip a colon */
4023       p = unpack_varlen_hex (p, &pass);
4024       type = bp_tracepoint;
4025       cond = NULL;
4026       /* Thumb through optional fields.  */
4027       while (*p == ':')
4028         {
4029           p++;  /* skip a colon */
4030           if (*p == 'F')
4031             {
4032               type = bp_fast_tracepoint;
4033               p++;
4034               p = unpack_varlen_hex (p, &orig_size);
4035             }
4036           else if (*p == 'S')
4037             {
4038               type = bp_static_tracepoint;
4039               p++;
4040             }
4041           else if (*p == 'X')
4042             {
4043               p++;
4044               p = unpack_varlen_hex (p, &xlen);
4045               p++;  /* skip a comma */
4046               cond = (char *) xmalloc (2 * xlen + 1);
4047               strncpy (cond, p, 2 * xlen);
4048               cond[2 * xlen] = '\0';
4049               p += 2 * xlen;
4050             }
4051           else
4052             warning (_("Unrecognized char '%c' in tracepoint "
4053                        "definition, skipping rest"), *p);
4054         }
4055       utp = get_uploaded_tp (num, addr, utpp);
4056       utp->type = type;
4057       utp->enabled = enabled;
4058       utp->step = step;
4059       utp->pass = pass;
4060       utp->cond = cond;
4061     }
4062   else if (piece == 'A')
4063     {
4064       utp = get_uploaded_tp (num, addr, utpp);
4065       VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4066     }
4067   else if (piece == 'S')
4068     {
4069       utp = get_uploaded_tp (num, addr, utpp);
4070       VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4071     }
4072   else if (piece == 'Z')
4073     {
4074       /* Parse a chunk of source form definition.  */
4075       utp = get_uploaded_tp (num, addr, utpp);
4076       srctype = p;
4077       p = strchr (p, ':');
4078       p++;  /* skip a colon */
4079       p = unpack_varlen_hex (p, &start);
4080       p++;  /* skip a colon */
4081       p = unpack_varlen_hex (p, &xlen);
4082       p++;  /* skip a colon */
4083
4084       buf = alloca (strlen (line));
4085
4086       end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4087       buf[end] = '\0';
4088
4089       if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4090         utp->at_string = xstrdup (buf);
4091       else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4092         utp->cond_string = xstrdup (buf);
4093       else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4094         VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4095     }
4096   else if (piece == 'V')
4097     {
4098       utp = get_uploaded_tp (num, addr, utpp);
4099
4100       parse_tracepoint_status (p, NULL, utp);
4101     }
4102   else
4103     {
4104       /* Don't error out, the target might be sending us optional
4105          info that we don't care about.  */
4106       warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4107     }
4108 }
4109
4110 /* Convert a textual description of a trace state variable into an
4111    uploaded object.  */
4112
4113 void
4114 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4115 {
4116   char *p, *buf;
4117   ULONGEST num, initval, builtin;
4118   int end;
4119   struct uploaded_tsv *utsv = NULL;
4120
4121   buf = alloca (strlen (line));
4122
4123   p = line;
4124   p = unpack_varlen_hex (p, &num);
4125   p++; /* skip a colon */
4126   p = unpack_varlen_hex (p, &initval);
4127   p++; /* skip a colon */
4128   p = unpack_varlen_hex (p, &builtin);
4129   p++; /* skip a colon */
4130   end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4131   buf[end] = '\0';
4132
4133   utsv = get_uploaded_tsv (num, utsvp);
4134   utsv->initial_value = initval;
4135   utsv->builtin = builtin;
4136   utsv->name = xstrdup (buf);
4137 }
4138
4139 /* Close the trace file and generally clean up.  */
4140
4141 static void
4142 tfile_close (int quitting)
4143 {
4144   int pid;
4145
4146   if (trace_fd < 0)
4147     return;
4148
4149   pid = ptid_get_pid (inferior_ptid);
4150   inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff.  */
4151   exit_inferior_silent (pid);
4152
4153   close (trace_fd);
4154   trace_fd = -1;
4155   xfree (trace_filename);
4156   trace_filename = NULL;
4157 }
4158
4159 static void
4160 tfile_files_info (struct target_ops *t)
4161 {
4162   /* (it would be useful to mention the name of the file).  */
4163   printf_filtered ("Looking at a trace file.\n");
4164 }
4165
4166 /* The trace status for a file is that tracing can never be run.  */
4167
4168 static int
4169 tfile_get_trace_status (struct trace_status *ts)
4170 {
4171   /* Other bits of trace status were collected as part of opening the
4172      trace files, so nothing to do here.  */
4173
4174   return -1;
4175 }
4176
4177 static void
4178 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4179 {
4180   /* Other bits of trace status were collected as part of opening the
4181      trace files, so nothing to do here.  */
4182 }
4183
4184 /* Given the position of a traceframe in the file, figure out what
4185    address the frame was collected at.  This would normally be the
4186    value of a collected PC register, but if not available, we
4187    improvise.  */
4188
4189 static ULONGEST
4190 tfile_get_traceframe_address (off_t tframe_offset)
4191 {
4192   ULONGEST addr = 0;
4193   short tpnum;
4194   struct tracepoint *tp;
4195   off_t saved_offset = cur_offset;
4196
4197   /* FIXME dig pc out of collected registers.  */
4198
4199   /* Fall back to using tracepoint address.  */
4200   lseek (trace_fd, tframe_offset, SEEK_SET);
4201   tfile_read ((gdb_byte *) &tpnum, 2);
4202   tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4203                                           gdbarch_byte_order
4204                                               (target_gdbarch));
4205
4206   tp = get_tracepoint_by_number_on_target (tpnum);
4207   /* FIXME this is a poor heuristic if multiple locations.  */
4208   if (tp && tp->base.loc)
4209     addr = tp->base.loc->address;
4210
4211   /* Restore our seek position.  */
4212   cur_offset = saved_offset;
4213   lseek (trace_fd, cur_offset, SEEK_SET);
4214   return addr;
4215 }
4216
4217 /* Make tfile's selected traceframe match GDB's selected
4218    traceframe.  */
4219
4220 static void
4221 set_tfile_traceframe (void)
4222 {
4223   int newnum;
4224
4225   if (cur_traceframe_number == get_traceframe_number ())
4226     return;
4227
4228   /* Avoid recursion, tfile_trace_find calls us again.  */
4229   cur_traceframe_number = get_traceframe_number ();
4230
4231   newnum = target_trace_find (tfind_number,
4232                               get_traceframe_number (), 0, 0, NULL);
4233
4234   /* Should not happen.  If it does, all bets are off.  */
4235   if (newnum != get_traceframe_number ())
4236     warning (_("could not set tfile's traceframe"));
4237 }
4238
4239 /* Given a type of search and some parameters, scan the collection of
4240    traceframes in the file looking for a match.  When found, return
4241    both the traceframe and tracepoint number, otherwise -1 for
4242    each.  */
4243
4244 static int
4245 tfile_trace_find (enum trace_find_type type, int num,
4246                   ULONGEST addr1, ULONGEST addr2, int *tpp)
4247 {
4248   short tpnum;
4249   int tfnum = 0, found = 0;
4250   unsigned int data_size;
4251   struct tracepoint *tp;
4252   off_t offset, tframe_offset;
4253   ULONGEST tfaddr;
4254
4255   /* Lookups other than by absolute frame number depend on the current
4256      trace selected, so make sure it is correct on the tfile end
4257      first.  */
4258   if (type != tfind_number)
4259     set_tfile_traceframe ();
4260   else if (num == -1)
4261     {
4262       if (tpp)
4263         *tpp = -1;
4264       return -1;
4265     }
4266
4267   lseek (trace_fd, trace_frames_offset, SEEK_SET);
4268   offset = trace_frames_offset;
4269   while (1)
4270     {
4271       tframe_offset = offset;
4272       tfile_read ((gdb_byte *) &tpnum, 2);
4273       tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4274                                               gdbarch_byte_order
4275                                                   (target_gdbarch));
4276       offset += 2;
4277       if (tpnum == 0)
4278         break;
4279       tfile_read ((gdb_byte *) &data_size, 4);
4280       data_size = (unsigned int) extract_unsigned_integer
4281                                      ((gdb_byte *) &data_size, 4,
4282                                       gdbarch_byte_order (target_gdbarch));
4283       offset += 4;
4284       switch (type)
4285         {
4286         case tfind_number:
4287           if (tfnum == num)
4288             found = 1;
4289           break;
4290         case tfind_pc:
4291           tfaddr = tfile_get_traceframe_address (tframe_offset);
4292           if (tfaddr == addr1)
4293             found = 1;
4294           break;
4295         case tfind_tp:
4296           tp = get_tracepoint (num);
4297           if (tp && tpnum == tp->number_on_target)
4298             found = 1;
4299           break;
4300         case tfind_range:
4301           tfaddr = tfile_get_traceframe_address (tframe_offset);
4302           if (addr1 <= tfaddr && tfaddr <= addr2)
4303             found = 1;
4304           break;
4305         case tfind_outside:
4306           tfaddr = tfile_get_traceframe_address (tframe_offset);
4307           if (!(addr1 <= tfaddr && tfaddr <= addr2))
4308             found = 1;
4309           break;
4310         default:
4311           internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4312         }
4313       if (found)
4314         {
4315           if (tpp)
4316             *tpp = tpnum;
4317           cur_offset = offset;
4318           cur_data_size = data_size;
4319           cur_traceframe_number = tfnum;
4320           return tfnum;
4321         }
4322       /* Skip past the traceframe's data.  */
4323       lseek (trace_fd, data_size, SEEK_CUR);
4324       offset += data_size;
4325       /* Update our own count of traceframes.  */
4326       ++tfnum;
4327     }
4328   /* Did not find what we were looking for.  */
4329   if (tpp)
4330     *tpp = -1;
4331   return -1;
4332 }
4333
4334 /* Prototype of the callback passed to tframe_walk_blocks.  */
4335 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4336
4337 /* Callback for traceframe_walk_blocks, used to find a given block
4338    type in a traceframe.  */
4339
4340 static int
4341 match_blocktype (char blocktype, void *data)
4342 {
4343   char *wantedp = data;
4344
4345   if (*wantedp == blocktype)
4346     return 1;
4347
4348   return 0;
4349 }
4350
4351 /* Walk over all traceframe block starting at POS offset from
4352    CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4353    unmodified.  If CALLBACK returns true, this returns the position in
4354    the traceframe where the block is found, relative to the start of
4355    the traceframe (cur_offset).  Returns -1 if no callback call
4356    returned true, indicating that all blocks have been walked.  */
4357
4358 static int
4359 traceframe_walk_blocks (walk_blocks_callback_func callback,
4360                         int pos, void *data)
4361 {
4362   /* Iterate through a traceframe's blocks, looking for a block of the
4363      requested type.  */
4364
4365   lseek (trace_fd, cur_offset + pos, SEEK_SET);
4366   while (pos < cur_data_size)
4367     {
4368       unsigned short mlen;
4369       char block_type;
4370
4371       tfile_read (&block_type, 1);
4372
4373       ++pos;
4374
4375       if ((*callback) (block_type, data))
4376         return pos;
4377
4378       switch (block_type)
4379         {
4380         case 'R':
4381           lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4382           pos += trace_regblock_size;
4383           break;
4384         case 'M':
4385           lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4386           tfile_read ((gdb_byte *) &mlen, 2);
4387           mlen = (unsigned short)
4388                 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4389                                           gdbarch_byte_order
4390                                               (target_gdbarch));
4391           lseek (trace_fd, mlen, SEEK_CUR);
4392           pos += (8 + 2 + mlen);
4393           break;
4394         case 'V':
4395           lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4396           pos += (4 + 8);
4397           break;
4398         default:
4399           error (_("Unknown block type '%c' (0x%x) in trace frame"),
4400                  block_type, block_type);
4401           break;
4402         }
4403     }
4404
4405   return -1;
4406 }
4407
4408 /* Convenience wrapper around traceframe_walk_blocks.  Looks for the
4409    position offset of a block of type TYPE_WANTED in the current trace
4410    frame, starting at POS.  Returns -1 if no such block was found.  */
4411
4412 static int
4413 traceframe_find_block_type (char type_wanted, int pos)
4414 {
4415   return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4416 }
4417
4418 /* Look for a block of saved registers in the traceframe, and get the
4419    requested register from it.  */
4420
4421 static void
4422 tfile_fetch_registers (struct target_ops *ops,
4423                        struct regcache *regcache, int regno)
4424 {
4425   struct gdbarch *gdbarch = get_regcache_arch (regcache);
4426   int offset, regn, regsize, pc_regno;
4427   char *regs;
4428
4429   /* An uninitialized reg size says we're not going to be
4430      successful at getting register blocks.  */
4431   if (!trace_regblock_size)
4432     return;
4433
4434   set_tfile_traceframe ();
4435
4436   regs = alloca (trace_regblock_size);
4437
4438   if (traceframe_find_block_type ('R', 0) >= 0)
4439     {
4440       tfile_read (regs, trace_regblock_size);
4441
4442       /* Assume the block is laid out in GDB register number order,
4443          each register with the size that it has in GDB.  */
4444       offset = 0;
4445       for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4446         {
4447           regsize = register_size (gdbarch, regn);
4448           /* Make sure we stay within block bounds.  */
4449           if (offset + regsize >= trace_regblock_size)
4450             break;
4451           if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4452             {
4453               if (regno == regn)
4454                 {
4455                   regcache_raw_supply (regcache, regno, regs + offset);
4456                   break;
4457                 }
4458               else if (regno == -1)
4459                 {
4460                   regcache_raw_supply (regcache, regn, regs + offset);
4461                 }
4462             }
4463           offset += regsize;
4464         }
4465       return;
4466     }
4467
4468   /* We get here if no register data has been found.  Mark registers
4469      as unavailable.  */
4470   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4471     regcache_raw_supply (regcache, regn, NULL);
4472
4473   /* We can often usefully guess that the PC is going to be the same
4474      as the address of the tracepoint.  */
4475   pc_regno = gdbarch_pc_regnum (gdbarch);
4476   if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4477     {
4478       struct tracepoint *tp = get_tracepoint (tracepoint_number);
4479
4480       if (tp && tp->base.loc)
4481         {
4482           /* But don't try to guess if tracepoint is multi-location...  */
4483           if (tp->base.loc->next)
4484             {
4485               warning (_("Tracepoint %d has multiple "
4486                          "locations, cannot infer $pc"),
4487                        tp->base.number);
4488               return;
4489             }
4490           /* ... or does while-stepping.  */
4491           if (tp->step_count > 0)
4492             {
4493               warning (_("Tracepoint %d does while-stepping, "
4494                          "cannot infer $pc"),
4495                        tp->base.number);
4496               return;
4497             }
4498
4499           store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4500                                   gdbarch_byte_order (gdbarch),
4501                                   tp->base.loc->address);
4502           regcache_raw_supply (regcache, pc_regno, regs);
4503         }
4504     }
4505 }
4506
4507 static LONGEST
4508 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4509                     const char *annex, gdb_byte *readbuf,
4510                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4511 {
4512   /* We're only doing regular memory for now.  */
4513   if (object != TARGET_OBJECT_MEMORY)
4514     return -1;
4515
4516   if (readbuf == NULL)
4517     error (_("tfile_xfer_partial: trace file is read-only"));
4518
4519   set_tfile_traceframe ();
4520
4521  if (traceframe_number != -1)
4522     {
4523       int pos = 0;
4524
4525       /* Iterate through the traceframe's blocks, looking for
4526          memory.  */
4527       while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4528         {
4529           ULONGEST maddr, amt;
4530           unsigned short mlen;
4531           enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4532
4533           tfile_read ((gdb_byte *) &maddr, 8);
4534           maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4535                                             byte_order);
4536           tfile_read ((gdb_byte *) &mlen, 2);
4537           mlen = (unsigned short)
4538             extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4539
4540           /* If the block includes the first part of the desired
4541              range, return as much it has; GDB will re-request the
4542              remainder, which might be in a different block of this
4543              trace frame.  */
4544           if (maddr <= offset && offset < (maddr + mlen))
4545             {
4546               amt = (maddr + mlen) - offset;
4547               if (amt > len)
4548                 amt = len;
4549
4550               if (maddr != offset)
4551                 lseek (trace_fd, offset - maddr, SEEK_CUR);
4552               tfile_read (readbuf, amt);
4553               return amt;
4554             }
4555
4556           /* Skip over this block.  */
4557           pos += (8 + 2 + mlen);
4558         }
4559     }
4560
4561   /* It's unduly pedantic to refuse to look at the executable for
4562      read-only pieces; so do the equivalent of readonly regions aka
4563      QTro packet.  */
4564   /* FIXME account for relocation at some point.  */
4565   if (exec_bfd)
4566     {
4567       asection *s;
4568       bfd_size_type size;
4569       bfd_vma vma;
4570
4571       for (s = exec_bfd->sections; s; s = s->next)
4572         {
4573           if ((s->flags & SEC_LOAD) == 0
4574               || (s->flags & SEC_READONLY) == 0)
4575             continue;
4576
4577           vma = s->vma;
4578           size = bfd_get_section_size (s);
4579           if (vma <= offset && offset < (vma + size))
4580             {
4581               ULONGEST amt;
4582
4583               amt = (vma + size) - offset;
4584               if (amt > len)
4585                 amt = len;
4586
4587               amt = bfd_get_section_contents (exec_bfd, s,
4588                                               readbuf, offset - vma, amt);
4589               return amt;
4590             }
4591         }
4592     }
4593
4594   /* Indicate failure to find the requested memory block.  */
4595   return -1;
4596 }
4597
4598 /* Iterate through the blocks of a trace frame, looking for a 'V'
4599    block with a matching tsv number.  */
4600
4601 static int
4602 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4603 {
4604   int pos;
4605
4606   set_tfile_traceframe ();
4607
4608   pos = 0;
4609   while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4610     {
4611       int vnum;
4612
4613       tfile_read ((gdb_byte *) &vnum, 4);
4614       vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4615                                            gdbarch_byte_order
4616                                            (target_gdbarch));
4617       if (tsvnum == vnum)
4618         {
4619           tfile_read ((gdb_byte *) val, 8);
4620           *val = extract_signed_integer ((gdb_byte *) val, 8,
4621                                          gdbarch_byte_order
4622                                          (target_gdbarch));
4623           return 1;
4624         }
4625       pos += (4 + 8);
4626     }
4627
4628   /* Didn't find anything.  */
4629   return 0;
4630 }
4631
4632 static int
4633 tfile_has_all_memory (struct target_ops *ops)
4634 {
4635   return 1;
4636 }
4637
4638 static int
4639 tfile_has_memory (struct target_ops *ops)
4640 {
4641   return 1;
4642 }
4643
4644 static int
4645 tfile_has_stack (struct target_ops *ops)
4646 {
4647   return traceframe_number != -1;
4648 }
4649
4650 static int
4651 tfile_has_registers (struct target_ops *ops)
4652 {
4653   return traceframe_number != -1;
4654 }
4655
4656 static int
4657 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
4658 {
4659   return 1;
4660 }
4661
4662 /* Callback for traceframe_walk_blocks.  Builds a traceframe_info
4663    object for the tfile target's current traceframe.  */
4664
4665 static int
4666 build_traceframe_info (char blocktype, void *data)
4667 {
4668   struct traceframe_info *info = data;
4669
4670   switch (blocktype)
4671     {
4672     case 'M':
4673       {
4674         struct mem_range *r;
4675         ULONGEST maddr;
4676         unsigned short mlen;
4677
4678         tfile_read ((gdb_byte *) &maddr, 8);
4679         tfile_read ((gdb_byte *) &mlen, 2);
4680
4681         r = VEC_safe_push (mem_range_s, info->memory, NULL);
4682
4683         r->start = maddr;
4684         r->length = mlen;
4685         break;
4686       }
4687     case 'V':
4688     case 'R':
4689     case 'S':
4690       {
4691         break;
4692       }
4693     default:
4694       warning (_("Unhandled trace block type (%d) '%c ' "
4695                  "while building trace frame info."),
4696                blocktype, blocktype);
4697       break;
4698     }
4699
4700   return 0;
4701 }
4702
4703 static struct traceframe_info *
4704 tfile_traceframe_info (void)
4705 {
4706   struct traceframe_info *info = XCNEW (struct traceframe_info);
4707
4708   traceframe_walk_blocks (build_traceframe_info, 0, info);
4709   return info;
4710 }
4711
4712 static void
4713 init_tfile_ops (void)
4714 {
4715   tfile_ops.to_shortname = "tfile";
4716   tfile_ops.to_longname = "Local trace dump file";
4717   tfile_ops.to_doc
4718     = "Use a trace file as a target.  Specify the filename of the trace file.";
4719   tfile_ops.to_open = tfile_open;
4720   tfile_ops.to_close = tfile_close;
4721   tfile_ops.to_fetch_registers = tfile_fetch_registers;
4722   tfile_ops.to_xfer_partial = tfile_xfer_partial;
4723   tfile_ops.to_files_info = tfile_files_info;
4724   tfile_ops.to_get_trace_status = tfile_get_trace_status;
4725   tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
4726   tfile_ops.to_trace_find = tfile_trace_find;
4727   tfile_ops.to_get_trace_state_variable_value
4728     = tfile_get_trace_state_variable_value;
4729   tfile_ops.to_stratum = process_stratum;
4730   tfile_ops.to_has_all_memory = tfile_has_all_memory;
4731   tfile_ops.to_has_memory = tfile_has_memory;
4732   tfile_ops.to_has_stack = tfile_has_stack;
4733   tfile_ops.to_has_registers = tfile_has_registers;
4734   tfile_ops.to_traceframe_info = tfile_traceframe_info;
4735   tfile_ops.to_thread_alive = tfile_thread_alive;
4736   tfile_ops.to_magic = OPS_MAGIC;
4737 }
4738
4739 void
4740 free_current_marker (void *arg)
4741 {
4742   struct static_tracepoint_marker **marker_p = arg;
4743
4744   if (*marker_p != NULL)
4745     {
4746       release_static_tracepoint_marker (*marker_p);
4747       xfree (*marker_p);
4748     }
4749   else
4750     *marker_p = NULL;
4751 }
4752
4753 /* Given a line of text defining a static tracepoint marker, parse it
4754    into a "static tracepoint marker" object.  Throws an error is
4755    parsing fails.  If PP is non-null, it points to one past the end of
4756    the parsed marker definition.  */
4757
4758 void
4759 parse_static_tracepoint_marker_definition (char *line, char **pp,
4760                                            struct static_tracepoint_marker *marker)
4761 {
4762   char *p, *endp;
4763   ULONGEST addr;
4764   int end;
4765
4766   p = line;
4767   p = unpack_varlen_hex (p, &addr);
4768   p++;  /* skip a colon */
4769
4770   marker->gdbarch = target_gdbarch;
4771   marker->address = (CORE_ADDR) addr;
4772
4773   endp = strchr (p, ':');
4774   if (endp == NULL)
4775     error (_("bad marker definition: %s"), line);
4776
4777   marker->str_id = xmalloc (endp - p + 1);
4778   end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4779   marker->str_id[end] = '\0';
4780
4781   p += 2 * end;
4782   p++;  /* skip a colon */
4783
4784   marker->extra = xmalloc (strlen (p) + 1);
4785   end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4786   marker->extra[end] = '\0';
4787
4788   if (pp)
4789     *pp = p;
4790 }
4791
4792 /* Release a static tracepoint marker's contents.  Note that the
4793    object itself isn't released here.  There objects are usually on
4794    the stack.  */
4795
4796 void
4797 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4798 {
4799   xfree (marker->str_id);
4800   marker->str_id = NULL;
4801 }
4802
4803 /* Print MARKER to gdb_stdout.  */
4804
4805 static void
4806 print_one_static_tracepoint_marker (int count,
4807                                     struct static_tracepoint_marker *marker)
4808 {
4809   struct command_line *l;
4810   struct symbol *sym;
4811
4812   char wrap_indent[80];
4813   char extra_field_indent[80];
4814   struct ui_out *uiout = current_uiout;
4815   struct cleanup *bkpt_chain;
4816   VEC(breakpoint_p) *tracepoints;
4817
4818   struct symtab_and_line sal;
4819
4820   init_sal (&sal);
4821
4822   sal.pc = marker->address;
4823
4824   tracepoints = static_tracepoints_here (marker->address);
4825
4826   bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4827
4828   /* A counter field to help readability.  This is not a stable
4829      identifier!  */
4830   ui_out_field_int (uiout, "count", count);
4831
4832   ui_out_field_string (uiout, "marker-id", marker->str_id);
4833
4834   ui_out_field_fmt (uiout, "enabled", "%c",
4835                     !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4836   ui_out_spaces (uiout, 2);
4837
4838   strcpy (wrap_indent, "                                   ");
4839
4840   if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4841     strcat (wrap_indent, "           ");
4842   else
4843     strcat (wrap_indent, "                   ");
4844
4845   strcpy (extra_field_indent, "         ");
4846
4847   ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4848
4849   sal = find_pc_line (marker->address, 0);
4850   sym = find_pc_sect_function (marker->address, NULL);
4851   if (sym)
4852     {
4853       ui_out_text (uiout, "in ");
4854       ui_out_field_string (uiout, "func",
4855                            SYMBOL_PRINT_NAME (sym));
4856       ui_out_wrap_hint (uiout, wrap_indent);
4857       ui_out_text (uiout, " at ");
4858     }
4859   else
4860     ui_out_field_skip (uiout, "func");
4861
4862   if (sal.symtab != NULL)
4863     {
4864       ui_out_field_string (uiout, "file", sal.symtab->filename);
4865       ui_out_text (uiout, ":");
4866
4867       if (ui_out_is_mi_like_p (uiout))
4868         {
4869           char *fullname = symtab_to_fullname (sal.symtab);
4870
4871           if (fullname)
4872             ui_out_field_string (uiout, "fullname", fullname);
4873         }
4874       else
4875         ui_out_field_skip (uiout, "fullname");
4876
4877       ui_out_field_int (uiout, "line", sal.line);
4878     }
4879   else
4880     {
4881       ui_out_field_skip (uiout, "fullname");
4882       ui_out_field_skip (uiout, "line");
4883     }
4884
4885   ui_out_text (uiout, "\n");
4886   ui_out_text (uiout, extra_field_indent);
4887   ui_out_text (uiout, _("Data: \""));
4888   ui_out_field_string (uiout, "extra-data", marker->extra);
4889   ui_out_text (uiout, "\"\n");
4890
4891   if (!VEC_empty (breakpoint_p, tracepoints))
4892     {
4893       struct cleanup *cleanup_chain;
4894       int ix;
4895       struct breakpoint *b;
4896
4897       cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4898                                                            "tracepoints-at");
4899
4900       ui_out_text (uiout, extra_field_indent);
4901       ui_out_text (uiout, _("Probed by static tracepoints: "));
4902       for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4903         {
4904           if (ix > 0)
4905             ui_out_text (uiout, ", ");
4906           ui_out_text (uiout, "#");
4907           ui_out_field_int (uiout, "tracepoint-id", b->number);
4908         }
4909
4910       do_cleanups (cleanup_chain);
4911
4912       if (ui_out_is_mi_like_p (uiout))
4913         ui_out_field_int (uiout, "number-of-tracepoints",
4914                           VEC_length(breakpoint_p, tracepoints));
4915       else
4916         ui_out_text (uiout, "\n");
4917     }
4918   VEC_free (breakpoint_p, tracepoints);
4919
4920   do_cleanups (bkpt_chain);
4921 }
4922
4923 static void
4924 info_static_tracepoint_markers_command (char *arg, int from_tty)
4925 {
4926   VEC(static_tracepoint_marker_p) *markers;
4927   struct cleanup *old_chain;
4928   struct static_tracepoint_marker *marker;
4929   struct ui_out *uiout = current_uiout;
4930   int i;
4931
4932   /* We don't have to check target_can_use_agent and agent's capability on
4933      static tracepoint here, in order to be compatible with older GDBserver.
4934      We don't check USE_AGENT is true or not, because static tracepoints
4935      don't work without in-process agent, so we don't bother users to type
4936      `set agent on' when to use static tracepoint.  */
4937
4938   old_chain
4939     = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4940                                            "StaticTracepointMarkersTable");
4941
4942   ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4943
4944   ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4945
4946   ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4947   if (gdbarch_addr_bit (target_gdbarch) <= 32)
4948     ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4949   else
4950     ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4951   ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4952
4953   ui_out_table_body (uiout);
4954
4955   markers = target_static_tracepoint_markers_by_strid (NULL);
4956   make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4957
4958   for (i = 0;
4959        VEC_iterate (static_tracepoint_marker_p,
4960                     markers, i, marker);
4961        i++)
4962     {
4963       print_one_static_tracepoint_marker (i + 1, marker);
4964       release_static_tracepoint_marker (marker);
4965     }
4966
4967   do_cleanups (old_chain);
4968 }
4969
4970 /* The $_sdata convenience variable is a bit special.  We don't know
4971    for sure type of the value until we actually have a chance to fetch
4972    the data --- the size of the object depends on what has been
4973    collected.  We solve this by making $_sdata be an internalvar that
4974    creates a new value on access.  */
4975
4976 /* Return a new value with the correct type for the sdata object of
4977    the current trace frame.  Return a void value if there's no object
4978    available.  */
4979
4980 static struct value *
4981 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
4982                   void *ignore)
4983 {
4984   LONGEST size;
4985   gdb_byte *buf;
4986
4987   /* We need to read the whole object before we know its size.  */
4988   size = target_read_alloc (&current_target,
4989                             TARGET_OBJECT_STATIC_TRACE_DATA,
4990                             NULL, &buf);
4991   if (size >= 0)
4992     {
4993       struct value *v;
4994       struct type *type;
4995
4996       type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4997                                size);
4998       v = allocate_value (type);
4999       memcpy (value_contents_raw (v), buf, size);
5000       xfree (buf);
5001       return v;
5002     }
5003   else
5004     return allocate_value (builtin_type (gdbarch)->builtin_void);
5005 }
5006
5007 #if !defined(HAVE_LIBEXPAT)
5008
5009 struct traceframe_info *
5010 parse_traceframe_info (const char *tframe_info)
5011 {
5012   static int have_warned;
5013
5014   if (!have_warned)
5015     {
5016       have_warned = 1;
5017       warning (_("Can not parse XML trace frame info; XML support "
5018                  "was disabled at compile time"));
5019     }
5020
5021   return NULL;
5022 }
5023
5024 #else /* HAVE_LIBEXPAT */
5025
5026 #include "xml-support.h"
5027
5028 /* Handle the start of a <memory> element.  */
5029
5030 static void
5031 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5032                               const struct gdb_xml_element *element,
5033                               void *user_data, VEC(gdb_xml_value_s) *attributes)
5034 {
5035   struct traceframe_info *info = user_data;
5036   struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5037   ULONGEST *start_p, *length_p;
5038
5039   start_p = xml_find_attribute (attributes, "start")->value;
5040   length_p = xml_find_attribute (attributes, "length")->value;
5041
5042   r->start = *start_p;
5043   r->length = *length_p;
5044 }
5045
5046 /* Discard the constructed trace frame info (if an error occurs).  */
5047
5048 static void
5049 free_result (void *p)
5050 {
5051   struct traceframe_info *result = p;
5052
5053   free_traceframe_info (result);
5054 }
5055
5056 /* The allowed elements and attributes for an XML memory map.  */
5057
5058 static const struct gdb_xml_attribute memory_attributes[] = {
5059   { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5060   { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5061   { NULL, GDB_XML_AF_NONE, NULL, NULL }
5062 };
5063
5064 static const struct gdb_xml_element traceframe_info_children[] = {
5065   { "memory", memory_attributes, NULL,
5066     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5067     traceframe_info_start_memory, NULL },
5068   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5069 };
5070
5071 static const struct gdb_xml_element traceframe_info_elements[] = {
5072   { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5073     NULL, NULL },
5074   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5075 };
5076
5077 /* Parse a traceframe-info XML document.  */
5078
5079 struct traceframe_info *
5080 parse_traceframe_info (const char *tframe_info)
5081 {
5082   struct traceframe_info *result;
5083   struct cleanup *back_to;
5084
5085   result = XCNEW (struct traceframe_info);
5086   back_to = make_cleanup (free_result, result);
5087
5088   if (gdb_xml_parse_quick (_("trace frame info"),
5089                            "traceframe-info.dtd", traceframe_info_elements,
5090                            tframe_info, result) == 0)
5091     {
5092       /* Parsed successfully, keep the result.  */
5093       discard_cleanups (back_to);
5094
5095       return result;
5096     }
5097
5098   do_cleanups (back_to);
5099   return NULL;
5100 }
5101
5102 #endif /* HAVE_LIBEXPAT */
5103
5104 /* Returns the traceframe_info object for the current traceframe.
5105    This is where we avoid re-fetching the object from the target if we
5106    already have it cached.  */
5107
5108 static struct traceframe_info *
5109 get_traceframe_info (void)
5110 {
5111   if (traceframe_info == NULL)
5112     traceframe_info = target_traceframe_info ();
5113
5114   return traceframe_info;
5115 }
5116
5117 /* If the target supports the query, return in RESULT the set of
5118    collected memory in the current traceframe, found within the LEN
5119    bytes range starting at MEMADDR.  Returns true if the target
5120    supports the query, otherwise returns false, and RESULT is left
5121    undefined.  */
5122
5123 int
5124 traceframe_available_memory (VEC(mem_range_s) **result,
5125                              CORE_ADDR memaddr, ULONGEST len)
5126 {
5127   struct traceframe_info *info = get_traceframe_info ();
5128
5129   if (info != NULL)
5130     {
5131       struct mem_range *r;
5132       int i;
5133
5134       *result = NULL;
5135
5136       for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5137         if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5138           {
5139             ULONGEST lo1, hi1, lo2, hi2;
5140             struct mem_range *nr;
5141
5142             lo1 = memaddr;
5143             hi1 = memaddr + len;
5144
5145             lo2 = r->start;
5146             hi2 = r->start + r->length;
5147
5148             nr = VEC_safe_push (mem_range_s, *result, NULL);
5149
5150             nr->start = max (lo1, lo2);
5151             nr->length = min (hi1, hi2) - nr->start;
5152           }
5153
5154       normalize_mem_ranges (*result);
5155       return 1;
5156     }
5157
5158   return 0;
5159 }
5160
5161 /* Implementation of `sdata' variable.  */
5162
5163 static const struct internalvar_funcs sdata_funcs =
5164 {
5165   sdata_make_value,
5166   NULL,
5167   NULL
5168 };
5169
5170 /* module initialization */
5171 void
5172 _initialize_tracepoint (void)
5173 {
5174   struct cmd_list_element *c;
5175
5176   /* Explicitly create without lookup, since that tries to create a
5177      value with a void typed value, and when we get here, gdbarch
5178      isn't initialized yet.  At this point, we're quite sure there
5179      isn't another convenience variable of the same name.  */
5180   create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5181
5182   traceframe_number = -1;
5183   tracepoint_number = -1;
5184
5185   if (tracepoint_list.list == NULL)
5186     {
5187       tracepoint_list.listsize = 128;
5188       tracepoint_list.list = xmalloc
5189         (tracepoint_list.listsize * sizeof (struct memrange));
5190     }
5191   if (tracepoint_list.aexpr_list == NULL)
5192     {
5193       tracepoint_list.aexpr_listsize = 128;
5194       tracepoint_list.aexpr_list = xmalloc
5195         (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
5196     }
5197
5198   if (stepping_list.list == NULL)
5199     {
5200       stepping_list.listsize = 128;
5201       stepping_list.list = xmalloc
5202         (stepping_list.listsize * sizeof (struct memrange));
5203     }
5204
5205   if (stepping_list.aexpr_list == NULL)
5206     {
5207       stepping_list.aexpr_listsize = 128;
5208       stepping_list.aexpr_list = xmalloc
5209         (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
5210     }
5211
5212   add_info ("scope", scope_info,
5213             _("List the variables local to a scope"));
5214
5215   add_cmd ("tracepoints", class_trace, NULL,
5216            _("Tracing of program execution without stopping the program."),
5217            &cmdlist);
5218
5219   add_com ("tdump", class_trace, trace_dump_command,
5220            _("Print everything collected at the current tracepoint."));
5221
5222   add_com ("tsave", class_trace, trace_save_command, _("\
5223 Save the trace data to a file.\n\
5224 Use the '-r' option to direct the target to save directly to the file,\n\
5225 using its own filesystem."));
5226
5227   c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5228 Define a trace state variable.\n\
5229 Argument is a $-prefixed name, optionally followed\n\
5230 by '=' and an expression that sets the initial value\n\
5231 at the start of tracing."));
5232   set_cmd_completer (c, expression_completer);
5233
5234   add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5235 Delete one or more trace state variables.\n\
5236 Arguments are the names of the variables to delete.\n\
5237 If no arguments are supplied, delete all variables."), &deletelist);
5238   /* FIXME add a trace variable completer.  */
5239
5240   add_info ("tvariables", tvariables_info, _("\
5241 Status of trace state variables and their values.\n\
5242 "));
5243
5244   add_info ("static-tracepoint-markers",
5245             info_static_tracepoint_markers_command, _("\
5246 List target static tracepoints markers.\n\
5247 "));
5248
5249   add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5250 Select a trace frame;\n\
5251 No argument means forward by one frame; '-' means backward by one frame."),
5252                   &tfindlist, "tfind ", 1, &cmdlist);
5253
5254   add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5255 Select a trace frame whose PC is outside the given range (exclusive).\n\
5256 Usage: tfind outside addr1, addr2"),
5257            &tfindlist);
5258
5259   add_cmd ("range", class_trace, trace_find_range_command, _("\
5260 Select a trace frame whose PC is in the given range (inclusive).\n\
5261 Usage: tfind range addr1,addr2"),
5262            &tfindlist);
5263
5264   add_cmd ("line", class_trace, trace_find_line_command, _("\
5265 Select a trace frame by source line.\n\
5266 Argument can be a line number (with optional source file),\n\
5267 a function name, or '*' followed by an address.\n\
5268 Default argument is 'the next source line that was traced'."),
5269            &tfindlist);
5270
5271   add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5272 Select a trace frame by tracepoint number.\n\
5273 Default is the tracepoint for the current trace frame."),
5274            &tfindlist);
5275
5276   add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5277 Select a trace frame by PC.\n\
5278 Default is the current PC, or the PC of the current trace frame."),
5279            &tfindlist);
5280
5281   add_cmd ("end", class_trace, trace_find_end_command, _("\
5282 Synonym for 'none'.\n\
5283 De-select any trace frame and resume 'live' debugging."),
5284            &tfindlist);
5285
5286   add_cmd ("none", class_trace, trace_find_none_command,
5287            _("De-select any trace frame and resume 'live' debugging."),
5288            &tfindlist);
5289
5290   add_cmd ("start", class_trace, trace_find_start_command,
5291            _("Select the first trace frame in the trace buffer."),
5292            &tfindlist);
5293
5294   add_com ("tstatus", class_trace, trace_status_command,
5295            _("Display the status of the current trace data collection."));
5296
5297   add_com ("tstop", class_trace, trace_stop_command, _("\
5298 Stop trace data collection.\n\
5299 Usage: tstop [ <notes> ... ]\n\
5300 Any arguments supplied are recorded with the trace as a stop reason and\n\
5301 reported by tstatus (if the target supports trace notes)."));
5302
5303   add_com ("tstart", class_trace, trace_start_command, _("\
5304 Start trace data collection.\n\
5305 Usage: tstart [ <notes> ... ]\n\
5306 Any arguments supplied are recorded with the trace as a note and\n\
5307 reported by tstatus (if the target supports trace notes)."));
5308
5309   add_com ("end", class_trace, end_actions_pseudocommand, _("\
5310 Ends a list of commands or actions.\n\
5311 Several GDB commands allow you to enter a list of commands or actions.\n\
5312 Entering \"end\" on a line by itself is the normal way to terminate\n\
5313 such a list.\n\n\
5314 Note: the \"end\" command cannot be used at the gdb prompt."));
5315
5316   add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5317 Specify single-stepping behavior at a tracepoint.\n\
5318 Argument is number of instructions to trace in single-step mode\n\
5319 following the tracepoint.  This command is normally followed by\n\
5320 one or more \"collect\" commands, to specify what to collect\n\
5321 while single-stepping.\n\n\
5322 Note: this command can only be used in a tracepoint \"actions\" list."));
5323
5324   add_com_alias ("ws", "while-stepping", class_alias, 0);
5325   add_com_alias ("stepping", "while-stepping", class_alias, 0);
5326
5327   add_com ("collect", class_trace, collect_pseudocommand, _("\
5328 Specify one or more data items to be collected at a tracepoint.\n\
5329 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
5330 collect all data (variables, registers) referenced by that expression.\n\
5331 Also accepts the following special arguments:\n\
5332     $regs   -- all registers.\n\
5333     $args   -- all function arguments.\n\
5334     $locals -- all variables local to the block/function scope.\n\
5335     $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5336 Note: this command can only be used in a tracepoint \"actions\" list."));
5337
5338   add_com ("teval", class_trace, teval_pseudocommand, _("\
5339 Specify one or more expressions to be evaluated at a tracepoint.\n\
5340 Accepts a comma-separated list of (one or more) expressions.\n\
5341 The result of each evaluation will be discarded.\n\
5342 Note: this command can only be used in a tracepoint \"actions\" list."));
5343
5344   add_com ("actions", class_trace, trace_actions_command, _("\
5345 Specify the actions to be taken at a tracepoint.\n\
5346 Tracepoint actions may include collecting of specified data,\n\
5347 single-stepping, or enabling/disabling other tracepoints,\n\
5348 depending on target's capabilities."));
5349
5350   default_collect = xstrdup ("");
5351   add_setshow_string_cmd ("default-collect", class_trace,
5352                           &default_collect, _("\
5353 Set the list of expressions to collect by default"), _("\
5354 Show the list of expressions to collect by default"), NULL,
5355                           NULL, NULL,
5356                           &setlist, &showlist);
5357
5358   add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5359                            &disconnected_tracing, _("\
5360 Set whether tracing continues after GDB disconnects."), _("\
5361 Show whether tracing continues after GDB disconnects."), _("\
5362 Use this to continue a tracing run even if GDB disconnects\n\
5363 or detaches from the target.  You can reconnect later and look at\n\
5364 trace data collected in the meantime."),
5365                            set_disconnected_tracing,
5366                            NULL,
5367                            &setlist,
5368                            &showlist);
5369
5370   add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5371                            &circular_trace_buffer, _("\
5372 Set target's use of circular trace buffer."), _("\
5373 Show target's use of circular trace buffer."), _("\
5374 Use this to make the trace buffer into a circular buffer,\n\
5375 which will discard traceframes (oldest first) instead of filling\n\
5376 up and stopping the trace run."),
5377                            set_circular_trace_buffer,
5378                            NULL,
5379                            &setlist,
5380                            &showlist);
5381
5382   add_setshow_string_cmd ("trace-user", class_trace,
5383                           &trace_user, _("\
5384 Set the user name to use for current and future trace runs"), _("\
5385 Show the user name to use for current and future trace runs"), NULL,
5386                           set_trace_user, NULL,
5387                           &setlist, &showlist);
5388
5389   add_setshow_string_cmd ("trace-notes", class_trace,
5390                           &trace_notes, _("\
5391 Set notes string to use for current and future trace runs"), _("\
5392 Show the notes string to use for current and future trace runs"), NULL,
5393                           set_trace_notes, NULL,
5394                           &setlist, &showlist);
5395
5396   add_setshow_string_cmd ("trace-stop-notes", class_trace,
5397                           &trace_stop_notes, _("\
5398 Set notes string to use for future tstop commands"), _("\
5399 Show the notes string to use for future tstop commands"), NULL,
5400                           set_trace_stop_notes, NULL,
5401                           &setlist, &showlist);
5402
5403   init_tfile_ops ();
5404
5405   add_target (&tfile_ops);
5406 }