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