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_tracepoint_num (-1);
2216   set_traceframe_context (NULL);
2217 }
2218
2219 /* Worker function for the various flavors of the tfind command.  */
2220 void
2221 tfind_1 (enum trace_find_type type, int num,
2222          ULONGEST addr1, ULONGEST addr2,
2223          int from_tty)
2224 {
2225   int target_frameno = -1, target_tracept = -1;
2226   struct frame_id old_frame_id = null_frame_id;
2227   struct tracepoint *tp;
2228   struct ui_out *uiout = current_uiout;
2229
2230   /* Only try to get the current stack frame if we have a chance of
2231      succeeding.  In particular, if we're trying to get a first trace
2232      frame while all threads are running, it's not going to succeed,
2233      so leave it with a default value and let the frame comparison
2234      below (correctly) decide to print out the source location of the
2235      trace frame.  */
2236   if (!(type == tfind_number && num == -1)
2237       && (has_stack_frames () || traceframe_number >= 0))
2238     old_frame_id = get_frame_id (get_current_frame ());
2239
2240   target_frameno = target_trace_find (type, num, addr1, addr2,
2241                                       &target_tracept);
2242
2243   if (type == tfind_number
2244       && num == -1
2245       && target_frameno == -1)
2246     {
2247       /* We told the target to get out of tfind mode, and it did.  */
2248     }
2249   else if (target_frameno == -1)
2250     {
2251       /* A request for a non-existent trace frame has failed.
2252          Our response will be different, depending on FROM_TTY:
2253
2254          If FROM_TTY is true, meaning that this command was
2255          typed interactively by the user, then give an error
2256          and DO NOT change the state of traceframe_number etc.
2257
2258          However if FROM_TTY is false, meaning that we're either
2259          in a script, a loop, or a user-defined command, then
2260          DON'T give an error, but DO change the state of
2261          traceframe_number etc. to invalid.
2262
2263          The rationalle is that if you typed the command, you
2264          might just have committed a typo or something, and you'd
2265          like to NOT lose your current debugging state.  However
2266          if you're in a user-defined command or especially in a
2267          loop, then you need a way to detect that the command
2268          failed WITHOUT aborting.  This allows you to write
2269          scripts that search thru the trace buffer until the end,
2270          and then continue on to do something else.  */
2271
2272       if (from_tty)
2273         error (_("Target failed to find requested trace frame."));
2274       else
2275         {
2276           if (info_verbose)
2277             printf_filtered ("End of trace buffer.\n");
2278 #if 0 /* dubious now?  */
2279           /* The following will not recurse, since it's
2280              special-cased.  */
2281           trace_find_command ("-1", from_tty);
2282 #endif
2283         }
2284     }
2285
2286   tp = get_tracepoint_by_number_on_target (target_tracept);
2287
2288   reinit_frame_cache ();
2289   target_dcache_invalidate ();
2290
2291   set_current_traceframe (target_frameno);
2292
2293   set_tracepoint_num (tp ? tp->base.number : target_tracept);
2294   if (target_frameno == -1)
2295     set_traceframe_context (NULL);
2296   else
2297     set_traceframe_context (get_current_frame ());
2298
2299   if (traceframe_number >= 0)
2300     {
2301       /* Use different branches for MI and CLI to make CLI messages
2302          i18n-eable.  */
2303       if (ui_out_is_mi_like_p (uiout))
2304         {
2305           ui_out_field_string (uiout, "found", "1");
2306           ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2307           ui_out_field_int (uiout, "traceframe", traceframe_number);
2308         }
2309       else
2310         {
2311           printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2312                              traceframe_number, tracepoint_number);
2313         }
2314     }
2315   else
2316     {
2317       if (ui_out_is_mi_like_p (uiout))
2318         ui_out_field_string (uiout, "found", "0");
2319       else if (type == tfind_number && num == -1)
2320         printf_unfiltered (_("No longer looking at any trace frame\n"));
2321       else /* This case may never occur, check.  */
2322         printf_unfiltered (_("No trace frame found\n"));
2323     }
2324
2325   /* If we're in nonstop mode and getting out of looking at trace
2326      frames, there won't be any current frame to go back to and
2327      display.  */
2328   if (from_tty
2329       && (has_stack_frames () || traceframe_number >= 0))
2330     {
2331       enum print_what print_what;
2332
2333       /* NOTE: in imitation of the step command, try to determine
2334          whether we have made a transition from one function to
2335          another.  If so, we'll print the "stack frame" (ie. the new
2336          function and it's arguments) -- otherwise we'll just show the
2337          new source line.  */
2338
2339       if (frame_id_eq (old_frame_id,
2340                        get_frame_id (get_current_frame ())))
2341         print_what = SRC_LINE;
2342       else
2343         print_what = SRC_AND_LOC;
2344
2345       print_stack_frame (get_selected_frame (NULL), 1, print_what);
2346       do_displays ();
2347     }
2348 }
2349
2350 /* trace_find_command takes a trace frame number n,
2351    sends "QTFrame:<n>" to the target,
2352    and accepts a reply that may contain several optional pieces
2353    of information: a frame number, a tracepoint number, and an
2354    indication of whether this is a trap frame or a stepping frame.
2355
2356    The minimal response is just "OK" (which indicates that the
2357    target does not give us a frame number or a tracepoint number).
2358    Instead of that, the target may send us a string containing
2359    any combination of:
2360    F<hexnum>    (gives the selected frame number)
2361    T<hexnum>    (gives the selected tracepoint number)
2362  */
2363
2364 /* tfind command */
2365 static void
2366 trace_find_command (char *args, int from_tty)
2367 { /* This should only be called with a numeric argument.  */
2368   int frameno = -1;
2369
2370   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2371     error (_("May not look at trace frames while trace is running."));
2372
2373   if (args == 0 || *args == 0)
2374     { /* TFIND with no args means find NEXT trace frame.  */
2375       if (traceframe_number == -1)
2376         frameno = 0;    /* "next" is first one.  */
2377         else
2378         frameno = traceframe_number + 1;
2379     }
2380   else if (0 == strcmp (args, "-"))
2381     {
2382       if (traceframe_number == -1)
2383         error (_("not debugging trace buffer"));
2384       else if (from_tty && traceframe_number == 0)
2385         error (_("already at start of trace buffer"));
2386
2387       frameno = traceframe_number - 1;
2388       }
2389   /* A hack to work around eval's need for fp to have been collected.  */
2390   else if (0 == strcmp (args, "-1"))
2391     frameno = -1;
2392   else
2393     frameno = parse_and_eval_long (args);
2394
2395   if (frameno < -1)
2396     error (_("invalid input (%d is less than zero)"), frameno);
2397
2398   tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2399 }
2400
2401 /* tfind end */
2402 static void
2403 trace_find_end_command (char *args, int from_tty)
2404 {
2405   trace_find_command ("-1", from_tty);
2406 }
2407
2408 /* tfind start */
2409 static void
2410 trace_find_start_command (char *args, int from_tty)
2411 {
2412   trace_find_command ("0", from_tty);
2413 }
2414
2415 /* tfind pc command */
2416 static void
2417 trace_find_pc_command (char *args, int from_tty)
2418 {
2419   CORE_ADDR pc;
2420
2421   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2422     error (_("May not look at trace frames while trace is running."));
2423
2424   if (args == 0 || *args == 0)
2425     pc = regcache_read_pc (get_current_regcache ());
2426   else
2427     pc = parse_and_eval_address (args);
2428
2429   tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2430 }
2431
2432 /* tfind tracepoint command */
2433 static void
2434 trace_find_tracepoint_command (char *args, int from_tty)
2435 {
2436   int tdp;
2437   struct tracepoint *tp;
2438
2439   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2440     error (_("May not look at trace frames while trace is running."));
2441
2442   if (args == 0 || *args == 0)
2443     {
2444       if (tracepoint_number == -1)
2445         error (_("No current tracepoint -- please supply an argument."));
2446       else
2447         tdp = tracepoint_number;        /* Default is current TDP.  */
2448     }
2449   else
2450     tdp = parse_and_eval_long (args);
2451
2452   /* If we have the tracepoint on hand, use the number that the
2453      target knows about (which may be different if we disconnected
2454      and reconnected).  */
2455   tp = get_tracepoint (tdp);
2456   if (tp)
2457     tdp = tp->number_on_target;
2458
2459   tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2460 }
2461
2462 /* TFIND LINE command:
2463
2464    This command will take a sourceline for argument, just like BREAK
2465    or TRACE (ie. anything that "decode_line_1" can handle).
2466
2467    With no argument, this command will find the next trace frame
2468    corresponding to a source line OTHER THAN THE CURRENT ONE.  */
2469
2470 static void
2471 trace_find_line_command (char *args, int from_tty)
2472 {
2473   static CORE_ADDR start_pc, end_pc;
2474   struct symtabs_and_lines sals;
2475   struct symtab_and_line sal;
2476   struct cleanup *old_chain;
2477
2478   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2479     error (_("May not look at trace frames while trace is running."));
2480
2481   if (args == 0 || *args == 0)
2482     {
2483       sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2484       sals.nelts = 1;
2485       sals.sals = (struct symtab_and_line *)
2486         xmalloc (sizeof (struct symtab_and_line));
2487       sals.sals[0] = sal;
2488     }
2489   else
2490     {
2491       sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2492       sal = sals.sals[0];
2493     }
2494
2495   old_chain = make_cleanup (xfree, sals.sals);
2496   if (sal.symtab == 0)
2497     error (_("No line number information available."));
2498
2499   if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2500     {
2501       if (start_pc == end_pc)
2502         {
2503           printf_filtered ("Line %d of \"%s\"",
2504                            sal.line, sal.symtab->filename);
2505           wrap_here ("  ");
2506           printf_filtered (" is at address ");
2507           print_address (get_current_arch (), start_pc, gdb_stdout);
2508           wrap_here ("  ");
2509           printf_filtered (" but contains no code.\n");
2510           sal = find_pc_line (start_pc, 0);
2511           if (sal.line > 0
2512               && find_line_pc_range (sal, &start_pc, &end_pc)
2513               && start_pc != end_pc)
2514             printf_filtered ("Attempting to find line %d instead.\n",
2515                              sal.line);
2516           else
2517             error (_("Cannot find a good line."));
2518         }
2519       }
2520     else
2521     /* Is there any case in which we get here, and have an address
2522        which the user would want to see?  If we have debugging
2523        symbols and no line numbers?  */
2524     error (_("Line number %d is out of range for \"%s\"."),
2525            sal.line, sal.symtab->filename);
2526
2527   /* Find within range of stated line.  */
2528   if (args && *args)
2529     tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2530   else
2531     tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2532   do_cleanups (old_chain);
2533 }
2534
2535 /* tfind range command */
2536 static void
2537 trace_find_range_command (char *args, int from_tty)
2538 {
2539   static CORE_ADDR start, stop;
2540   char *tmp;
2541
2542   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2543     error (_("May not look at trace frames while trace is running."));
2544
2545   if (args == 0 || *args == 0)
2546     { /* XXX FIXME: what should default behavior be?  */
2547       printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2548       return;
2549     }
2550
2551   if (0 != (tmp = strchr (args, ',')))
2552     {
2553       *tmp++ = '\0';    /* Terminate start address.  */
2554       while (isspace ((int) *tmp))
2555         tmp++;
2556       start = parse_and_eval_address (args);
2557       stop = parse_and_eval_address (tmp);
2558     }
2559   else
2560     {                   /* No explicit end address?  */
2561       start = parse_and_eval_address (args);
2562       stop = start + 1; /* ??? */
2563     }
2564
2565   tfind_1 (tfind_range, 0, start, stop, from_tty);
2566 }
2567
2568 /* tfind outside command */
2569 static void
2570 trace_find_outside_command (char *args, int from_tty)
2571 {
2572   CORE_ADDR start, stop;
2573   char *tmp;
2574
2575   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2576     error (_("May not look at trace frames while trace is running."));
2577
2578   if (args == 0 || *args == 0)
2579     { /* XXX FIXME: what should default behavior be?  */
2580       printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2581       return;
2582     }
2583
2584   if (0 != (tmp = strchr (args, ',')))
2585     {
2586       *tmp++ = '\0';    /* Terminate start address.  */
2587       while (isspace ((int) *tmp))
2588         tmp++;
2589       start = parse_and_eval_address (args);
2590       stop = parse_and_eval_address (tmp);
2591     }
2592   else
2593     {                   /* No explicit end address?  */
2594       start = parse_and_eval_address (args);
2595       stop = start + 1; /* ??? */
2596     }
2597
2598   tfind_1 (tfind_outside, 0, start, stop, from_tty);
2599 }
2600
2601 /* info scope command: list the locals for a scope.  */
2602 static void
2603 scope_info (char *args, int from_tty)
2604 {
2605   struct symtabs_and_lines sals;
2606   struct symbol *sym;
2607   struct minimal_symbol *msym;
2608   struct block *block;
2609   const char *symname;
2610   char *save_args = args;
2611   struct block_iterator iter;
2612   int j, count = 0;
2613   struct gdbarch *gdbarch;
2614   int regno;
2615
2616   if (args == 0 || *args == 0)
2617     error (_("requires an argument (function, "
2618              "line or *addr) to define a scope"));
2619
2620   sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2621   if (sals.nelts == 0)
2622     return;             /* Presumably decode_line_1 has already warned.  */
2623
2624   /* Resolve line numbers to PC.  */
2625   resolve_sal_pc (&sals.sals[0]);
2626   block = block_for_pc (sals.sals[0].pc);
2627
2628   while (block != 0)
2629     {
2630       QUIT;                     /* Allow user to bail out with ^C.  */
2631       ALL_BLOCK_SYMBOLS (block, iter, sym)
2632         {
2633           QUIT;                 /* Allow user to bail out with ^C.  */
2634           if (count == 0)
2635             printf_filtered ("Scope for %s:\n", save_args);
2636           count++;
2637
2638           symname = SYMBOL_PRINT_NAME (sym);
2639           if (symname == NULL || *symname == '\0')
2640             continue;           /* Probably botched, certainly useless.  */
2641
2642           gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2643
2644           printf_filtered ("Symbol %s is ", symname);
2645           switch (SYMBOL_CLASS (sym))
2646             {
2647             default:
2648             case LOC_UNDEF:     /* Messed up symbol?  */
2649               printf_filtered ("a bogus symbol, class %d.\n",
2650                                SYMBOL_CLASS (sym));
2651               count--;          /* Don't count this one.  */
2652               continue;
2653             case LOC_CONST:
2654               printf_filtered ("a constant with value %s (%s)",
2655                                plongest (SYMBOL_VALUE (sym)),
2656                                hex_string (SYMBOL_VALUE (sym)));
2657               break;
2658             case LOC_CONST_BYTES:
2659               printf_filtered ("constant bytes: ");
2660               if (SYMBOL_TYPE (sym))
2661                 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2662                   fprintf_filtered (gdb_stdout, " %02x",
2663                                     (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2664               break;
2665             case LOC_STATIC:
2666               printf_filtered ("in static storage at address ");
2667               printf_filtered ("%s", paddress (gdbarch,
2668                                                SYMBOL_VALUE_ADDRESS (sym)));
2669               break;
2670             case LOC_REGISTER:
2671               /* GDBARCH is the architecture associated with the objfile
2672                  the symbol is defined in; the target architecture may be
2673                  different, and may provide additional registers.  However,
2674                  we do not know the target architecture at this point.
2675                  We assume the objfile architecture will contain all the
2676                  standard registers that occur in debug info in that
2677                  objfile.  */
2678               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2679                                                                   gdbarch);
2680
2681               if (SYMBOL_IS_ARGUMENT (sym))
2682                 printf_filtered ("an argument in register $%s",
2683                                  gdbarch_register_name (gdbarch, regno));
2684               else
2685                 printf_filtered ("a local variable in register $%s",
2686                                  gdbarch_register_name (gdbarch, regno));
2687               break;
2688             case LOC_ARG:
2689               printf_filtered ("an argument at stack/frame offset %s",
2690                                plongest (SYMBOL_VALUE (sym)));
2691               break;
2692             case LOC_LOCAL:
2693               printf_filtered ("a local variable at frame offset %s",
2694                                plongest (SYMBOL_VALUE (sym)));
2695               break;
2696             case LOC_REF_ARG:
2697               printf_filtered ("a reference argument at offset %s",
2698                                plongest (SYMBOL_VALUE (sym)));
2699               break;
2700             case LOC_REGPARM_ADDR:
2701               /* Note comment at LOC_REGISTER.  */
2702               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2703                                                                   gdbarch);
2704               printf_filtered ("the address of an argument, in register $%s",
2705                                gdbarch_register_name (gdbarch, regno));
2706               break;
2707             case LOC_TYPEDEF:
2708               printf_filtered ("a typedef.\n");
2709               continue;
2710             case LOC_LABEL:
2711               printf_filtered ("a label at address ");
2712               printf_filtered ("%s", paddress (gdbarch,
2713                                                SYMBOL_VALUE_ADDRESS (sym)));
2714               break;
2715             case LOC_BLOCK:
2716               printf_filtered ("a function at address ");
2717               printf_filtered ("%s",
2718                 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2719               break;
2720             case LOC_UNRESOLVED:
2721               msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2722                                             NULL, NULL);
2723               if (msym == NULL)
2724                 printf_filtered ("Unresolved Static");
2725               else
2726                 {
2727                   printf_filtered ("static storage at address ");
2728                   printf_filtered ("%s",
2729                     paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2730                 }
2731               break;
2732             case LOC_OPTIMIZED_OUT:
2733               printf_filtered ("optimized out.\n");
2734               continue;
2735             case LOC_COMPUTED:
2736               SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2737                                                             BLOCK_START (block),
2738                                                             gdb_stdout);
2739               break;
2740             }
2741           if (SYMBOL_TYPE (sym))
2742             printf_filtered (", length %d.\n",
2743                              TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2744         }
2745       if (BLOCK_FUNCTION (block))
2746         break;
2747       else
2748         block = BLOCK_SUPERBLOCK (block);
2749     }
2750   if (count <= 0)
2751     printf_filtered ("Scope for %s contains no locals or arguments.\n",
2752                      save_args);
2753 }
2754
2755 /* worker function (cleanup) */
2756 static void
2757 replace_comma (void *data)
2758 {
2759   char *comma = data;
2760   *comma = ',';
2761 }
2762
2763
2764 /* Helper for trace_dump_command.  Dump the action list starting at
2765    ACTION.  STEPPING_ACTIONS is true if we're iterating over the
2766    actions of the body of a while-stepping action.  STEPPING_FRAME is
2767    set if the current traceframe was determined to be a while-stepping
2768    traceframe.  */
2769
2770 static void
2771 trace_dump_actions (struct command_line *action,
2772                     int stepping_actions, int stepping_frame,
2773                     int from_tty)
2774 {
2775   char *action_exp, *next_comma;
2776
2777   for (; action != NULL; action = action->next)
2778     {
2779       struct cmd_list_element *cmd;
2780
2781       QUIT;                     /* Allow user to bail out with ^C.  */
2782       action_exp = action->line;
2783       while (isspace ((int) *action_exp))
2784         action_exp++;
2785
2786       /* The collection actions to be done while stepping are
2787          bracketed by the commands "while-stepping" and "end".  */
2788
2789       if (*action_exp == '#')   /* comment line */
2790         continue;
2791
2792       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2793       if (cmd == 0)
2794         error (_("Bad action list item: %s"), action_exp);
2795
2796       if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2797         {
2798           int i;
2799
2800           for (i = 0; i < action->body_count; ++i)
2801             trace_dump_actions (action->body_list[i],
2802                                 1, stepping_frame, from_tty);
2803         }
2804       else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2805         {
2806           /* Display the collected data.
2807              For the trap frame, display only what was collected at
2808              the trap.  Likewise for stepping frames, display only
2809              what was collected while stepping.  This means that the
2810              two boolean variables, STEPPING_FRAME and
2811              STEPPING_ACTIONS should be equal.  */
2812           if (stepping_frame == stepping_actions)
2813             {
2814               if (*action_exp == '/')
2815                 action_exp = decode_agent_options (action_exp);
2816
2817               do
2818                 {               /* Repeat over a comma-separated list.  */
2819                   QUIT;         /* Allow user to bail out with ^C.  */
2820                   if (*action_exp == ',')
2821                     action_exp++;
2822                   while (isspace ((int) *action_exp))
2823                     action_exp++;
2824
2825                   next_comma = strchr (action_exp, ',');
2826
2827                   if (0 == strncasecmp (action_exp, "$reg", 4))
2828                     registers_info (NULL, from_tty);
2829                   else if (0 == strncasecmp (action_exp, "$_ret", 5))
2830                     ;
2831                   else if (0 == strncasecmp (action_exp, "$loc", 4))
2832                     locals_info (NULL, from_tty);
2833                   else if (0 == strncasecmp (action_exp, "$arg", 4))
2834                     args_info (NULL, from_tty);
2835                   else
2836                     {           /* variable */
2837                       if (next_comma)
2838                         {
2839                           make_cleanup (replace_comma, next_comma);
2840                           *next_comma = '\0';
2841                         }
2842                       printf_filtered ("%s = ", action_exp);
2843                       output_command (action_exp, from_tty);
2844                       printf_filtered ("\n");
2845                     }
2846                   if (next_comma)
2847                     *next_comma = ',';
2848                   action_exp = next_comma;
2849                 }
2850               while (action_exp && *action_exp == ',');
2851             }
2852         }
2853     }
2854 }
2855
2856 /* The tdump command.  */
2857
2858 static void
2859 trace_dump_command (char *args, int from_tty)
2860 {
2861   struct regcache *regcache;
2862   struct tracepoint *t;
2863   int stepping_frame = 0;
2864   struct bp_location *loc;
2865   char *line, *default_collect_line = NULL;
2866   struct command_line *actions, *default_collect_action = NULL;
2867   struct cleanup *old_chain = NULL;
2868
2869   if (tracepoint_number == -1)
2870     {
2871       warning (_("No current trace frame."));
2872       return;
2873     }
2874
2875   t = get_tracepoint (tracepoint_number);
2876
2877   if (t == NULL)
2878     error (_("No known tracepoint matches 'current' tracepoint #%d."),
2879            tracepoint_number);
2880
2881   printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2882                    tracepoint_number, traceframe_number);
2883
2884   /* The current frame is a trap frame if the frame PC is equal
2885      to the tracepoint PC.  If not, then the current frame was
2886      collected during single-stepping.  */
2887
2888   regcache = get_current_regcache ();
2889
2890   /* If the traceframe's address matches any of the tracepoint's
2891      locations, assume it is a direct hit rather than a while-stepping
2892      frame.  (FIXME this is not reliable, should record each frame's
2893      type.)  */
2894   stepping_frame = 1;
2895   for (loc = t->base.loc; loc; loc = loc->next)
2896     if (loc->address == regcache_read_pc (regcache))
2897       stepping_frame = 0;
2898
2899   actions = breakpoint_commands (&t->base);
2900
2901   /* If there is a default-collect list, make up a collect command,
2902      prepend to the tracepoint's commands, and pass the whole mess to
2903      the trace dump scanner.  We need to validate because
2904      default-collect might have been junked since the trace run.  */
2905   if (*default_collect)
2906     {
2907       default_collect_line = xstrprintf ("collect %s", default_collect);
2908       old_chain = make_cleanup (xfree, default_collect_line);
2909       line = default_collect_line;
2910       validate_actionline (&line, &t->base);
2911       default_collect_action = xmalloc (sizeof (struct command_line));
2912       make_cleanup (xfree, default_collect_action);
2913       default_collect_action->next = actions;
2914       default_collect_action->line = line;
2915       actions = default_collect_action;
2916     }
2917
2918   trace_dump_actions (actions, 0, stepping_frame, from_tty);
2919
2920   if (*default_collect)
2921     do_cleanups (old_chain);
2922 }
2923
2924 /* Encode a piece of a tracepoint's source-level definition in a form
2925    that is suitable for both protocol and saving in files.  */
2926 /* This version does not do multiple encodes for long strings; it should
2927    return an offset to the next piece to encode.  FIXME  */
2928
2929 extern int
2930 encode_source_string (int tpnum, ULONGEST addr,
2931                       char *srctype, char *src, char *buf, int buf_size)
2932 {
2933   if (80 + strlen (srctype) > buf_size)
2934     error (_("Buffer too small for source encoding"));
2935   sprintf (buf, "%x:%s:%s:%x:%x:",
2936            tpnum, phex_nz (addr, sizeof (addr)),
2937            srctype, 0, (int) strlen (src));
2938   if (strlen (buf) + strlen (src) * 2 >= buf_size)
2939     error (_("Source string too long for buffer"));
2940   bin2hex (src, buf + strlen (buf), 0);
2941   return -1;
2942 }
2943
2944 extern int trace_regblock_size;
2945
2946 /* Save tracepoint data to file named FILENAME.  If TARGET_DOES_SAVE is
2947    non-zero, the save is performed on the target, otherwise GDB obtains all
2948    trace data and saves it locally.  */
2949
2950 void
2951 trace_save (const char *filename, int target_does_save)
2952 {
2953   struct cleanup *cleanup;
2954   char *pathname;
2955   struct trace_status *ts = current_trace_status ();
2956   int err, status;
2957   FILE *fp;
2958   struct uploaded_tp *uploaded_tps = NULL, *utp;
2959   struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2960   int a;
2961   char *act;
2962   LONGEST gotten = 0;
2963   ULONGEST offset = 0;
2964 #define MAX_TRACE_UPLOAD 2000
2965   gdb_byte buf[MAX_TRACE_UPLOAD];
2966   int written;
2967
2968   /* If the target is to save the data to a file on its own, then just
2969      send the command and be done with it.  */
2970   if (target_does_save)
2971     {
2972       err = target_save_trace_data (filename);
2973       if (err < 0)
2974         error (_("Target failed to save trace data to '%s'."),
2975                filename);
2976       return;
2977     }
2978
2979   /* Get the trace status first before opening the file, so if the
2980      target is losing, we can get out without touching files.  */
2981   status = target_get_trace_status (ts);
2982
2983   pathname = tilde_expand (filename);
2984   cleanup = make_cleanup (xfree, pathname);
2985
2986   fp = fopen (pathname, "wb");
2987   if (!fp)
2988     error (_("Unable to open file '%s' for saving trace data (%s)"),
2989            filename, safe_strerror (errno));
2990   make_cleanup_fclose (fp);
2991
2992   /* Write a file header, with a high-bit-set char to indicate a
2993      binary file, plus a hint as what this file is, and a version
2994      number in case of future needs.  */
2995   written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2996   if (written < 1)
2997     perror_with_name (pathname);
2998
2999   /* Write descriptive info.  */
3000
3001   /* Write out the size of a register block.  */
3002   fprintf (fp, "R %x\n", trace_regblock_size);
3003
3004   /* Write out status of the tracing run (aka "tstatus" info).  */
3005   fprintf (fp, "status %c;%s",
3006            (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3007   if (ts->stop_reason == tracepoint_error)
3008     {
3009       char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3010
3011       bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3012       fprintf (fp, ":%s", buf);
3013     }
3014   fprintf (fp, ":%x", ts->stopping_tracepoint);
3015   if (ts->traceframe_count >= 0)
3016     fprintf (fp, ";tframes:%x", ts->traceframe_count);
3017   if (ts->traceframes_created >= 0)
3018     fprintf (fp, ";tcreated:%x", ts->traceframes_created);
3019   if (ts->buffer_free >= 0)
3020     fprintf (fp, ";tfree:%x", ts->buffer_free);
3021   if (ts->buffer_size >= 0)
3022     fprintf (fp, ";tsize:%x", ts->buffer_size);
3023   if (ts->disconnected_tracing)
3024     fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
3025   if (ts->circular_buffer)
3026     fprintf (fp, ";circular:%x", ts->circular_buffer);
3027   fprintf (fp, "\n");
3028
3029   /* Note that we want to upload tracepoints and save those, rather
3030      than simply writing out the local ones, because the user may have
3031      changed tracepoints in GDB in preparation for a future tracing
3032      run, or maybe just mass-deleted all types of breakpoints as part
3033      of cleaning up.  So as not to contaminate the session, leave the
3034      data in its uploaded form, don't make into real tracepoints.  */
3035
3036   /* Get trace state variables first, they may be checked when parsing
3037      uploaded commands.  */
3038
3039   target_upload_trace_state_variables (&uploaded_tsvs);
3040
3041   for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3042     {
3043       char *buf = "";
3044
3045       if (utsv->name)
3046         {
3047           buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3048           bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3049         }
3050
3051       fprintf (fp, "tsv %x:%s:%x:%s\n",
3052                utsv->number, phex_nz (utsv->initial_value, 8),
3053                utsv->builtin, buf);
3054
3055       if (utsv->name)
3056         xfree (buf);
3057     }
3058
3059   free_uploaded_tsvs (&uploaded_tsvs);
3060
3061   target_upload_tracepoints (&uploaded_tps);
3062
3063   for (utp = uploaded_tps; utp; utp = utp->next)
3064     target_get_tracepoint_status (NULL, utp);
3065
3066   for (utp = uploaded_tps; utp; utp = utp->next)
3067     {
3068       fprintf (fp, "tp T%x:%s:%c:%x:%x",
3069                utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3070                (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3071       if (utp->type == bp_fast_tracepoint)
3072         fprintf (fp, ":F%x", utp->orig_size);
3073       if (utp->cond)
3074         fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3075                  utp->cond);
3076       fprintf (fp, "\n");
3077       for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3078         fprintf (fp, "tp A%x:%s:%s\n",
3079                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3080       for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3081         fprintf (fp, "tp S%x:%s:%s\n",
3082                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3083       if (utp->at_string)
3084         {
3085           encode_source_string (utp->number, utp->addr,
3086                                 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3087           fprintf (fp, "tp Z%s\n", buf);
3088         }
3089       if (utp->cond_string)
3090         {
3091           encode_source_string (utp->number, utp->addr,
3092                                 "cond", utp->cond_string,
3093                                 buf, MAX_TRACE_UPLOAD);
3094           fprintf (fp, "tp Z%s\n", buf);
3095         }
3096       for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3097         {
3098           encode_source_string (utp->number, utp->addr, "cmd", act,
3099                                 buf, MAX_TRACE_UPLOAD);
3100           fprintf (fp, "tp Z%s\n", buf);
3101         }
3102       fprintf (fp, "tp V%x:%s:%x:%s\n",
3103                utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3104                utp->hit_count,
3105                phex_nz (utp->traceframe_usage,
3106                         sizeof (utp->traceframe_usage)));
3107     }
3108
3109   free_uploaded_tps (&uploaded_tps);
3110
3111   /* Mark the end of the definition section.  */
3112   fprintf (fp, "\n");
3113
3114   /* Get and write the trace data proper.  We ask for big blocks, in
3115      the hopes of efficiency, but will take less if the target has
3116      packet size limitations or some such.  */
3117   while (1)
3118     {
3119       gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
3120       if (gotten < 0)
3121         error (_("Failure to get requested trace buffer data"));
3122       /* No more data is forthcoming, we're done.  */
3123       if (gotten == 0)
3124         break;
3125       written = fwrite (buf, gotten, 1, fp);
3126       if (written < 1)
3127         perror_with_name (pathname);
3128       offset += gotten;
3129     }
3130
3131   /* Mark the end of trace data.  (We know that gotten is 0 at this point.)  */
3132   written = fwrite (&gotten, 4, 1, fp);
3133   if (written < 1)
3134     perror_with_name (pathname);
3135
3136   do_cleanups (cleanup);
3137 }
3138
3139 static void
3140 trace_save_command (char *args, int from_tty)
3141 {
3142   int target_does_save = 0;
3143   char **argv;
3144   char *filename = NULL;
3145   struct cleanup *back_to;
3146
3147   if (args == NULL)
3148     error_no_arg (_("file in which to save trace data"));
3149
3150   argv = gdb_buildargv (args);
3151   back_to = make_cleanup_freeargv (argv);
3152
3153   for (; *argv; ++argv)
3154     {
3155       if (strcmp (*argv, "-r") == 0)
3156         target_does_save = 1;
3157       else if (**argv == '-')
3158         error (_("unknown option `%s'"), *argv);
3159       else
3160         filename = *argv;
3161     }
3162
3163   if (!filename)
3164     error_no_arg (_("file in which to save trace data"));
3165
3166   trace_save (filename, target_does_save);
3167
3168   if (from_tty)
3169     printf_filtered (_("Trace data saved to file '%s'.\n"), filename);
3170
3171   do_cleanups (back_to);
3172 }
3173
3174 /* Tell the target what to do with an ongoing tracing run if GDB
3175    disconnects for some reason.  */
3176
3177 static void
3178 set_disconnected_tracing (char *args, int from_tty,
3179                           struct cmd_list_element *c)
3180 {
3181   target_set_disconnected_tracing (disconnected_tracing);
3182 }
3183
3184 static void
3185 set_circular_trace_buffer (char *args, int from_tty,
3186                            struct cmd_list_element *c)
3187 {
3188   target_set_circular_trace_buffer (circular_trace_buffer);
3189 }
3190
3191 static void
3192 set_trace_user (char *args, int from_tty,
3193                 struct cmd_list_element *c)
3194 {
3195   int ret;
3196
3197   ret = target_set_trace_notes (trace_user, NULL, NULL);
3198
3199   if (!ret)
3200     warning (_("Target does not support trace notes, user ignored"));
3201 }
3202
3203 static void
3204 set_trace_notes (char *args, int from_tty,
3205                  struct cmd_list_element *c)
3206 {
3207   int ret;
3208
3209   ret = target_set_trace_notes (NULL, trace_notes, NULL);
3210
3211   if (!ret)
3212     warning (_("Target does not support trace notes, note ignored"));
3213 }
3214
3215 static void
3216 set_trace_stop_notes (char *args, int from_tty,
3217                       struct cmd_list_element *c)
3218 {
3219   int ret;
3220
3221   ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3222
3223   if (!ret)
3224     warning (_("Target does not support trace notes, stop note ignored"));
3225 }
3226
3227 /* Convert the memory pointed to by mem into hex, placing result in buf.
3228  * Return a pointer to the last char put in buf (null)
3229  * "stolen" from sparc-stub.c
3230  */
3231
3232 static const char hexchars[] = "0123456789abcdef";
3233
3234 static char *
3235 mem2hex (gdb_byte *mem, char *buf, int count)
3236 {
3237   gdb_byte ch;
3238
3239   while (count-- > 0)
3240     {
3241       ch = *mem++;
3242
3243       *buf++ = hexchars[ch >> 4];
3244       *buf++ = hexchars[ch & 0xf];
3245     }
3246
3247   *buf = 0;
3248
3249   return buf;
3250 }
3251
3252 int
3253 get_traceframe_number (void)
3254 {
3255   return traceframe_number;
3256 }
3257
3258 /* Make the traceframe NUM be the current trace frame.  Does nothing
3259    if NUM is already current.  */
3260
3261 void
3262 set_current_traceframe (int num)
3263 {
3264   int newnum;
3265
3266   if (traceframe_number == num)
3267     {
3268       /* Nothing to do.  */
3269       return;
3270     }
3271
3272   newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3273
3274   if (newnum != num)
3275     warning (_("could not change traceframe"));
3276
3277   set_traceframe_num (newnum);
3278
3279   /* Changing the traceframe changes our view of registers and of the
3280      frame chain.  */
3281   registers_changed ();
3282
3283   clear_traceframe_info ();
3284 }
3285
3286 /* Make the traceframe NUM be the current trace frame, and do nothing
3287    more.  */
3288
3289 void
3290 set_traceframe_number (int num)
3291 {
3292   traceframe_number = num;
3293 }
3294
3295 /* A cleanup used when switching away and back from tfind mode.  */
3296
3297 struct current_traceframe_cleanup
3298 {
3299   /* The traceframe we were inspecting.  */
3300   int traceframe_number;
3301 };
3302
3303 static void
3304 do_restore_current_traceframe_cleanup (void *arg)
3305 {
3306   struct current_traceframe_cleanup *old = arg;
3307
3308   set_current_traceframe (old->traceframe_number);
3309 }
3310
3311 static void
3312 restore_current_traceframe_cleanup_dtor (void *arg)
3313 {
3314   struct current_traceframe_cleanup *old = arg;
3315
3316   xfree (old);
3317 }
3318
3319 struct cleanup *
3320 make_cleanup_restore_current_traceframe (void)
3321 {
3322   struct current_traceframe_cleanup *old;
3323
3324   old = xmalloc (sizeof (struct current_traceframe_cleanup));
3325   old->traceframe_number = traceframe_number;
3326
3327   return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3328                             restore_current_traceframe_cleanup_dtor);
3329 }
3330
3331 struct cleanup *
3332 make_cleanup_restore_traceframe_number (void)
3333 {
3334   return make_cleanup_restore_integer (&traceframe_number);
3335 }
3336
3337 /* Given a number and address, return an uploaded tracepoint with that
3338    number, creating if necessary.  */
3339
3340 struct uploaded_tp *
3341 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3342 {
3343   struct uploaded_tp *utp;
3344
3345   for (utp = *utpp; utp; utp = utp->next)
3346     if (utp->number == num && utp->addr == addr)
3347       return utp;
3348   utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3349   memset (utp, 0, sizeof (struct uploaded_tp));
3350   utp->number = num;
3351   utp->addr = addr;
3352   utp->actions = NULL;
3353   utp->step_actions = NULL;
3354   utp->cmd_strings = NULL;
3355   utp->next = *utpp;
3356   *utpp = utp;
3357   return utp;
3358 }
3359
3360 static void
3361 free_uploaded_tps (struct uploaded_tp **utpp)
3362 {
3363   struct uploaded_tp *next_one;
3364
3365   while (*utpp)
3366     {
3367       next_one = (*utpp)->next;
3368       xfree (*utpp);
3369       *utpp = next_one;
3370     }
3371 }
3372
3373 /* Given a number and address, return an uploaded tracepoint with that
3374    number, creating if necessary.  */
3375
3376 static struct uploaded_tsv *
3377 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3378 {
3379   struct uploaded_tsv *utsv;
3380
3381   for (utsv = *utsvp; utsv; utsv = utsv->next)
3382     if (utsv->number == num)
3383       return utsv;
3384   utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3385   memset (utsv, 0, sizeof (struct uploaded_tsv));
3386   utsv->number = num;
3387   utsv->next = *utsvp;
3388   *utsvp = utsv;
3389   return utsv;
3390 }
3391
3392 static void
3393 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3394 {
3395   struct uploaded_tsv *next_one;
3396
3397   while (*utsvp)
3398     {
3399       next_one = (*utsvp)->next;
3400       xfree (*utsvp);
3401       *utsvp = next_one;
3402     }
3403 }
3404
3405 /* FIXME this function is heuristic and will miss the cases where the
3406    conditional is semantically identical but differs in whitespace,
3407    such as "x == 0" vs "x==0".  */
3408
3409 static int
3410 cond_string_is_same (char *str1, char *str2)
3411 {
3412   if (str1 == NULL || str2 == NULL)
3413     return (str1 == str2);
3414
3415   return (strcmp (str1, str2) == 0);
3416 }
3417
3418 /* Look for an existing tracepoint that seems similar enough to the
3419    uploaded one.  Enablement isn't compared, because the user can
3420    toggle that freely, and may have done so in anticipation of the
3421    next trace run.  Return the location of matched tracepoint.  */
3422
3423 static struct bp_location *
3424 find_matching_tracepoint_location (struct uploaded_tp *utp)
3425 {
3426   VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3427   int ix;
3428   struct breakpoint *b;
3429   struct bp_location *loc;
3430
3431   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3432     {
3433       struct tracepoint *t = (struct tracepoint *) b;
3434
3435       if (b->type == utp->type
3436           && t->step_count == utp->step
3437           && t->pass_count == utp->pass
3438           && cond_string_is_same (t->base.cond_string, utp->cond_string)
3439           /* FIXME also test actions.  */
3440           )
3441         {
3442           /* Scan the locations for an address match.  */
3443           for (loc = b->loc; loc; loc = loc->next)
3444             {
3445               if (loc->address == utp->addr)
3446                 return loc;
3447             }
3448         }
3449     }
3450   return NULL;
3451 }
3452
3453 /* Given a list of tracepoints uploaded from a target, attempt to
3454    match them up with existing tracepoints, and create new ones if not
3455    found.  */
3456
3457 void
3458 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3459 {
3460   struct uploaded_tp *utp;
3461
3462   /* Look for GDB tracepoints that match up with our uploaded versions.  */
3463   for (utp = *uploaded_tps; utp; utp = utp->next)
3464     {
3465       struct bp_location *loc;
3466       struct tracepoint *t;
3467
3468       loc = find_matching_tracepoint_location (utp);
3469       if (loc)
3470         {
3471           /* Mark this location as already inserted.  */
3472           loc->inserted = 1;
3473           t = (struct tracepoint *) loc->owner;
3474           printf_filtered (_("Assuming tracepoint %d is same "
3475                              "as target's tracepoint %d at %s.\n"),
3476                            loc->owner->number, utp->number,
3477                            paddress (loc->gdbarch, utp->addr));
3478         }
3479       else
3480         {
3481           t = create_tracepoint_from_upload (utp);
3482           if (t)
3483             printf_filtered (_("Created tracepoint %d for "
3484                                "target's tracepoint %d at %s.\n"),
3485                              t->base.number, utp->number,
3486                              paddress (get_current_arch (), utp->addr));
3487           else
3488             printf_filtered (_("Failed to create tracepoint for target's "
3489                                "tracepoint %d at %s, skipping it.\n"),
3490                              utp->number,
3491                              paddress (get_current_arch (), utp->addr));
3492         }
3493       /* Whether found or created, record the number used by the
3494          target, to help with mapping target tracepoints back to their
3495          counterparts here.  */
3496       if (t)
3497         t->number_on_target = utp->number;
3498     }
3499
3500   free_uploaded_tps (uploaded_tps);
3501 }
3502
3503 /* Trace state variables don't have much to identify them beyond their
3504    name, so just use that to detect matches.  */
3505
3506 static struct trace_state_variable *
3507 find_matching_tsv (struct uploaded_tsv *utsv)
3508 {
3509   if (!utsv->name)
3510     return NULL;
3511
3512   return find_trace_state_variable (utsv->name);
3513 }
3514
3515 static struct trace_state_variable *
3516 create_tsv_from_upload (struct uploaded_tsv *utsv)
3517 {
3518   const char *namebase;
3519   char *buf;
3520   int try_num = 0;
3521   struct trace_state_variable *tsv;
3522   struct cleanup *old_chain;
3523
3524   if (utsv->name)
3525     {
3526       namebase = utsv->name;
3527       buf = xstrprintf ("%s", namebase);
3528     }
3529   else
3530     {
3531       namebase = "__tsv";
3532       buf = xstrprintf ("%s_%d", namebase, try_num++);
3533     }
3534
3535   /* Fish for a name that is not in use.  */
3536   /* (should check against all internal vars?)  */
3537   while (find_trace_state_variable (buf))
3538     {
3539       xfree (buf);
3540       buf = xstrprintf ("%s_%d", namebase, try_num++);
3541     }
3542
3543   old_chain = make_cleanup (xfree, buf);
3544
3545   /* We have an available name, create the variable.  */
3546   tsv = create_trace_state_variable (buf);
3547   tsv->initial_value = utsv->initial_value;
3548   tsv->builtin = utsv->builtin;
3549
3550   do_cleanups (old_chain);
3551
3552   return tsv;
3553 }
3554
3555 /* Given a list of uploaded trace state variables, try to match them
3556    up with existing variables, or create additional ones.  */
3557
3558 void
3559 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3560 {
3561   int ix;
3562   struct uploaded_tsv *utsv;
3563   struct trace_state_variable *tsv;
3564   int highest;
3565
3566   /* Most likely some numbers will have to be reassigned as part of
3567      the merge, so clear them all in anticipation.  */
3568   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3569     tsv->number = 0;
3570
3571   for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3572     {
3573       tsv = find_matching_tsv (utsv);
3574       if (tsv)
3575         {
3576           if (info_verbose)
3577             printf_filtered (_("Assuming trace state variable $%s "
3578                                "is same as target's variable %d.\n"),
3579                              tsv->name, utsv->number);
3580         }
3581       else
3582         {
3583           tsv = create_tsv_from_upload (utsv);
3584           if (info_verbose)
3585             printf_filtered (_("Created trace state variable "
3586                                "$%s for target's variable %d.\n"),
3587                              tsv->name, utsv->number);
3588         }
3589       /* Give precedence to numberings that come from the target.  */
3590       if (tsv)
3591         tsv->number = utsv->number;
3592     }
3593
3594   /* Renumber everything that didn't get a target-assigned number.  */
3595   highest = 0;
3596   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3597     if (tsv->number > highest)
3598       highest = tsv->number;
3599
3600   ++highest;
3601   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3602     if (tsv->number == 0)
3603       tsv->number = highest++;
3604
3605   free_uploaded_tsvs (uploaded_tsvs);
3606 }
3607
3608 /* target tfile command */
3609
3610 static struct target_ops tfile_ops;
3611
3612 /* Fill in tfile_ops with its defined operations and properties.  */
3613
3614 #define TRACE_HEADER_SIZE 8
3615
3616 static char *trace_filename;
3617 static int trace_fd = -1;
3618 static off_t trace_frames_offset;
3619 static off_t cur_offset;
3620 static int cur_data_size;
3621 int trace_regblock_size;
3622
3623 static void tfile_interp_line (char *line,
3624                                struct uploaded_tp **utpp,
3625                                struct uploaded_tsv **utsvp);
3626
3627 /* Read SIZE bytes into READBUF from the trace frame, starting at
3628    TRACE_FD's current position.  Note that this call `read'
3629    underneath, hence it advances the file's seek position.  Throws an
3630    error if the `read' syscall fails, or less than SIZE bytes are
3631    read.  */
3632
3633 static void
3634 tfile_read (gdb_byte *readbuf, int size)
3635 {
3636   int gotten;
3637
3638   gotten = read (trace_fd, readbuf, size);
3639   if (gotten < 0)
3640     perror_with_name (trace_filename);
3641   else if (gotten < size)
3642     error (_("Premature end of file while reading trace file"));
3643 }
3644
3645 static void
3646 tfile_open (char *filename, int from_tty)
3647 {
3648   volatile struct gdb_exception ex;
3649   char *temp;
3650   struct cleanup *old_chain;
3651   int flags;
3652   int scratch_chan;
3653   char header[TRACE_HEADER_SIZE];
3654   char linebuf[1000]; /* Should be max remote packet size or so.  */
3655   char byte;
3656   int bytes, i;
3657   struct trace_status *ts;
3658   struct uploaded_tp *uploaded_tps = NULL;
3659   struct uploaded_tsv *uploaded_tsvs = NULL;
3660
3661   target_preopen (from_tty);
3662   if (!filename)
3663     error (_("No trace file specified."));
3664
3665   filename = tilde_expand (filename);
3666   if (!IS_ABSOLUTE_PATH(filename))
3667     {
3668       temp = concat (current_directory, "/", filename, (char *) NULL);
3669       xfree (filename);
3670       filename = temp;
3671     }
3672
3673   old_chain = make_cleanup (xfree, filename);
3674
3675   flags = O_BINARY | O_LARGEFILE;
3676   flags |= O_RDONLY;
3677   scratch_chan = open (filename, flags, 0);
3678   if (scratch_chan < 0)
3679     perror_with_name (filename);
3680
3681   /* Looks semi-reasonable.  Toss the old trace file and work on the new.  */
3682
3683   discard_cleanups (old_chain); /* Don't free filename any more.  */
3684   unpush_target (&tfile_ops);
3685
3686   trace_filename = xstrdup (filename);
3687   trace_fd = scratch_chan;
3688
3689   bytes = 0;
3690   /* Read the file header and test for validity.  */
3691   tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3692
3693   bytes += TRACE_HEADER_SIZE;
3694   if (!(header[0] == 0x7f
3695         && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3696     error (_("File is not a valid trace file."));
3697
3698   push_target (&tfile_ops);
3699
3700   trace_regblock_size = 0;
3701   ts = current_trace_status ();
3702   /* We know we're working with a file.  */
3703   ts->from_file = 1;
3704   /* Set defaults in case there is no status line.  */
3705   ts->running_known = 0;
3706   ts->stop_reason = trace_stop_reason_unknown;
3707   ts->traceframe_count = -1;
3708   ts->buffer_free = 0;
3709   ts->disconnected_tracing = 0;
3710   ts->circular_buffer = 0;
3711
3712   TRY_CATCH (ex, RETURN_MASK_ALL)
3713     {
3714       /* Read through a section of newline-terminated lines that
3715          define things like tracepoints.  */
3716       i = 0;
3717       while (1)
3718         {
3719           tfile_read (&byte, 1);
3720
3721           ++bytes;
3722           if (byte == '\n')
3723             {
3724               /* Empty line marks end of the definition section.  */
3725               if (i == 0)
3726                 break;
3727               linebuf[i] = '\0';
3728               i = 0;
3729               tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3730             }
3731           else
3732             linebuf[i++] = byte;
3733           if (i >= 1000)
3734             error (_("Excessively long lines in trace file"));
3735         }
3736
3737       /* Record the starting offset of the binary trace data.  */
3738       trace_frames_offset = bytes;
3739
3740       /* If we don't have a blocksize, we can't interpret the
3741          traceframes.  */
3742       if (trace_regblock_size == 0)
3743         error (_("No register block size recorded in trace file"));
3744     }
3745   if (ex.reason < 0)
3746     {
3747       /* Pop the partially set up target.  */
3748       pop_target ();
3749       throw_exception (ex);
3750     }
3751
3752   inferior_appeared (current_inferior (), TFILE_PID);
3753   inferior_ptid = pid_to_ptid (TFILE_PID);
3754   add_thread_silent (inferior_ptid);
3755
3756   if (ts->traceframe_count <= 0)
3757     warning (_("No traceframes present in this file."));
3758
3759   /* Add the file's tracepoints and variables into the current mix.  */
3760
3761   /* Get trace state variables first, they may be checked when parsing
3762      uploaded commands.  */
3763   merge_uploaded_trace_state_variables (&uploaded_tsvs);
3764
3765   merge_uploaded_tracepoints (&uploaded_tps);
3766
3767   post_create_inferior (&tfile_ops, from_tty);
3768 }
3769
3770 /* Interpret the given line from the definitions part of the trace
3771    file.  */
3772
3773 static void
3774 tfile_interp_line (char *line,
3775                    struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3776 {
3777   char *p = line;
3778
3779   if (strncmp (p, "R ", strlen ("R ")) == 0)
3780     {
3781       p += strlen ("R ");
3782       trace_regblock_size = strtol (p, &p, 16);
3783     }
3784   else if (strncmp (p, "status ", strlen ("status ")) == 0)
3785     {
3786       p += strlen ("status ");
3787       parse_trace_status (p, current_trace_status ());
3788     }
3789   else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3790     {
3791       p += strlen ("tp ");
3792       parse_tracepoint_definition (p, utpp);
3793     }
3794   else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3795     {
3796       p += strlen ("tsv ");
3797       parse_tsv_definition (p, utsvp);
3798     }
3799   else
3800     warning (_("Ignoring trace file definition \"%s\""), line);
3801 }
3802
3803 /* Parse the part of trace status syntax that is shared between
3804    the remote protocol and the trace file reader.  */
3805
3806 void
3807 parse_trace_status (char *line, struct trace_status *ts)
3808 {
3809   char *p = line, *p1, *p2, *p3, *p_temp;
3810   int end;
3811   ULONGEST val;
3812
3813   ts->running_known = 1;
3814   ts->running = (*p++ == '1');
3815   ts->stop_reason = trace_stop_reason_unknown;
3816   xfree (ts->stop_desc);
3817   ts->stop_desc = NULL;
3818   ts->traceframe_count = -1;
3819   ts->traceframes_created = -1;
3820   ts->buffer_free = -1;
3821   ts->buffer_size = -1;
3822   ts->disconnected_tracing = 0;
3823   ts->circular_buffer = 0;
3824   xfree (ts->user_name);
3825   ts->user_name = NULL;
3826   xfree (ts->notes);
3827   ts->notes = NULL;
3828   ts->start_time = ts->stop_time = 0;
3829
3830   while (*p++)
3831     {
3832       p1 = strchr (p, ':');
3833       if (p1 == NULL)
3834         error (_("Malformed trace status, at %s\n\
3835 Status line: '%s'\n"), p, line);
3836       p3 = strchr (p, ';');
3837       if (p3 == NULL)
3838         p3 = p + strlen (p);
3839       if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3840         {
3841           p = unpack_varlen_hex (++p1, &val);
3842           ts->stop_reason = trace_buffer_full;
3843         }
3844       else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3845         {
3846           p = unpack_varlen_hex (++p1, &val);
3847           ts->stop_reason = trace_never_run;
3848         }
3849       else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3850                         p1 - p) == 0)
3851         {
3852           p = unpack_varlen_hex (++p1, &val);
3853           ts->stop_reason = tracepoint_passcount;
3854           ts->stopping_tracepoint = val;
3855         }
3856       else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3857         {
3858           p2 = strchr (++p1, ':');
3859           if (!p2 || p2 > p3)
3860             {
3861               /*older style*/
3862               p2 = p1;
3863             }
3864           else if (p2 != p1)
3865             {
3866               ts->stop_desc = xmalloc (strlen (line));
3867               end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
3868               ts->stop_desc[end] = '\0';
3869             }
3870           else
3871             ts->stop_desc = xstrdup ("");
3872
3873           p = unpack_varlen_hex (++p2, &val);
3874           ts->stop_reason = tstop_command;
3875         }
3876       else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3877         {
3878           p = unpack_varlen_hex (++p1, &val);
3879           ts->stop_reason = trace_disconnected;
3880         }
3881       else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3882         {
3883           p2 = strchr (++p1, ':');
3884           if (p2 != p1)
3885             {
3886               ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
3887               end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
3888               ts->stop_desc[end] = '\0';
3889             }
3890           else
3891             ts->stop_desc = xstrdup ("");
3892
3893           p = unpack_varlen_hex (++p2, &val);
3894           ts->stopping_tracepoint = val;
3895           ts->stop_reason = tracepoint_error;
3896         }
3897       else if (strncmp (p, "tframes", p1 - p) == 0)
3898         {
3899           p = unpack_varlen_hex (++p1, &val);
3900           ts->traceframe_count = val;
3901         }
3902       else if (strncmp (p, "tcreated", p1 - p) == 0)
3903         {
3904           p = unpack_varlen_hex (++p1, &val);
3905           ts->traceframes_created = val;
3906         }
3907       else if (strncmp (p, "tfree", p1 - p) == 0)
3908         {
3909           p = unpack_varlen_hex (++p1, &val);
3910           ts->buffer_free = val;
3911         }
3912       else if (strncmp (p, "tsize", p1 - p) == 0)
3913         {
3914           p = unpack_varlen_hex (++p1, &val);
3915           ts->buffer_size = val;
3916         }
3917       else if (strncmp (p, "disconn", p1 - p) == 0)
3918         {
3919           p = unpack_varlen_hex (++p1, &val);
3920           ts->disconnected_tracing = val;
3921         }
3922       else if (strncmp (p, "circular", p1 - p) == 0)
3923         {
3924           p = unpack_varlen_hex (++p1, &val);
3925           ts->circular_buffer = val;
3926         }
3927       else if (strncmp (p, "starttime", p1 - p) == 0)
3928         {
3929           p = unpack_varlen_hex (++p1, &val);
3930           ts->start_time = val;
3931         }
3932       else if (strncmp (p, "stoptime", p1 - p) == 0)
3933         {
3934           p = unpack_varlen_hex (++p1, &val);
3935           ts->stop_time = val;
3936         }
3937       else if (strncmp (p, "username", p1 - p) == 0)
3938         {
3939           ++p1;
3940           ts->user_name = xmalloc (strlen (p) / 2);
3941           end = hex2bin (p1, ts->user_name, (p3 - p1)  / 2);
3942           ts->user_name[end] = '\0';
3943           p = p3;
3944         }
3945       else if (strncmp (p, "notes", p1 - p) == 0)
3946         {
3947           ++p1;
3948           ts->notes = xmalloc (strlen (p) / 2);
3949           end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
3950           ts->notes[end] = '\0';
3951           p = p3;
3952         }
3953       else
3954         {
3955           /* Silently skip unknown optional info.  */
3956           p_temp = strchr (p1 + 1, ';');
3957           if (p_temp)
3958             p = p_temp;
3959           else
3960             /* Must be at the end.  */
3961             break;
3962         }
3963     }
3964 }
3965
3966 void
3967 parse_tracepoint_status (char *p, struct breakpoint *bp,
3968                          struct uploaded_tp *utp)
3969 {
3970   ULONGEST uval;
3971   struct tracepoint *tp = (struct tracepoint *) bp;
3972
3973   p = unpack_varlen_hex (p, &uval);
3974   if (tp)
3975     tp->base.hit_count += uval;
3976   else
3977     utp->hit_count += uval;
3978   p = unpack_varlen_hex (p + 1, &uval);
3979   if (tp)
3980     tp->traceframe_usage += uval;
3981   else
3982     utp->traceframe_usage += uval;
3983   /* Ignore any extra, allowing for future extensions.  */
3984 }
3985
3986 /* Given a line of text defining a part of a tracepoint, parse it into
3987    an "uploaded tracepoint".  */
3988
3989 void
3990 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3991 {
3992   char *p;
3993   char piece;
3994   ULONGEST num, addr, step, pass, orig_size, xlen, start;
3995   int enabled, end;
3996   enum bptype type;
3997   char *cond, *srctype, *buf;
3998   struct uploaded_tp *utp = NULL;
3999
4000   p = line;
4001   /* Both tracepoint and action definitions start with the same number
4002      and address sequence.  */
4003   piece = *p++;
4004   p = unpack_varlen_hex (p, &num);
4005   p++;  /* skip a colon */
4006   p = unpack_varlen_hex (p, &addr);
4007   p++;  /* skip a colon */
4008   if (piece == 'T')
4009     {
4010       enabled = (*p++ == 'E');
4011       p++;  /* skip a colon */
4012       p = unpack_varlen_hex (p, &step);
4013       p++;  /* skip a colon */
4014       p = unpack_varlen_hex (p, &pass);
4015       type = bp_tracepoint;
4016       cond = NULL;
4017       /* Thumb through optional fields.  */
4018       while (*p == ':')
4019         {
4020           p++;  /* skip a colon */
4021           if (*p == 'F')
4022             {
4023               type = bp_fast_tracepoint;
4024               p++;
4025               p = unpack_varlen_hex (p, &orig_size);
4026             }
4027           else if (*p == 'S')
4028             {
4029               type = bp_static_tracepoint;
4030               p++;
4031             }
4032           else if (*p == 'X')
4033             {
4034               p++;
4035               p = unpack_varlen_hex (p, &xlen);
4036               p++;  /* skip a comma */
4037               cond = (char *) xmalloc (2 * xlen + 1);
4038               strncpy (cond, p, 2 * xlen);
4039               cond[2 * xlen] = '\0';
4040               p += 2 * xlen;
4041             }
4042           else
4043             warning (_("Unrecognized char '%c' in tracepoint "
4044                        "definition, skipping rest"), *p);
4045         }
4046       utp = get_uploaded_tp (num, addr, utpp);
4047       utp->type = type;
4048       utp->enabled = enabled;
4049       utp->step = step;
4050       utp->pass = pass;
4051       utp->cond = cond;
4052     }
4053   else if (piece == 'A')
4054     {
4055       utp = get_uploaded_tp (num, addr, utpp);
4056       VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4057     }
4058   else if (piece == 'S')
4059     {
4060       utp = get_uploaded_tp (num, addr, utpp);
4061       VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4062     }
4063   else if (piece == 'Z')
4064     {
4065       /* Parse a chunk of source form definition.  */
4066       utp = get_uploaded_tp (num, addr, utpp);
4067       srctype = p;
4068       p = strchr (p, ':');
4069       p++;  /* skip a colon */
4070       p = unpack_varlen_hex (p, &start);
4071       p++;  /* skip a colon */
4072       p = unpack_varlen_hex (p, &xlen);
4073       p++;  /* skip a colon */
4074
4075       buf = alloca (strlen (line));
4076
4077       end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4078       buf[end] = '\0';
4079
4080       if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4081         utp->at_string = xstrdup (buf);
4082       else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4083         utp->cond_string = xstrdup (buf);
4084       else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4085         VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4086     }
4087   else if (piece == 'V')
4088     {
4089       utp = get_uploaded_tp (num, addr, utpp);
4090
4091       parse_tracepoint_status (p, NULL, utp);
4092     }
4093   else
4094     {
4095       /* Don't error out, the target might be sending us optional
4096          info that we don't care about.  */
4097       warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4098     }
4099 }
4100
4101 /* Convert a textual description of a trace state variable into an
4102    uploaded object.  */
4103
4104 void
4105 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4106 {
4107   char *p, *buf;
4108   ULONGEST num, initval, builtin;
4109   int end;
4110   struct uploaded_tsv *utsv = NULL;
4111
4112   buf = alloca (strlen (line));
4113
4114   p = line;
4115   p = unpack_varlen_hex (p, &num);
4116   p++; /* skip a colon */
4117   p = unpack_varlen_hex (p, &initval);
4118   p++; /* skip a colon */
4119   p = unpack_varlen_hex (p, &builtin);
4120   p++; /* skip a colon */
4121   end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4122   buf[end] = '\0';
4123
4124   utsv = get_uploaded_tsv (num, utsvp);
4125   utsv->initial_value = initval;
4126   utsv->builtin = builtin;
4127   utsv->name = xstrdup (buf);
4128 }
4129
4130 /* Close the trace file and generally clean up.  */
4131
4132 static void
4133 tfile_close (int quitting)
4134 {
4135   int pid;
4136
4137   if (trace_fd < 0)
4138     return;
4139
4140   pid = ptid_get_pid (inferior_ptid);
4141   inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff.  */
4142   exit_inferior_silent (pid);
4143
4144   close (trace_fd);
4145   trace_fd = -1;
4146   xfree (trace_filename);
4147   trace_filename = NULL;
4148 }
4149
4150 static void
4151 tfile_files_info (struct target_ops *t)
4152 {
4153   /* (it would be useful to mention the name of the file).  */
4154   printf_filtered ("Looking at a trace file.\n");
4155 }
4156
4157 /* The trace status for a file is that tracing can never be run.  */
4158
4159 static int
4160 tfile_get_trace_status (struct trace_status *ts)
4161 {
4162   /* Other bits of trace status were collected as part of opening the
4163      trace files, so nothing to do here.  */
4164
4165   return -1;
4166 }
4167
4168 static void
4169 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4170 {
4171   /* Other bits of trace status were collected as part of opening the
4172      trace files, so nothing to do here.  */
4173 }
4174
4175 /* Given the position of a traceframe in the file, figure out what
4176    address the frame was collected at.  This would normally be the
4177    value of a collected PC register, but if not available, we
4178    improvise.  */
4179
4180 static ULONGEST
4181 tfile_get_traceframe_address (off_t tframe_offset)
4182 {
4183   ULONGEST addr = 0;
4184   short tpnum;
4185   struct tracepoint *tp;
4186   off_t saved_offset = cur_offset;
4187
4188   /* FIXME dig pc out of collected registers.  */
4189
4190   /* Fall back to using tracepoint address.  */
4191   lseek (trace_fd, tframe_offset, SEEK_SET);
4192   tfile_read ((gdb_byte *) &tpnum, 2);
4193   tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4194                                           gdbarch_byte_order
4195                                               (target_gdbarch));
4196
4197   tp = get_tracepoint_by_number_on_target (tpnum);
4198   /* FIXME this is a poor heuristic if multiple locations.  */
4199   if (tp && tp->base.loc)
4200     addr = tp->base.loc->address;
4201
4202   /* Restore our seek position.  */
4203   cur_offset = saved_offset;
4204   lseek (trace_fd, cur_offset, SEEK_SET);
4205   return addr;
4206 }
4207
4208 /* Given a type of search and some parameters, scan the collection of
4209    traceframes in the file looking for a match.  When found, return
4210    both the traceframe and tracepoint number, otherwise -1 for
4211    each.  */
4212
4213 static int
4214 tfile_trace_find (enum trace_find_type type, int num,
4215                   ULONGEST addr1, ULONGEST addr2, int *tpp)
4216 {
4217   short tpnum;
4218   int tfnum = 0, found = 0;
4219   unsigned int data_size;
4220   struct tracepoint *tp;
4221   off_t offset, tframe_offset;
4222   ULONGEST tfaddr;
4223
4224   if (num == -1)
4225     {
4226       if (tpp)
4227         *tpp = -1;
4228       return -1;
4229     }
4230
4231   lseek (trace_fd, trace_frames_offset, SEEK_SET);
4232   offset = trace_frames_offset;
4233   while (1)
4234     {
4235       tframe_offset = offset;
4236       tfile_read ((gdb_byte *) &tpnum, 2);
4237       tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4238                                               gdbarch_byte_order
4239                                                   (target_gdbarch));
4240       offset += 2;
4241       if (tpnum == 0)
4242         break;
4243       tfile_read ((gdb_byte *) &data_size, 4);
4244       data_size = (unsigned int) extract_unsigned_integer
4245                                      ((gdb_byte *) &data_size, 4,
4246                                       gdbarch_byte_order (target_gdbarch));
4247       offset += 4;
4248       switch (type)
4249         {
4250         case tfind_number:
4251           if (tfnum == num)
4252             found = 1;
4253           break;
4254         case tfind_pc:
4255           tfaddr = tfile_get_traceframe_address (tframe_offset);
4256           if (tfaddr == addr1)
4257             found = 1;
4258           break;
4259         case tfind_tp:
4260           tp = get_tracepoint (num);
4261           if (tp && tpnum == tp->number_on_target)
4262             found = 1;
4263           break;
4264         case tfind_range:
4265           tfaddr = tfile_get_traceframe_address (tframe_offset);
4266           if (addr1 <= tfaddr && tfaddr <= addr2)
4267             found = 1;
4268           break;
4269         case tfind_outside:
4270           tfaddr = tfile_get_traceframe_address (tframe_offset);
4271           if (!(addr1 <= tfaddr && tfaddr <= addr2))
4272             found = 1;
4273           break;
4274         default:
4275           internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4276         }
4277       if (found)
4278         {
4279           if (tpp)
4280             *tpp = tpnum;
4281           cur_offset = offset;
4282           cur_data_size = data_size;
4283
4284           return tfnum;
4285         }
4286       /* Skip past the traceframe's data.  */
4287       lseek (trace_fd, data_size, SEEK_CUR);
4288       offset += data_size;
4289       /* Update our own count of traceframes.  */
4290       ++tfnum;
4291     }
4292   /* Did not find what we were looking for.  */
4293   if (tpp)
4294     *tpp = -1;
4295   return -1;
4296 }
4297
4298 /* Prototype of the callback passed to tframe_walk_blocks.  */
4299 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4300
4301 /* Callback for traceframe_walk_blocks, used to find a given block
4302    type in a traceframe.  */
4303
4304 static int
4305 match_blocktype (char blocktype, void *data)
4306 {
4307   char *wantedp = data;
4308
4309   if (*wantedp == blocktype)
4310     return 1;
4311
4312   return 0;
4313 }
4314
4315 /* Walk over all traceframe block starting at POS offset from
4316    CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4317    unmodified.  If CALLBACK returns true, this returns the position in
4318    the traceframe where the block is found, relative to the start of
4319    the traceframe (cur_offset).  Returns -1 if no callback call
4320    returned true, indicating that all blocks have been walked.  */
4321
4322 static int
4323 traceframe_walk_blocks (walk_blocks_callback_func callback,
4324                         int pos, void *data)
4325 {
4326   /* Iterate through a traceframe's blocks, looking for a block of the
4327      requested type.  */
4328
4329   lseek (trace_fd, cur_offset + pos, SEEK_SET);
4330   while (pos < cur_data_size)
4331     {
4332       unsigned short mlen;
4333       char block_type;
4334
4335       tfile_read (&block_type, 1);
4336
4337       ++pos;
4338
4339       if ((*callback) (block_type, data))
4340         return pos;
4341
4342       switch (block_type)
4343         {
4344         case 'R':
4345           lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4346           pos += trace_regblock_size;
4347           break;
4348         case 'M':
4349           lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4350           tfile_read ((gdb_byte *) &mlen, 2);
4351           mlen = (unsigned short)
4352                 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4353                                           gdbarch_byte_order
4354                                               (target_gdbarch));
4355           lseek (trace_fd, mlen, SEEK_CUR);
4356           pos += (8 + 2 + mlen);
4357           break;
4358         case 'V':
4359           lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4360           pos += (4 + 8);
4361           break;
4362         default:
4363           error (_("Unknown block type '%c' (0x%x) in trace frame"),
4364                  block_type, block_type);
4365           break;
4366         }
4367     }
4368
4369   return -1;
4370 }
4371
4372 /* Convenience wrapper around traceframe_walk_blocks.  Looks for the
4373    position offset of a block of type TYPE_WANTED in the current trace
4374    frame, starting at POS.  Returns -1 if no such block was found.  */
4375
4376 static int
4377 traceframe_find_block_type (char type_wanted, int pos)
4378 {
4379   return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4380 }
4381
4382 /* Look for a block of saved registers in the traceframe, and get the
4383    requested register from it.  */
4384
4385 static void
4386 tfile_fetch_registers (struct target_ops *ops,
4387                        struct regcache *regcache, int regno)
4388 {
4389   struct gdbarch *gdbarch = get_regcache_arch (regcache);
4390   int offset, regn, regsize, pc_regno;
4391   char *regs;
4392
4393   /* An uninitialized reg size says we're not going to be
4394      successful at getting register blocks.  */
4395   if (!trace_regblock_size)
4396     return;
4397
4398   regs = alloca (trace_regblock_size);
4399
4400   if (traceframe_find_block_type ('R', 0) >= 0)
4401     {
4402       tfile_read (regs, trace_regblock_size);
4403
4404       /* Assume the block is laid out in GDB register number order,
4405          each register with the size that it has in GDB.  */
4406       offset = 0;
4407       for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4408         {
4409           regsize = register_size (gdbarch, regn);
4410           /* Make sure we stay within block bounds.  */
4411           if (offset + regsize >= trace_regblock_size)
4412             break;
4413           if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4414             {
4415               if (regno == regn)
4416                 {
4417                   regcache_raw_supply (regcache, regno, regs + offset);
4418                   break;
4419                 }
4420               else if (regno == -1)
4421                 {
4422                   regcache_raw_supply (regcache, regn, regs + offset);
4423                 }
4424             }
4425           offset += regsize;
4426         }
4427       return;
4428     }
4429
4430   /* We get here if no register data has been found.  Mark registers
4431      as unavailable.  */
4432   for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4433     regcache_raw_supply (regcache, regn, NULL);
4434
4435   /* We can often usefully guess that the PC is going to be the same
4436      as the address of the tracepoint.  */
4437   pc_regno = gdbarch_pc_regnum (gdbarch);
4438   if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4439     {
4440       struct tracepoint *tp = get_tracepoint (tracepoint_number);
4441
4442       if (tp && tp->base.loc)
4443         {
4444           /* But don't try to guess if tracepoint is multi-location...  */
4445           if (tp->base.loc->next)
4446             {
4447               warning (_("Tracepoint %d has multiple "
4448                          "locations, cannot infer $pc"),
4449                        tp->base.number);
4450               return;
4451             }
4452           /* ... or does while-stepping.  */
4453           if (tp->step_count > 0)
4454             {
4455               warning (_("Tracepoint %d does while-stepping, "
4456                          "cannot infer $pc"),
4457                        tp->base.number);
4458               return;
4459             }
4460
4461           store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4462                                   gdbarch_byte_order (gdbarch),
4463                                   tp->base.loc->address);
4464           regcache_raw_supply (regcache, pc_regno, regs);
4465         }
4466     }
4467 }
4468
4469 static LONGEST
4470 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4471                     const char *annex, gdb_byte *readbuf,
4472                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4473 {
4474   /* We're only doing regular memory for now.  */
4475   if (object != TARGET_OBJECT_MEMORY)
4476     return -1;
4477
4478   if (readbuf == NULL)
4479     error (_("tfile_xfer_partial: trace file is read-only"));
4480
4481  if (traceframe_number != -1)
4482     {
4483       int pos = 0;
4484
4485       /* Iterate through the traceframe's blocks, looking for
4486          memory.  */
4487       while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4488         {
4489           ULONGEST maddr, amt;
4490           unsigned short mlen;
4491           enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4492
4493           tfile_read ((gdb_byte *) &maddr, 8);
4494           maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4495                                             byte_order);
4496           tfile_read ((gdb_byte *) &mlen, 2);
4497           mlen = (unsigned short)
4498             extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4499
4500           /* If the block includes the first part of the desired
4501              range, return as much it has; GDB will re-request the
4502              remainder, which might be in a different block of this
4503              trace frame.  */
4504           if (maddr <= offset && offset < (maddr + mlen))
4505             {
4506               amt = (maddr + mlen) - offset;
4507               if (amt > len)
4508                 amt = len;
4509
4510               if (maddr != offset)
4511                 lseek (trace_fd, offset - maddr, SEEK_CUR);
4512               tfile_read (readbuf, amt);
4513               return amt;
4514             }
4515
4516           /* Skip over this block.  */
4517           pos += (8 + 2 + mlen);
4518         }
4519     }
4520
4521   /* It's unduly pedantic to refuse to look at the executable for
4522      read-only pieces; so do the equivalent of readonly regions aka
4523      QTro packet.  */
4524   /* FIXME account for relocation at some point.  */
4525   if (exec_bfd)
4526     {
4527       asection *s;
4528       bfd_size_type size;
4529       bfd_vma vma;
4530
4531       for (s = exec_bfd->sections; s; s = s->next)
4532         {
4533           if ((s->flags & SEC_LOAD) == 0
4534               || (s->flags & SEC_READONLY) == 0)
4535             continue;
4536
4537           vma = s->vma;
4538           size = bfd_get_section_size (s);
4539           if (vma <= offset && offset < (vma + size))
4540             {
4541               ULONGEST amt;
4542
4543               amt = (vma + size) - offset;
4544               if (amt > len)
4545                 amt = len;
4546
4547               amt = bfd_get_section_contents (exec_bfd, s,
4548                                               readbuf, offset - vma, amt);
4549               return amt;
4550             }
4551         }
4552     }
4553
4554   /* Indicate failure to find the requested memory block.  */
4555   return -1;
4556 }
4557
4558 /* Iterate through the blocks of a trace frame, looking for a 'V'
4559    block with a matching tsv number.  */
4560
4561 static int
4562 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4563 {
4564   int pos;
4565
4566   pos = 0;
4567   while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4568     {
4569       int vnum;
4570
4571       tfile_read ((gdb_byte *) &vnum, 4);
4572       vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4573                                            gdbarch_byte_order
4574                                            (target_gdbarch));
4575       if (tsvnum == vnum)
4576         {
4577           tfile_read ((gdb_byte *) val, 8);
4578           *val = extract_signed_integer ((gdb_byte *) val, 8,
4579                                          gdbarch_byte_order
4580                                          (target_gdbarch));
4581           return 1;
4582         }
4583       pos += (4 + 8);
4584     }
4585
4586   /* Didn't find anything.  */
4587   return 0;
4588 }
4589
4590 static int
4591 tfile_has_all_memory (struct target_ops *ops)
4592 {
4593   return 1;
4594 }
4595
4596 static int
4597 tfile_has_memory (struct target_ops *ops)
4598 {
4599   return 1;
4600 }
4601
4602 static int
4603 tfile_has_stack (struct target_ops *ops)
4604 {
4605   return traceframe_number != -1;
4606 }
4607
4608 static int
4609 tfile_has_registers (struct target_ops *ops)
4610 {
4611   return traceframe_number != -1;
4612 }
4613
4614 static int
4615 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
4616 {
4617   return 1;
4618 }
4619
4620 /* Callback for traceframe_walk_blocks.  Builds a traceframe_info
4621    object for the tfile target's current traceframe.  */
4622
4623 static int
4624 build_traceframe_info (char blocktype, void *data)
4625 {
4626   struct traceframe_info *info = data;
4627
4628   switch (blocktype)
4629     {
4630     case 'M':
4631       {
4632         struct mem_range *r;
4633         ULONGEST maddr;
4634         unsigned short mlen;
4635
4636         tfile_read ((gdb_byte *) &maddr, 8);
4637         tfile_read ((gdb_byte *) &mlen, 2);
4638
4639         r = VEC_safe_push (mem_range_s, info->memory, NULL);
4640
4641         r->start = maddr;
4642         r->length = mlen;
4643         break;
4644       }
4645     case 'V':
4646     case 'R':
4647     case 'S':
4648       {
4649         break;
4650       }
4651     default:
4652       warning (_("Unhandled trace block type (%d) '%c ' "
4653                  "while building trace frame info."),
4654                blocktype, blocktype);
4655       break;
4656     }
4657
4658   return 0;
4659 }
4660
4661 static struct traceframe_info *
4662 tfile_traceframe_info (void)
4663 {
4664   struct traceframe_info *info = XCNEW (struct traceframe_info);
4665
4666   traceframe_walk_blocks (build_traceframe_info, 0, info);
4667   return info;
4668 }
4669
4670 static void
4671 init_tfile_ops (void)
4672 {
4673   tfile_ops.to_shortname = "tfile";
4674   tfile_ops.to_longname = "Local trace dump file";
4675   tfile_ops.to_doc
4676     = "Use a trace file as a target.  Specify the filename of the trace file.";
4677   tfile_ops.to_open = tfile_open;
4678   tfile_ops.to_close = tfile_close;
4679   tfile_ops.to_fetch_registers = tfile_fetch_registers;
4680   tfile_ops.to_xfer_partial = tfile_xfer_partial;
4681   tfile_ops.to_files_info = tfile_files_info;
4682   tfile_ops.to_get_trace_status = tfile_get_trace_status;
4683   tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
4684   tfile_ops.to_trace_find = tfile_trace_find;
4685   tfile_ops.to_get_trace_state_variable_value
4686     = tfile_get_trace_state_variable_value;
4687   tfile_ops.to_stratum = process_stratum;
4688   tfile_ops.to_has_all_memory = tfile_has_all_memory;
4689   tfile_ops.to_has_memory = tfile_has_memory;
4690   tfile_ops.to_has_stack = tfile_has_stack;
4691   tfile_ops.to_has_registers = tfile_has_registers;
4692   tfile_ops.to_traceframe_info = tfile_traceframe_info;
4693   tfile_ops.to_thread_alive = tfile_thread_alive;
4694   tfile_ops.to_magic = OPS_MAGIC;
4695 }
4696
4697 void
4698 free_current_marker (void *arg)
4699 {
4700   struct static_tracepoint_marker **marker_p = arg;
4701
4702   if (*marker_p != NULL)
4703     {
4704       release_static_tracepoint_marker (*marker_p);
4705       xfree (*marker_p);
4706     }
4707   else
4708     *marker_p = NULL;
4709 }
4710
4711 /* Given a line of text defining a static tracepoint marker, parse it
4712    into a "static tracepoint marker" object.  Throws an error is
4713    parsing fails.  If PP is non-null, it points to one past the end of
4714    the parsed marker definition.  */
4715
4716 void
4717 parse_static_tracepoint_marker_definition (char *line, char **pp,
4718                                            struct static_tracepoint_marker *marker)
4719 {
4720   char *p, *endp;
4721   ULONGEST addr;
4722   int end;
4723
4724   p = line;
4725   p = unpack_varlen_hex (p, &addr);
4726   p++;  /* skip a colon */
4727
4728   marker->gdbarch = target_gdbarch;
4729   marker->address = (CORE_ADDR) addr;
4730
4731   endp = strchr (p, ':');
4732   if (endp == NULL)
4733     error (_("bad marker definition: %s"), line);
4734
4735   marker->str_id = xmalloc (endp - p + 1);
4736   end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4737   marker->str_id[end] = '\0';
4738
4739   p += 2 * end;
4740   p++;  /* skip a colon */
4741
4742   marker->extra = xmalloc (strlen (p) + 1);
4743   end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4744   marker->extra[end] = '\0';
4745
4746   if (pp)
4747     *pp = p;
4748 }
4749
4750 /* Release a static tracepoint marker's contents.  Note that the
4751    object itself isn't released here.  There objects are usually on
4752    the stack.  */
4753
4754 void
4755 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4756 {
4757   xfree (marker->str_id);
4758   marker->str_id = NULL;
4759 }
4760
4761 /* Print MARKER to gdb_stdout.  */
4762
4763 static void
4764 print_one_static_tracepoint_marker (int count,
4765                                     struct static_tracepoint_marker *marker)
4766 {
4767   struct command_line *l;
4768   struct symbol *sym;
4769
4770   char wrap_indent[80];
4771   char extra_field_indent[80];
4772   struct ui_out *uiout = current_uiout;
4773   struct cleanup *bkpt_chain;
4774   VEC(breakpoint_p) *tracepoints;
4775
4776   struct symtab_and_line sal;
4777
4778   init_sal (&sal);
4779
4780   sal.pc = marker->address;
4781
4782   tracepoints = static_tracepoints_here (marker->address);
4783
4784   bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4785
4786   /* A counter field to help readability.  This is not a stable
4787      identifier!  */
4788   ui_out_field_int (uiout, "count", count);
4789
4790   ui_out_field_string (uiout, "marker-id", marker->str_id);
4791
4792   ui_out_field_fmt (uiout, "enabled", "%c",
4793                     !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4794   ui_out_spaces (uiout, 2);
4795
4796   strcpy (wrap_indent, "                                   ");
4797
4798   if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4799     strcat (wrap_indent, "           ");
4800   else
4801     strcat (wrap_indent, "                   ");
4802
4803   strcpy (extra_field_indent, "         ");
4804
4805   ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4806
4807   sal = find_pc_line (marker->address, 0);
4808   sym = find_pc_sect_function (marker->address, NULL);
4809   if (sym)
4810     {
4811       ui_out_text (uiout, "in ");
4812       ui_out_field_string (uiout, "func",
4813                            SYMBOL_PRINT_NAME (sym));
4814       ui_out_wrap_hint (uiout, wrap_indent);
4815       ui_out_text (uiout, " at ");
4816     }
4817   else
4818     ui_out_field_skip (uiout, "func");
4819
4820   if (sal.symtab != NULL)
4821     {
4822       ui_out_field_string (uiout, "file", sal.symtab->filename);
4823       ui_out_text (uiout, ":");
4824
4825       if (ui_out_is_mi_like_p (uiout))
4826         {
4827           char *fullname = symtab_to_fullname (sal.symtab);
4828
4829           if (fullname)
4830             ui_out_field_string (uiout, "fullname", fullname);
4831         }
4832       else
4833         ui_out_field_skip (uiout, "fullname");
4834
4835       ui_out_field_int (uiout, "line", sal.line);
4836     }
4837   else
4838     {
4839       ui_out_field_skip (uiout, "fullname");
4840       ui_out_field_skip (uiout, "line");
4841     }
4842
4843   ui_out_text (uiout, "\n");
4844   ui_out_text (uiout, extra_field_indent);
4845   ui_out_text (uiout, _("Data: \""));
4846   ui_out_field_string (uiout, "extra-data", marker->extra);
4847   ui_out_text (uiout, "\"\n");
4848
4849   if (!VEC_empty (breakpoint_p, tracepoints))
4850     {
4851       struct cleanup *cleanup_chain;
4852       int ix;
4853       struct breakpoint *b;
4854
4855       cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4856                                                            "tracepoints-at");
4857
4858       ui_out_text (uiout, extra_field_indent);
4859       ui_out_text (uiout, _("Probed by static tracepoints: "));
4860       for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4861         {
4862           if (ix > 0)
4863             ui_out_text (uiout, ", ");
4864           ui_out_text (uiout, "#");
4865           ui_out_field_int (uiout, "tracepoint-id", b->number);
4866         }
4867
4868       do_cleanups (cleanup_chain);
4869
4870       if (ui_out_is_mi_like_p (uiout))
4871         ui_out_field_int (uiout, "number-of-tracepoints",
4872                           VEC_length(breakpoint_p, tracepoints));
4873       else
4874         ui_out_text (uiout, "\n");
4875     }
4876   VEC_free (breakpoint_p, tracepoints);
4877
4878   do_cleanups (bkpt_chain);
4879 }
4880
4881 static void
4882 info_static_tracepoint_markers_command (char *arg, int from_tty)
4883 {
4884   VEC(static_tracepoint_marker_p) *markers;
4885   struct cleanup *old_chain;
4886   struct static_tracepoint_marker *marker;
4887   struct ui_out *uiout = current_uiout;
4888   int i;
4889
4890   /* We don't have to check target_can_use_agent and agent's capability on
4891      static tracepoint here, in order to be compatible with older GDBserver.
4892      We don't check USE_AGENT is true or not, because static tracepoints
4893      don't work without in-process agent, so we don't bother users to type
4894      `set agent on' when to use static tracepoint.  */
4895
4896   old_chain
4897     = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4898                                            "StaticTracepointMarkersTable");
4899
4900   ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4901
4902   ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4903
4904   ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4905   if (gdbarch_addr_bit (target_gdbarch) <= 32)
4906     ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4907   else
4908     ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4909   ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4910
4911   ui_out_table_body (uiout);
4912
4913   markers = target_static_tracepoint_markers_by_strid (NULL);
4914   make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4915
4916   for (i = 0;
4917        VEC_iterate (static_tracepoint_marker_p,
4918                     markers, i, marker);
4919        i++)
4920     {
4921       print_one_static_tracepoint_marker (i + 1, marker);
4922       release_static_tracepoint_marker (marker);
4923     }
4924
4925   do_cleanups (old_chain);
4926 }
4927
4928 /* The $_sdata convenience variable is a bit special.  We don't know
4929    for sure type of the value until we actually have a chance to fetch
4930    the data --- the size of the object depends on what has been
4931    collected.  We solve this by making $_sdata be an internalvar that
4932    creates a new value on access.  */
4933
4934 /* Return a new value with the correct type for the sdata object of
4935    the current trace frame.  Return a void value if there's no object
4936    available.  */
4937
4938 static struct value *
4939 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
4940                   void *ignore)
4941 {
4942   LONGEST size;
4943   gdb_byte *buf;
4944
4945   /* We need to read the whole object before we know its size.  */
4946   size = target_read_alloc (&current_target,
4947                             TARGET_OBJECT_STATIC_TRACE_DATA,
4948                             NULL, &buf);
4949   if (size >= 0)
4950     {
4951       struct value *v;
4952       struct type *type;
4953
4954       type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4955                                size);
4956       v = allocate_value (type);
4957       memcpy (value_contents_raw (v), buf, size);
4958       xfree (buf);
4959       return v;
4960     }
4961   else
4962     return allocate_value (builtin_type (gdbarch)->builtin_void);
4963 }
4964
4965 #if !defined(HAVE_LIBEXPAT)
4966
4967 struct traceframe_info *
4968 parse_traceframe_info (const char *tframe_info)
4969 {
4970   static int have_warned;
4971
4972   if (!have_warned)
4973     {
4974       have_warned = 1;
4975       warning (_("Can not parse XML trace frame info; XML support "
4976                  "was disabled at compile time"));
4977     }
4978
4979   return NULL;
4980 }
4981
4982 #else /* HAVE_LIBEXPAT */
4983
4984 #include "xml-support.h"
4985
4986 /* Handle the start of a <memory> element.  */
4987
4988 static void
4989 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4990                               const struct gdb_xml_element *element,
4991                               void *user_data, VEC(gdb_xml_value_s) *attributes)
4992 {
4993   struct traceframe_info *info = user_data;
4994   struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4995   ULONGEST *start_p, *length_p;
4996
4997   start_p = xml_find_attribute (attributes, "start")->value;
4998   length_p = xml_find_attribute (attributes, "length")->value;
4999
5000   r->start = *start_p;
5001   r->length = *length_p;
5002 }
5003
5004 /* Discard the constructed trace frame info (if an error occurs).  */
5005
5006 static void
5007 free_result (void *p)
5008 {
5009   struct traceframe_info *result = p;
5010
5011   free_traceframe_info (result);
5012 }
5013
5014 /* The allowed elements and attributes for an XML memory map.  */
5015
5016 static const struct gdb_xml_attribute memory_attributes[] = {
5017   { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5018   { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5019   { NULL, GDB_XML_AF_NONE, NULL, NULL }
5020 };
5021
5022 static const struct gdb_xml_element traceframe_info_children[] = {
5023   { "memory", memory_attributes, NULL,
5024     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5025     traceframe_info_start_memory, NULL },
5026   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5027 };
5028
5029 static const struct gdb_xml_element traceframe_info_elements[] = {
5030   { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5031     NULL, NULL },
5032   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5033 };
5034
5035 /* Parse a traceframe-info XML document.  */
5036
5037 struct traceframe_info *
5038 parse_traceframe_info (const char *tframe_info)
5039 {
5040   struct traceframe_info *result;
5041   struct cleanup *back_to;
5042
5043   result = XCNEW (struct traceframe_info);
5044   back_to = make_cleanup (free_result, result);
5045
5046   if (gdb_xml_parse_quick (_("trace frame info"),
5047                            "traceframe-info.dtd", traceframe_info_elements,
5048                            tframe_info, result) == 0)
5049     {
5050       /* Parsed successfully, keep the result.  */
5051       discard_cleanups (back_to);
5052
5053       return result;
5054     }
5055
5056   do_cleanups (back_to);
5057   return NULL;
5058 }
5059
5060 #endif /* HAVE_LIBEXPAT */
5061
5062 /* Returns the traceframe_info object for the current traceframe.
5063    This is where we avoid re-fetching the object from the target if we
5064    already have it cached.  */
5065
5066 static struct traceframe_info *
5067 get_traceframe_info (void)
5068 {
5069   if (traceframe_info == NULL)
5070     traceframe_info = target_traceframe_info ();
5071
5072   return traceframe_info;
5073 }
5074
5075 /* If the target supports the query, return in RESULT the set of
5076    collected memory in the current traceframe, found within the LEN
5077    bytes range starting at MEMADDR.  Returns true if the target
5078    supports the query, otherwise returns false, and RESULT is left
5079    undefined.  */
5080
5081 int
5082 traceframe_available_memory (VEC(mem_range_s) **result,
5083                              CORE_ADDR memaddr, ULONGEST len)
5084 {
5085   struct traceframe_info *info = get_traceframe_info ();
5086
5087   if (info != NULL)
5088     {
5089       struct mem_range *r;
5090       int i;
5091
5092       *result = NULL;
5093
5094       for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5095         if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5096           {
5097             ULONGEST lo1, hi1, lo2, hi2;
5098             struct mem_range *nr;
5099
5100             lo1 = memaddr;
5101             hi1 = memaddr + len;
5102
5103             lo2 = r->start;
5104             hi2 = r->start + r->length;
5105
5106             nr = VEC_safe_push (mem_range_s, *result, NULL);
5107
5108             nr->start = max (lo1, lo2);
5109             nr->length = min (hi1, hi2) - nr->start;
5110           }
5111
5112       normalize_mem_ranges (*result);
5113       return 1;
5114     }
5115
5116   return 0;
5117 }
5118
5119 /* Implementation of `sdata' variable.  */
5120
5121 static const struct internalvar_funcs sdata_funcs =
5122 {
5123   sdata_make_value,
5124   NULL,
5125   NULL
5126 };
5127
5128 /* module initialization */
5129 void
5130 _initialize_tracepoint (void)
5131 {
5132   struct cmd_list_element *c;
5133
5134   /* Explicitly create without lookup, since that tries to create a
5135      value with a void typed value, and when we get here, gdbarch
5136      isn't initialized yet.  At this point, we're quite sure there
5137      isn't another convenience variable of the same name.  */
5138   create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5139
5140   traceframe_number = -1;
5141   tracepoint_number = -1;
5142
5143   if (tracepoint_list.list == NULL)
5144     {
5145       tracepoint_list.listsize = 128;
5146       tracepoint_list.list = xmalloc
5147         (tracepoint_list.listsize * sizeof (struct memrange));
5148     }
5149   if (tracepoint_list.aexpr_list == NULL)
5150     {
5151       tracepoint_list.aexpr_listsize = 128;
5152       tracepoint_list.aexpr_list = xmalloc
5153         (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
5154     }
5155
5156   if (stepping_list.list == NULL)
5157     {
5158       stepping_list.listsize = 128;
5159       stepping_list.list = xmalloc
5160         (stepping_list.listsize * sizeof (struct memrange));
5161     }
5162
5163   if (stepping_list.aexpr_list == NULL)
5164     {
5165       stepping_list.aexpr_listsize = 128;
5166       stepping_list.aexpr_list = xmalloc
5167         (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
5168     }
5169
5170   add_info ("scope", scope_info,
5171             _("List the variables local to a scope"));
5172
5173   add_cmd ("tracepoints", class_trace, NULL,
5174            _("Tracing of program execution without stopping the program."),
5175            &cmdlist);
5176
5177   add_com ("tdump", class_trace, trace_dump_command,
5178            _("Print everything collected at the current tracepoint."));
5179
5180   add_com ("tsave", class_trace, trace_save_command, _("\
5181 Save the trace data to a file.\n\
5182 Use the '-r' option to direct the target to save directly to the file,\n\
5183 using its own filesystem."));
5184
5185   c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5186 Define a trace state variable.\n\
5187 Argument is a $-prefixed name, optionally followed\n\
5188 by '=' and an expression that sets the initial value\n\
5189 at the start of tracing."));
5190   set_cmd_completer (c, expression_completer);
5191
5192   add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5193 Delete one or more trace state variables.\n\
5194 Arguments are the names of the variables to delete.\n\
5195 If no arguments are supplied, delete all variables."), &deletelist);
5196   /* FIXME add a trace variable completer.  */
5197
5198   add_info ("tvariables", tvariables_info, _("\
5199 Status of trace state variables and their values.\n\
5200 "));
5201
5202   add_info ("static-tracepoint-markers",
5203             info_static_tracepoint_markers_command, _("\
5204 List target static tracepoints markers.\n\
5205 "));
5206
5207   add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5208 Select a trace frame;\n\
5209 No argument means forward by one frame; '-' means backward by one frame."),
5210                   &tfindlist, "tfind ", 1, &cmdlist);
5211
5212   add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5213 Select a trace frame whose PC is outside the given range (exclusive).\n\
5214 Usage: tfind outside addr1, addr2"),
5215            &tfindlist);
5216
5217   add_cmd ("range", class_trace, trace_find_range_command, _("\
5218 Select a trace frame whose PC is in the given range (inclusive).\n\
5219 Usage: tfind range addr1,addr2"),
5220            &tfindlist);
5221
5222   add_cmd ("line", class_trace, trace_find_line_command, _("\
5223 Select a trace frame by source line.\n\
5224 Argument can be a line number (with optional source file),\n\
5225 a function name, or '*' followed by an address.\n\
5226 Default argument is 'the next source line that was traced'."),
5227            &tfindlist);
5228
5229   add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5230 Select a trace frame by tracepoint number.\n\
5231 Default is the tracepoint for the current trace frame."),
5232            &tfindlist);
5233
5234   add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5235 Select a trace frame by PC.\n\
5236 Default is the current PC, or the PC of the current trace frame."),
5237            &tfindlist);
5238
5239   add_cmd ("end", class_trace, trace_find_end_command, _("\
5240 De-select any trace frame and resume 'live' debugging."),
5241            &tfindlist);
5242
5243   add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5244
5245   add_cmd ("start", class_trace, trace_find_start_command,
5246            _("Select the first trace frame in the trace buffer."),
5247            &tfindlist);
5248
5249   add_com ("tstatus", class_trace, trace_status_command,
5250            _("Display the status of the current trace data collection."));
5251
5252   add_com ("tstop", class_trace, trace_stop_command, _("\
5253 Stop trace data collection.\n\
5254 Usage: tstop [ <notes> ... ]\n\
5255 Any arguments supplied are recorded with the trace as a stop reason and\n\
5256 reported by tstatus (if the target supports trace notes)."));
5257
5258   add_com ("tstart", class_trace, trace_start_command, _("\
5259 Start trace data collection.\n\
5260 Usage: tstart [ <notes> ... ]\n\
5261 Any arguments supplied are recorded with the trace as a note and\n\
5262 reported by tstatus (if the target supports trace notes)."));
5263
5264   add_com ("end", class_trace, end_actions_pseudocommand, _("\
5265 Ends a list of commands or actions.\n\
5266 Several GDB commands allow you to enter a list of commands or actions.\n\
5267 Entering \"end\" on a line by itself is the normal way to terminate\n\
5268 such a list.\n\n\
5269 Note: the \"end\" command cannot be used at the gdb prompt."));
5270
5271   add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5272 Specify single-stepping behavior at a tracepoint.\n\
5273 Argument is number of instructions to trace in single-step mode\n\
5274 following the tracepoint.  This command is normally followed by\n\
5275 one or more \"collect\" commands, to specify what to collect\n\
5276 while single-stepping.\n\n\
5277 Note: this command can only be used in a tracepoint \"actions\" list."));
5278
5279   add_com_alias ("ws", "while-stepping", class_alias, 0);
5280   add_com_alias ("stepping", "while-stepping", class_alias, 0);
5281
5282   add_com ("collect", class_trace, collect_pseudocommand, _("\
5283 Specify one or more data items to be collected at a tracepoint.\n\
5284 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
5285 collect all data (variables, registers) referenced by that expression.\n\
5286 Also accepts the following special arguments:\n\
5287     $regs   -- all registers.\n\
5288     $args   -- all function arguments.\n\
5289     $locals -- all variables local to the block/function scope.\n\
5290     $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5291 Note: this command can only be used in a tracepoint \"actions\" list."));
5292
5293   add_com ("teval", class_trace, teval_pseudocommand, _("\
5294 Specify one or more expressions to be evaluated at a tracepoint.\n\
5295 Accepts a comma-separated list of (one or more) expressions.\n\
5296 The result of each evaluation will be discarded.\n\
5297 Note: this command can only be used in a tracepoint \"actions\" list."));
5298
5299   add_com ("actions", class_trace, trace_actions_command, _("\
5300 Specify the actions to be taken at a tracepoint.\n\
5301 Tracepoint actions may include collecting of specified data,\n\
5302 single-stepping, or enabling/disabling other tracepoints,\n\
5303 depending on target's capabilities."));
5304
5305   default_collect = xstrdup ("");
5306   add_setshow_string_cmd ("default-collect", class_trace,
5307                           &default_collect, _("\
5308 Set the list of expressions to collect by default"), _("\
5309 Show the list of expressions to collect by default"), NULL,
5310                           NULL, NULL,
5311                           &setlist, &showlist);
5312
5313   add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5314                            &disconnected_tracing, _("\
5315 Set whether tracing continues after GDB disconnects."), _("\
5316 Show whether tracing continues after GDB disconnects."), _("\
5317 Use this to continue a tracing run even if GDB disconnects\n\
5318 or detaches from the target.  You can reconnect later and look at\n\
5319 trace data collected in the meantime."),
5320                            set_disconnected_tracing,
5321                            NULL,
5322                            &setlist,
5323                            &showlist);
5324
5325   add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5326                            &circular_trace_buffer, _("\
5327 Set target's use of circular trace buffer."), _("\
5328 Show target's use of circular trace buffer."), _("\
5329 Use this to make the trace buffer into a circular buffer,\n\
5330 which will discard traceframes (oldest first) instead of filling\n\
5331 up and stopping the trace run."),
5332                            set_circular_trace_buffer,
5333                            NULL,
5334                            &setlist,
5335                            &showlist);
5336
5337   add_setshow_string_cmd ("trace-user", class_trace,
5338                           &trace_user, _("\
5339 Set the user name to use for current and future trace runs"), _("\
5340 Show the user name to use for current and future trace runs"), NULL,
5341                           set_trace_user, NULL,
5342                           &setlist, &showlist);
5343
5344   add_setshow_string_cmd ("trace-notes", class_trace,
5345                           &trace_notes, _("\
5346 Set notes string to use for current and future trace runs"), _("\
5347 Show the notes string to use for current and future trace runs"), NULL,
5348                           set_trace_notes, NULL,
5349                           &setlist, &showlist);
5350
5351   add_setshow_string_cmd ("trace-stop-notes", class_trace,
5352                           &trace_stop_notes, _("\
5353 Set notes string to use for future tstop commands"), _("\
5354 Show the notes string to use for future tstop commands"), NULL,
5355                           set_trace_stop_notes, NULL,
5356                           &setlist, &showlist);
5357
5358   init_tfile_ops ();
5359
5360   add_target (&tfile_ops);
5361 }