gdb/tracepoint.c

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