gdb/tracepoint.c

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