gdb/tracepoint.c

   1 /* Tracing functionality for remote targets in custom GDB protocol
   2
   3    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   4    2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "arch-utils.h"
  23 #include "symtab.h"
  24 #include "frame.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "gdbcmd.h"
  28 #include "value.h"
  29 #include "target.h"
  30 #include "language.h"
  31 #include "gdb_string.h"
  32 #include "inferior.h"
  33 #include "breakpoint.h"
  34 #include "tracepoint.h"
  35 #include "linespec.h"
  36 #include "regcache.h"
  37 #include "completer.h"
  38 #include "block.h"
  39 #include "dictionary.h"
  40 #include "observer.h"
  41 #include "user-regs.h"
  42 #include "valprint.h"
  43 #include "gdbcore.h"
  44 #include "objfiles.h"
  45 #include "filenames.h"
  46 #include "gdbthread.h"
  47
  48 #include "ax.h"
  49 #include "ax-gdb.h"
  50
  51 /* readline include files */
  52 #include "readline/readline.h"
  53 #include "readline/history.h"
  54
  55 /* readline defines this.  */
  56 #undef savestring
  57
  58 #ifdef HAVE_UNISTD_H
  59 #include <unistd.h>
  60 #endif
  61
  62 #ifndef O_LARGEFILE
  63 #define O_LARGEFILE 0
  64 #endif
  65
  66 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
  67 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
  68
  69 extern void stop_tracing ();
  70
  71 /* Maximum length of an agent aexpression.
  72    This accounts for the fact that packets are limited to 400 bytes
  73    (which includes everything -- including the checksum), and assumes
  74    the worst case of maximum length for each of the pieces of a
  75    continuation packet.
  76
  77    NOTE: expressions get mem2hex'ed otherwise this would be twice as
  78    large.  (400 - 31)/2 == 184 */
  79 #define MAX_AGENT_EXPR_LEN      184
  80
  81 /* A hook used to notify the UI of tracepoint operations.  */
  82
  83 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
  84 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
  85
  86 extern void (*deprecated_readline_begin_hook) (char *, ...);
  87 extern char *(*deprecated_readline_hook) (char *);
  88 extern void (*deprecated_readline_end_hook) (void);
  89
  90 /* GDB commands implemented in other modules:
  91  */
  92
  93 extern void output_command (char *, int);
  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 /* Tracing command lists */
 149 static struct cmd_list_element *tfindlist;
 150
 151 /* List of expressions to collect by default at each tracepoint hit.  */
 152 char *default_collect = "";
 153
 154 static int disconnected_tracing;
 155
 156 /* ======= Important command functions: ======= */
 157 static void trace_actions_command (char *, int);
 158 static void trace_start_command (char *, int);
 159 static void trace_stop_command (char *, int);
 160 static void trace_status_command (char *, int);
 161 static void trace_find_command (char *, int);
 162 static void trace_find_pc_command (char *, int);
 163 static void trace_find_tracepoint_command (char *, int);
 164 static void trace_find_line_command (char *, int);
 165 static void trace_find_range_command (char *, int);
 166 static void trace_find_outside_command (char *, int);
 167 static void trace_dump_command (char *, int);
 168
 169 /* support routines */
 170
 171 struct collection_list;
 172 static void add_aexpr (struct collection_list *, struct agent_expr *);
 173 static char *mem2hex (gdb_byte *, char *, int);
 174 static void add_register (struct collection_list *collection,
 175                           unsigned int regno);
 176 static struct cleanup *make_cleanup_free_actions (struct breakpoint *t);
 177
 178 extern void send_disconnected_tracing_value (int value);
 179
 180 static void free_uploaded_tps (struct uploaded_tp **utpp);
 181 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
 182
 183
 184 extern void _initialize_tracepoint (void);
 185
 186 static struct trace_status trace_status;
 187
 188 char *stop_reason_names[] = {
 189   "tunknown",
 190   "tnotrun",
 191   "tstop",
 192   "tfull",
 193   "tdisconnected",
 194   "tpasscount"
 195 };
 196
 197 struct trace_status *
 198 current_trace_status ()
 199 {
 200   return &trace_status;
 201 }
 202
 203 /* Set traceframe number to NUM.  */
 204 static void
 205 set_traceframe_num (int num)
 206 {
 207   traceframe_number = num;
 208   set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
 209 }
 210
 211 /* Set tracepoint number to NUM.  */
 212 static void
 213 set_tracepoint_num (int num)
 214 {
 215   tracepoint_number = num;
 216   set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
 217 }
 218
 219 /* Set externally visible debug variables for querying/printing
 220    the traceframe context (line, function, file) */
 221
 222 static void
 223 set_traceframe_context (struct frame_info *trace_frame)
 224 {
 225   CORE_ADDR trace_pc;
 226
 227   if (trace_frame == NULL)              /* Cease debugging any trace buffers.  */
 228     {
 229       traceframe_fun = 0;
 230       traceframe_sal.pc = traceframe_sal.line = 0;
 231       traceframe_sal.symtab = NULL;
 232       clear_internalvar (lookup_internalvar ("trace_func"));
 233       clear_internalvar (lookup_internalvar ("trace_file"));
 234       set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
 235       return;
 236     }
 237
 238   /* Save as globals for internal use.  */
 239   trace_pc = get_frame_pc (trace_frame);
 240   traceframe_sal = find_pc_line (trace_pc, 0);
 241   traceframe_fun = find_pc_function (trace_pc);
 242
 243   /* Save linenumber as "$trace_line", a debugger variable visible to
 244      users.  */
 245   set_internalvar_integer (lookup_internalvar ("trace_line"),
 246                            traceframe_sal.line);
 247
 248   /* Save func name as "$trace_func", a debugger variable visible to
 249      users.  */
 250   if (traceframe_fun == NULL
 251       || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
 252     clear_internalvar (lookup_internalvar ("trace_func"));
 253   else
 254     set_internalvar_string (lookup_internalvar ("trace_func"),
 255                             SYMBOL_LINKAGE_NAME (traceframe_fun));
 256
 257   /* Save file name as "$trace_file", a debugger variable visible to
 258      users.  */
 259   if (traceframe_sal.symtab == NULL
 260       || traceframe_sal.symtab->filename == NULL)
 261     clear_internalvar (lookup_internalvar ("trace_file"));
 262   else
 263     set_internalvar_string (lookup_internalvar ("trace_file"),
 264                             traceframe_sal.symtab->filename);
 265 }
 266
 267 /* Create a new trace state variable with the given name.  */
 268
 269 struct trace_state_variable *
 270 create_trace_state_variable (const char *name)
 271 {
 272   struct trace_state_variable tsv;
 273
 274   memset (&tsv, 0, sizeof (tsv));
 275   tsv.name = name;
 276   tsv.number = next_tsv_number++;
 277   return VEC_safe_push (tsv_s, tvariables, &tsv);
 278 }
 279
 280 /* Look for a trace state variable of the given name.  */
 281
 282 struct trace_state_variable *
 283 find_trace_state_variable (const char *name)
 284 {
 285   struct trace_state_variable *tsv;
 286   int ix;
 287
 288   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 289     if (strcmp (name, tsv->name) == 0)
 290       return tsv;
 291
 292   return NULL;
 293 }
 294
 295 void
 296 delete_trace_state_variable (const char *name)
 297 {
 298   struct trace_state_variable *tsv;
 299   int ix;
 300
 301   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 302     if (strcmp (name, tsv->name) == 0)
 303       {
 304         VEC_unordered_remove (tsv_s, tvariables, ix);
 305         return;
 306       }
 307
 308   warning (_("No trace variable named \"$%s\", not deleting"), name);
 309 }
 310
 311 /* The 'tvariable' command collects a name and optional expression to
 312    evaluate into an initial value.  */
 313
 314 void
 315 trace_variable_command (char *args, int from_tty)
 316 {
 317   struct expression *expr;
 318   struct cleanup *old_chain;
 319   struct internalvar *intvar = NULL;
 320   LONGEST initval = 0;
 321   struct trace_state_variable *tsv;
 322
 323   if (!args || !*args)
 324     error_no_arg (_("trace state variable name"));
 325
 326   /* All the possible valid arguments are expressions.  */
 327   expr = parse_expression (args);
 328   old_chain = make_cleanup (free_current_contents, &expr);
 329
 330   if (expr->nelts == 0)
 331     error (_("No expression?"));
 332
 333   /* Only allow two syntaxes; "$name" and "$name=value".  */
 334   if (expr->elts[0].opcode == OP_INTERNALVAR)
 335     {
 336       intvar = expr->elts[1].internalvar;
 337     }
 338   else if (expr->elts[0].opcode == BINOP_ASSIGN
 339            && expr->elts[1].opcode == OP_INTERNALVAR)
 340     {
 341       intvar = expr->elts[2].internalvar;
 342       initval = value_as_long (evaluate_subexpression_type (expr, 4));
 343     }
 344   else
 345     error (_("Syntax must be $NAME [ = EXPR ]"));
 346
 347   if (!intvar)
 348     error (_("No name given"));
 349
 350   if (strlen (internalvar_name (intvar)) <= 0)
 351     error (_("Must supply a non-empty variable name"));
 352
 353   /* If the variable already exists, just change its initial value.  */
 354   tsv = find_trace_state_variable (internalvar_name (intvar));
 355   if (tsv)
 356     {
 357       tsv->initial_value = initval;
 358       printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
 359                        tsv->name, plongest (tsv->initial_value));
 360       return;
 361     }
 362
 363   /* Create a new variable.  */
 364   tsv = create_trace_state_variable (internalvar_name (intvar));
 365   tsv->initial_value = initval;
 366
 367   printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
 368                    tsv->name, plongest (tsv->initial_value));
 369
 370   do_cleanups (old_chain);
 371 }
 372
 373 void
 374 delete_trace_variable_command (char *args, int from_tty)
 375 {
 376   int i, ix;
 377   char **argv;
 378   struct cleanup *back_to;
 379   struct trace_state_variable *tsv;
 380
 381   if (args == NULL)
 382     {
 383       if (query (_("Delete all trace state variables? ")))
 384         VEC_free (tsv_s, tvariables);
 385       dont_repeat ();
 386       return;
 387     }
 388
 389   argv = gdb_buildargv (args);
 390   back_to = make_cleanup_freeargv (argv);
 391
 392   for (i = 0; argv[i] != NULL; i++)
 393     {
 394       if (*argv[i] == '$')
 395         delete_trace_state_variable (argv[i] + 1);
 396       else
 397         warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[i]);
 398     }
 399
 400   do_cleanups (back_to);
 401
 402   dont_repeat ();
 403 }
 404
 405 /* List all the trace state variables.  */
 406
 407 static void
 408 tvariables_info (char *args, int from_tty)
 409 {
 410   struct trace_state_variable *tsv;
 411   int ix;
 412   char *reply;
 413   ULONGEST tval;
 414
 415   if (VEC_length (tsv_s, tvariables) == 0)
 416     {
 417       printf_filtered (_("No trace state variables.\n"));
 418       return;
 419     }
 420
 421   /* Try to acquire values from the target.  */
 422   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 423     tsv->value_known = target_get_trace_state_variable_value (tsv->number,
 424                                                               &(tsv->value));
 425
 426   printf_filtered (_("Name\t\t  Initial\tCurrent\n"));
 427
 428   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
 429     {
 430       printf_filtered ("$%s", tsv->name);
 431       print_spaces_filtered (17 - strlen (tsv->name), gdb_stdout);
 432       printf_filtered ("%s ", plongest (tsv->initial_value));
 433       print_spaces_filtered (11 - strlen (plongest (tsv->initial_value)), gdb_stdout);
 434       if (tsv->value_known)
 435         printf_filtered ("  %s", plongest (tsv->value));
 436       else if (current_trace_status ()->running || traceframe_number >= 0)
 437         /* The value is/was defined, but we don't have it.  */
 438         printf_filtered (_("  <unknown>"));
 439       else
 440         /* It is not meaningful to ask about the value.  */
 441         printf_filtered (_("  <undefined>"));
 442       printf_filtered ("\n");
 443     }
 444 }
 445
 446 /* ACTIONS functions: */
 447
 448 /* Prototypes for action-parsing utility commands  */
 449 static void read_actions (struct breakpoint *);
 450
 451 /* The three functions:
 452    collect_pseudocommand,
 453    while_stepping_pseudocommand, and
 454    end_actions_pseudocommand
 455    are placeholders for "commands" that are actually ONLY to be used
 456    within a tracepoint action list.  If the actual function is ever called,
 457    it means that somebody issued the "command" at the top level,
 458    which is always an error.  */
 459
 460 void
 461 end_actions_pseudocommand (char *args, int from_tty)
 462 {
 463   error (_("This command cannot be used at the top level."));
 464 }
 465
 466 void
 467 while_stepping_pseudocommand (char *args, int from_tty)
 468 {
 469   error (_("This command can only be used in a tracepoint actions list."));
 470 }
 471
 472 static void
 473 collect_pseudocommand (char *args, int from_tty)
 474 {
 475   error (_("This command can only be used in a tracepoint actions list."));
 476 }
 477
 478 static void
 479 teval_pseudocommand (char *args, int from_tty)
 480 {
 481   error (_("This command can only be used in a tracepoint actions list."));
 482 }
 483
 484 /* Enter a list of actions for a tracepoint.  */
 485 static void
 486 trace_actions_command (char *args, int from_tty)
 487 {
 488   struct breakpoint *t;
 489   char tmpbuf[128];
 490   char *end_msg = "End with a line saying just \"end\".";
 491
 492   t = get_tracepoint_by_number (&args, 0, 1);
 493   if (t)
 494     {
 495       sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
 496                t->number);
 497
 498       if (from_tty)
 499         {
 500           if (deprecated_readline_begin_hook)
 501             (*deprecated_readline_begin_hook) ("%s  %s\n", tmpbuf, end_msg);
 502           else if (input_from_terminal_p ())
 503             printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
 504         }
 505
 506       free_actions (t);
 507       t->step_count = 0;        /* read_actions may set this */
 508       read_actions (t);
 509
 510       if (deprecated_readline_end_hook)
 511         (*deprecated_readline_end_hook) ();
 512       /* tracepoints_changed () */
 513     }
 514   /* else just return */
 515 }
 516
 517 /* worker function */
 518 static void
 519 read_actions (struct breakpoint *t)
 520 {
 521   char *line;
 522   char *prompt1 = "> ", *prompt2 = "  > ";
 523   char *prompt = prompt1;
 524   enum actionline_type linetype;
 525   extern FILE *instream;
 526   struct action_line *next = NULL, *temp;
 527   struct cleanup *old_chain;
 528
 529   /* Control-C quits instantly if typed while in this loop
 530      since it should not wait until the user types a newline.  */
 531   immediate_quit++;
 532   /* FIXME: kettenis/20010823: Something is wrong here.  In this file
 533      STOP_SIGNAL is never defined.  So this code has been left out, at
 534      least for quite a while now.  Replacing STOP_SIGNAL with SIGTSTP
 535      leads to compilation failures since the variable job_control
 536      isn't declared.  Leave this alone for now.  */
 537 #ifdef STOP_SIGNAL
 538   if (job_control)
 539     signal (STOP_SIGNAL, handle_stop_sig);
 540 #endif
 541   old_chain = make_cleanup_free_actions (t);
 542   while (1)
 543     {
 544       /* Make sure that all output has been output.  Some machines may
 545          let you get away with leaving out some of the gdb_flush, but
 546          not all.  */
 547       wrap_here ("");
 548       gdb_flush (gdb_stdout);
 549       gdb_flush (gdb_stderr);
 550
 551       if (deprecated_readline_hook && instream == NULL)
 552         line = (*deprecated_readline_hook) (prompt);
 553       else if (instream == stdin && ISATTY (instream))
 554         {
 555           line = gdb_readline_wrapper (prompt);
 556           if (line && *line)    /* add it to command history */
 557             add_history (line);
 558         }
 559       else
 560         line = gdb_readline (0);
 561
 562       if (!line)
 563         {
 564           line = xstrdup ("end");
 565           printf_filtered ("end\n");
 566         }
 567
 568       linetype = validate_actionline (&line, t);
 569       if (linetype == BADLINE)
 570         continue;               /* already warned -- collect another line */
 571
 572       temp = xmalloc (sizeof (struct action_line));
 573       temp->next = NULL;
 574       temp->action = line;
 575
 576       if (next == NULL)         /* first action for this tracepoint? */
 577         t->actions = next = temp;
 578       else
 579         {
 580           next->next = temp;
 581           next = temp;
 582         }
 583
 584       if (linetype == STEPPING) /* begin "while-stepping" */
 585         {
 586           if (prompt == prompt2)
 587             {
 588               warning (_("Already processing 'while-stepping'"));
 589               continue;
 590             }
 591           else
 592             prompt = prompt2;   /* change prompt for stepping actions */
 593         }
 594       else if (linetype == END)
 595         {
 596           if (prompt == prompt2)
 597             {
 598               prompt = prompt1; /* end of single-stepping actions */
 599             }
 600           else
 601             {                   /* end of actions */
 602               if (t->actions->next == NULL)
 603                 {
 604                   /* An "end" all by itself with no other actions
 605                      means this tracepoint has no actions.
 606                      Discard empty list.  */
 607                   free_actions (t);
 608                 }
 609               break;
 610             }
 611         }
 612     }
 613 #ifdef STOP_SIGNAL
 614   if (job_control)
 615     signal (STOP_SIGNAL, SIG_DFL);
 616 #endif
 617   immediate_quit--;
 618   discard_cleanups (old_chain);
 619 }
 620
 621 /* worker function */
 622 enum actionline_type
 623 validate_actionline (char **line, struct breakpoint *t)
 624 {
 625   struct cmd_list_element *c;
 626   struct expression *exp = NULL;
 627   struct cleanup *old_chain = NULL;
 628   char *p;
 629
 630   /* if EOF is typed, *line is NULL */
 631   if (*line == NULL)
 632     return END;
 633
 634   for (p = *line; isspace ((int) *p);)
 635     p++;
 636
 637   /* Symbol lookup etc.  */
 638   if (*p == '\0')       /* empty line: just prompt for another line.  */
 639     return BADLINE;
 640
 641   if (*p == '#')                /* comment line */
 642     return GENERIC;
 643
 644   c = lookup_cmd (&p, cmdlist, "", -1, 1);
 645   if (c == 0)
 646     {
 647       warning (_("'%s' is not an action that I know, or is ambiguous."),
 648                p);
 649       return BADLINE;
 650     }
 651
 652   if (cmd_cfunc_eq (c, collect_pseudocommand))
 653     {
 654       struct agent_expr *aexpr;
 655       struct agent_reqs areqs;
 656
 657       do
 658         {                       /* repeat over a comma-separated list */
 659           QUIT;                 /* allow user to bail out with ^C */
 660           while (isspace ((int) *p))
 661             p++;
 662
 663           if (*p == '$')        /* look for special pseudo-symbols */
 664             {
 665               if ((0 == strncasecmp ("reg", p + 1, 3)) ||
 666                   (0 == strncasecmp ("arg", p + 1, 3)) ||
 667                   (0 == strncasecmp ("loc", p + 1, 3)))
 668                 {
 669                   p = strchr (p, ',');
 670                   continue;
 671                 }
 672               /* else fall thru, treat p as an expression and parse it!  */
 673             }
 674           exp = parse_exp_1 (&p, block_for_pc (t->loc->address), 1);
 675           old_chain = make_cleanup (free_current_contents, &exp);
 676
 677           if (exp->elts[0].opcode == OP_VAR_VALUE)
 678             {
 679               if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
 680                 {
 681                   warning (_("constant %s (value %ld) will not be collected."),
 682                            SYMBOL_PRINT_NAME (exp->elts[2].symbol),
 683                            SYMBOL_VALUE (exp->elts[2].symbol));
 684                   return BADLINE;
 685                 }
 686               else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
 687                 {
 688                   warning (_("%s is optimized away and cannot be collected."),
 689                            SYMBOL_PRINT_NAME (exp->elts[2].symbol));
 690                   return BADLINE;
 691                 }
 692             }
 693
 694           /* We have something to collect, make sure that the expr to
 695              bytecode translator can handle it and that it's not too
 696              long.  */
 697           aexpr = gen_trace_for_expr (t->loc->address, exp);
 698           make_cleanup_free_agent_expr (aexpr);
 699
 700           if (aexpr->len > MAX_AGENT_EXPR_LEN)
 701             error (_("expression too complicated, try simplifying"));
 702
 703           ax_reqs (aexpr, &areqs);
 704           (void) make_cleanup (xfree, areqs.reg_mask);
 705
 706           if (areqs.flaw != agent_flaw_none)
 707             error (_("malformed expression"));
 708
 709           if (areqs.min_height < 0)
 710             error (_("gdb: Internal error: expression has min height < 0"));
 711
 712           if (areqs.max_height > 20)
 713             error (_("expression too complicated, try simplifying"));
 714
 715           do_cleanups (old_chain);
 716         }
 717       while (p && *p++ == ',');
 718       return GENERIC;
 719     }
 720   else if (cmd_cfunc_eq (c, teval_pseudocommand))
 721     {
 722       struct agent_expr *aexpr;
 723
 724       do
 725         {                       /* repeat over a comma-separated list */
 726           QUIT;                 /* allow user to bail out with ^C */
 727           while (isspace ((int) *p))
 728             p++;
 729
 730           /* Only expressions are allowed for this action.  */
 731           exp = parse_exp_1 (&p, block_for_pc (t->loc->address), 1);
 732           old_chain = make_cleanup (free_current_contents, &exp);
 733
 734           /* We have something to evaluate, make sure that the expr to
 735              bytecode translator can handle it and that it's not too
 736              long.  */
 737           aexpr = gen_eval_for_expr (t->loc->address, exp);
 738           make_cleanup_free_agent_expr (aexpr);
 739
 740           if (aexpr->len > MAX_AGENT_EXPR_LEN)
 741             error (_("expression too complicated, try simplifying"));
 742
 743           do_cleanups (old_chain);
 744         }
 745       while (p && *p++ == ',');
 746       return GENERIC;
 747     }
 748   else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
 749     {
 750       char *steparg;            /* in case warning is necessary */
 751
 752       while (isspace ((int) *p))
 753         p++;
 754       steparg = p;
 755
 756       if (*p == '\0' ||
 757           (t->step_count = strtol (p, &p, 0)) == 0)
 758         {
 759           warning (_("'%s': bad step-count; command ignored."), *line);
 760           return BADLINE;
 761         }
 762       return STEPPING;
 763     }
 764   else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
 765     return END;
 766   else
 767     {
 768       warning (_("'%s' is not a supported tracepoint action."), *line);
 769       return BADLINE;
 770     }
 771 }
 772
 773 /* worker function */
 774 void
 775 free_actions (struct breakpoint *t)
 776 {
 777   struct action_line *line, *next;
 778
 779   for (line = t->actions; line; line = next)
 780     {
 781       next = line->next;
 782       if (line->action)
 783         xfree (line->action);
 784       xfree (line);
 785     }
 786   t->actions = NULL;
 787 }
 788
 789 static void
 790 do_free_actions_cleanup (void *t)
 791 {
 792   free_actions (t);
 793 }
 794
 795 static struct cleanup *
 796 make_cleanup_free_actions (struct breakpoint *t)
 797 {
 798   return make_cleanup (do_free_actions_cleanup, t);
 799 }
 800
 801 enum {
 802   memrange_absolute = -1
 803 };
 804
 805 struct memrange
 806 {
 807   int type;             /* memrange_absolute for absolute memory range,
 808                            else basereg number */
 809   bfd_signed_vma start;
 810   bfd_signed_vma end;
 811 };
 812
 813 struct collection_list
 814   {
 815     unsigned char regs_mask[32];        /* room for up to 256 regs */
 816     long listsize;
 817     long next_memrange;
 818     struct memrange *list;
 819     long aexpr_listsize;        /* size of array pointed to by expr_list elt */
 820     long next_aexpr_elt;
 821     struct agent_expr **aexpr_list;
 822
 823   }
 824 tracepoint_list, stepping_list;
 825
 826 /* MEMRANGE functions: */
 827
 828 static int memrange_cmp (const void *, const void *);
 829
 830 /* compare memranges for qsort */
 831 static int
 832 memrange_cmp (const void *va, const void *vb)
 833 {
 834   const struct memrange *a = va, *b = vb;
 835
 836   if (a->type < b->type)
 837     return -1;
 838   if (a->type > b->type)
 839     return 1;
 840   if (a->type == memrange_absolute)
 841     {
 842       if ((bfd_vma) a->start < (bfd_vma) b->start)
 843         return -1;
 844       if ((bfd_vma) a->start > (bfd_vma) b->start)
 845         return 1;
 846     }
 847   else
 848     {
 849       if (a->start < b->start)
 850         return -1;
 851       if (a->start > b->start)
 852         return 1;
 853     }
 854   return 0;
 855 }
 856
 857 /* Sort the memrange list using qsort, and merge adjacent memranges.  */
 858 static void
 859 memrange_sortmerge (struct collection_list *memranges)
 860 {
 861   int a, b;
 862
 863   qsort (memranges->list, memranges->next_memrange,
 864          sizeof (struct memrange), memrange_cmp);
 865   if (memranges->next_memrange > 0)
 866     {
 867       for (a = 0, b = 1; b < memranges->next_memrange; b++)
 868         {
 869           if (memranges->list[a].type == memranges->list[b].type &&
 870               memranges->list[b].start - memranges->list[a].end <=
 871               MAX_REGISTER_SIZE)
 872             {
 873               /* memrange b starts before memrange a ends; merge them.  */
 874               if (memranges->list[b].end > memranges->list[a].end)
 875                 memranges->list[a].end = memranges->list[b].end;
 876               continue;         /* next b, same a */
 877             }
 878           a++;                  /* next a */
 879           if (a != b)
 880             memcpy (&memranges->list[a], &memranges->list[b],
 881                     sizeof (struct memrange));
 882         }
 883       memranges->next_memrange = a + 1;
 884     }
 885 }
 886
 887 /* Add a register to a collection list.  */
 888 static void
 889 add_register (struct collection_list *collection, unsigned int regno)
 890 {
 891   if (info_verbose)
 892     printf_filtered ("collect register %d\n", regno);
 893   if (regno >= (8 * sizeof (collection->regs_mask)))
 894     error (_("Internal: register number %d too large for tracepoint"),
 895            regno);
 896   collection->regs_mask[regno / 8] |= 1 << (regno % 8);
 897 }
 898
 899 /* Add a memrange to a collection list */
 900 static void
 901 add_memrange (struct collection_list *memranges,
 902               int type, bfd_signed_vma base,
 903               unsigned long len)
 904 {
 905   if (info_verbose)
 906     {
 907       printf_filtered ("(%d,", type);
 908       printf_vma (base);
 909       printf_filtered (",%ld)\n", len);
 910     }
 911
 912   /* type: memrange_absolute == memory, other n == basereg */
 913   memranges->list[memranges->next_memrange].type = type;
 914   /* base: addr if memory, offset if reg relative.  */
 915   memranges->list[memranges->next_memrange].start = base;
 916   /* len: we actually save end (base + len) for convenience */
 917   memranges->list[memranges->next_memrange].end = base + len;
 918   memranges->next_memrange++;
 919   if (memranges->next_memrange >= memranges->listsize)
 920     {
 921       memranges->listsize *= 2;
 922       memranges->list = xrealloc (memranges->list,
 923                                   memranges->listsize);
 924     }
 925
 926   if (type != memrange_absolute)                /* Better collect the base register!  */
 927     add_register (memranges, type);
 928 }
 929
 930 /* Add a symbol to a collection list.  */
 931 static void
 932 collect_symbol (struct collection_list *collect,
 933                 struct symbol *sym,
 934                 struct gdbarch *gdbarch,
 935                 long frame_regno, long frame_offset,
 936                 CORE_ADDR scope)
 937 {
 938   unsigned long len;
 939   unsigned int reg;
 940   bfd_signed_vma offset;
 941
 942   len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
 943   switch (SYMBOL_CLASS (sym))
 944     {
 945     default:
 946       printf_filtered ("%s: don't know symbol class %d\n",
 947                        SYMBOL_PRINT_NAME (sym),
 948                        SYMBOL_CLASS (sym));
 949       break;
 950     case LOC_CONST:
 951       printf_filtered ("constant %s (value %ld) will not be collected.\n",
 952                        SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
 953       break;
 954     case LOC_STATIC:
 955       offset = SYMBOL_VALUE_ADDRESS (sym);
 956       if (info_verbose)
 957         {
 958           char tmp[40];
 959
 960           sprintf_vma (tmp, offset);
 961           printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
 962                            SYMBOL_PRINT_NAME (sym), len,
 963                            tmp /* address */);
 964         }
 965       add_memrange (collect, memrange_absolute, offset, len);
 966       break;
 967     case LOC_REGISTER:
 968       reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
 969       if (info_verbose)
 970         printf_filtered ("LOC_REG[parm] %s: ",
 971                          SYMBOL_PRINT_NAME (sym));
 972       add_register (collect, reg);
 973       /* Check for doubles stored in two registers.  */
 974       /* FIXME: how about larger types stored in 3 or more regs?  */
 975       if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
 976           len > register_size (gdbarch, reg))
 977         add_register (collect, reg + 1);
 978       break;
 979     case LOC_REF_ARG:
 980       printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
 981       printf_filtered ("       (will not collect %s)\n",
 982                        SYMBOL_PRINT_NAME (sym));
 983       break;
 984     case LOC_ARG:
 985       reg = frame_regno;
 986       offset = frame_offset + SYMBOL_VALUE (sym);
 987       if (info_verbose)
 988         {
 989           printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
 990                            SYMBOL_PRINT_NAME (sym), len);
 991           printf_vma (offset);
 992           printf_filtered (" from frame ptr reg %d\n", reg);
 993         }
 994       add_memrange (collect, reg, offset, len);
 995       break;
 996     case LOC_REGPARM_ADDR:
 997       reg = SYMBOL_VALUE (sym);
 998       offset = 0;
 999       if (info_verbose)
