gdb/tracepoint.c

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