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