1000         {
1001           printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1002                            SYMBOL_PRINT_NAME (sym), len);
1003           printf_vma (offset);
1004           printf_filtered (" from reg %d\n", reg);
1005         }
1006       add_memrange (collect, reg, offset, len);
1007       break;
1008     case LOC_LOCAL:
1009       reg = frame_regno;
1010       offset = frame_offset + SYMBOL_VALUE (sym);
1011       if (info_verbose)
1012         {
1013           printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1014                            SYMBOL_PRINT_NAME (sym), len);
1015           printf_vma (offset);
1016           printf_filtered (" from frame ptr reg %d\n", reg);
1017         }
1018       add_memrange (collect, reg, offset, len);
1019       break;
1020     case LOC_UNRESOLVED:
1021       printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1022                        SYMBOL_PRINT_NAME (sym));
1023       break;
1024     case LOC_OPTIMIZED_OUT:
1025       printf_filtered ("%s has been optimized out of existence.\n",
1026                        SYMBOL_PRINT_NAME (sym));
1027       break;
1028
1029     case LOC_COMPUTED:
1030       {
1031         struct agent_expr *aexpr;
1032         struct cleanup *old_chain1 = NULL;
1033         struct agent_reqs areqs;
1034
1035         aexpr = gen_trace_for_var (scope, sym);
1036
1037         old_chain1 = make_cleanup_free_agent_expr (aexpr);
1038
1039         ax_reqs (aexpr, &areqs);
1040         if (areqs.flaw != agent_flaw_none)
1041           error (_("malformed expression"));
1042
1043         if (areqs.min_height < 0)
1044           error (_("gdb: Internal error: expression has min height < 0"));
1045         if (areqs.max_height > 20)
1046           error (_("expression too complicated, try simplifying"));
1047
1048         discard_cleanups (old_chain1);
1049         add_aexpr (collect, aexpr);
1050
1051         /* take care of the registers */
1052         if (areqs.reg_mask_len > 0)
1053           {
1054             int ndx1, ndx2;
1055
1056             for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1057               {
1058                 QUIT;   /* allow user to bail out with ^C */
1059                 if (areqs.reg_mask[ndx1] != 0)
1060                   {
1061                     /* assume chars have 8 bits */
1062                     for (ndx2 = 0; ndx2 < 8; ndx2++)
1063                       if (areqs.reg_mask[ndx1] & (1 << ndx2))
1064                         /* it's used -- record it */
1065                         add_register (collect,
1066                                       ndx1 * 8 + ndx2);
1067                   }
1068               }
1069           }
1070       }
1071       break;
1072     }
1073 }
1074
1075 /* Add all locals (or args) symbols to collection list */
1076 static void
1077 add_local_symbols (struct collection_list *collect,
1078                    struct gdbarch *gdbarch, CORE_ADDR pc,
1079                    long frame_regno, long frame_offset, int type)
1080 {
1081   struct symbol *sym;
1082   struct block *block;
1083   struct dict_iterator iter;
1084   int count = 0;
1085
1086   block = block_for_pc (pc);
1087   while (block != 0)
1088     {
1089       QUIT;                     /* allow user to bail out with ^C */
1090       ALL_BLOCK_SYMBOLS (block, iter, sym)
1091         {
1092           if (SYMBOL_IS_ARGUMENT (sym)
1093               ? type == 'A'     /* collecting Arguments */
1094               : type == 'L')    /* collecting Locals */
1095             {
1096               count++;
1097               collect_symbol (collect, sym, gdbarch,
1098                               frame_regno, frame_offset, pc);
1099             }
1100         }
1101       if (BLOCK_FUNCTION (block))
1102         break;
1103       else
1104         block = BLOCK_SUPERBLOCK (block);
1105     }
1106   if (count == 0)
1107     warning (_("No %s found in scope."),
1108              type == 'L' ? "locals" : "args");
1109 }
1110
1111 /* worker function */
1112 static void
1113 clear_collection_list (struct collection_list *list)
1114 {
1115   int ndx;
1116
1117   list->next_memrange = 0;
1118   for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1119     {
1120       free_agent_expr (list->aexpr_list[ndx]);
1121       list->aexpr_list[ndx] = NULL;
1122     }
1123   list->next_aexpr_elt = 0;
1124   memset (list->regs_mask, 0, sizeof (list->regs_mask));
1125 }
1126
1127 /* reduce a collection list to string form (for gdb protocol) */
1128 static char **
1129 stringify_collection_list (struct collection_list *list, char *string)
1130 {
1131   char temp_buf[2048];
1132   char tmp2[40];
1133   int count;
1134   int ndx = 0;
1135   char *(*str_list)[];
1136   char *end;
1137   long i;
1138
1139   count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1140   str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1141
1142   for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1143     if (list->regs_mask[i] != 0)        /* skip leading zeroes in regs_mask */
1144       break;
1145   if (list->regs_mask[i] != 0)  /* prepare to send regs_mask to the stub */
1146     {
1147       if (info_verbose)
1148         printf_filtered ("\nCollecting registers (mask): 0x");
1149       end = temp_buf;
1150       *end++ = 'R';
1151       for (; i >= 0; i--)
1152         {
1153           QUIT;                 /* allow user to bail out with ^C */
1154           if (info_verbose)
1155             printf_filtered ("%02X", list->regs_mask[i]);
1156           sprintf (end, "%02X", list->regs_mask[i]);
1157           end += 2;
1158         }
1159       (*str_list)[ndx] = xstrdup (temp_buf);
1160       ndx++;
1161     }
1162   if (info_verbose)
1163     printf_filtered ("\n");
1164   if (list->next_memrange > 0 && info_verbose)
1165     printf_filtered ("Collecting memranges: \n");
1166   for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1167     {
1168       QUIT;                     /* allow user to bail out with ^C */
1169       sprintf_vma (tmp2, list->list[i].start);
1170       if (info_verbose)
1171         {
1172           printf_filtered ("(%d, %s, %ld)\n",
1173                            list->list[i].type,
1174                            tmp2,
1175                            (long) (list->list[i].end - list->list[i].start));
1176         }
1177       if (count + 27 > MAX_AGENT_EXPR_LEN)
1178         {
1179           (*str_list)[ndx] = savestring (temp_buf, count);
1180           ndx++;
1181           count = 0;
1182           end = temp_buf;
1183         }
1184
1185       {
1186         bfd_signed_vma length = list->list[i].end - list->list[i].start;
1187
1188         /* The "%X" conversion specifier expects an unsigned argument,
1189            so passing -1 (memrange_absolute) to it directly gives you
1190            "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1191            Special-case it.  */
1192         if (list->list[i].type == memrange_absolute)
1193           sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1194         else
1195           sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1196       }
1197
1198       count += strlen (end);
1199       end = temp_buf + count;
1200     }
1201
1202   for (i = 0; i < list->next_aexpr_elt; i++)
1203     {
1204       QUIT;                     /* allow user to bail out with ^C */
1205       if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1206         {
1207           (*str_list)[ndx] = savestring (temp_buf, count);
1208           ndx++;
1209           count = 0;
1210           end = temp_buf;
1211         }
1212       sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1213       end += 10;                /* 'X' + 8 hex digits + ',' */
1214       count += 10;
1215
1216       end = mem2hex (list->aexpr_list[i]->buf,
1217                      end, list->aexpr_list[i]->len);
1218       count += 2 * list->aexpr_list[i]->len;
1219     }
1220
1221   if (count != 0)
1222     {
1223       (*str_list)[ndx] = savestring (temp_buf, count);
1224       ndx++;
1225       count = 0;
1226       end = temp_buf;
1227     }
1228   (*str_list)[ndx] = NULL;
1229
1230   if (ndx == 0)
1231     {
1232       xfree (str_list);
1233       return NULL;
1234     }
1235   else
1236     return *str_list;
1237 }
1238
1239 /* Render all actions into gdb protocol.  */
1240 /*static*/ void
1241 encode_actions (struct breakpoint *t, char ***tdp_actions,
1242                 char ***stepping_actions)
1243 {
1244   static char tdp_buff[2048], step_buff[2048];
1245   char *action_exp;
1246   struct expression *exp = NULL;
1247   struct action_line *action;
1248   int i;
1249   struct value *tempval;
1250   struct collection_list *collect;
1251   struct cmd_list_element *cmd;
1252   struct agent_expr *aexpr;
1253   int frame_reg;
1254   LONGEST frame_offset;
1255   char *default_collect_line = NULL;
1256   struct action_line *default_collect_action = NULL;
1257
1258   clear_collection_list (&tracepoint_list);
1259   clear_collection_list (&stepping_list);
1260   collect = &tracepoint_list;
1261
1262   *tdp_actions = NULL;
1263   *stepping_actions = NULL;
1264
1265   gdbarch_virtual_frame_pointer (t->gdbarch,
1266                                  t->loc->address, &frame_reg, &frame_offset);
1267
1268   action = t->actions;
1269
1270   /* If there are default expressions to collect, make up a collect
1271      action and prepend to the action list to encode.  Note that since
1272      validation is per-tracepoint (local var "xyz" might be valid for
1273      one tracepoint and not another, etc), we make up the action on
1274      the fly, and don't cache it.  */
1275   if (*default_collect)
1276     {
1277       char *line;
1278       enum actionline_type linetype;
1279
1280       default_collect_line = xmalloc (12 + strlen (default_collect));
1281       sprintf (default_collect_line, "collect %s", default_collect);
1282       line = default_collect_line;
1283       linetype = validate_actionline (&line, t);
1284       if (linetype != BADLINE)
1285         {
1286           default_collect_action = xmalloc (sizeof (struct action_line));
1287           default_collect_action->next = t->actions;
1288           default_collect_action->action = line;
1289           action = default_collect_action;
1290         }
1291     }
1292
1293   for (; action; action = action->next)
1294     {
1295       QUIT;                     /* allow user to bail out with ^C */
1296       action_exp = action->action;
1297       while (isspace ((int) *action_exp))
1298         action_exp++;
1299
1300       if (*action_exp == '#')   /* comment line */
1301         return;
1302
1303       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1304       if (cmd == 0)
1305         error (_("Bad action list item: %s"), action_exp);
1306
1307       if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1308         {
1309           do
1310             {                   /* repeat over a comma-separated list */
1311               QUIT;             /* allow user to bail out with ^C */
1312               while (isspace ((int) *action_exp))
1313                 action_exp++;
1314
1315               if (0 == strncasecmp ("$reg", action_exp, 4))
1316                 {
1317                   for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1318                     add_register (collect, i);
1319                   action_exp = strchr (action_exp, ',');        /* more? */
1320                 }
1321               else if (0 == strncasecmp ("$arg", action_exp, 4))
1322                 {
1323                   add_local_symbols (collect,
1324                                      t->gdbarch,
1325                                      t->loc->address,
1326                                      frame_reg,
1327                                      frame_offset,
1328                                      'A');
1329                   action_exp = strchr (action_exp, ',');        /* more? */
1330                 }
1331               else if (0 == strncasecmp ("$loc", action_exp, 4))
1332                 {
1333                   add_local_symbols (collect,
1334                                      t->gdbarch,
1335                                      t->loc->address,
1336                                      frame_reg,
1337                                      frame_offset,
1338                                      'L');
1339                   action_exp = strchr (action_exp, ',');        /* more? */
1340                 }
1341               else
1342                 {
1343                   unsigned long addr, len;
1344                   struct cleanup *old_chain = NULL;
1345                   struct cleanup *old_chain1 = NULL;
1346                   struct agent_reqs areqs;
1347
1348                   exp = parse_exp_1 (&action_exp,
1349                                      block_for_pc (t->loc->address), 1);
1350                   old_chain = make_cleanup (free_current_contents, &exp);
1351
1352                   switch (exp->elts[0].opcode)
1353                     {
1354                     case OP_REGISTER:
1355                       {
1356                         const char *name = &exp->elts[2].string;
1357
1358                         i = user_reg_map_name_to_regnum (t->gdbarch,
1359                                                          name, strlen (name));
1360                         if (i == -1)
1361                           internal_error (__FILE__, __LINE__,
1362                                           _("Register $%s not available"),
1363                                           name);
1364                         if (info_verbose)
1365                           printf_filtered ("OP_REGISTER: ");
1366                         add_register (collect, i);
1367                         break;
1368                       }
1369
1370                     case UNOP_MEMVAL:
1371                       /* safe because we know it's a simple expression */
1372                       tempval = evaluate_expression (exp);
1373                       addr = value_address (tempval);
1374                       len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1375                       add_memrange (collect, memrange_absolute, addr, len);
1376                       break;
1377
1378                     case OP_VAR_VALUE:
1379                       collect_symbol (collect,
1380                                       exp->elts[2].symbol,
1381                                       t->gdbarch,
1382                                       frame_reg,
1383                                       frame_offset,
1384                                       t->loc->address);
1385                       break;
1386
1387                     default:    /* full-fledged expression */
1388                       aexpr = gen_trace_for_expr (t->loc->address, exp);
1389
1390                       old_chain1 = make_cleanup_free_agent_expr (aexpr);
1391
1392                       ax_reqs (aexpr, &areqs);
1393                       if (areqs.flaw != agent_flaw_none)
1394                         error (_("malformed expression"));
1395
1396                       if (areqs.min_height < 0)
1397                         error (_("gdb: Internal error: expression has min height < 0"));
1398                       if (areqs.max_height > 20)
1399                         error (_("expression too complicated, try simplifying"));
1400
1401                       discard_cleanups (old_chain1);
1402                       add_aexpr (collect, aexpr);
1403
1404                       /* take care of the registers */
1405                       if (areqs.reg_mask_len > 0)
1406                         {
1407                           int ndx1;
1408                           int ndx2;
1409
1410                           for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1411                             {
1412                               QUIT;     /* allow user to bail out with ^C */
1413                               if (areqs.reg_mask[ndx1] != 0)
1414                                 {
1415                                   /* assume chars have 8 bits */
1416                                   for (ndx2 = 0; ndx2 < 8; ndx2++)
1417                                     if (areqs.reg_mask[ndx1] & (1 << ndx2))
1418                                       /* it's used -- record it */
1419                                       add_register (collect,
1420                                                     ndx1 * 8 + ndx2);
1421                                 }
1422                             }
1423                         }
1424                       break;
1425                     }           /* switch */
1426                   do_cleanups (old_chain);
1427                 }               /* do */
1428             }
1429           while (action_exp && *action_exp++ == ',');
1430         }                       /* if */
1431       else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1432         {
1433           do
1434             {                   /* repeat over a comma-separated list */
1435               QUIT;             /* allow user to bail out with ^C */
1436               while (isspace ((int) *action_exp))
1437                 action_exp++;
1438
1439                 {
1440                   unsigned long addr, len;
1441                   struct cleanup *old_chain = NULL;
1442                   struct cleanup *old_chain1 = NULL;
1443                   struct agent_reqs areqs;
1444
1445                   exp = parse_exp_1 (&action_exp,
1446                                      block_for_pc (t->loc->address), 1);
1447                   old_chain = make_cleanup (free_current_contents, &exp);
1448
1449                   aexpr = gen_eval_for_expr (t->loc->address, exp);
1450                   old_chain1 = make_cleanup_free_agent_expr (aexpr);
1451
1452                   ax_reqs (aexpr, &areqs);
1453                   if (areqs.flaw != agent_flaw_none)
1454                     error (_("malformed expression"));
1455
1456                   if (areqs.min_height < 0)
1457                     error (_("gdb: Internal error: expression has min height < 0"));
1458                   if (areqs.max_height > 20)
1459                     error (_("expression too complicated, try simplifying"));
1460
1461                   discard_cleanups (old_chain1);
1462                   /* Even though we're not officially collecting, add
1463                      to the collect list anyway.  */
1464                   add_aexpr (collect, aexpr);
1465
1466                   do_cleanups (old_chain);
1467                 }               /* do */
1468             }
1469           while (action_exp && *action_exp++ == ',');
1470         }                       /* if */
1471       else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1472         {
1473           collect = &stepping_list;
1474         }
1475       else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
1476         {
1477           if (collect == &stepping_list)        /* end stepping actions */
1478             collect = &tracepoint_list;
1479           else
1480             break;              /* end tracepoint actions */
1481         }
1482     }                           /* for */
1483   memrange_sortmerge (&tracepoint_list);
1484   memrange_sortmerge (&stepping_list);
1485
1486   *tdp_actions = stringify_collection_list (&tracepoint_list,
1487                                             tdp_buff);
1488   *stepping_actions = stringify_collection_list (&stepping_list,
1489                                                  step_buff);
1490
1491   xfree (default_collect_line);
1492   xfree (default_collect_action);
1493 }
1494
1495 static void
1496 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1497 {
1498   if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1499     {
1500       collect->aexpr_list =
1501         xrealloc (collect->aexpr_list,
1502                 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1503       collect->aexpr_listsize *= 2;
1504     }
1505   collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1506   collect->next_aexpr_elt++;
1507 }
1508
1509 /* tstart command:
1510
1511    Tell target to clear any previous trace experiment.
1512    Walk the list of tracepoints, and send them (and their actions)
1513    to the target.  If no errors,
1514    Tell target to start a new trace experiment.  */
1515
1516 static void
1517 trace_start_command (char *args, int from_tty)
1518 {
1519   char buf[2048];
1520   VEC(breakpoint_p) *tp_vec = NULL;
1521   int ix;
1522   struct breakpoint *t;
1523   struct trace_state_variable *tsv;
1524   int any_downloaded = 0;
1525
1526   dont_repeat ();       /* Like "run", dangerous to repeat accidentally.  */
1527
1528   target_trace_init ();
1529
1530   tp_vec = all_tracepoints ();
1531   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1532     {
1533       t->number_on_target = 0;
1534       target_download_tracepoint (t);
1535       t->number_on_target = t->number;
1536       any_downloaded = 1;
1537     }
1538   VEC_free (breakpoint_p, tp_vec);
1539
1540   /* No point in tracing without any tracepoints... */
1541   if (!any_downloaded)
1542     error ("No tracepoints downloaded, not starting trace");
1543
1544   /* Send down all the trace state variables too.  */
1545   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1546     {
1547       target_download_trace_state_variable (tsv);
1548     }
1549
1550   /* Tell target to treat text-like sections as transparent.  */
1551   target_trace_set_readonly_regions ();
1552
1553   /* Now insert traps and begin collecting data.  */
1554   target_trace_start ();
1555
1556   /* Reset our local state.  */
1557   set_traceframe_num (-1);
1558   set_tracepoint_num (-1);
1559   set_traceframe_context (NULL);
1560   current_trace_status()->running = 1;
1561 }
1562
1563 /* tstop command */
1564 static void
1565 trace_stop_command (char *args, int from_tty)
1566 {
1567   stop_tracing ();
1568 }
1569
1570 void
1571 stop_tracing ()
1572 {
1573   target_trace_stop ();
1574   /* should change in response to reply? */
1575   current_trace_status ()->running = 0;
1576 }
1577
1578 /* tstatus command */
1579 static void
1580 trace_status_command (char *args, int from_tty)
1581 {
1582   struct trace_status *ts = current_trace_status ();
1583   int status;
1584
1585   status = target_get_trace_status (ts);
1586
1587   if (status == -1)
1588     {
1589       if (ts->from_file)
1590         printf_filtered (_("Using a trace file.\n"));
1591       else
1592         {
1593           printf_filtered (_("Trace can not be run on this target.\n"));
1594           return;
1595         }
1596     }
1597
1598   if (!ts->running_known)
1599     {
1600       printf_filtered (_("Run/stop status is unknown.\n"));
1601     }
1602   else if (ts->running)
1603     {
1604       printf_filtered (_("Trace is running on the target.\n"));
1605       if (disconnected_tracing)
1606         printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1607       else
1608         printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1609     }
1610   else
1611     {
1612       switch (ts->stop_reason)
1613         {
1614         case trace_never_run:
1615           printf_filtered (_("No trace has been run on the target.\n"));
1616           break;
1617         case tstop_command:
1618           printf_filtered (_("Trace stopped by a tstop command.\n"));
1619           break;
1620         case trace_buffer_full:
1621           printf_filtered (_("Trace stopped because the buffer was full.\n"));
1622           break;
1623         case trace_disconnected:
1624           printf_filtered (_("Trace stopped because of disconnection.\n"));
1625           break;
1626         case tracepoint_passcount:
1627           /* FIXME account for number on target */
1628           printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1629                            ts->stopping_tracepoint);
1630           break;
1631         case trace_stop_reason_unknown:
1632           printf_filtered (_("Trace stopped for an unknown reason.\n"));
1633           break;
1634         default:
1635           printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1636                            ts->stop_reason);
1637           break;
1638         }
1639     }
1640
1641   if (ts->traceframe_count >= 0)
1642     {
1643       printf_filtered (_("Collected %d trace frames.\n"),
1644                        ts->traceframe_count);
1645     }
1646
1647   if (ts->buffer_free)
1648     {
1649       printf_filtered (_("Trace buffer has %llu bytes free.\n"),
1650                        ts->buffer_free);
1651     }
1652
1653   /* Now report on what we're doing with tfind.  */
1654   if (traceframe_number >= 0)
1655     printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1656                      traceframe_number, tracepoint_number);
1657   else
1658     printf_filtered (_("Not looking at any trace frame.\n"));
1659 }
1660
1661 void
1662 disconnect_or_stop_tracing (int from_tty)
1663 {
1664   /* It can happen that the target that was tracing went away on its
1665      own, and we didn't notice.  Get a status update, and if the
1666      current target doesn't even do tracing, then assume it's not
1667      running anymore.  */
1668   if (target_get_trace_status (current_trace_status ()) < 0)
1669     current_trace_status ()->running = 0;
1670
1671   if (current_trace_status ()->running && from_tty)
1672     {
1673       int cont = query (_("Trace is running.  Continue tracing after detach? "));
1674       /* Note that we send the query result without affecting the
1675          user's setting of disconnected_tracing, so that the answer is
1676          a one-time-only.  */
1677       send_disconnected_tracing_value (cont);
1678
1679       /* Also ensure that we do the equivalent of a tstop command if
1680          tracing is not to continue after the detach.  */
1681       if (!cont)
1682         stop_tracing ();
1683     }
1684 }
1685
1686 /* Worker function for the various flavors of the tfind command.  */
1687 static void
1688 finish_tfind_command (enum trace_find_type type, int num,
1689                       ULONGEST addr1, ULONGEST addr2,
1690                       int from_tty)
1691 {
1692   int target_frameno = -1, target_tracept = -1;
1693   struct frame_id old_frame_id;
1694   char *reply;
1695   struct breakpoint *tp;
1696
1697   old_frame_id = get_frame_id (get_current_frame ());
1698
1699   target_frameno = target_trace_find (type, num, addr1, addr2,
1700                                       &target_tracept);
1701
1702   if (type == tfind_number
1703       && num == -1
1704       && target_frameno == -1)
1705     {
1706       /* We told the target to get out of tfind mode, and it did.  */
1707     }
1708   else if (target_frameno == -1)
1709     {
1710       /* A request for a non-existant trace frame has failed.
1711          Our response will be different, depending on FROM_TTY:
1712
1713          If FROM_TTY is true, meaning that this command was
1714          typed interactively by the user, then give an error
1715          and DO NOT change the state of traceframe_number etc.
1716
1717          However if FROM_TTY is false, meaning that we're either
1718          in a script, a loop, or a user-defined command, then
1719          DON'T give an error, but DO change the state of
1720          traceframe_number etc. to invalid.
1721
1722          The rationalle is that if you typed the command, you
1723          might just have committed a typo or something, and you'd
1724          like to NOT lose your current debugging state.  However
1725          if you're in a user-defined command or especially in a
1726          loop, then you need a way to detect that the command
1727          failed WITHOUT aborting.  This allows you to write
1728          scripts that search thru the trace buffer until the end,
1729          and then continue on to do something else.  */
1730
1731       if (from_tty)
1732         error (_("Target failed to find requested trace frame."));
1733       else
1734         {
1735           if (info_verbose)
1736             printf_filtered ("End of trace buffer.\n");
1737 #if 0 /* dubious now? */
1738           /* The following will not recurse, since it's
1739              special-cased.  */
1740           trace_find_command ("-1", from_tty);
1741 #endif
1742         }
1743     }
1744
1745   tp = get_tracepoint_by_number_on_target (target_tracept);
1746
1747   reinit_frame_cache ();
1748   registers_changed ();
1749   set_traceframe_num (target_frameno);
1750   set_tracepoint_num (tp ? tp->number : target_tracept);
1751   if (target_frameno == -1)
1752     set_traceframe_context (NULL);
1753   else
1754     set_traceframe_context (get_current_frame ());
1755
1756   /* If we're in nonstop mode and getting out of looking at trace
1757      frames, there won't be any current frame to go back to and
1758      display.  */
1759   if (from_tty
1760       && (has_stack_frames () || traceframe_number >= 0))
1761     {
1762       enum print_what print_what;
1763
1764       /* NOTE: in immitation of the step command, try to determine
1765          whether we have made a transition from one function to
1766          another.  If so, we'll print the "stack frame" (ie. the new
1767          function and it's arguments) -- otherwise we'll just show the
1768          new source line.  */
1769
1770       if (frame_id_eq (old_frame_id,
1771                        get_frame_id (get_current_frame ())))
1772         print_what = SRC_LINE;
1773       else
1774         print_what = SRC_AND_LOC;
1775
1776       print_stack_frame (get_selected_frame (NULL), 1, print_what);
1777       do_displays ();
1778     }
1779 }
1780
1781 /* trace_find_command takes a trace frame number n,
1782    sends "QTFrame:<n>" to the target,
1783    and accepts a reply that may contain several optional pieces
1784    of information: a frame number, a tracepoint number, and an
1785    indication of whether this is a trap frame or a stepping frame.
1786
1787    The minimal response is just "OK" (which indicates that the
1788    target does not give us a frame number or a tracepoint number).
1789    Instead of that, the target may send us a string containing
1790    any combination of:
1791    F<hexnum>    (gives the selected frame number)
1792    T<hexnum>    (gives the selected tracepoint number)
1793  */
1794
1795 /* tfind command */
1796 static void
1797 trace_find_command (char *args, int from_tty)
1798 { /* this should only be called with a numeric argument */
1799   int frameno = -1;
1800
1801   if (current_trace_status ()->running && !current_trace_status ()->from_file)
1802     error ("May not look at trace frames while trace is running.");
1803
1804   if (args == 0 || *args == 0)
1805     { /* TFIND with no args means find NEXT trace frame.  */
1806       if (traceframe_number == -1)
1807         frameno = 0;    /* "next" is first one */
1808         else
1809         frameno = traceframe_number + 1;
1810     }
1811   else if (0 == strcmp (args, "-"))
1812     {
1813       if (traceframe_number == -1)
1814         error (_("not debugging trace buffer"));
1815       else if (from_tty && traceframe_number == 0)
1816         error (_("already at start of trace buffer"));
1817
1818       frameno = traceframe_number - 1;
1819       }
1820   /* A hack to work around eval's need for fp to have been collected.  */
1821   else if (0 == strcmp (args, "-1"))
1822     frameno = -1;
1823   else
1824     frameno = parse_and_eval_long (args);
1825
1826   if (frameno < -1)
1827     error (_("invalid input (%d is less than zero)"), frameno);
1828
1829   finish_tfind_command (tfind_number, frameno, 0, 0, from_tty);
1830 }
1831
1832 /* tfind end */
1833 static void
1834 trace_find_end_command (char *args, int from_tty)
1835 {
1836   trace_find_command ("-1", from_tty);
1837 }
1838
1839 /* tfind none */
1840 static void
1841 trace_find_none_command (char *args, int from_tty)
1842 {
1843   trace_find_command ("-1", from_tty);
1844 }
1845
1846 /* tfind start */
1847 static void
1848 trace_find_start_command (char *args, int from_tty)
1849 {
1850   trace_find_command ("0", from_tty);
1851 }
1852
1853 /* tfind pc command */
1854 static void
1855 trace_find_pc_command (char *args, int from_tty)
1856 {
1857   CORE_ADDR pc;
1858   char tmp[40];
1859
1860   if (current_trace_status ()->running && !current_trace_status ()->from_file)
1861     error ("May not look at trace frames while trace is running.");
1862
1863   if (args == 0 || *args == 0)
1864     pc = regcache_read_pc (get_current_regcache ());
1865   else
1866     pc = parse_and_eval_address (args);
1867
1868   finish_tfind_command (tfind_pc, 0, pc, 0, from_tty);
1869 }
1870
1871 /* tfind tracepoint command */
1872 static void
1873 trace_find_tracepoint_command (char *args, int from_tty)
1874 {
1875   int tdp;
1876   struct breakpoint *tp;
1877
1878   if (current_trace_status ()->running && !current_trace_status ()->from_file)
1879     error ("May not look at trace frames while trace is running.");
1880
1881   if (args == 0 || *args == 0)
1882     {
1883       if (tracepoint_number == -1)
1884         error (_("No current tracepoint -- please supply an argument."));
1885       else
1886         tdp = tracepoint_number;        /* default is current TDP */
1887     }
1888   else
1889     tdp = parse_and_eval_long (args);
1890
1891   /* If we have the tracepoint on hand, use the number that the
1892      target knows about (which may be different if we disconnected
1893      and reconnected).  */
1894   tp = get_tracepoint (tdp);
1895   if (tp)
1896     tdp = tp->number_on_target;
1897
1898   finish_tfind_command (tfind_tp, tdp, 0, 0, from_tty);
1899 }
1900
1901 /* TFIND LINE command:
1902
1903    This command will take a sourceline for argument, just like BREAK
1904    or TRACE (ie. anything that "decode_line_1" can handle).
1905
1906    With no argument, this command will find the next trace frame
1907    corresponding to a source line OTHER THAN THE CURRENT ONE.  */
1908
1909 static void
1910 trace_find_line_command (char *args, int from_tty)
1911 {
1912   static CORE_ADDR start_pc, end_pc;
1913   struct symtabs_and_lines sals;
1914   struct symtab_and_line sal;
1915   struct cleanup *old_chain;
1916   char   startpc_str[40], endpc_str[40];
1917
1918   if (current_trace_status ()->running && !current_trace_status ()->from_file)
1919     error ("May not look at trace frames while trace is running.");
1920
1921   if (args == 0 || *args == 0)
1922     {
1923       sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
1924       sals.nelts = 1;
1925       sals.sals = (struct symtab_and_line *)
1926         xmalloc (sizeof (struct symtab_and_line));
1927       sals.sals[0] = sal;
1928     }
1929   else
1930       {
1931       sals = decode_line_spec (args, 1);
1932       sal = sals.sals[0];
1933     }
1934
1935   old_chain = make_cleanup (xfree, sals.sals);
1936   if (sal.symtab == 0)
1937     {
1938       printf_filtered ("TFIND: No line number information available");
1939       if (sal.pc != 0)
1940         {
1941           /* This is useful for "info line *0x7f34".  If we can't
1942              tell the user about a source line, at least let them
1943              have the symbolic address.  */
1944           printf_filtered (" for address ");
1945           wrap_here ("  ");
1946           print_address (get_current_arch (), sal.pc, gdb_stdout);
1947           printf_filtered (";\n -- will attempt to find by PC. \n");
1948         }
1949         else
1950         {
1951           printf_filtered (".\n");
1952           return;               /* No line, no PC; what can we do?  */
1953         }
1954     }
1955   else if (sal.line > 0
1956            && find_line_pc_range (sal, &start_pc, &end_pc))
1957     {
1958       if (start_pc == end_pc)
1959         {
1960           printf_filtered ("Line %d of \"%s\"",
1961                            sal.line, sal.symtab->filename);
1962           wrap_here ("  ");
1963           printf_filtered (" is at address ");
1964           print_address (get_current_arch (), start_pc, gdb_stdout);
1965           wrap_here ("  ");
1966           printf_filtered (" but contains no code.\n");
1967           sal = find_pc_line (start_pc, 0);
1968           if (sal.line > 0
1969               && find_line_pc_range (sal, &start_pc, &end_pc)
1970               && start_pc != end_pc)
1971             printf_filtered ("Attempting to find line %d instead.\n",
1972                              sal.line);
1973           else
1974             error (_("Cannot find a good line."));
1975         }
1976       }
1977     else
1978     /* Is there any case in which we get here, and have an address
1979        which the user would want to see?  If we have debugging
1980        symbols and no line numbers?  */
1981     error (_("Line number %d is out of range for \"%s\"."),
1982            sal.line, sal.symtab->filename);
1983
1984   /* Find within range of stated line.  */
1985   if (args && *args)
1986     finish_tfind_command (tfind_range, 0, start_pc, end_pc - 1, from_tty);
1987   else
1988     finish_tfind_command (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
1989   do_cleanups (old_chain);
1990 }
1991
1992 /* tfind range command */
1993 static void
1994 trace_find_range_command (char *args, int from_tty)
1995 {
1996   static CORE_ADDR start, stop;
1997   char start_str[40], stop_str[40];
1998   char *tmp;
1999
2000   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2001     error ("May not look at trace frames while trace is running.");
2002
2003   if (args == 0 || *args == 0)
2004     { /* XXX FIXME: what should default behavior be?  */
2005       printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2006       return;
2007     }
2008
2009   if (0 != (tmp = strchr (args, ',')))
2010     {
2011       *tmp++ = '\0';    /* terminate start address */
2012       while (isspace ((int) *tmp))
2013         tmp++;
2014       start = parse_and_eval_address (args);
2015       stop = parse_and_eval_address (tmp);
2016     }
2017   else
2018     {                   /* no explicit end address? */
2019       start = parse_and_eval_address (args);
2020       stop = start + 1; /* ??? */
2021     }
2022
2023   finish_tfind_command (tfind_range, 0, start, stop, from_tty);
2024 }
2025
2026 /* tfind outside command */
2027 static void
2028 trace_find_outside_command (char *args, int from_tty)
2029 {
2030   CORE_ADDR start, stop;
2031   char start_str[40], stop_str[40];
2032   char *tmp;
2033
2034   if (current_trace_status ()->running && !current_trace_status ()->from_file)
2035     error ("May not look at trace frames while trace is running.");
2036
2037   if (args == 0 || *args == 0)
2038     { /* XXX FIXME: what should default behavior be? */
2039       printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2040       return;
2041     }
2042
2043   if (0 != (tmp = strchr (args, ',')))
2044     {
2045       *tmp++ = '\0';    /* terminate start address */
2046       while (isspace ((int) *tmp))
2047         tmp++;
2048       start = parse_and_eval_address (args);
2049       stop = parse_and_eval_address (tmp);
2050     }
2051   else
2052     {                   /* no explicit end address? */
2053       start = parse_and_eval_address (args);
2054       stop = start + 1; /* ??? */
2055     }
2056
2057   finish_tfind_command (tfind_outside, 0, start, stop, from_tty);
2058 }
2059
2060 /* info scope command: list the locals for a scope.  */
2061 static void
2062 scope_info (char *args, int from_tty)
2063 {
2064   struct symtabs_and_lines sals;
2065   struct symbol *sym;
2066   struct minimal_symbol *msym;
2067   struct block *block;
2068   char **canonical, *symname, *save_args = args;
2069   struct dict_iterator iter;
2070   int j, count = 0;
2071   struct gdbarch *gdbarch;
2072   int regno;
2073
2074   if (args == 0 || *args == 0)
2075     error (_("requires an argument (function, line or *addr) to define a scope"));
2076
2077   sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2078   if (sals.nelts == 0)
2079     return;             /* presumably decode_line_1 has already warned */
2080
2081   /* Resolve line numbers to PC */
2082   resolve_sal_pc (&sals.sals[0]);
2083   block = block_for_pc (sals.sals[0].pc);
2084
2085   while (block != 0)
2086     {
2087       QUIT;                     /* allow user to bail out with ^C */
2088       ALL_BLOCK_SYMBOLS (block, iter, sym)
2089         {
2090           QUIT;                 /* allow user to bail out with ^C */
2091           if (count == 0)
2092             printf_filtered ("Scope for %s:\n", save_args);
2093           count++;
2094
2095           symname = SYMBOL_PRINT_NAME (sym);
2096           if (symname == NULL || *symname == '\0')
2097             continue;           /* probably botched, certainly useless */
2098
2099           gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2100
2101           printf_filtered ("Symbol %s is ", symname);
2102           switch (SYMBOL_CLASS (sym))
2103             {
2104             default:
2105             case LOC_UNDEF:     /* messed up symbol? */
2106               printf_filtered ("a bogus symbol, class %d.\n",
2107                                SYMBOL_CLASS (sym));
2108               count--;          /* don't count this one */
2109               continue;
2110             case LOC_CONST:
2111               printf_filtered ("a constant with value %ld (0x%lx)",
2112                                SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2113               break;
2114             case LOC_CONST_BYTES:
2115               printf_filtered ("constant bytes: ");
2116               if (SYMBOL_TYPE (sym))
2117                 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2118                   fprintf_filtered (gdb_stdout, " %02x",
2119                                     (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2120               break;
2121             case LOC_STATIC:
2122               printf_filtered ("in static storage at address ");
2123               printf_filtered ("%s", paddress (gdbarch,
2124                                                SYMBOL_VALUE_ADDRESS (sym)));
2125               break;
2126             case LOC_REGISTER:
2127               /* GDBARCH is the architecture associated with the objfile
2128                  the symbol is defined in; the target architecture may be
2129                  different, and may provide additional registers.  However,
2130                  we do not know the target architecture at this point.
2131                  We assume the objfile architecture will contain all the
2132                  standard registers that occur in debug info in that
2133                  objfile.  */
2134               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2135
2136               if (SYMBOL_IS_ARGUMENT (sym))
2137                 printf_filtered ("an argument in register $%s",
2138                                  gdbarch_register_name (gdbarch, regno));
2139               else
2140                 printf_filtered ("a local variable in register $%s",
2141                                  gdbarch_register_name (gdbarch, regno));
2142               break;
2143             case LOC_ARG:
2144               printf_filtered ("an argument at stack/frame offset %ld",
2145                                SYMBOL_VALUE (sym));
2146               break;
2147             case LOC_LOCAL:
2148               printf_filtered ("a local variable at frame offset %ld",
2149                                SYMBOL_VALUE (sym));
2150               break;
2151             case LOC_REF_ARG:
2152               printf_filtered ("a reference argument at offset %ld",
2153                                SYMBOL_VALUE (sym));
2154               break;
2155             case LOC_REGPARM_ADDR:
2156               /* Note comment at LOC_REGISTER.  */
2157               regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2158               printf_filtered ("the address of an argument, in register $%s",
2159                                gdbarch_register_name (gdbarch, regno));
2160               break;
2161             case LOC_TYPEDEF:
2162               printf_filtered ("a typedef.\n");
2163               continue;
2164             case LOC_LABEL:
2165               printf_filtered ("a label at address ");
2166               printf_filtered ("%s", paddress (gdbarch,
2167                                                SYMBOL_VALUE_ADDRESS (sym)));
2168               break;
2169             case LOC_BLOCK:
2170               printf_filtered ("a function at address ");
2171               printf_filtered ("%s",
2172                 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2173               break;
2174             case LOC_UNRESOLVED:
2175               msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2176                                             NULL, NULL);
2177               if (msym == NULL)
2178                 printf_filtered ("Unresolved Static");
2179               else
2180                 {
2181                   printf_filtered ("static storage at address ");
2182                   printf_filtered ("%s",
2183                     paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2184                 }
2185               break;
2186             case LOC_OPTIMIZED_OUT:
2187               printf_filtered ("optimized out.\n");
2188               continue;
2189             case LOC_COMPUTED:
2190               SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
2191               break;
2192             }
2193           if (SYMBOL_TYPE (sym))
2194             printf_filtered (", length %d.\n",
2195                              TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2196         }
2197       if (BLOCK_FUNCTION (block))
2198         break;
2199       else
2200         block = BLOCK_SUPERBLOCK (block);
2201     }
2202   if (count <= 0)
2203     printf_filtered ("Scope for %s contains no locals or arguments.\n",
2204                      save_args);
2205 }
2206
2207 /* worker function (cleanup) */
2208 static void
2209 replace_comma (void *data)
2210 {
2211   char *comma = data;
2212   *comma = ',';
2213 }
2214
2215 /* tdump command */
2216 static void
2217 trace_dump_command (char *args, int from_tty)
2218 {
2219   struct regcache *regcache;
2220   struct gdbarch *gdbarch;
2221   struct breakpoint *t;
2222   struct action_line *action;
2223   char *action_exp, *next_comma;
2224   struct cleanup *old_cleanups;
2225   int stepping_actions = 0;
2226   int stepping_frame = 0;
2227
2228   if (tracepoint_number == -1)
2229     {
2230       warning (_("No current trace frame."));
2231       return;
2232     }
2233
2234   t = get_tracepoint (tracepoint_number);
2235
2236   if (t == NULL)
2237     error (_("No known tracepoint matches 'current' tracepoint #%d."),
2238            tracepoint_number);
2239
2240   old_cleanups = make_cleanup (null_cleanup, NULL);
2241
2242   printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2243                    tracepoint_number, traceframe_number);
2244
2245   /* The current frame is a trap frame if the frame PC is equal
2246      to the tracepoint PC.  If not, then the current frame was
2247      collected during single-stepping.  */
2248
2249   regcache = get_current_regcache ();
2250   gdbarch = get_regcache_arch (regcache);
2251
2252   stepping_frame = (t->loc->address != (regcache_read_pc (regcache)));
2253
2254   for (action = t->actions; action; action = action->next)
2255     {
2256       struct cmd_list_element *cmd;
2257
2258       QUIT;                     /* allow user to bail out with ^C */
2259       action_exp = action->action;
2260       while (isspace ((int) *action_exp))
2261         action_exp++;
2262
2263       /* The collection actions to be done while stepping are
2264          bracketed by the commands "while-stepping" and "end".  */
2265
2266       if (*action_exp == '#')   /* comment line */
2267         continue;
2268
2269       cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2270       if (cmd == 0)
2271         error (_("Bad action list item: %s"), action_exp);
2272
2273       if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2274         stepping_actions = 1;
2275       else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
2276         stepping_actions = 0;
2277       else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2278         {
2279           /* Display the collected data.
2280              For the trap frame, display only what was collected at
2281              the trap.  Likewise for stepping frames, display only
2282              what was collected while stepping.  This means that the
2283              two boolean variables, STEPPING_FRAME and
2284              STEPPING_ACTIONS should be equal.  */
2285           if (stepping_frame == stepping_actions)
2286             {
2287               do
2288                 {               /* repeat over a comma-separated list */
2289                   QUIT;         /* allow user to bail out with ^C */
2290                   if (*action_exp == ',')
2291                     action_exp++;
2292                   while (isspace ((int) *action_exp))
2293                     action_exp++;
2294
2295                   next_comma = strchr (action_exp, ',');
2296
2297                   if (0 == strncasecmp (action_exp, "$reg", 4))
2298                     registers_info (NULL, from_tty);
2299                   else if (0 == strncasecmp (action_exp, "$loc", 4))
2300                     locals_info (NULL, from_tty);
2301                   else if (0 == strncasecmp (action_exp, "$arg", 4))
2302                     args_info (NULL, from_tty);
2303                   else
2304                     {           /* variable */
2305                       if (next_comma)
2306                         {
2307                           make_cleanup (replace_comma, next_comma);
2308                           *next_comma = '\0';
2309                         }
2310                       printf_filtered ("%s = ", action_exp);
2311                       output_command (action_exp, from_tty);
2312                       printf_filtered ("\n");
2313                     }
2314                   if (next_comma)
2315                     *next_comma = ',';
2316                   action_exp = next_comma;
2317                 }
2318               while (action_exp && *action_exp == ',');
2319             }
2320         }
2321     }
2322   discard_cleanups (old_cleanups);
2323 }
2324
2325 extern int trace_regblock_size;
2326
2327 static void
2328 trace_save_command (char *args, int from_tty)
2329 {
2330   char **argv;
2331   char *filename = NULL, *pathname;
2332   int target_does_save = 0;
2333   struct cleanup *cleanup;
2334   struct trace_status *ts = current_trace_status ();
2335   int err, status;
2336   FILE *fp;
2337   struct uploaded_tp *uploaded_tps = NULL, *utp;
2338   struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2339   int a;
2340   LONGEST gotten = 0;
2341   ULONGEST offset = 0;
2342 #define MAX_TRACE_UPLOAD 2000
2343   gdb_byte buf[MAX_TRACE_UPLOAD];
2344   int written;
2345
2346   if (args == NULL)
2347     error_no_arg (_("file in which to save trace data"));
2348
2349   argv = gdb_buildargv (args);
2350   make_cleanup_freeargv (argv);
2351
2352   for (; *argv; ++argv)
2353     {
2354       if (strcmp (*argv, "-r") == 0)
2355         target_does_save = 1;
2356       else if (**argv == '-')
2357         error (_("unknown option `%s'"), *argv);
2358       else
2359         filename = *argv;
2360     }
2361
2362   if (!filename)
2363     error_no_arg (_("file in which to save trace data"));
2364
2365   /* If the target is to save the data to a file on its own, then just
2366      send the command and be done with it.  */
2367   if (target_does_save)
2368     {
2369       err = target_save_trace_data (filename);
2370       if (err < 0)
2371         error (_("Target failed to save trace data to '%s'."),
2372                filename);
2373       return;
2374     }
2375
2376   /* Get the trace status first before opening the file, so if the
2377      target is losing, we can get out without touching files.  */
2378   status = target_get_trace_status (ts);
2379
2380   pathname = tilde_expand (args);
2381   cleanup = make_cleanup (xfree, pathname);
2382
2383   fp = fopen (pathname, "w");
2384   if (!fp)
2385     error (_("Unable to open file '%s' for saving trace data (%s)"),
2386            args, safe_strerror (errno));
2387   make_cleanup_fclose (fp);
2388
2389   /* Write a file header, with a high-bit-set char to indicate a
2390      binary file, plus a hint as what this file is, and a version
2391      number in case of future needs.  */
2392   written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2393   if (written < 8)
2394     perror_with_name (pathname);
2395
2396   /* Write descriptive info.  */
2397
2398   /* Write out the size of a register block.  */
2399   fprintf (fp, "R %x\n", trace_regblock_size);
2400
2401   /* Write out status of the tracing run (aka "tstatus" info).  */
2402   fprintf (fp, "status %c;%s:%x;tframes:%x;tfree:%llx\n",
2403            (ts->running ? '1' : '0'),
2404            stop_reason_names[ts->stop_reason], ts->stopping_tracepoint,
2405            ts->traceframe_count, ts->buffer_free);
2406
2407   /* Note that we want to upload tracepoints and save those, rather
2408      than simply writing out the local ones, because the user may have
2409      changed tracepoints in GDB in preparation for a future tracing
2410      run, or maybe just mass-deleted all types of breakpoints as part
2411      of cleaning up.  So as not to contaminate the session, leave the
2412      data in its uploaded form, don't make into real tracepoints.  */
2413
2414   /* Get trace state variables first, they may be checked when parsing
2415      uploaded commands.  */
2416
2417   target_upload_trace_state_variables (&uploaded_tsvs);
2418
2419   for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2420     {
2421       char *buf = "";
2422
2423       if (utsv->name)
2424         {
2425           buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2426           bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2427         }
2428
2429       fprintf (fp, "tsv %x:%s:%x:%s\n",
2430                utsv->number, phex_nz (utsv->initial_value, 8),
2431                utsv->builtin, buf);
2432
2433       if (utsv->name)
2434         xfree (buf);
2435     }
2436
2437   free_uploaded_tsvs (&uploaded_tsvs);
2438
2439   target_upload_tracepoints (&uploaded_tps);
2440
2441   for (utp = uploaded_tps; utp; utp = utp->next)
2442     {
2443       fprintf (fp, "tp T%x:%s:%c:%x:%x",
2444                utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2445                (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2446       if (utp->type == bp_fast_tracepoint)
2447         fprintf (fp, ":F%x", utp->orig_size);
2448       if (utp->cond)
2449         fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2450                  utp->cond);
2451       fprintf (fp, "\n");
2452       for (a = 0; a < utp->numactions; ++a)
2453         fprintf (fp, "tp A%x:%s:%s\n",
2454                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2455                  utp->actions[a]);
2456       for (a = 0; a < utp->num_step_actions; ++a)
2457         fprintf (fp, "tp S%x:%s:%s\n",
2458                  utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2459                  utp->step_actions[a]);
2460     }
2461
2462   free_uploaded_tps (&uploaded_tps);
2463
2464   /* Mark the end of the definition section.  */
2465   fprintf (fp, "\n");
2466
2467   /* Get and write the trace data proper.  We ask for big blocks, in
2468      the hopes of efficiency, but will take less if the target has
2469      packet size limitations or some such.  */
2470   while (1)
2471     {
2472       gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2473       if (gotten < 0)
2474         error (_("Failure to get requested trace buffer data"));
2475       /* No more data is forthcoming, we're done.  */
2476       if (gotten == 0)
2477         break;
2478       written = fwrite (buf, gotten, 1, fp);
2479       if (written < gotten)
2480         perror_with_name (pathname);
2481       offset += gotten;
2482     }
2483
2484   /* Mark the end of trace data.  */
2485   written = fwrite (&gotten, 4, 1, fp);
2486   if (written < 4)
2487     perror_with_name (pathname);
2488
2489   do_cleanups (cleanup);
2490   if (from_tty)
2491     printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2492 }
2493
2494 /* Tell the target what to do with an ongoing tracing run if GDB
2495    disconnects for some reason.  */
2496
2497 void
2498 send_disconnected_tracing_value (int value)
2499 {
2500   target_set_disconnected_tracing (value);
2501 }
2502
2503 static void
2504 set_disconnected_tracing (char *args, int from_tty,
2505                           struct cmd_list_element *c)
2506 {
2507   send_disconnected_tracing_value (disconnected_tracing);
2508 }
2509
2510 /* Convert the memory pointed to by mem into hex, placing result in buf.
2511  * Return a pointer to the last char put in buf (null)
2512  * "stolen" from sparc-stub.c
2513  */
2514
2515 static const char hexchars[] = "0123456789abcdef";
2516
2517 static char *
2518 mem2hex (gdb_byte *mem, char *buf, int count)
2519 {
2520   gdb_byte ch;
2521
2522   while (count-- > 0)
2523     {
2524       ch = *mem++;
2525
2526       *buf++ = hexchars[ch >> 4];
2527       *buf++ = hexchars[ch & 0xf];
2528     }
2529
2530   *buf = 0;
2531
2532   return buf;
2533 }
2534
2535 int
2536 get_traceframe_number (void)
2537 {
2538   return traceframe_number;
2539 }
2540
2541
2542 /* Given a number and address, return an uploaded tracepoint with that
2543    number, creating if necessary.  */
2544
2545 struct uploaded_tp *
2546 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2547 {
2548   struct uploaded_tp *utp;
2549
2550   for (utp = *utpp; utp; utp = utp->next)
2551     if (utp->number == num && utp->addr == addr)
2552       return utp;
2553   utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2554   memset (utp, 0, sizeof (struct uploaded_tp));
2555   utp->number = num;
2556   utp->addr = addr;
2557   utp->next = *utpp;
2558   *utpp = utp;
2559   return utp;
2560 }
2561
2562 static void
2563 free_uploaded_tps (struct uploaded_tp **utpp)
2564 {
2565   struct uploaded_tp *next_one;
2566
2567   while (*utpp)
2568     {
2569       next_one = (*utpp)->next;
2570       xfree (*utpp);
2571       *utpp = next_one;
2572     }
2573 }
2574
2575 /* Given a number and address, return an uploaded tracepoint with that
2576    number, creating if necessary.  */
2577
2578 struct uploaded_tsv *
2579 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2580 {
2581   struct uploaded_tsv *utsv;
2582
2583   for (utsv = *utsvp; utsv; utsv = utsv->next)
2584     if (utsv->number == num)
2585       return utsv;
2586   utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
2587   memset (utsv, 0, sizeof (struct uploaded_tsv));
2588   utsv->number = num;
2589   utsv->next = *utsvp;
2590   *utsvp = utsv;
2591   return utsv;
2592 }
2593
2594 static void
2595 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
2596 {
2597   struct uploaded_tsv *next_one;
2598
2599   while (*utsvp)
2600     {
2601       next_one = (*utsvp)->next;
2602       xfree (*utsvp);
2603       *utsvp = next_one;
2604     }
2605 }
2606
2607 /* Look for an existing tracepoint that seems similar enough to the
2608    uploaded one.  Enablement isn't compared, because the user can
2609    toggle that freely, and may have done so in anticipation of the
2610    next trace run.  */
2611
2612 struct breakpoint *
2613 find_matching_tracepoint (struct uploaded_tp *utp)
2614 {
2615   VEC(breakpoint_p) *tp_vec = all_tracepoints ();
2616   int ix;
2617   struct breakpoint *t;
2618   struct bp_location *loc;
2619
2620   for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2621     {
2622       if (t->type == utp->type
2623           && t->step_count == utp->step
2624           && t->pass_count == utp->pass
2625           /* FIXME also test conditionals and actions */
2626           )
2627         {
2628           /* Scan the locations for an address match.  */
2629           for (loc = t->loc; loc; loc = loc->next)
2630             {
2631               if (loc->address == utp->addr)
2632                 return t;
2633             }
2634         }
2635     }
2636   return NULL;
2637 }
2638
2639 /* Given a list of tracepoints uploaded from a target, attempt to
2640    match them up with existing tracepoints, and create new ones if not
2641    found.  */
2642
2643 void
2644 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
2645 {
2646   struct uploaded_tp *utp;
2647   struct breakpoint *t;
2648
2649   /* Look for GDB tracepoints that match up with our uploaded versions.  */
2650   for (utp = *uploaded_tps; utp; utp = utp->next)
2651     {
2652       t = find_matching_tracepoint (utp);
2653       if (t)
2654         printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2655                          t->number, utp->number, paddress (get_current_arch (), utp->addr));
2656       else
2657         {
2658           t = create_tracepoint_from_upload (utp);
2659           if (t)
2660             printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2661                              t->number, utp->number, paddress (get_current_arch (), utp->addr));
2662           else
2663             printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2664                              utp->number, paddress (get_current_arch (), utp->addr));
2665         }
2666       /* Whether found or created, record the number used by the
2667          target, to help with mapping target tracepoints back to their
2668          counterparts here.  */
2669       if (t)
2670         t->number_on_target = utp->number;
2671     }
2672
2673   free_uploaded_tps (uploaded_tps);
2674 }
2675
2676 /* Trace state variables don't have much to identify them beyond their
2677    name, so just use that to detect matches.  */
2678
2679 struct trace_state_variable *
2680 find_matching_tsv (struct uploaded_tsv *utsv)
2681 {
2682   if (!utsv->name)
2683     return NULL;
2684
2685   return find_trace_state_variable (utsv->name);
2686 }
2687
2688 struct trace_state_variable *
2689 create_tsv_from_upload (struct uploaded_tsv *utsv)
2690 {
2691   const char *namebase;
2692   char buf[20];
2693   int try_num = 0;
2694   struct trace_state_variable *tsv;
2695
2696   if (utsv->name)
2697     {
2698       namebase = utsv->name;
2699       sprintf (buf, "%s", namebase);
2700     }
2701   else
2702     {
2703       namebase = "__tsv";
2704       sprintf (buf, "%s_%d", namebase, try_num++);
2705     }
2706
2707   /* Fish for a name that is not in use.  */
2708   /* (should check against all internal vars?) */
2709   while (find_trace_state_variable (buf))
2710     sprintf (buf, "%s_%d", namebase, try_num++);
2711
2712   /* We have an available name, create the variable.  */
2713   tsv = create_trace_state_variable (xstrdup (buf));
2714   tsv->initial_value = utsv->initial_value;
2715   tsv->builtin = utsv->builtin;
2716
2717   return tsv;
2718 }
2719
2720 /* Given a list of uploaded trace state variables, try to match them
2721    up with existing variables, or create additional ones.  */
2722
2723 void
2724 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
2725 {
2726   int ix;
2727   struct uploaded_tsv *utsv;
2728   struct trace_state_variable *tsv;
2729   int highest;
2730
2731   /* Most likely some numbers will have to be reassigned as part of
2732      the merge, so clear them all in anticipation.  */
2733   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2734     tsv->number = 0;
2735
2736   for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
2737     {
2738       tsv = find_matching_tsv (utsv);
2739       if (tsv)
2740         printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2741                          tsv->name, utsv->number);
2742       else
2743         {
2744           tsv = create_tsv_from_upload (utsv);
2745           printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2746                            tsv->name, utsv->number);
2747         }
2748       /* Give precedence to numberings that come from the target.  */
2749       if (tsv)
2750         tsv->number = utsv->number;
2751     }
2752
2753   /* Renumber everything that didn't get a target-assigned number.  */
2754   highest = 0;
2755   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2756     if (tsv->number > highest)
2757       highest = tsv->number;
2758
2759   ++highest;
2760   for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2761     if (tsv->number == 0)
2762       tsv->number = highest++;
2763
2764   free_uploaded_tsvs (uploaded_tsvs);
2765 }
2766
2767 /* target tfile command */
2768
2769 struct target_ops tfile_ops;
2770
2771 /* Fill in tfile_ops with its defined operations and properties.  */
2772
2773 #define TRACE_HEADER_SIZE 8
2774
2775 char *trace_filename;
2776 int trace_fd = -1;
2777 off_t trace_frames_offset;
2778 off_t cur_offset;
2779 int cur_data_size;
2780 int trace_regblock_size;
2781
2782 static void tfile_interp_line (char *line,
2783                                struct uploaded_tp **utpp,
2784                                struct uploaded_tsv **utsvp);
2785
2786 static void
2787 tfile_open (char *filename, int from_tty)
2788 {
2789   char *temp;
2790   struct cleanup *old_chain;
2791   int flags;
2792   int scratch_chan;
2793   char header[TRACE_HEADER_SIZE];
2794   char linebuf[1000]; /* should be max remote packet size or so */
2795   char byte;
2796   int bytes, i, gotten;
2797   struct trace_status *ts;
2798   struct uploaded_tp *uploaded_tps = NULL;
2799   struct uploaded_tsv *uploaded_tsvs = NULL;
2800
2801   target_preopen (from_tty);
2802   if (!filename)
2803     error (_("No trace file specified."));
2804
2805   filename = tilde_expand (filename);
2806   if (!IS_ABSOLUTE_PATH(filename))
2807     {
2808       temp = concat (current_directory, "/", filename, (char *)NULL);
2809       xfree (filename);
2810       filename = temp;
2811     }
2812
2813   old_chain = make_cleanup (xfree, filename);
2814
2815   flags = O_BINARY | O_LARGEFILE;
2816   flags |= O_RDONLY;
2817   scratch_chan = open (filename, flags, 0);
2818   if (scratch_chan < 0)
2819     perror_with_name (filename);
2820
2821   /* Looks semi-reasonable.  Toss the old trace file and work on the new.  */
2822
2823   discard_cleanups (old_chain); /* Don't free filename any more */
2824   unpush_target (&tfile_ops);
2825
2826   push_target (&tfile_ops);
2827   discard_cleanups (old_chain);
2828
2829   trace_filename = xstrdup (filename);
2830   trace_fd = scratch_chan;
2831
2832   bytes = 0;
2833   /* Read the file header and test for validity.  */
2834   gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
2835   if (gotten < 0)
2836     perror_with_name (trace_filename);
2837   else if (gotten < TRACE_HEADER_SIZE)
2838     error (_("Premature end of file while reading trace file"));
2839
2840   bytes += TRACE_HEADER_SIZE;
2841   if (!(header[0] == 0x7f
2842         && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
2843     error (_("File is not a valid trace file."));
2844
2845   trace_regblock_size = 0;
2846   ts = current_trace_status ();
2847   /* We know we're working with a file.  */
2848   ts->from_file = 1;
2849   /* Set defaults in case there is no status line.  */
2850   ts->running_known = 0;
2851   ts->stop_reason = trace_stop_reason_unknown;
2852   ts->traceframe_count = -1;
2853   ts->buffer_free = 0;
2854
2855   /* Read through a section of newline-terminated lines that
2856      define things like tracepoints.  */
2857   i = 0;
2858   while (1)
2859     {
2860       gotten = read (trace_fd, &byte, 1);
2861       if (gotten < 0)
2862         perror_with_name (trace_filename);
2863       else if (gotten < 1)
2864         error (_("Premature end of file while reading trace file"));
2865
2866       ++bytes;
2867       if (byte == '\n')
2868         {
2869           /* Empty line marks end of the definition section.  */
2870           if (i == 0)
2871             break;
2872           linebuf[i] = '\0';
2873           i = 0;
2874           tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
2875         }
2876       else
2877         linebuf[i++] = byte;
2878       if (i >= 1000)
2879         error (_("Excessively long lines in trace file"));
2880     }
2881
2882   /* Add the file's tracepoints and variables into the current mix.  */
2883
2884   merge_uploaded_tracepoints (&uploaded_tps);
2885
2886   merge_uploaded_trace_state_variables (&uploaded_tsvs);
2887
2888   /* Record the starting offset of the binary trace data.  */
2889   trace_frames_offset = bytes;
2890
2891   /* If we don't have a blocksize, we can't interpret the
2892      traceframes.  */
2893   if (trace_regblock_size == 0)
2894     error (_("No register block size recorded in trace file"));
2895   if (ts->traceframe_count <= 0)
2896     {
2897       warning ("No traceframes present in this file.");
2898       return;
2899     }
2900
2901 #define TFILE_PID (1)
2902   inferior_appeared (current_inferior (), TFILE_PID);
2903   inferior_ptid = pid_to_ptid (TFILE_PID);
2904   add_thread_silent (inferior_ptid);
2905
2906   post_create_inferior (&tfile_ops, from_tty);
2907
2908 #if 0
2909   /* FIXME this will get defined in MI patch submission */
2910   tfind_1 (tfind_number, 0, 0, 0, 0);
2911 #endif
2912 }
2913
2914 /* Interpret the given line from the definitions part of the trace
2915    file.  */
2916
2917 static void
2918 tfile_interp_line (char *line,
2919                    struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
2920 {
2921   char *p = line;
2922
2923   if (strncmp (p, "R ", strlen ("R ")) == 0)
2924     {
2925       p += strlen ("R ");
2926       trace_regblock_size = strtol (p, &p, 16);
2927     }
2928   else if (strncmp (p, "status ", strlen ("status ")) == 0)
2929     {
2930       p += strlen ("status ");
2931       parse_trace_status (p, current_trace_status ());
2932     }
2933   else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
2934     {
2935       p += strlen ("tp ");
2936       parse_tracepoint_definition (p, utpp);
2937     }
2938   else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
2939     {
2940       p += strlen ("tsv ");
2941       parse_tsv_definition (p, utsvp);
2942     }
2943   else
2944     warning ("Ignoring trace file definition \"%s\"", line);
2945 }
2946
2947 /* Parse the part of trace status syntax that is shared between
2948    the remote protocol and the trace file reader.  */
2949
2950 extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
2951
2952 void
2953 parse_trace_status (char *line, struct trace_status *ts)
2954 {
2955   char *p = line, *p1, *p_temp;
2956   ULONGEST val;
2957
2958   ts->running_known = 1;
2959   ts->running = (*p++ == '1');
2960   ts->stop_reason = trace_stop_reason_unknown;
2961   while (*p++)
2962     {
2963       p1 = strchr (p, ':');
2964       if (p1 == NULL)
2965         error (_("Malformed trace status, at %s\n\
2966 Status line: '%s'\n"), p, line);
2967       if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
2968         {
2969           p = unpack_varlen_hex (++p1, &val);
2970           ts->stop_reason = trace_buffer_full;
2971         }
2972       else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
2973         {
2974           p = unpack_varlen_hex (++p1, &val);
2975           ts->stop_reason = trace_never_run;
2976         }
2977       else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0)
2978         {
2979           p = unpack_varlen_hex (++p1, &val);
2980           ts->stop_reason = tracepoint_passcount;
2981           ts->stopping_tracepoint = val;
2982         }
2983       else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
2984         {
2985           p = unpack_varlen_hex (++p1, &val);
2986           ts->stop_reason = tstop_command;
2987         }
2988       if (strncmp (p, "tframes", p1 - p) == 0)
2989         {
2990           p = unpack_varlen_hex (++p1, &val);
2991           ts->traceframe_count = val;
2992         }
2993       if (strncmp (p, "tfree", p1 - p) == 0)
2994         {
2995           p = unpack_varlen_hex (++p1, &val);
2996           ts->buffer_free = val;
2997         }
2998       else
2999         {
3000           /* Silently skip unknown optional info.  */
3001           p_temp = strchr (p1 + 1, ';');
3002           if (p_temp)
3003             p = p_temp;
3004           else
3005             /* Must be at the end.  */
3006             break;
3007         }
3008     }
3009 }
3010
3011 /* Given a line of text defining a tracepoint or tracepoint action, parse
3012    it into an "uploaded tracepoint".  */
3013
3014 void
3015 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3016 {
3017   char *p;
3018   char piece;
3019   ULONGEST num, addr, step, pass, orig_size, xlen;
3020   int enabled, i;
3021   enum bptype type;
3022   char *cond;
3023   struct uploaded_tp *utp = NULL;
3024
3025   p = line;
3026   /* Both tracepoint and action definitions start with the same number
3027      and address sequence.  */
3028   piece = *p++;
3029   p = unpack_varlen_hex (p, &num);
3030   p++;  /* skip a colon */
3031   p = unpack_varlen_hex (p, &addr);
3032   p++;  /* skip a colon */
3033   if (piece == 'T')
3034     {
3035       enabled = (*p++ == 'E');
3036       p++;  /* skip a colon */
3037       p = unpack_varlen_hex (p, &step);
3038       p++;  /* skip a colon */
3039       p = unpack_varlen_hex (p, &pass);
3040       type = bp_tracepoint;
3041       cond = NULL;
3042       /* Thumb through optional fields.  */
3043       while (*p == ':')
3044         {
3045           p++;  /* skip a colon */
3046           if (*p == 'F')
3047             {
3048               type = bp_fast_tracepoint;
3049               p++;
3050               p = unpack_varlen_hex (p, &orig_size);
3051             }
3052           else if (*p == 'X')
3053             {
3054               p++;
3055               p = unpack_varlen_hex (p, &xlen);
3056               p++;  /* skip a comma */
3057               cond = (char *) xmalloc (2 * xlen + 1);
3058               strncpy (cond, p, 2 * xlen);
3059               cond[2 * xlen] = '\0';
3060               p += 2 * xlen;
3061             }
3062           else
3063             warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p);
3064         }
3065       utp = get_uploaded_tp (num, addr, utpp);
3066       utp->type = type;
3067       utp->enabled = enabled;
3068       utp->step = step;
3069       utp->pass = pass;
3070       utp->cond = cond;
3071     }
3072   else if (piece == 'A')
3073     {
3074       utp = get_uploaded_tp (num, addr, utpp);
3075       utp->actions[utp->numactions++] = xstrdup (p);
3076     }
3077   else if (piece == 'S')
3078     {
3079       utp = get_uploaded_tp (num, addr, utpp);
3080       utp->step_actions[utp->num_step_actions++] = xstrdup (p);
3081     }
3082   else
3083     {
3084       error ("Invalid tracepoint piece");
3085     }
3086 }
3087
3088 /* Convert a textual description of a trace state variable into an
3089    uploaded object.  */
3090
3091 void
3092 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3093 {
3094   char *p, *buf;
3095   ULONGEST num, initval, builtin;
3096   int end;
3097   struct uploaded_tsv *utsv = NULL;
3098
3099   buf = alloca (strlen (line));
3100
3101   p = line;
3102   p = unpack_varlen_hex (p, &num);
3103   p++; /* skip a colon */
3104   p = unpack_varlen_hex (p, &initval);
3105   p++; /* skip a colon */
3106   p = unpack_varlen_hex (p, &builtin);
3107   p++; /* skip a colon */
3108   end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3109   buf[end] = '\0';
3110
3111   utsv = get_uploaded_tsv (num, utsvp);
3112   utsv->initial_value = initval;
3113   utsv->builtin = builtin;
3114   utsv->name = xstrdup (buf);
3115 }
3116
3117 /* Close the trace file and generally clean up.  */
3118
3119 static void
3120 tfile_close (int quitting)
3121 {
3122   int pid;
3123
3124   if (trace_fd < 0)
3125     return;
3126
3127   pid = ptid_get_pid (inferior_ptid);
3128   inferior_ptid = null_ptid;    /* Avoid confusion from thread stuff */
3129   exit_inferior_silent (pid);
3130
3131   close (trace_fd);
3132   trace_fd = -1;
3133   if (trace_filename)
3134     xfree (trace_filename);
3135 }
3136
3137 static void
3138 tfile_files_info (struct target_ops *t)
3139 {
3140   /* (it would be useful to mention the name of the file) */
3141   printf_filtered ("Looking at a trace file.\n");
3142 }
3143
3144 /* The trace status for a file is that tracing can never be run.  */
3145
3146 static int
3147 tfile_get_trace_status (struct trace_status *ts)
3148 {
3149   /* Other bits of trace status were collected as part of opening the
3150      trace files, so nothing to do here.  */
3151
3152   return -1;
3153 }
3154
3155 /* Given the position of a traceframe in the file, figure out what
3156    address the frame was collected at.  This would normally be the
3157    value of a collected PC register, but if not available, we
3158    improvise.  */
3159
3160 static ULONGEST
3161 tfile_get_traceframe_address (off_t tframe_offset)
3162 {
3163   ULONGEST addr = 0;
3164   short tpnum;
3165   struct breakpoint *tp;
3166   off_t saved_offset = cur_offset;
3167   int gotten;
3168
3169   /* FIXME dig pc out of collected registers */
3170
3171   /* Fall back to using tracepoint address.  */
3172   lseek (trace_fd, tframe_offset, SEEK_SET);
3173   gotten = read (trace_fd, &tpnum, 2);
3174   if (gotten < 0)
3175     perror_with_name (trace_filename);
3176   else if (gotten < 2)
3177     error (_("Premature end of file while reading trace file"));
3178
3179   tp = get_tracepoint_by_number_on_target (tpnum);
3180   if (tp && tp->loc)
3181     addr = tp->loc->address;
3182
3183   /* Restore our seek position.  */
3184   cur_offset = saved_offset;
3185   lseek (trace_fd, cur_offset, SEEK_SET);
3186   return addr;
3187 }
3188
3189 /* Given a type of search and some parameters, scan the collection of
3190    traceframes in the file looking for a match.  When found, return
3191    both the traceframe and tracepoint number, otherwise -1 for
3192    each.  */
3193
3194 static int
3195 tfile_trace_find (enum trace_find_type type, int num,
3196                   ULONGEST addr1, ULONGEST addr2, int *tpp)
3197 {
3198   short tpnum;
3199   int tfnum = 0, found = 0, gotten;
3200   int data_size;
3201   struct breakpoint *tp;
3202   off_t offset, tframe_offset;
3203   ULONGEST tfaddr;
3204
3205   lseek (trace_fd, trace_frames_offset, SEEK_SET);
3206   offset = trace_frames_offset;
3207   while (1)
3208     {
3209       tframe_offset = offset;
3210       gotten = read (trace_fd, &tpnum, 2);
3211       if (gotten < 0)
3212         perror_with_name (trace_filename);
3213       else if (gotten < 2)
3214         error (_("Premature end of file while reading trace file"));
3215       offset += 2;
3216       if (tpnum == 0)
3217         break;
3218       gotten = read (trace_fd, &data_size, 4);
3219       if (gotten < 0)
3220         perror_with_name (trace_filename);
3221       else if (gotten < 4)
3222         error (_("Premature end of file while reading trace file"));
3223       offset += 4;
3224       switch (type)
3225         {
3226         case tfind_number:
3227           if (tfnum == num)
3228             found = 1;
3229           break;
3230         case tfind_pc:
3231           tfaddr = tfile_get_traceframe_address (tframe_offset);
3232           if (tfaddr == addr1)
3233             found = 1;
3234           break;
3235         case tfind_tp:
3236           tp = get_tracepoint (num);
3237           if (tp && tpnum == tp->number_on_target)
3238             found = 1;
3239           break;
3240         case tfind_range:
3241           tfaddr = tfile_get_traceframe_address (tframe_offset);
3242           if (addr1 <= tfaddr && tfaddr <= addr2)
3243             found = 1;
3244           break;
3245         case tfind_outside:
3246           tfaddr = tfile_get_traceframe_address (tframe_offset);
3247           if (!(addr1 <= tfaddr && tfaddr <= addr2))
3248             found = 1;
3249           break;
3250         default:
3251           internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3252         }
3253       if (found)
3254         {
3255           printf_filtered ("Found traceframe %d.\n", tfnum);
3256           if (tpp)
3257             *tpp = tpnum;
3258           cur_offset = offset;
3259           cur_data_size = data_size;
3260           return tfnum;
3261         }
3262       /* Skip past the traceframe's data.  */
3263       lseek (trace_fd, data_size, SEEK_CUR);
3264       offset += data_size;
3265       /* Update our own count of traceframes.  */
3266       ++tfnum;
3267     }
3268   /* Did not find what we were looking for.  */
3269   if (tpp)
3270     *tpp = -1;
3271   return -1;
3272 }
3273
3274 /* Look for a block of saved registers in the traceframe, and get the
3275    requested register from it.  */
3276
3277 static void
3278 tfile_fetch_registers (struct target_ops *ops,
3279                        struct regcache *regcache, int regno)
3280 {
3281   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3282   char block_type;
3283   int i, pos, offset, regn, regsize, gotten;
3284   unsigned short mlen;
3285   char *regs;
3286
3287   /* An uninitialized reg size says we're not going to be
3288      successful at getting register blocks.  */
3289   if (!trace_regblock_size)
3290     return;
3291
3292   regs = alloca (trace_regblock_size);
3293
3294   lseek (trace_fd, cur_offset, SEEK_SET);
3295   pos = 0;
3296   while (pos < cur_data_size)
3297     {
3298       gotten = read (trace_fd, &block_type, 1);
3299       if (gotten < 0)
3300         perror_with_name (trace_filename);
3301       else if (gotten < 1)
3302         error (_("Premature end of file while reading trace file"));
3303
3304       ++pos;
3305       switch (block_type)
3306         {
3307         case 'R':
3308           gotten = read (trace_fd, regs, trace_regblock_size);
3309           if (gotten < 0)
3310             perror_with_name (trace_filename);
3311           else if (gotten < trace_regblock_size)
3312             error (_("Premature end of file while reading trace file"));
3313
3314           /* Assume the block is laid out in GDB register number order,
3315              each register with the size that it has in GDB.  */
3316           offset = 0;
3317           for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3318             {
3319               regsize = register_size (gdbarch, regn);
3320               /* Make sure we stay within block bounds.  */
3321               if (offset + regsize >= trace_regblock_size)
3322                 break;
3323               if (!regcache_valid_p (regcache, regn))
3324                 {
3325                   if (regno == regn)
3326                     {
3327                       regcache_raw_supply (regcache, regno, regs + offset);
3328                       break;
3329                     }
3330                   else if (regno == -1)
3331                     {
3332                       regcache_raw_supply (regcache, regn, regs + offset);
3333                     }
3334                 }
3335               offset += regsize;
3336             }
3337           return;
3338         case 'M':
3339           lseek (trace_fd, 8, SEEK_CUR);
3340           gotten = read (trace_fd, &mlen, 2);
3341           if (gotten < 0)
3342             perror_with_name (trace_filename);
3343           else if (gotten < 2)
3344             error (_("Premature end of file while reading trace file"));
3345           lseek (trace_fd, mlen, SEEK_CUR);
3346           pos += (8 + 2 + mlen);
3347           break;
3348         case 'V':
3349           lseek (trace_fd, 4 + 8, SEEK_CUR);
3350           pos += (4 + 8);
3351           break;
3352         default:
3353           error ("Unknown block type '%c' (0x%x) in trace frame",
3354                  block_type, block_type);
3355           break;
3356         }
3357     }
3358 }
3359
3360 static LONGEST
3361 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3362                     const char *annex, gdb_byte *readbuf,
3363                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3364 {
3365   char block_type;
3366   int pos, gotten;
3367   ULONGEST maddr;
3368   unsigned short mlen;
3369
3370   /* We're only doing regular memory for now.  */
3371   if (object != TARGET_OBJECT_MEMORY)
3372     return -1;
3373
3374   if (readbuf == NULL)
3375     error ("tfile_xfer_partial: trace file is read-only");
3376
3377   lseek (trace_fd, cur_offset, SEEK_SET);
3378   pos = 0;
3379   while (pos < cur_data_size)
3380     {
3381       gotten = read (trace_fd, &block_type, 1);
3382       if (gotten < 0)
3383         perror_with_name (trace_filename);
3384       else if (gotten < 1)
3385         error (_("Premature end of file while reading trace file"));
3386       ++pos;
3387       switch (block_type)
3388         {
3389         case 'R':
3390           lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3391           pos += trace_regblock_size;
3392           break;
3393         case 'M':
3394           gotten = read (trace_fd, &maddr, 8);
3395           if (gotten < 0)
3396             perror_with_name (trace_filename);
3397           else if (gotten < 8)
3398             error (_("Premature end of file while reading trace file"));
3399
3400           gotten = read (trace_fd, &mlen, 2);
3401           if (gotten < 0)
3402             perror_with_name (trace_filename);
3403           else if (gotten < 2)
3404             error (_("Premature end of file while reading trace file"));
3405           if (maddr <= offset && (offset + len) <= (maddr + mlen))
3406             {
3407               gotten = read (trace_fd, readbuf, mlen);
3408               if (gotten < 0)
3409                 perror_with_name (trace_filename);
3410               else if (gotten < mlen)
3411                 error (_("Premature end of file qwhile reading trace file"));
3412
3413               return mlen;
3414             }
3415           lseek (trace_fd, mlen, SEEK_CUR);
3416           pos += (8 + 2 + mlen);
3417           break;
3418         case 'V':
3419           lseek (trace_fd, 4 + 8, SEEK_CUR);
3420           pos += (4 + 8);
3421           break;
3422         default:
3423           error ("Unknown block type '%c' (0x%x) in traceframe",
3424                  block_type, block_type);
3425           break;
3426         }
3427     }
3428   /* Indicate failure to find the requested memory block.  */
3429   return -1;
3430 }
3431
3432 /* Iterate through the blocks of a trace frame, looking for a 'V'
3433    block with a matching tsv number.  */
3434
3435 static int
3436 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
3437 {
3438   char block_type;
3439   int pos, vnum, gotten;
3440   unsigned short mlen;
3441
3442   lseek (trace_fd, cur_offset, SEEK_SET);
3443   pos = 0;
3444   while (pos < cur_data_size)
3445     {
3446       gotten = read (trace_fd, &block_type, 1);
3447       if (gotten < 0)
3448         perror_with_name (trace_filename);
3449       else if (gotten < 1)
3450         error (_("Premature end of file while reading trace file"));
3451       ++pos;
3452       switch (block_type)
3453         {
3454         case 'R':
3455           lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3456           pos += trace_regblock_size;
3457           break;
3458         case 'M':
3459           lseek (trace_fd, 8, SEEK_CUR);
3460           gotten = read (trace_fd, &mlen, 2);
3461           if (gotten < 0)
3462             perror_with_name (trace_filename);
3463           else if (gotten < 2)
3464             error (_("Premature end of file while reading trace file"));
3465           lseek (trace_fd, mlen, SEEK_CUR);
3466           pos += (8 + 2 + mlen);
3467           break;
3468         case 'V':
3469           gotten = read (trace_fd, &vnum, 4);
3470           if (gotten < 0)
3471             perror_with_name (trace_filename);
3472           else if (gotten < 4)
3473             error (_("Premature end of file while reading trace file"));
3474           if (tsvnum == vnum)
3475             {
3476               gotten = read (trace_fd, val, 8);
3477               if (gotten < 0)
3478                 perror_with_name (trace_filename);
3479               else if (gotten < 8)
3480                 error (_("Premature end of file while reading trace file"));
3481               return 1;
3482             }
3483           lseek (trace_fd, 8, SEEK_CUR);
3484           pos += (4 + 8);
3485           break;
3486         default:
3487           error ("Unknown block type '%c' (0x%x) in traceframe",
3488                  block_type, block_type);
3489           break;
3490         }
3491     }
3492   /* Didn't find anything.  */
3493   return 0;
3494 }
3495
3496 static int
3497 tfile_has_memory (struct target_ops *ops)
3498 {
3499   return 1;
3500 }
3501
3502 static int
3503 tfile_has_stack (struct target_ops *ops)
3504 {
3505   return 1;
3506 }
3507
3508 static int
3509 tfile_has_registers (struct target_ops *ops)
3510 {
3511   return 1;
3512 }
3513
3514 static void
3515 init_tfile_ops (void)
3516 {
3517   tfile_ops.to_shortname = "tfile";
3518   tfile_ops.to_longname = "Local trace dump file";
3519   tfile_ops.to_doc =
3520     "Use a trace file as a target.  Specify the filename of the trace file.";
3521   tfile_ops.to_open = tfile_open;
3522   tfile_ops.to_close = tfile_close;
3523   tfile_ops.to_fetch_registers = tfile_fetch_registers;
3524   tfile_ops.to_xfer_partial = tfile_xfer_partial;
3525   tfile_ops.to_files_info = tfile_files_info;
3526   tfile_ops.to_get_trace_status = tfile_get_trace_status;
3527   tfile_ops.to_trace_find = tfile_trace_find;
3528   tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value;
3529   /* core_stratum might seem more logical, but GDB doesn't like having
3530      more than one core_stratum vector.  */
3531   tfile_ops.to_stratum = process_stratum;
3532   tfile_ops.to_has_memory = tfile_has_memory;
3533   tfile_ops.to_has_stack = tfile_has_stack;
3534   tfile_ops.to_has_registers = tfile_has_registers;
3535   tfile_ops.to_magic = OPS_MAGIC;
3536 }
3537
3538 /* module initialization */
3539 void
3540 _initialize_tracepoint (void)
3541 {
3542   struct cmd_list_element *c;
3543
3544   traceframe_number = -1;
3545   tracepoint_number = -1;
3546
3547   if (tracepoint_list.list == NULL)
3548     {
3549       tracepoint_list.listsize = 128;
3550       tracepoint_list.list = xmalloc
3551         (tracepoint_list.listsize * sizeof (struct memrange));
3552     }
3553   if (tracepoint_list.aexpr_list == NULL)
3554     {
3555       tracepoint_list.aexpr_listsize = 128;
3556       tracepoint_list.aexpr_list = xmalloc
3557         (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
3558     }
3559
3560   if (stepping_list.list == NULL)
3561     {
3562       stepping_list.listsize = 128;
3563       stepping_list.list = xmalloc
3564         (stepping_list.listsize * sizeof (struct memrange));
3565     }
3566
3567   if (stepping_list.aexpr_list == NULL)
3568     {
3569       stepping_list.aexpr_listsize = 128;
3570       stepping_list.aexpr_list = xmalloc
3571         (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
3572     }
3573
3574   add_info ("scope", scope_info,
3575             _("List the variables local to a scope"));
3576
3577   add_cmd ("tracepoints", class_trace, NULL,
3578            _("Tracing of program execution without stopping the program."),
3579            &cmdlist);
3580
3581   add_com ("tdump", class_trace, trace_dump_command,
3582            _("Print everything collected at the current tracepoint."));
3583
3584   add_com ("tsave", class_trace, trace_save_command, _("\
3585 Save the trace data to a file.\n\
3586 Use the '-r' option to direct the target to save directly to the file,\n\
3587 using its own filesystem."));
3588
3589   c = add_com ("tvariable", class_trace, trace_variable_command,_("\
3590 Define a trace state variable.\n\
3591 Argument is a $-prefixed name, optionally followed\n\
3592 by '=' and an expression that sets the initial value\n\
3593 at the start of tracing."));
3594   set_cmd_completer (c, expression_completer);
3595
3596   add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
3597 Delete one or more trace state variables.\n\
3598 Arguments are the names of the variables to delete.\n\
3599 If no arguments are supplied, delete all variables."), &deletelist);
3600   /* FIXME add a trace variable completer */
3601
3602   add_info ("tvariables", tvariables_info, _("\
3603 Status of trace state variables and their values.\n\
3604 "));
3605
3606   add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
3607 Select a trace frame;\n\
3608 No argument means forward by one frame; '-' means backward by one frame."),
3609                   &tfindlist, "tfind ", 1, &cmdlist);
3610
3611   add_cmd ("outside", class_trace, trace_find_outside_command, _("\
3612 Select a trace frame whose PC is outside the given range.\n\
3613 Usage: tfind outside addr1, addr2"),
3614            &tfindlist);
3615
3616   add_cmd ("range", class_trace, trace_find_range_command, _("\
3617 Select a trace frame whose PC is in the given range.\n\
3618 Usage: tfind range addr1,addr2"),
3619            &tfindlist);
3620
3621   add_cmd ("line", class_trace, trace_find_line_command, _("\
3622 Select a trace frame by source line.\n\
3623 Argument can be a line number (with optional source file), \n\
3624 a function name, or '*' followed by an address.\n\
3625 Default argument is 'the next source line that was traced'."),
3626            &tfindlist);
3627
3628   add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
3629 Select a trace frame by tracepoint number.\n\
3630 Default is the tracepoint for the current trace frame."),
3631            &tfindlist);
3632
3633   add_cmd ("pc", class_trace, trace_find_pc_command, _("\
3634 Select a trace frame by PC.\n\
3635 Default is the current PC, or the PC of the current trace frame."),
3636            &tfindlist);
3637
3638   add_cmd ("end", class_trace, trace_find_end_command, _("\
3639 Synonym for 'none'.\n\
3640 De-select any trace frame and resume 'live' debugging."),
3641            &tfindlist);
3642
3643   add_cmd ("none", class_trace, trace_find_none_command,
3644            _("De-select any trace frame and resume 'live' debugging."),
3645            &tfindlist);
3646
3647   add_cmd ("start", class_trace, trace_find_start_command,
3648            _("Select the first trace frame in the trace buffer."),
3649            &tfindlist);
3650
3651   add_com ("tstatus", class_trace, trace_status_command,
3652            _("Display the status of the current trace data collection."));
3653
3654   add_com ("tstop", class_trace, trace_stop_command,
3655            _("Stop trace data collection."));
3656
3657   add_com ("tstart", class_trace, trace_start_command,
3658            _("Start trace data collection."));
3659
3660   add_com ("end", class_trace, end_actions_pseudocommand, _("\
3661 Ends a list of commands or actions.\n\
3662 Several GDB commands allow you to enter a list of commands or actions.\n\
3663 Entering \"end\" on a line by itself is the normal way to terminate\n\
3664 such a list.\n\n\
3665 Note: the \"end\" command cannot be used at the gdb prompt."));
3666
3667   add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
3668 Specify single-stepping behavior at a tracepoint.\n\
3669 Argument is number of instructions to trace in single-step mode\n\
3670 following the tracepoint.  This command is normally followed by\n\
3671 one or more \"collect\" commands, to specify what to collect\n\
3672 while single-stepping.\n\n\
3673 Note: this command can only be used in a tracepoint \"actions\" list."));
3674
3675   add_com_alias ("ws", "while-stepping", class_alias, 0);
3676   add_com_alias ("stepping", "while-stepping", class_alias, 0);
3677
3678   add_com ("collect", class_trace, collect_pseudocommand, _("\
3679 Specify one or more data items to be collected at a tracepoint.\n\
3680 Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
3681 collect all data (variables, registers) referenced by that expression.\n\
3682 Also accepts the following special arguments:\n\
3683     $regs   -- all registers.\n\
3684     $args   -- all function arguments.\n\
3685     $locals -- all variables local to the block/function scope.\n\
3686 Note: this command can only be used in a tracepoint \"actions\" list."));
3687
3688   add_com ("teval", class_trace, teval_pseudocommand, _("\
3689 Specify one or more expressions to be evaluated at a tracepoint.\n\
3690 Accepts a comma-separated list of (one or more) expressions.\n\
3691 The result of each evaluation will be discarded.\n\
3692 Note: this command can only be used in a tracepoint \"actions\" list."));
3693
3694   add_com ("actions", class_trace, trace_actions_command, _("\
3695 Specify the actions to be taken at a tracepoint.\n\
3696 Tracepoint actions may include collecting of specified data, \n\
3697 single-stepping, or enabling/disabling other tracepoints, \n\
3698 depending on target's capabilities."));
3699
3700   default_collect = xstrdup ("");
3701   add_setshow_string_cmd ("default-collect", class_trace,
3702                           &default_collect, _("\
3703 Set the list of expressions to collect by default"), _("\
3704 Show the list of expressions to collect by default"), NULL,
3705                           NULL, NULL,
3706                           &setlist, &showlist);
3707
3708   add_setshow_boolean_cmd ("disconnected-tracing", no_class,
3709                            &disconnected_tracing, _("\
3710 Set whether tracing continues after GDB disconnects."), _("\
3711 Show whether tracing continues after GDB disconnects."), _("\
3712 Use this to continue a tracing run even if GDB disconnects\n\
3713 or detaches from the target.  You can reconnect later and look at\n\
3714 trace data collected in the meantime."),
3715                            set_disconnected_tracing,
3716                            NULL,
3717                            &setlist,
3718                            &showlist);
3719
3720   init_tfile_ops ();
3721
3722   add_target (&tfile_ops);
3723 }