1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
54 /* readline include files */
55 #include "readline/readline.h"
56 #include "readline/history.h"
58 /* readline defines this. */
69 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
70 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
72 extern void stop_tracing ();
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
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
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
87 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
89 extern void (*deprecated_readline_begin_hook
) (char *, ...);
90 extern char *(*deprecated_readline_hook
) (char *);
91 extern void (*deprecated_readline_end_hook
) (void);
93 /* GDB commands implemented in other modules:
96 extern void output_command (char *, int);
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.
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.
124 /* ======= Important global variables: ======= */
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. */
130 typedef struct trace_state_variable tsv_s
;
133 static VEC(tsv_s
) *tvariables
;
135 /* The next integer to assign to a variable. */
137 static int next_tsv_number
= 1;
139 /* Number of last traceframe collected. */
140 static int traceframe_number
;
142 /* Tracepoint for last traceframe collected. */
143 static int tracepoint_number
;
145 /* Symbol for function for last traceframe collected */
146 static struct symbol
*traceframe_fun
;
148 /* Symtab and line for last traceframe collected */
149 static struct symtab_and_line traceframe_sal
;
151 /* Tracing command lists */
152 static struct cmd_list_element
*tfindlist
;
154 /* List of expressions to collect by default at each tracepoint hit. */
155 char *default_collect
= "";
157 static int disconnected_tracing
;
159 /* This variable controls whether we ask the target for a linear or
160 circular trace buffer. */
162 static int circular_trace_buffer
;
164 /* ======= Important command functions: ======= */
165 static void trace_actions_command (char *, int);
166 static void trace_start_command (char *, int);
167 static void trace_stop_command (char *, int);
168 static void trace_status_command (char *, int);
169 static void trace_find_command (char *, int);
170 static void trace_find_pc_command (char *, int);
171 static void trace_find_tracepoint_command (char *, int);
172 static void trace_find_line_command (char *, int);
173 static void trace_find_range_command (char *, int);
174 static void trace_find_outside_command (char *, int);
175 static void trace_dump_command (char *, int);
177 /* support routines */
179 struct collection_list
;
180 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
181 static char *mem2hex (gdb_byte
*, char *, int);
182 static void add_register (struct collection_list
*collection
,
185 extern void send_disconnected_tracing_value (int value
);
187 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
188 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
191 extern void _initialize_tracepoint (void);
193 static struct trace_status trace_status
;
195 char *stop_reason_names
[] = {
205 struct trace_status
*
206 current_trace_status ()
208 return &trace_status
;
211 /* Set traceframe number to NUM. */
213 set_traceframe_num (int num
)
215 traceframe_number
= num
;
216 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
219 /* Set tracepoint number to NUM. */
221 set_tracepoint_num (int num
)
223 tracepoint_number
= num
;
224 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
227 /* Set externally visible debug variables for querying/printing
228 the traceframe context (line, function, file) */
231 set_traceframe_context (struct frame_info
*trace_frame
)
235 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
238 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
239 traceframe_sal
.symtab
= NULL
;
240 clear_internalvar (lookup_internalvar ("trace_func"));
241 clear_internalvar (lookup_internalvar ("trace_file"));
242 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
246 /* Save as globals for internal use. */
247 trace_pc
= get_frame_pc (trace_frame
);
248 traceframe_sal
= find_pc_line (trace_pc
, 0);
249 traceframe_fun
= find_pc_function (trace_pc
);
251 /* Save linenumber as "$trace_line", a debugger variable visible to
253 set_internalvar_integer (lookup_internalvar ("trace_line"),
254 traceframe_sal
.line
);
256 /* Save func name as "$trace_func", a debugger variable visible to
258 if (traceframe_fun
== NULL
259 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
260 clear_internalvar (lookup_internalvar ("trace_func"));
262 set_internalvar_string (lookup_internalvar ("trace_func"),
263 SYMBOL_LINKAGE_NAME (traceframe_fun
));
265 /* Save file name as "$trace_file", a debugger variable visible to
267 if (traceframe_sal
.symtab
== NULL
268 || traceframe_sal
.symtab
->filename
== NULL
)
269 clear_internalvar (lookup_internalvar ("trace_file"));
271 set_internalvar_string (lookup_internalvar ("trace_file"),
272 traceframe_sal
.symtab
->filename
);
275 /* Create a new trace state variable with the given name. */
277 struct trace_state_variable
*
278 create_trace_state_variable (const char *name
)
280 struct trace_state_variable tsv
;
282 memset (&tsv
, 0, sizeof (tsv
));
283 tsv
.name
= xstrdup (name
);
284 tsv
.number
= next_tsv_number
++;
285 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
288 /* Look for a trace state variable of the given name. */
290 struct trace_state_variable
*
291 find_trace_state_variable (const char *name
)
293 struct trace_state_variable
*tsv
;
296 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
297 if (strcmp (name
, tsv
->name
) == 0)
304 delete_trace_state_variable (const char *name
)
306 struct trace_state_variable
*tsv
;
309 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
310 if (strcmp (name
, tsv
->name
) == 0)
312 xfree ((void *)tsv
->name
);
313 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
317 warning (_("No trace variable named \"$%s\", not deleting"), name
);
320 /* The 'tvariable' command collects a name and optional expression to
321 evaluate into an initial value. */
324 trace_variable_command (char *args
, int from_tty
)
326 struct expression
*expr
;
327 struct cleanup
*old_chain
;
328 struct internalvar
*intvar
= NULL
;
330 struct trace_state_variable
*tsv
;
333 error_no_arg (_("trace state variable name"));
335 /* All the possible valid arguments are expressions. */
336 expr
= parse_expression (args
);
337 old_chain
= make_cleanup (free_current_contents
, &expr
);
339 if (expr
->nelts
== 0)
340 error (_("No expression?"));
342 /* Only allow two syntaxes; "$name" and "$name=value". */
343 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
345 intvar
= expr
->elts
[1].internalvar
;
347 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
348 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
350 intvar
= expr
->elts
[2].internalvar
;
351 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
354 error (_("Syntax must be $NAME [ = EXPR ]"));
357 error (_("No name given"));
359 if (strlen (internalvar_name (intvar
)) <= 0)
360 error (_("Must supply a non-empty variable name"));
362 /* If the variable already exists, just change its initial value. */
363 tsv
= find_trace_state_variable (internalvar_name (intvar
));
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
));
369 do_cleanups (old_chain
);
373 /* Create a new variable. */
374 tsv
= create_trace_state_variable (internalvar_name (intvar
));
375 tsv
->initial_value
= initval
;
377 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
378 tsv
->name
, plongest (tsv
->initial_value
));
380 do_cleanups (old_chain
);
384 delete_trace_variable_command (char *args
, int from_tty
)
388 struct cleanup
*back_to
;
392 if (query (_("Delete all trace state variables? ")))
393 VEC_free (tsv_s
, tvariables
);
398 argv
= gdb_buildargv (args
);
399 back_to
= make_cleanup_freeargv (argv
);
401 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
403 if (*argv
[ix
] == '$')
404 delete_trace_state_variable (argv
[ix
] + 1);
406 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
409 do_cleanups (back_to
);
415 tvariables_info_1 (void)
417 struct trace_state_variable
*tsv
;
420 struct cleanup
*back_to
;
422 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
424 printf_filtered (_("No trace state variables.\n"));
428 /* Try to acquire values from the target. */
429 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
430 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
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");
439 ui_out_table_body (uiout
);
441 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
443 struct cleanup
*back_to2
;
447 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
449 name
= concat ("$", tsv
->name
, (char *) NULL
);
450 make_cleanup (xfree
, name
);
451 ui_out_field_string (uiout
, "name", name
);
452 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
454 if (tsv
->value_known
)
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. */
461 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
462 /* The value is/was defined, but we don't have it. */
465 /* It is not meaningful to ask about the value. */
468 ui_out_field_string (uiout
, "current", c
);
469 ui_out_text (uiout
, "\n");
471 do_cleanups (back_to2
);
474 do_cleanups (back_to
);
477 /* List all the trace state variables. */
480 tvariables_info (char *args
, int from_tty
)
482 tvariables_info_1 ();
485 /* Stash definitions of tsvs into the given file. */
488 save_trace_state_variables (struct ui_file
*fp
)
490 struct trace_state_variable
*tsv
;
493 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
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");
502 /* ACTIONS functions: */
504 /* The three functions:
505 collect_pseudocommand,
506 while_stepping_pseudocommand, and
507 end_actions_pseudocommand
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. */
514 end_actions_pseudocommand (char *args
, int from_tty
)
516 error (_("This command cannot be used at the top level."));
520 while_stepping_pseudocommand (char *args
, int from_tty
)
522 error (_("This command can only be used in a tracepoint actions list."));
526 collect_pseudocommand (char *args
, int from_tty
)
528 error (_("This command can only be used in a tracepoint actions list."));
532 teval_pseudocommand (char *args
, int from_tty
)
534 error (_("This command can only be used in a tracepoint actions list."));
537 /* Enter a list of actions for a tracepoint. */
539 trace_actions_command (char *args
, int from_tty
)
541 struct breakpoint
*t
;
542 struct command_line
*l
;
544 t
= get_tracepoint_by_number (&args
, 0, 1);
548 xstrprintf ("Enter actions for tracepoint %d, one per line.",
550 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
552 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
553 do_cleanups (cleanups
);
554 breakpoint_set_commands (t
, l
);
556 /* else just return */
559 /* Report the results of checking the agent expression, as errors or
563 report_agent_reqs_errors (struct agent_expr
*aexpr
)
565 /* All of the "flaws" are serious bytecode generation issues that
566 should never occur. */
567 if (aexpr
->flaw
!= agent_flaw_none
)
568 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
570 /* If analysis shows a stack underflow, GDB must have done something
571 badly wrong in its bytecode generation. */
572 if (aexpr
->min_height
< 0)
573 internal_error (__FILE__
, __LINE__
,
574 _("expression has min height < 0"));
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. */
582 if (aexpr
->max_height
> 20)
583 error (_("Expression is too complicated."));
586 /* worker function */
588 validate_actionline (char **line
, struct breakpoint
*t
)
590 struct cmd_list_element
*c
;
591 struct expression
*exp
= NULL
;
592 struct cleanup
*old_chain
= NULL
;
594 struct bp_location
*loc
;
595 struct agent_expr
*aexpr
;
597 /* if EOF is typed, *line is NULL */
601 for (p
= *line
; isspace ((int) *p
);)
604 /* Symbol lookup etc. */
605 if (*p
== '\0') /* empty line: just prompt for another line. */
608 if (*p
== '#') /* comment line */
611 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
613 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
615 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
618 { /* repeat over a comma-separated list */
619 QUIT
; /* allow user to bail out with ^C */
620 while (isspace ((int) *p
))
623 if (*p
== '$') /* look for special pseudo-symbols */
625 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
626 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
627 (0 == strncasecmp ("loc", p
+ 1, 3)))
632 /* else fall thru, treat p as an expression and parse it! */
635 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
638 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
639 old_chain
= make_cleanup (free_current_contents
, &exp
);
641 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
643 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
645 error (_("constant `%s' (value %ld) will not be collected."),
646 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
647 SYMBOL_VALUE (exp
->elts
[2].symbol
));
649 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
651 error (_("`%s' is optimized away and cannot be collected."),
652 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
656 /* We have something to collect, make sure that the expr to
657 bytecode translator can handle it and that it's not too
659 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
660 make_cleanup_free_agent_expr (aexpr
);
662 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
663 error (_("Expression is too complicated."));
667 report_agent_reqs_errors (aexpr
);
669 do_cleanups (old_chain
);
672 while (p
&& *p
++ == ',');
675 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
678 { /* repeat over a comma-separated list */
679 QUIT
; /* allow user to bail out with ^C */
680 while (isspace ((int) *p
))
684 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
687 /* Only expressions are allowed for this action. */
688 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
689 old_chain
= make_cleanup (free_current_contents
, &exp
);
691 /* We have something to evaluate, make sure that the expr to
692 bytecode translator can handle it and that it's not too
694 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
695 make_cleanup_free_agent_expr (aexpr
);
697 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
698 error (_("Expression is too complicated."));
701 report_agent_reqs_errors (aexpr
);
703 do_cleanups (old_chain
);
706 while (p
&& *p
++ == ',');
709 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
711 char *steparg
; /* in case warning is necessary */
713 while (isspace ((int) *p
))
717 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
718 error (_("while-stepping step count `%s' is malformed."), *line
);
721 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
725 error (_("`%s' is not a supported tracepoint action."), *line
);
729 memrange_absolute
= -1
734 int type
; /* memrange_absolute for absolute memory range,
735 else basereg number */
736 bfd_signed_vma start
;
740 struct collection_list
742 unsigned char regs_mask
[32]; /* room for up to 256 regs */
745 struct memrange
*list
;
746 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
748 struct agent_expr
**aexpr_list
;
751 tracepoint_list
, stepping_list
;
753 /* MEMRANGE functions: */
755 static int memrange_cmp (const void *, const void *);
757 /* compare memranges for qsort */
759 memrange_cmp (const void *va
, const void *vb
)
761 const struct memrange
*a
= va
, *b
= vb
;
763 if (a
->type
< b
->type
)
765 if (a
->type
> b
->type
)
767 if (a
->type
== memrange_absolute
)
769 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
771 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
776 if (a
->start
< b
->start
)
778 if (a
->start
> b
->start
)
784 /* Sort the memrange list using qsort, and merge adjacent memranges. */
786 memrange_sortmerge (struct collection_list
*memranges
)
790 qsort (memranges
->list
, memranges
->next_memrange
,
791 sizeof (struct memrange
), memrange_cmp
);
792 if (memranges
->next_memrange
> 0)
794 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
796 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
797 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
800 /* memrange b starts before memrange a ends; merge them. */
801 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
802 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
803 continue; /* next b, same a */
807 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
808 sizeof (struct memrange
));
810 memranges
->next_memrange
= a
+ 1;
814 /* Add a register to a collection list. */
816 add_register (struct collection_list
*collection
, unsigned int regno
)
819 printf_filtered ("collect register %d\n", regno
);
820 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
821 error (_("Internal: register number %d too large for tracepoint"),
823 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
826 /* Add a memrange to a collection list */
828 add_memrange (struct collection_list
*memranges
,
829 int type
, bfd_signed_vma base
,
834 printf_filtered ("(%d,", type
);
836 printf_filtered (",%ld)\n", len
);
839 /* type: memrange_absolute == memory, other n == basereg */
840 memranges
->list
[memranges
->next_memrange
].type
= type
;
841 /* base: addr if memory, offset if reg relative. */
842 memranges
->list
[memranges
->next_memrange
].start
= base
;
843 /* len: we actually save end (base + len) for convenience */
844 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
845 memranges
->next_memrange
++;
846 if (memranges
->next_memrange
>= memranges
->listsize
)
848 memranges
->listsize
*= 2;
849 memranges
->list
= xrealloc (memranges
->list
,
850 memranges
->listsize
);
853 if (type
!= memrange_absolute
) /* Better collect the base register! */
854 add_register (memranges
, type
);
857 /* Add a symbol to a collection list. */
859 collect_symbol (struct collection_list
*collect
,
861 struct gdbarch
*gdbarch
,
862 long frame_regno
, long frame_offset
,
867 bfd_signed_vma offset
;
868 int treat_as_expr
= 0;
870 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
871 switch (SYMBOL_CLASS (sym
))
874 printf_filtered ("%s: don't know symbol class %d\n",
875 SYMBOL_PRINT_NAME (sym
),
879 printf_filtered ("constant %s (value %ld) will not be collected.\n",
880 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
883 offset
= SYMBOL_VALUE_ADDRESS (sym
);
888 sprintf_vma (tmp
, offset
);
889 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
890 SYMBOL_PRINT_NAME (sym
), len
,
893 /* A struct may be a C++ class with static fields, go to general
894 expression handling. */
895 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
898 add_memrange (collect
, memrange_absolute
, offset
, len
);
901 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
903 printf_filtered ("LOC_REG[parm] %s: ",
904 SYMBOL_PRINT_NAME (sym
));
905 add_register (collect
, reg
);
906 /* Check for doubles stored in two registers. */
907 /* FIXME: how about larger types stored in 3 or more regs? */
908 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
909 len
> register_size (gdbarch
, reg
))
910 add_register (collect
, reg
+ 1);
913 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
914 printf_filtered (" (will not collect %s)\n",
915 SYMBOL_PRINT_NAME (sym
));
919 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
922 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
923 SYMBOL_PRINT_NAME (sym
), len
);
925 printf_filtered (" from frame ptr reg %d\n", reg
);
927 add_memrange (collect
, reg
, offset
, len
);
929 case LOC_REGPARM_ADDR
:
930 reg
= SYMBOL_VALUE (sym
);
934 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
935 SYMBOL_PRINT_NAME (sym
), len
);
937 printf_filtered (" from reg %d\n", reg
);
939 add_memrange (collect
, reg
, offset
, len
);
943 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
946 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
947 SYMBOL_PRINT_NAME (sym
), len
);
949 printf_filtered (" from frame ptr reg %d\n", reg
);
951 add_memrange (collect
, reg
, offset
, len
);
958 case LOC_OPTIMIZED_OUT
:
959 printf_filtered ("%s has been optimized out of existence.\n",
960 SYMBOL_PRINT_NAME (sym
));
968 /* Expressions are the most general case. */
971 struct agent_expr
*aexpr
;
972 struct cleanup
*old_chain1
= NULL
;
974 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
976 /* It can happen that the symbol is recorded as a computed
977 location, but it's been optimized away and doesn't actually
978 have a location expression. */
981 printf_filtered ("%s has been optimized out of existence.\n",
982 SYMBOL_PRINT_NAME (sym
));
986 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
990 report_agent_reqs_errors (aexpr
);
992 discard_cleanups (old_chain1
);
993 add_aexpr (collect
, aexpr
);
995 /* take care of the registers */
996 if (aexpr
->reg_mask_len
> 0)
1000 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1002 QUIT
; /* allow user to bail out with ^C */
1003 if (aexpr
->reg_mask
[ndx1
] != 0)
1005 /* assume chars have 8 bits */
1006 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1007 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1008 /* it's used -- record it */
1009 add_register (collect
, ndx1
* 8 + ndx2
);
1016 /* Data to be passed around in the calls to the locals and args
1019 struct add_local_symbols_data
1021 struct collection_list
*collect
;
1022 struct gdbarch
*gdbarch
;
1029 /* The callback for the locals and args iterators */
1032 do_collect_symbol (const char *print_name
,
1036 struct add_local_symbols_data
*p
= cb_data
;
1038 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1039 p
->frame_offset
, p
->pc
);
1043 /* Add all locals (or args) symbols to collection list */
1045 add_local_symbols (struct collection_list
*collect
,
1046 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1047 long frame_regno
, long frame_offset
, int type
)
1049 struct block
*block
;
1050 struct add_local_symbols_data cb_data
;
1052 cb_data
.collect
= collect
;
1053 cb_data
.gdbarch
= gdbarch
;
1055 cb_data
.frame_regno
= frame_regno
;
1056 cb_data
.frame_offset
= frame_offset
;
1061 block
= block_for_pc (pc
);
1064 warning (_("Can't collect locals; "
1065 "no symbol table info available.\n"));
1069 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1070 if (cb_data
.count
== 0)
1071 warning (_("No locals found in scope."));
1075 pc
= get_pc_function_start (pc
);
1076 block
= block_for_pc (pc
);
1079 warning (_("Can't collect args; no symbol table info available.\n"));
1083 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1084 if (cb_data
.count
== 0)
1085 warning (_("No args found in scope."));
1089 /* worker function */
1091 clear_collection_list (struct collection_list
*list
)
1095 list
->next_memrange
= 0;
1096 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1098 free_agent_expr (list
->aexpr_list
[ndx
]);
1099 list
->aexpr_list
[ndx
] = NULL
;
1101 list
->next_aexpr_elt
= 0;
1102 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1105 /* reduce a collection list to string form (for gdb protocol) */
1107 stringify_collection_list (struct collection_list
*list
, char *string
)
1109 char temp_buf
[2048];
1113 char *(*str_list
)[];
1117 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1118 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1120 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1121 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1123 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1126 printf_filtered ("\nCollecting registers (mask): 0x");
1131 QUIT
; /* allow user to bail out with ^C */
1133 printf_filtered ("%02X", list
->regs_mask
[i
]);
1134 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1137 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1141 printf_filtered ("\n");
1142 if (list
->next_memrange
> 0 && info_verbose
)
1143 printf_filtered ("Collecting memranges: \n");
1144 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1146 QUIT
; /* allow user to bail out with ^C */
1147 sprintf_vma (tmp2
, list
->list
[i
].start
);
1150 printf_filtered ("(%d, %s, %ld)\n",
1153 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1155 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1157 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1164 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1166 /* The "%X" conversion specifier expects an unsigned argument,
1167 so passing -1 (memrange_absolute) to it directly gives you
1168 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1170 if (list
->list
[i
].type
== memrange_absolute
)
1171 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1173 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1176 count
+= strlen (end
);
1177 end
= temp_buf
+ count
;
1180 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1182 QUIT
; /* allow user to bail out with ^C */
1183 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1185 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1190 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1191 end
+= 10; /* 'X' + 8 hex digits + ',' */
1194 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1195 end
, list
->aexpr_list
[i
]->len
);
1196 count
+= 2 * list
->aexpr_list
[i
]->len
;
1201 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1206 (*str_list
)[ndx
] = NULL
;
1219 encode_actions_1 (struct command_line
*action
,
1220 struct breakpoint
*t
,
1221 struct bp_location
*tloc
,
1223 LONGEST frame_offset
,
1224 struct collection_list
*collect
,
1225 struct collection_list
*stepping_list
)
1228 struct expression
*exp
= NULL
;
1230 struct value
*tempval
;
1231 struct cmd_list_element
*cmd
;
1232 struct agent_expr
*aexpr
;
1234 for (; action
; action
= action
->next
)
1236 QUIT
; /* allow user to bail out with ^C */
1237 action_exp
= action
->line
;
1238 while (isspace ((int) *action_exp
))
1241 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1243 error (_("Bad action list item: %s"), action_exp
);
1245 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1248 { /* repeat over a comma-separated list */
1249 QUIT
; /* allow user to bail out with ^C */
1250 while (isspace ((int) *action_exp
))
1253 if (0 == strncasecmp ("$reg", action_exp
, 4))
1255 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1256 add_register (collect
, i
);
1257 action_exp
= strchr (action_exp
, ','); /* more? */
1259 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1261 add_local_symbols (collect
,
1267 action_exp
= strchr (action_exp
, ','); /* more? */
1269 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1271 add_local_symbols (collect
,
1277 action_exp
= strchr (action_exp
, ','); /* more? */
1281 unsigned long addr
, len
;
1282 struct cleanup
*old_chain
= NULL
;
1283 struct cleanup
*old_chain1
= NULL
;
1285 exp
= parse_exp_1 (&action_exp
,
1286 block_for_pc (tloc
->address
), 1);
1287 old_chain
= make_cleanup (free_current_contents
, &exp
);
1289 switch (exp
->elts
[0].opcode
)
1293 const char *name
= &exp
->elts
[2].string
;
1295 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1296 name
, strlen (name
));
1298 internal_error (__FILE__
, __LINE__
,
1299 _("Register $%s not available"),
1302 printf_filtered ("OP_REGISTER: ");
1303 add_register (collect
, i
);
1308 /* safe because we know it's a simple expression */
1309 tempval
= evaluate_expression (exp
);
1310 addr
= value_address (tempval
);
1311 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1312 add_memrange (collect
, memrange_absolute
, addr
, len
);
1316 collect_symbol (collect
,
1317 exp
->elts
[2].symbol
,
1324 default: /* full-fledged expression */
1325 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1327 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1331 report_agent_reqs_errors (aexpr
);
1333 discard_cleanups (old_chain1
);
1334 add_aexpr (collect
, aexpr
);
1336 /* take care of the registers */
1337 if (aexpr
->reg_mask_len
> 0)
1342 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1344 QUIT
; /* allow user to bail out with ^C */
1345 if (aexpr
->reg_mask
[ndx1
] != 0)
1347 /* assume chars have 8 bits */
1348 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1349 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1350 /* it's used -- record it */
1351 add_register (collect
,
1358 do_cleanups (old_chain
);
1361 while (action_exp
&& *action_exp
++ == ',');
1363 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1366 { /* repeat over a comma-separated list */
1367 QUIT
; /* allow user to bail out with ^C */
1368 while (isspace ((int) *action_exp
))
1372 struct cleanup
*old_chain
= NULL
;
1373 struct cleanup
*old_chain1
= NULL
;
1375 exp
= parse_exp_1 (&action_exp
,
1376 block_for_pc (tloc
->address
), 1);
1377 old_chain
= make_cleanup (free_current_contents
, &exp
);
1379 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1380 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1383 report_agent_reqs_errors (aexpr
);
1385 discard_cleanups (old_chain1
);
1386 /* Even though we're not officially collecting, add
1387 to the collect list anyway. */
1388 add_aexpr (collect
, aexpr
);
1390 do_cleanups (old_chain
);
1393 while (action_exp
&& *action_exp
++ == ',');
1395 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1397 /* We check against nested while-stepping when setting
1398 breakpoint action, so no way to run into nested
1400 gdb_assert (stepping_list
);
1402 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1403 frame_offset
, stepping_list
, NULL
);
1406 error (_("Invalid tracepoint command '%s'"), action
->line
);
1410 /* Render all actions into gdb protocol. */
1412 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1413 char ***tdp_actions
, char ***stepping_actions
)
1415 static char tdp_buff
[2048], step_buff
[2048];
1416 char *default_collect_line
= NULL
;
1417 struct command_line
*actions
;
1418 struct command_line
*default_collect_action
= NULL
;
1420 LONGEST frame_offset
;
1421 struct cleanup
*back_to
;
1423 back_to
= make_cleanup (null_cleanup
, NULL
);
1425 clear_collection_list (&tracepoint_list
);
1426 clear_collection_list (&stepping_list
);
1428 *tdp_actions
= NULL
;
1429 *stepping_actions
= NULL
;
1431 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1432 t
->loc
->address
, &frame_reg
, &frame_offset
);
1434 actions
= breakpoint_commands (t
);
1436 /* If there are default expressions to collect, make up a collect
1437 action and prepend to the action list to encode. Note that since
1438 validation is per-tracepoint (local var "xyz" might be valid for
1439 one tracepoint and not another, etc), we make up the action on
1440 the fly, and don't cache it. */
1441 if (*default_collect
)
1445 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1446 make_cleanup (xfree
, default_collect_line
);
1448 line
= default_collect_line
;
1449 validate_actionline (&line
, t
);
1451 default_collect_action
= xmalloc (sizeof (struct command_line
));
1452 make_cleanup (xfree
, default_collect_action
);
1453 default_collect_action
->next
= actions
;
1454 default_collect_action
->line
= line
;
1455 actions
= default_collect_action
;
1457 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1458 &tracepoint_list
, &stepping_list
);
1460 memrange_sortmerge (&tracepoint_list
);
1461 memrange_sortmerge (&stepping_list
);
1463 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1465 *stepping_actions
= stringify_collection_list (&stepping_list
,
1468 do_cleanups (back_to
);
1472 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1474 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1476 collect
->aexpr_list
=
1477 xrealloc (collect
->aexpr_list
,
1478 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1479 collect
->aexpr_listsize
*= 2;
1481 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1482 collect
->next_aexpr_elt
++;
1487 start_tracing (void)
1489 VEC(breakpoint_p
) *tp_vec
= NULL
;
1491 struct breakpoint
*t
;
1492 struct trace_state_variable
*tsv
;
1493 int any_enabled
= 0, num_to_download
= 0;
1495 tp_vec
= all_tracepoints ();
1497 /* No point in tracing without any tracepoints... */
1498 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1500 VEC_free (breakpoint_p
, tp_vec
);
1501 error (_("No tracepoints defined, not starting trace"));
1504 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1506 if (t
->enable_state
== bp_enabled
)
1509 if ((t
->type
== bp_fast_tracepoint
1510 ? may_insert_fast_tracepoints
1511 : may_insert_tracepoints
))
1514 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1515 (t
->type
== bp_fast_tracepoint
? "fast " : ""), t
->number
);
1518 /* No point in tracing with only disabled tracepoints. */
1521 VEC_free (breakpoint_p
, tp_vec
);
1522 error (_("No tracepoints enabled, not starting trace"));
1525 if (num_to_download
<= 0)
1527 VEC_free (breakpoint_p
, tp_vec
);
1528 error (_("No tracepoints that may be downloaded, not starting trace"));
1531 target_trace_init ();
1533 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1535 if ((t
->type
== bp_fast_tracepoint
1536 ? !may_insert_fast_tracepoints
1537 : !may_insert_tracepoints
))
1540 t
->number_on_target
= 0;
1541 target_download_tracepoint (t
);
1542 t
->number_on_target
= t
->number
;
1544 VEC_free (breakpoint_p
, tp_vec
);
1546 /* Send down all the trace state variables too. */
1547 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1549 target_download_trace_state_variable (tsv
);
1552 /* Tell target to treat text-like sections as transparent. */
1553 target_trace_set_readonly_regions ();
1554 /* Set some mode flags. */
1555 target_set_disconnected_tracing (disconnected_tracing
);
1556 target_set_circular_trace_buffer (circular_trace_buffer
);
1558 /* Now insert traps and begin collecting data. */
1559 target_trace_start ();
1561 /* Reset our local state. */
1562 set_traceframe_num (-1);
1563 set_tracepoint_num (-1);
1564 set_traceframe_context (NULL
);
1565 current_trace_status()->running
= 1;
1570 Tell target to clear any previous trace experiment.
1571 Walk the list of tracepoints, and send them (and their actions)
1572 to the target. If no errors,
1573 Tell target to start a new trace experiment. */
1576 trace_start_command (char *args
, int from_tty
)
1578 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1580 if (current_trace_status ()->running
)
1583 && !query (_("A trace is running already. Start a new run? ")))
1584 error (_("New trace run not started."));
1592 trace_stop_command (char *args
, int from_tty
)
1594 if (!current_trace_status ()->running
)
1595 error (_("Trace is not running."));
1603 target_trace_stop ();
1604 /* should change in response to reply? */
1605 current_trace_status ()->running
= 0;
1608 /* tstatus command */
1610 trace_status_command (char *args
, int from_tty
)
1612 struct trace_status
*ts
= current_trace_status ();
1615 status
= target_get_trace_status (ts
);
1620 printf_filtered (_("Using a trace file.\n"));
1623 printf_filtered (_("Trace can not be run on this target.\n"));
1628 if (!ts
->running_known
)
1630 printf_filtered (_("Run/stop status is unknown.\n"));
1632 else if (ts
->running
)
1634 printf_filtered (_("Trace is running on the target.\n"));
1638 switch (ts
->stop_reason
)
1640 case trace_never_run
:
1641 printf_filtered (_("No trace has been run on the target.\n"));
1644 printf_filtered (_("Trace stopped by a tstop command.\n"));
1646 case trace_buffer_full
:
1647 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1649 case trace_disconnected
:
1650 printf_filtered (_("Trace stopped because of disconnection.\n"));
1652 case tracepoint_passcount
:
1653 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1654 ts
->stopping_tracepoint
);
1656 case tracepoint_error
:
1657 if (ts
->stopping_tracepoint
)
1658 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1659 ts
->error_desc
, ts
->stopping_tracepoint
);
1661 printf_filtered (_("Trace stopped by an error (%s).\n"),
1664 case trace_stop_reason_unknown
:
1665 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1668 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1674 if (ts
->traceframes_created
>= 0
1675 && ts
->traceframe_count
!= ts
->traceframes_created
)
1677 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1678 ts
->traceframe_count
, ts
->traceframes_created
);
1680 else if (ts
->traceframe_count
>= 0)
1682 printf_filtered (_("Collected %d trace frames.\n"),
1683 ts
->traceframe_count
);
1686 if (ts
->buffer_free
>= 0)
1688 if (ts
->buffer_size
>= 0)
1690 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1691 ts
->buffer_free
, ts
->buffer_size
);
1692 if (ts
->buffer_size
> 0)
1693 printf_filtered (_(" (%d%% full)"),
1694 ((int) ((((long long) (ts
->buffer_size
1695 - ts
->buffer_free
)) * 100)
1696 / ts
->buffer_size
)));
1697 printf_filtered (_(".\n"));
1700 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1704 if (ts
->disconnected_tracing
)
1705 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1707 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1709 if (ts
->circular_buffer
)
1710 printf_filtered (_("Trace buffer is circular.\n"));
1712 /* Now report on what we're doing with tfind. */
1713 if (traceframe_number
>= 0)
1714 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1715 traceframe_number
, tracepoint_number
);
1717 printf_filtered (_("Not looking at any trace frame.\n"));
1720 /* Report the trace status to uiout, in a way suitable for MI, and not
1721 suitable for CLI. If ON_STOP is true, suppress a few fields that
1722 are not meaningful in the -trace-stop response.
1724 The implementation is essentially parallel to trace_status_command, but
1725 merging them will result in unreadable code. */
1727 trace_status_mi (int on_stop
)
1729 struct trace_status
*ts
= current_trace_status ();
1732 status
= target_get_trace_status (ts
);
1734 if (status
== -1 && !ts
->from_file
)
1736 ui_out_field_string (uiout
, "supported", "0");
1741 ui_out_field_string (uiout
, "supported", "file");
1743 ui_out_field_string (uiout
, "supported", "1");
1745 gdb_assert (ts
->running_known
);
1749 ui_out_field_string (uiout
, "running", "1");
1751 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1752 Given that the frontend gets the status either on -trace-stop, or from
1753 -trace-status after re-connection, it does not seem like this
1754 information is necessary for anything. It is not necessary for either
1755 figuring the vital state of the target nor for navigation of trace
1756 frames. If the frontend wants to show the current state is some
1757 configure dialog, it can request the value when such dialog is
1758 invoked by the user. */
1762 char *stop_reason
= NULL
;
1763 int stopping_tracepoint
= -1;
1766 ui_out_field_string (uiout
, "running", "0");
1768 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1770 switch (ts
->stop_reason
)
1773 stop_reason
= "request";
1775 case trace_buffer_full
:
1776 stop_reason
= "overflow";
1778 case trace_disconnected
:
1779 stop_reason
= "disconnection";
1781 case tracepoint_passcount
:
1782 stop_reason
= "passcount";
1783 stopping_tracepoint
= ts
->stopping_tracepoint
;
1785 case tracepoint_error
:
1786 stop_reason
= "error";
1787 stopping_tracepoint
= ts
->stopping_tracepoint
;
1793 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1794 if (stopping_tracepoint
!= -1)
1795 ui_out_field_int (uiout
, "stopping-tracepoint",
1796 stopping_tracepoint
);
1797 if (ts
->stop_reason
== tracepoint_error
)
1798 ui_out_field_string (uiout
, "error-description",
1804 if (ts
->traceframe_count
!= -1)
1805 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1806 if (ts
->traceframes_created
!= -1)
1807 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1808 if (ts
->buffer_size
!= -1)
1809 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1810 if (ts
->buffer_free
!= -1)
1811 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1813 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1814 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1817 /* This function handles the details of what to do about an ongoing
1818 tracing run if the user has asked to detach or otherwise disconnect
1821 disconnect_tracing (int from_tty
)
1823 /* It can happen that the target that was tracing went away on its
1824 own, and we didn't notice. Get a status update, and if the
1825 current target doesn't even do tracing, then assume it's not
1827 if (target_get_trace_status (current_trace_status ()) < 0)
1828 current_trace_status ()->running
= 0;
1830 /* If running interactively, give the user the option to cancel and
1831 then decide what to do differently with the run. Scripts are
1832 just going to disconnect and let the target deal with it,
1833 according to how it's been instructed previously via
1834 disconnected-tracing. */
1835 if (current_trace_status ()->running
&& from_tty
)
1837 if (current_trace_status ()->disconnected_tracing
)
1839 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1840 error (_("Not confirmed."));
1844 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1845 error (_("Not confirmed."));
1849 /* Also we want to be out of tfind mode, otherwise things can get
1850 confusing upon reconnection. Just use these calls instead of
1851 full tfind_1 behavior because we're in the middle of detaching,
1852 and there's no point to updating current stack frame etc. */
1853 set_traceframe_number (-1);
1854 set_traceframe_context (NULL
);
1857 /* Worker function for the various flavors of the tfind command. */
1859 tfind_1 (enum trace_find_type type
, int num
,
1860 ULONGEST addr1
, ULONGEST addr2
,
1863 int target_frameno
= -1, target_tracept
= -1;
1864 struct frame_id old_frame_id
= null_frame_id
;
1865 struct breakpoint
*tp
;
1867 /* Only try to get the current stack frame if we have a chance of
1868 succeeding. In particular, if we're trying to get a first trace
1869 frame while all threads are running, it's not going to succeed,
1870 so leave it with a default value and let the frame comparison
1871 below (correctly) decide to print out the source location of the
1873 if (!(type
== tfind_number
&& num
== -1)
1874 && (has_stack_frames () || traceframe_number
>= 0))
1875 old_frame_id
= get_frame_id (get_current_frame ());
1877 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1880 if (type
== tfind_number
1882 && target_frameno
== -1)
1884 /* We told the target to get out of tfind mode, and it did. */
1886 else if (target_frameno
== -1)
1888 /* A request for a non-existent trace frame has failed.
1889 Our response will be different, depending on FROM_TTY:
1891 If FROM_TTY is true, meaning that this command was
1892 typed interactively by the user, then give an error
1893 and DO NOT change the state of traceframe_number etc.
1895 However if FROM_TTY is false, meaning that we're either
1896 in a script, a loop, or a user-defined command, then
1897 DON'T give an error, but DO change the state of
1898 traceframe_number etc. to invalid.
1900 The rationalle is that if you typed the command, you
1901 might just have committed a typo or something, and you'd
1902 like to NOT lose your current debugging state. However
1903 if you're in a user-defined command or especially in a
1904 loop, then you need a way to detect that the command
1905 failed WITHOUT aborting. This allows you to write
1906 scripts that search thru the trace buffer until the end,
1907 and then continue on to do something else. */
1910 error (_("Target failed to find requested trace frame."));
1914 printf_filtered ("End of trace buffer.\n");
1915 #if 0 /* dubious now? */
1916 /* The following will not recurse, since it's
1918 trace_find_command ("-1", from_tty
);
1923 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1925 reinit_frame_cache ();
1926 registers_changed ();
1927 target_dcache_invalidate ();
1928 set_traceframe_num (target_frameno
);
1929 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1930 if (target_frameno
== -1)
1931 set_traceframe_context (NULL
);
1933 set_traceframe_context (get_current_frame ());
1935 if (traceframe_number
>= 0)
1937 /* Use different branches for MI and CLI to make CLI messages
1939 if (ui_out_is_mi_like_p (uiout
))
1941 ui_out_field_string (uiout
, "found", "1");
1942 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1943 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1947 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1948 traceframe_number
, tracepoint_number
);
1953 if (ui_out_is_mi_like_p (uiout
))
1954 ui_out_field_string (uiout
, "found", "0");
1955 else if (type
== tfind_number
&& num
== -1)
1956 printf_unfiltered (_("No longer looking at any trace frame\n"));
1957 else /* this case may never occur, check */
1958 printf_unfiltered (_("No trace frame found\n"));
1961 /* If we're in nonstop mode and getting out of looking at trace
1962 frames, there won't be any current frame to go back to and
1965 && (has_stack_frames () || traceframe_number
>= 0))
1967 enum print_what print_what
;
1969 /* NOTE: in imitation of the step command, try to determine
1970 whether we have made a transition from one function to
1971 another. If so, we'll print the "stack frame" (ie. the new
1972 function and it's arguments) -- otherwise we'll just show the
1975 if (frame_id_eq (old_frame_id
,
1976 get_frame_id (get_current_frame ())))
1977 print_what
= SRC_LINE
;
1979 print_what
= SRC_AND_LOC
;
1981 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1986 /* trace_find_command takes a trace frame number n,
1987 sends "QTFrame:<n>" to the target,
1988 and accepts a reply that may contain several optional pieces
1989 of information: a frame number, a tracepoint number, and an
1990 indication of whether this is a trap frame or a stepping frame.
1992 The minimal response is just "OK" (which indicates that the
1993 target does not give us a frame number or a tracepoint number).
1994 Instead of that, the target may send us a string containing
1996 F<hexnum> (gives the selected frame number)
1997 T<hexnum> (gives the selected tracepoint number)
2002 trace_find_command (char *args
, int from_tty
)
2003 { /* this should only be called with a numeric argument */
2006 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2007 error ("May not look at trace frames while trace is running.");
2009 if (args
== 0 || *args
== 0)
2010 { /* TFIND with no args means find NEXT trace frame. */
2011 if (traceframe_number
== -1)
2012 frameno
= 0; /* "next" is first one */
2014 frameno
= traceframe_number
+ 1;
2016 else if (0 == strcmp (args
, "-"))
2018 if (traceframe_number
== -1)
2019 error (_("not debugging trace buffer"));
2020 else if (from_tty
&& traceframe_number
== 0)
2021 error (_("already at start of trace buffer"));
2023 frameno
= traceframe_number
- 1;
2025 /* A hack to work around eval's need for fp to have been collected. */
2026 else if (0 == strcmp (args
, "-1"))
2029 frameno
= parse_and_eval_long (args
);
2032 error (_("invalid input (%d is less than zero)"), frameno
);
2034 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2039 trace_find_end_command (char *args
, int from_tty
)
2041 trace_find_command ("-1", from_tty
);
2046 trace_find_none_command (char *args
, int from_tty
)
2048 trace_find_command ("-1", from_tty
);
2053 trace_find_start_command (char *args
, int from_tty
)
2055 trace_find_command ("0", from_tty
);
2058 /* tfind pc command */
2060 trace_find_pc_command (char *args
, int from_tty
)
2064 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2065 error ("May not look at trace frames while trace is running.");
2067 if (args
== 0 || *args
== 0)
2068 pc
= regcache_read_pc (get_current_regcache ());
2070 pc
= parse_and_eval_address (args
);
2072 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2075 /* tfind tracepoint command */
2077 trace_find_tracepoint_command (char *args
, int from_tty
)
2080 struct breakpoint
*tp
;
2082 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2083 error ("May not look at trace frames while trace is running.");
2085 if (args
== 0 || *args
== 0)
2087 if (tracepoint_number
== -1)
2088 error (_("No current tracepoint -- please supply an argument."));
2090 tdp
= tracepoint_number
; /* default is current TDP */
2093 tdp
= parse_and_eval_long (args
);
2095 /* If we have the tracepoint on hand, use the number that the
2096 target knows about (which may be different if we disconnected
2097 and reconnected). */
2098 tp
= get_tracepoint (tdp
);
2100 tdp
= tp
->number_on_target
;
2102 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2105 /* TFIND LINE command:
2107 This command will take a sourceline for argument, just like BREAK
2108 or TRACE (ie. anything that "decode_line_1" can handle).
2110 With no argument, this command will find the next trace frame
2111 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2114 trace_find_line_command (char *args
, int from_tty
)
2116 static CORE_ADDR start_pc
, end_pc
;
2117 struct symtabs_and_lines sals
;
2118 struct symtab_and_line sal
;
2119 struct cleanup
*old_chain
;
2121 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2122 error ("May not look at trace frames while trace is running.");
2124 if (args
== 0 || *args
== 0)
2126 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2128 sals
.sals
= (struct symtab_and_line
*)
2129 xmalloc (sizeof (struct symtab_and_line
));
2134 sals
= decode_line_spec (args
, 1);
2138 old_chain
= make_cleanup (xfree
, sals
.sals
);
2139 if (sal
.symtab
== 0)
2140 error (_("No line number information available."));
2142 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2144 if (start_pc
== end_pc
)
2146 printf_filtered ("Line %d of \"%s\"",
2147 sal
.line
, sal
.symtab
->filename
);
2149 printf_filtered (" is at address ");
2150 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2152 printf_filtered (" but contains no code.\n");
2153 sal
= find_pc_line (start_pc
, 0);
2155 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2156 && start_pc
!= end_pc
)
2157 printf_filtered ("Attempting to find line %d instead.\n",
2160 error (_("Cannot find a good line."));
2164 /* Is there any case in which we get here, and have an address
2165 which the user would want to see? If we have debugging
2166 symbols and no line numbers? */
2167 error (_("Line number %d is out of range for \"%s\"."),
2168 sal
.line
, sal
.symtab
->filename
);
2170 /* Find within range of stated line. */
2172 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2174 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2175 do_cleanups (old_chain
);
2178 /* tfind range command */
2180 trace_find_range_command (char *args
, int from_tty
)
2182 static CORE_ADDR start
, stop
;
2185 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2186 error ("May not look at trace frames while trace is running.");
2188 if (args
== 0 || *args
== 0)
2189 { /* XXX FIXME: what should default behavior be? */
2190 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2194 if (0 != (tmp
= strchr (args
, ',')))
2196 *tmp
++ = '\0'; /* terminate start address */
2197 while (isspace ((int) *tmp
))
2199 start
= parse_and_eval_address (args
);
2200 stop
= parse_and_eval_address (tmp
);
2203 { /* no explicit end address? */
2204 start
= parse_and_eval_address (args
);
2205 stop
= start
+ 1; /* ??? */
2208 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2211 /* tfind outside command */
2213 trace_find_outside_command (char *args
, int from_tty
)
2215 CORE_ADDR start
, stop
;
2218 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2219 error ("May not look at trace frames while trace is running.");
2221 if (args
== 0 || *args
== 0)
2222 { /* XXX FIXME: what should default behavior be? */
2223 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2227 if (0 != (tmp
= strchr (args
, ',')))
2229 *tmp
++ = '\0'; /* terminate start address */
2230 while (isspace ((int) *tmp
))
2232 start
= parse_and_eval_address (args
);
2233 stop
= parse_and_eval_address (tmp
);
2236 { /* no explicit end address? */
2237 start
= parse_and_eval_address (args
);
2238 stop
= start
+ 1; /* ??? */
2241 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2244 /* info scope command: list the locals for a scope. */
2246 scope_info (char *args
, int from_tty
)
2248 struct symtabs_and_lines sals
;
2250 struct minimal_symbol
*msym
;
2251 struct block
*block
;
2252 char **canonical
, *symname
, *save_args
= args
;
2253 struct dict_iterator iter
;
2255 struct gdbarch
*gdbarch
;
2258 if (args
== 0 || *args
== 0)
2259 error (_("requires an argument (function, line or *addr) to define a scope"));
2261 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2262 if (sals
.nelts
== 0)
2263 return; /* presumably decode_line_1 has already warned */
2265 /* Resolve line numbers to PC */
2266 resolve_sal_pc (&sals
.sals
[0]);
2267 block
= block_for_pc (sals
.sals
[0].pc
);
2271 QUIT
; /* allow user to bail out with ^C */
2272 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2274 QUIT
; /* allow user to bail out with ^C */
2276 printf_filtered ("Scope for %s:\n", save_args
);
2279 symname
= SYMBOL_PRINT_NAME (sym
);
2280 if (symname
== NULL
|| *symname
== '\0')
2281 continue; /* probably botched, certainly useless */
2283 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2285 printf_filtered ("Symbol %s is ", symname
);
2286 switch (SYMBOL_CLASS (sym
))
2289 case LOC_UNDEF
: /* messed up symbol? */
2290 printf_filtered ("a bogus symbol, class %d.\n",
2291 SYMBOL_CLASS (sym
));
2292 count
--; /* don't count this one */
2295 printf_filtered ("a constant with value %ld (0x%lx)",
2296 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2298 case LOC_CONST_BYTES
:
2299 printf_filtered ("constant bytes: ");
2300 if (SYMBOL_TYPE (sym
))
2301 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2302 fprintf_filtered (gdb_stdout
, " %02x",
2303 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2306 printf_filtered ("in static storage at address ");
2307 printf_filtered ("%s", paddress (gdbarch
,
2308 SYMBOL_VALUE_ADDRESS (sym
)));
2311 /* GDBARCH is the architecture associated with the objfile
2312 the symbol is defined in; the target architecture may be
2313 different, and may provide additional registers. However,
2314 we do not know the target architecture at this point.
2315 We assume the objfile architecture will contain all the
2316 standard registers that occur in debug info in that
2318 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2320 if (SYMBOL_IS_ARGUMENT (sym
))
2321 printf_filtered ("an argument in register $%s",
2322 gdbarch_register_name (gdbarch
, regno
));
2324 printf_filtered ("a local variable in register $%s",
2325 gdbarch_register_name (gdbarch
, regno
));
2328 printf_filtered ("an argument at stack/frame offset %ld",
2329 SYMBOL_VALUE (sym
));
2332 printf_filtered ("a local variable at frame offset %ld",
2333 SYMBOL_VALUE (sym
));
2336 printf_filtered ("a reference argument at offset %ld",
2337 SYMBOL_VALUE (sym
));
2339 case LOC_REGPARM_ADDR
:
2340 /* Note comment at LOC_REGISTER. */
2341 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2342 printf_filtered ("the address of an argument, in register $%s",
2343 gdbarch_register_name (gdbarch
, regno
));
2346 printf_filtered ("a typedef.\n");
2349 printf_filtered ("a label at address ");
2350 printf_filtered ("%s", paddress (gdbarch
,
2351 SYMBOL_VALUE_ADDRESS (sym
)));
2354 printf_filtered ("a function at address ");
2355 printf_filtered ("%s",
2356 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2358 case LOC_UNRESOLVED
:
2359 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2362 printf_filtered ("Unresolved Static");
2365 printf_filtered ("static storage at address ");
2366 printf_filtered ("%s",
2367 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2370 case LOC_OPTIMIZED_OUT
:
2371 printf_filtered ("optimized out.\n");
2374 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2375 BLOCK_START (block
),
2379 if (SYMBOL_TYPE (sym
))
2380 printf_filtered (", length %d.\n",
2381 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2383 if (BLOCK_FUNCTION (block
))
2386 block
= BLOCK_SUPERBLOCK (block
);
2389 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2393 /* worker function (cleanup) */
2395 replace_comma (void *data
)
2402 /* Helper for trace_dump_command. Dump the action list starting at
2403 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2404 actions of the body of a while-stepping action. STEPPING_FRAME is
2405 set if the current traceframe was determined to be a while-stepping
2409 trace_dump_actions (struct command_line
*action
,
2410 int stepping_actions
, int stepping_frame
,
2413 char *action_exp
, *next_comma
;
2415 for (; action
!= NULL
; action
= action
->next
)
2417 struct cmd_list_element
*cmd
;
2419 QUIT
; /* allow user to bail out with ^C */
2420 action_exp
= action
->line
;
2421 while (isspace ((int) *action_exp
))
2424 /* The collection actions to be done while stepping are
2425 bracketed by the commands "while-stepping" and "end". */
2427 if (*action_exp
== '#') /* comment line */
2430 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2432 error (_("Bad action list item: %s"), action_exp
);
2434 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2438 for (i
= 0; i
< action
->body_count
; ++i
)
2439 trace_dump_actions (action
->body_list
[i
],
2440 1, stepping_frame
, from_tty
);
2442 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2444 /* Display the collected data.
2445 For the trap frame, display only what was collected at
2446 the trap. Likewise for stepping frames, display only
2447 what was collected while stepping. This means that the
2448 two boolean variables, STEPPING_FRAME and
2449 STEPPING_ACTIONS should be equal. */
2450 if (stepping_frame
== stepping_actions
)
2453 { /* repeat over a comma-separated list */
2454 QUIT
; /* allow user to bail out with ^C */
2455 if (*action_exp
== ',')
2457 while (isspace ((int) *action_exp
))
2460 next_comma
= strchr (action_exp
, ',');
2462 if (0 == strncasecmp (action_exp
, "$reg", 4))
2463 registers_info (NULL
, from_tty
);
2464 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2465 locals_info (NULL
, from_tty
);
2466 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2467 args_info (NULL
, from_tty
);
2472 make_cleanup (replace_comma
, next_comma
);
2475 printf_filtered ("%s = ", action_exp
);
2476 output_command (action_exp
, from_tty
);
2477 printf_filtered ("\n");
2481 action_exp
= next_comma
;
2483 while (action_exp
&& *action_exp
== ',');
2489 /* The tdump command. */
2492 trace_dump_command (char *args
, int from_tty
)
2494 struct regcache
*regcache
;
2495 struct breakpoint
*t
;
2496 int stepping_frame
= 0;
2497 struct bp_location
*loc
;
2498 char *line
, *default_collect_line
= NULL
;
2499 struct command_line
*actions
, *default_collect_action
= NULL
;
2500 struct cleanup
*old_chain
= NULL
;
2502 if (tracepoint_number
== -1)
2504 warning (_("No current trace frame."));
2508 t
= get_tracepoint (tracepoint_number
);
2511 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2514 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2515 tracepoint_number
, traceframe_number
);
2517 /* The current frame is a trap frame if the frame PC is equal
2518 to the tracepoint PC. If not, then the current frame was
2519 collected during single-stepping. */
2521 regcache
= get_current_regcache ();
2523 /* If the traceframe's address matches any of the tracepoint's
2524 locations, assume it is a direct hit rather than a while-stepping
2525 frame. (FIXME this is not reliable, should record each frame's
2528 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2529 if (loc
->address
== regcache_read_pc (regcache
))
2532 actions
= breakpoint_commands (t
);
2534 /* If there is a default-collect list, make up a collect command,
2535 prepend to the tracepoint's commands, and pass the whole mess to
2536 the trace dump scanner. We need to validate because
2537 default-collect might have been junked since the trace run. */
2538 if (*default_collect
)
2540 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2541 old_chain
= make_cleanup (xfree
, default_collect_line
);
2542 line
= default_collect_line
;
2543 validate_actionline (&line
, t
);
2544 default_collect_action
= xmalloc (sizeof (struct command_line
));
2545 make_cleanup (xfree
, default_collect_action
);
2546 default_collect_action
->next
= actions
;
2547 default_collect_action
->line
= line
;
2548 actions
= default_collect_action
;
2551 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2553 if (*default_collect
)
2554 do_cleanups (old_chain
);
2557 /* Encode a piece of a tracepoint's source-level definition in a form
2558 that is suitable for both protocol and saving in files. */
2559 /* This version does not do multiple encodes for long strings; it should
2560 return an offset to the next piece to encode. FIXME */
2563 encode_source_string (int tpnum
, ULONGEST addr
,
2564 char *srctype
, char *src
, char *buf
, int buf_size
)
2566 if (80 + strlen (srctype
) > buf_size
)
2567 error (_("Buffer too small for source encoding"));
2568 sprintf (buf
, "%x:%s:%s:%x:%x:",
2569 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2570 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2571 error (_("Source string too long for buffer"));
2572 bin2hex (src
, buf
+ strlen (buf
), 0);
2576 extern int trace_regblock_size
;
2578 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2579 non-zero, the save is performed on the target, otherwise GDB obtains all
2580 trace data and saves it locally. */
2583 trace_save (const char *filename
, int target_does_save
)
2585 struct cleanup
*cleanup
;
2587 struct trace_status
*ts
= current_trace_status ();
2590 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2591 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2595 ULONGEST offset
= 0;
2596 #define MAX_TRACE_UPLOAD 2000
2597 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2600 /* If the target is to save the data to a file on its own, then just
2601 send the command and be done with it. */
2602 if (target_does_save
)
2604 err
= target_save_trace_data (filename
);
2606 error (_("Target failed to save trace data to '%s'."),
2611 /* Get the trace status first before opening the file, so if the
2612 target is losing, we can get out without touching files. */
2613 status
= target_get_trace_status (ts
);
2615 pathname
= tilde_expand (filename
);
2616 cleanup
= make_cleanup (xfree
, pathname
);
2618 fp
= fopen (pathname
, "wb");
2620 error (_("Unable to open file '%s' for saving trace data (%s)"),
2621 filename
, safe_strerror (errno
));
2622 make_cleanup_fclose (fp
);
2624 /* Write a file header, with a high-bit-set char to indicate a
2625 binary file, plus a hint as what this file is, and a version
2626 number in case of future needs. */
2627 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2629 perror_with_name (pathname
);
2631 /* Write descriptive info. */
2633 /* Write out the size of a register block. */
2634 fprintf (fp
, "R %x\n", trace_regblock_size
);
2636 /* Write out status of the tracing run (aka "tstatus" info). */
2637 fprintf (fp
, "status %c;%s",
2638 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2639 if (ts
->stop_reason
== tracepoint_error
)
2641 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2643 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2644 fprintf (fp
, ":%s", buf
);
2646 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2647 if (ts
->traceframe_count
>= 0)
2648 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2649 if (ts
->traceframes_created
>= 0)
2650 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2651 if (ts
->buffer_free
>= 0)
2652 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2653 if (ts
->buffer_size
>= 0)
2654 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2655 if (ts
->disconnected_tracing
)
2656 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2657 if (ts
->circular_buffer
)
2658 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2661 /* Note that we want to upload tracepoints and save those, rather
2662 than simply writing out the local ones, because the user may have
2663 changed tracepoints in GDB in preparation for a future tracing
2664 run, or maybe just mass-deleted all types of breakpoints as part
2665 of cleaning up. So as not to contaminate the session, leave the
2666 data in its uploaded form, don't make into real tracepoints. */
2668 /* Get trace state variables first, they may be checked when parsing
2669 uploaded commands. */
2671 target_upload_trace_state_variables (&uploaded_tsvs
);
2673 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2679 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2680 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2683 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2684 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2685 utsv
->builtin
, buf
);
2691 free_uploaded_tsvs (&uploaded_tsvs
);
2693 target_upload_tracepoints (&uploaded_tps
);
2695 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2697 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2698 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2699 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2700 if (utp
->type
== bp_fast_tracepoint
)
2701 fprintf (fp
, ":F%x", utp
->orig_size
);
2703 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2706 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2707 fprintf (fp
, "tp A%x:%s:%s\n",
2708 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2709 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2710 fprintf (fp
, "tp S%x:%s:%s\n",
2711 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2714 encode_source_string (utp
->number
, utp
->addr
,
2715 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2716 fprintf (fp
, "tp Z%s\n", buf
);
2718 if (utp
->cond_string
)
2720 encode_source_string (utp
->number
, utp
->addr
,
2721 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2722 fprintf (fp
, "tp Z%s\n", buf
);
2724 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2726 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2727 buf
, MAX_TRACE_UPLOAD
);
2728 fprintf (fp
, "tp Z%s\n", buf
);
2732 free_uploaded_tps (&uploaded_tps
);
2734 /* Mark the end of the definition section. */
2737 /* Get and write the trace data proper. We ask for big blocks, in
2738 the hopes of efficiency, but will take less if the target has
2739 packet size limitations or some such. */
2742 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2744 error (_("Failure to get requested trace buffer data"));
2745 /* No more data is forthcoming, we're done. */
2748 written
= fwrite (buf
, gotten
, 1, fp
);
2750 perror_with_name (pathname
);
2754 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2755 written
= fwrite (&gotten
, 4, 1, fp
);
2757 perror_with_name (pathname
);
2759 do_cleanups (cleanup
);
2763 trace_save_command (char *args
, int from_tty
)
2765 int target_does_save
= 0;
2767 char *filename
= NULL
;
2768 struct cleanup
*back_to
;
2771 error_no_arg (_("file in which to save trace data"));
2773 argv
= gdb_buildargv (args
);
2774 back_to
= make_cleanup_freeargv (argv
);
2776 for (; *argv
; ++argv
)
2778 if (strcmp (*argv
, "-r") == 0)
2779 target_does_save
= 1;
2780 else if (**argv
== '-')
2781 error (_("unknown option `%s'"), *argv
);
2787 error_no_arg (_("file in which to save trace data"));
2789 trace_save (filename
, target_does_save
);
2792 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2794 do_cleanups (back_to
);
2797 /* Tell the target what to do with an ongoing tracing run if GDB
2798 disconnects for some reason. */
2801 send_disconnected_tracing_value (int value
)
2803 target_set_disconnected_tracing (value
);
2807 set_disconnected_tracing (char *args
, int from_tty
,
2808 struct cmd_list_element
*c
)
2810 send_disconnected_tracing_value (disconnected_tracing
);
2814 set_circular_trace_buffer (char *args
, int from_tty
,
2815 struct cmd_list_element
*c
)
2817 target_set_circular_trace_buffer (circular_trace_buffer
);
2820 /* Convert the memory pointed to by mem into hex, placing result in buf.
2821 * Return a pointer to the last char put in buf (null)
2822 * "stolen" from sparc-stub.c
2825 static const char hexchars
[] = "0123456789abcdef";
2828 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2836 *buf
++ = hexchars
[ch
>> 4];
2837 *buf
++ = hexchars
[ch
& 0xf];
2846 get_traceframe_number (void)
2848 return traceframe_number
;
2851 /* Make the traceframe NUM be the current trace frame. Does nothing
2852 if NUM is already current. */
2855 set_traceframe_number (int num
)
2859 if (traceframe_number
== num
)
2861 /* Nothing to do. */
2865 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2868 warning (_("could not change traceframe"));
2870 traceframe_number
= newnum
;
2872 /* Changing the traceframe changes our view of registers and of the
2874 registers_changed ();
2877 /* A cleanup used when switching away and back from tfind mode. */
2879 struct current_traceframe_cleanup
2881 /* The traceframe we were inspecting. */
2882 int traceframe_number
;
2886 do_restore_current_traceframe_cleanup (void *arg
)
2888 struct current_traceframe_cleanup
*old
= arg
;
2890 set_traceframe_number (old
->traceframe_number
);
2894 restore_current_traceframe_cleanup_dtor (void *arg
)
2896 struct current_traceframe_cleanup
*old
= arg
;
2902 make_cleanup_restore_current_traceframe (void)
2904 struct current_traceframe_cleanup
*old
;
2906 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2907 old
->traceframe_number
= traceframe_number
;
2909 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2910 restore_current_traceframe_cleanup_dtor
);
2913 /* Given a number and address, return an uploaded tracepoint with that
2914 number, creating if necessary. */
2916 struct uploaded_tp
*
2917 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2919 struct uploaded_tp
*utp
;
2921 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2922 if (utp
->number
== num
&& utp
->addr
== addr
)
2924 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2925 memset (utp
, 0, sizeof (struct uploaded_tp
));
2928 utp
->actions
= NULL
;
2929 utp
->step_actions
= NULL
;
2930 utp
->cmd_strings
= NULL
;
2937 free_uploaded_tps (struct uploaded_tp
**utpp
)
2939 struct uploaded_tp
*next_one
;
2943 next_one
= (*utpp
)->next
;
2949 /* Given a number and address, return an uploaded tracepoint with that
2950 number, creating if necessary. */
2952 struct uploaded_tsv
*
2953 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2955 struct uploaded_tsv
*utsv
;
2957 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2958 if (utsv
->number
== num
)
2960 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2961 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2963 utsv
->next
= *utsvp
;
2969 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2971 struct uploaded_tsv
*next_one
;
2975 next_one
= (*utsvp
)->next
;
2981 /* Look for an existing tracepoint that seems similar enough to the
2982 uploaded one. Enablement isn't compared, because the user can
2983 toggle that freely, and may have done so in anticipation of the
2987 find_matching_tracepoint (struct uploaded_tp
*utp
)
2989 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2991 struct breakpoint
*t
;
2992 struct bp_location
*loc
;
2994 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2996 if (t
->type
== utp
->type
2997 && t
->step_count
== utp
->step
2998 && t
->pass_count
== utp
->pass
2999 /* FIXME also test conditionals and actions */
3002 /* Scan the locations for an address match. */
3003 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
3005 if (loc
->address
== utp
->addr
)
3013 /* Given a list of tracepoints uploaded from a target, attempt to
3014 match them up with existing tracepoints, and create new ones if not
3018 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3020 struct uploaded_tp
*utp
;
3021 struct breakpoint
*t
;
3023 /* Look for GDB tracepoints that match up with our uploaded versions. */
3024 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3026 t
= find_matching_tracepoint (utp
);
3028 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3029 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3032 t
= create_tracepoint_from_upload (utp
);
3034 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3035 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3037 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3038 utp
->number
, paddress (get_current_arch (), utp
->addr
));
3040 /* Whether found or created, record the number used by the
3041 target, to help with mapping target tracepoints back to their
3042 counterparts here. */
3044 t
->number_on_target
= utp
->number
;
3047 free_uploaded_tps (uploaded_tps
);
3050 /* Trace state variables don't have much to identify them beyond their
3051 name, so just use that to detect matches. */
3053 struct trace_state_variable
*
3054 find_matching_tsv (struct uploaded_tsv
*utsv
)
3059 return find_trace_state_variable (utsv
->name
);
3062 struct trace_state_variable
*
3063 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3065 const char *namebase
;
3068 struct trace_state_variable
*tsv
;
3072 namebase
= utsv
->name
;
3073 sprintf (buf
, "%s", namebase
);
3078 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3081 /* Fish for a name that is not in use. */
3082 /* (should check against all internal vars?) */
3083 while (find_trace_state_variable (buf
))
3084 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3086 /* We have an available name, create the variable. */
3087 tsv
= create_trace_state_variable (xstrdup (buf
));
3088 tsv
->initial_value
= utsv
->initial_value
;
3089 tsv
->builtin
= utsv
->builtin
;
3094 /* Given a list of uploaded trace state variables, try to match them
3095 up with existing variables, or create additional ones. */
3098 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3101 struct uploaded_tsv
*utsv
;
3102 struct trace_state_variable
*tsv
;
3105 /* Most likely some numbers will have to be reassigned as part of
3106 the merge, so clear them all in anticipation. */
3107 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3110 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3112 tsv
= find_matching_tsv (utsv
);
3114 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3115 tsv
->name
, utsv
->number
);
3118 tsv
= create_tsv_from_upload (utsv
);
3119 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3120 tsv
->name
, utsv
->number
);
3122 /* Give precedence to numberings that come from the target. */
3124 tsv
->number
= utsv
->number
;
3127 /* Renumber everything that didn't get a target-assigned number. */
3129 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3130 if (tsv
->number
> highest
)
3131 highest
= tsv
->number
;
3134 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3135 if (tsv
->number
== 0)
3136 tsv
->number
= highest
++;
3138 free_uploaded_tsvs (uploaded_tsvs
);
3141 /* target tfile command */
3143 struct target_ops tfile_ops
;
3145 /* Fill in tfile_ops with its defined operations and properties. */
3147 #define TRACE_HEADER_SIZE 8
3149 char *trace_filename
;
3151 off_t trace_frames_offset
;
3154 int trace_regblock_size
;
3156 static void tfile_interp_line (char *line
,
3157 struct uploaded_tp
**utpp
,
3158 struct uploaded_tsv
**utsvp
);
3161 tfile_open (char *filename
, int from_tty
)
3164 struct cleanup
*old_chain
;
3167 char header
[TRACE_HEADER_SIZE
];
3168 char linebuf
[1000]; /* should be max remote packet size or so */
3170 int bytes
, i
, gotten
;
3171 struct trace_status
*ts
;
3172 struct uploaded_tp
*uploaded_tps
= NULL
;
3173 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3175 target_preopen (from_tty
);
3177 error (_("No trace file specified."));
3179 filename
= tilde_expand (filename
);
3180 if (!IS_ABSOLUTE_PATH(filename
))
3182 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3187 old_chain
= make_cleanup (xfree
, filename
);
3189 flags
= O_BINARY
| O_LARGEFILE
;
3191 scratch_chan
= open (filename
, flags
, 0);
3192 if (scratch_chan
< 0)
3193 perror_with_name (filename
);
3195 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3197 discard_cleanups (old_chain
); /* Don't free filename any more */
3198 unpush_target (&tfile_ops
);
3200 push_target (&tfile_ops
);
3202 trace_filename
= xstrdup (filename
);
3203 trace_fd
= scratch_chan
;
3206 /* Read the file header and test for validity. */
3207 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3209 perror_with_name (trace_filename
);
3210 else if (gotten
< TRACE_HEADER_SIZE
)
3211 error (_("Premature end of file while reading trace file"));
3213 bytes
+= TRACE_HEADER_SIZE
;
3214 if (!(header
[0] == 0x7f
3215 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3216 error (_("File is not a valid trace file."));
3218 trace_regblock_size
= 0;
3219 ts
= current_trace_status ();
3220 /* We know we're working with a file. */
3222 /* Set defaults in case there is no status line. */
3223 ts
->running_known
= 0;
3224 ts
->stop_reason
= trace_stop_reason_unknown
;
3225 ts
->traceframe_count
= -1;
3226 ts
->buffer_free
= 0;
3227 ts
->disconnected_tracing
= 0;
3228 ts
->circular_buffer
= 0;
3230 /* Read through a section of newline-terminated lines that
3231 define things like tracepoints. */
3235 gotten
= read (trace_fd
, &byte
, 1);
3237 perror_with_name (trace_filename
);
3238 else if (gotten
< 1)
3239 error (_("Premature end of file while reading trace file"));
3244 /* Empty line marks end of the definition section. */
3249 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3252 linebuf
[i
++] = byte
;
3254 error (_("Excessively long lines in trace file"));
3257 /* Add the file's tracepoints and variables into the current mix. */
3259 /* Get trace state variables first, they may be checked when parsing
3260 uploaded commands. */
3261 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3263 merge_uploaded_tracepoints (&uploaded_tps
);
3265 /* Record the starting offset of the binary trace data. */
3266 trace_frames_offset
= bytes
;
3268 /* If we don't have a blocksize, we can't interpret the
3270 if (trace_regblock_size
== 0)
3271 error (_("No register block size recorded in trace file"));
3272 if (ts
->traceframe_count
<= 0)
3274 warning ("No traceframes present in this file.");
3278 #define TFILE_PID (1)
3279 inferior_appeared (current_inferior (), TFILE_PID
);
3280 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3281 add_thread_silent (inferior_ptid
);
3283 post_create_inferior (&tfile_ops
, from_tty
);
3286 /* FIXME this will get defined in MI patch submission */
3287 tfind_1 (tfind_number
, 0, 0, 0, 0);
3291 /* Interpret the given line from the definitions part of the trace
3295 tfile_interp_line (char *line
,
3296 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3300 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3303 trace_regblock_size
= strtol (p
, &p
, 16);
3305 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3307 p
+= strlen ("status ");
3308 parse_trace_status (p
, current_trace_status ());
3310 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3312 p
+= strlen ("tp ");
3313 parse_tracepoint_definition (p
, utpp
);
3315 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3317 p
+= strlen ("tsv ");
3318 parse_tsv_definition (p
, utsvp
);
3321 warning ("Ignoring trace file definition \"%s\"", line
);
3324 /* Parse the part of trace status syntax that is shared between
3325 the remote protocol and the trace file reader. */
3328 parse_trace_status (char *line
, struct trace_status
*ts
)
3330 char *p
= line
, *p1
, *p2
, *p_temp
;
3333 ts
->running_known
= 1;
3334 ts
->running
= (*p
++ == '1');
3335 ts
->stop_reason
= trace_stop_reason_unknown
;
3336 xfree (ts
->error_desc
);
3337 ts
->error_desc
= NULL
;
3338 ts
->traceframe_count
= -1;
3339 ts
->traceframes_created
= -1;
3340 ts
->buffer_free
= -1;
3341 ts
->buffer_size
= -1;
3342 ts
->disconnected_tracing
= 0;
3343 ts
->circular_buffer
= 0;
3347 p1
= strchr (p
, ':');
3349 error (_("Malformed trace status, at %s\n\
3350 Status line: '%s'\n"), p
, line
);
3351 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3353 p
= unpack_varlen_hex (++p1
, &val
);
3354 ts
->stop_reason
= trace_buffer_full
;
3356 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3358 p
= unpack_varlen_hex (++p1
, &val
);
3359 ts
->stop_reason
= trace_never_run
;
3361 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3363 p
= unpack_varlen_hex (++p1
, &val
);
3364 ts
->stop_reason
= tracepoint_passcount
;
3365 ts
->stopping_tracepoint
= val
;
3367 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3369 p
= unpack_varlen_hex (++p1
, &val
);
3370 ts
->stop_reason
= tstop_command
;
3372 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3374 p
= unpack_varlen_hex (++p1
, &val
);
3375 ts
->stop_reason
= trace_disconnected
;
3377 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3379 p2
= strchr (++p1
, ':');
3384 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3385 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3386 ts
->error_desc
[end
] = '\0';
3389 ts
->error_desc
= xstrdup ("");
3391 p
= unpack_varlen_hex (++p2
, &val
);
3392 ts
->stopping_tracepoint
= val
;
3393 ts
->stop_reason
= tracepoint_error
;
3395 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3397 p
= unpack_varlen_hex (++p1
, &val
);
3398 ts
->traceframe_count
= val
;
3400 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3402 p
= unpack_varlen_hex (++p1
, &val
);
3403 ts
->traceframes_created
= val
;
3405 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3407 p
= unpack_varlen_hex (++p1
, &val
);
3408 ts
->buffer_free
= val
;
3410 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3412 p
= unpack_varlen_hex (++p1
, &val
);
3413 ts
->buffer_size
= val
;
3415 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3417 p
= unpack_varlen_hex (++p1
, &val
);
3418 ts
->disconnected_tracing
= val
;
3420 else if (strncmp (p
, "circular", p1
- p
) == 0)
3422 p
= unpack_varlen_hex (++p1
, &val
);
3423 ts
->circular_buffer
= val
;
3427 /* Silently skip unknown optional info. */
3428 p_temp
= strchr (p1
+ 1, ';');
3432 /* Must be at the end. */
3438 /* Given a line of text defining a part of a tracepoint, parse it into
3439 an "uploaded tracepoint". */
3442 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3446 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3449 char *cond
, *srctype
, *buf
;
3450 struct uploaded_tp
*utp
= NULL
;
3453 /* Both tracepoint and action definitions start with the same number
3454 and address sequence. */
3456 p
= unpack_varlen_hex (p
, &num
);
3457 p
++; /* skip a colon */
3458 p
= unpack_varlen_hex (p
, &addr
);
3459 p
++; /* skip a colon */
3462 enabled
= (*p
++ == 'E');
3463 p
++; /* skip a colon */
3464 p
= unpack_varlen_hex (p
, &step
);
3465 p
++; /* skip a colon */
3466 p
= unpack_varlen_hex (p
, &pass
);
3467 type
= bp_tracepoint
;
3469 /* Thumb through optional fields. */
3472 p
++; /* skip a colon */
3475 type
= bp_fast_tracepoint
;
3477 p
= unpack_varlen_hex (p
, &orig_size
);
3482 p
= unpack_varlen_hex (p
, &xlen
);
3483 p
++; /* skip a comma */
3484 cond
= (char *) xmalloc (2 * xlen
+ 1);
3485 strncpy (cond
, p
, 2 * xlen
);
3486 cond
[2 * xlen
] = '\0';
3490 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3492 utp
= get_uploaded_tp (num
, addr
, utpp
);
3494 utp
->enabled
= enabled
;
3499 else if (piece
== 'A')
3501 utp
= get_uploaded_tp (num
, addr
, utpp
);
3502 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3504 else if (piece
== 'S')
3506 utp
= get_uploaded_tp (num
, addr
, utpp
);
3507 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3509 else if (piece
== 'Z')
3511 /* Parse a chunk of source form definition. */
3512 utp
= get_uploaded_tp (num
, addr
, utpp
);
3514 p
= strchr (p
, ':');
3515 p
++; /* skip a colon */
3516 p
= unpack_varlen_hex (p
, &start
);
3517 p
++; /* skip a colon */
3518 p
= unpack_varlen_hex (p
, &xlen
);
3519 p
++; /* skip a colon */
3521 buf
= alloca (strlen (line
));
3523 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3526 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3527 utp
->at_string
= xstrdup (buf
);
3528 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3529 utp
->cond_string
= xstrdup (buf
);
3530 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3531 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3535 /* Don't error out, the target might be sending us optional
3536 info that we don't care about. */
3537 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3541 /* Convert a textual description of a trace state variable into an
3545 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3548 ULONGEST num
, initval
, builtin
;
3550 struct uploaded_tsv
*utsv
= NULL
;
3552 buf
= alloca (strlen (line
));
3555 p
= unpack_varlen_hex (p
, &num
);
3556 p
++; /* skip a colon */
3557 p
= unpack_varlen_hex (p
, &initval
);
3558 p
++; /* skip a colon */
3559 p
= unpack_varlen_hex (p
, &builtin
);
3560 p
++; /* skip a colon */
3561 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3564 utsv
= get_uploaded_tsv (num
, utsvp
);
3565 utsv
->initial_value
= initval
;
3566 utsv
->builtin
= builtin
;
3567 utsv
->name
= xstrdup (buf
);
3570 /* Close the trace file and generally clean up. */
3573 tfile_close (int quitting
)
3580 pid
= ptid_get_pid (inferior_ptid
);
3581 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3582 exit_inferior_silent (pid
);
3587 xfree (trace_filename
);
3591 tfile_files_info (struct target_ops
*t
)
3593 /* (it would be useful to mention the name of the file) */
3594 printf_filtered ("Looking at a trace file.\n");
3597 /* The trace status for a file is that tracing can never be run. */
3600 tfile_get_trace_status (struct trace_status
*ts
)
3602 /* Other bits of trace status were collected as part of opening the
3603 trace files, so nothing to do here. */
3608 /* Given the position of a traceframe in the file, figure out what
3609 address the frame was collected at. This would normally be the
3610 value of a collected PC register, but if not available, we
3614 tfile_get_traceframe_address (off_t tframe_offset
)
3618 struct breakpoint
*tp
;
3619 off_t saved_offset
= cur_offset
;
3622 /* FIXME dig pc out of collected registers */
3624 /* Fall back to using tracepoint address. */
3625 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3626 gotten
= read (trace_fd
, &tpnum
, 2);
3628 perror_with_name (trace_filename
);
3629 else if (gotten
< 2)
3630 error (_("Premature end of file while reading trace file"));
3632 tp
= get_tracepoint_by_number_on_target (tpnum
);
3633 /* FIXME this is a poor heuristic if multiple locations */
3635 addr
= tp
->loc
->address
;
3637 /* Restore our seek position. */
3638 cur_offset
= saved_offset
;
3639 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3643 /* Given a type of search and some parameters, scan the collection of
3644 traceframes in the file looking for a match. When found, return
3645 both the traceframe and tracepoint number, otherwise -1 for
3649 tfile_trace_find (enum trace_find_type type
, int num
,
3650 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3653 int tfnum
= 0, found
= 0, gotten
;
3655 struct breakpoint
*tp
;
3656 off_t offset
, tframe_offset
;
3659 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3660 offset
= trace_frames_offset
;
3663 tframe_offset
= offset
;
3664 gotten
= read (trace_fd
, &tpnum
, 2);
3666 perror_with_name (trace_filename
);
3667 else if (gotten
< 2)
3668 error (_("Premature end of file while reading trace file"));
3672 gotten
= read (trace_fd
, &data_size
, 4);
3674 perror_with_name (trace_filename
);
3675 else if (gotten
< 4)
3676 error (_("Premature end of file while reading trace file"));
3685 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3686 if (tfaddr
== addr1
)
3690 tp
= get_tracepoint (num
);
3691 if (tp
&& tpnum
== tp
->number_on_target
)
3695 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3696 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3700 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3701 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3705 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3711 cur_offset
= offset
;
3712 cur_data_size
= data_size
;
3715 /* Skip past the traceframe's data. */
3716 lseek (trace_fd
, data_size
, SEEK_CUR
);
3717 offset
+= data_size
;
3718 /* Update our own count of traceframes. */
3721 /* Did not find what we were looking for. */
3727 /* Look for a block of saved registers in the traceframe, and get the
3728 requested register from it. */
3731 tfile_fetch_registers (struct target_ops
*ops
,
3732 struct regcache
*regcache
, int regno
)
3734 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3736 int pos
, offset
, regn
, regsize
, gotten
, pc_regno
;
3737 unsigned short mlen
;
3740 /* An uninitialized reg size says we're not going to be
3741 successful at getting register blocks. */
3742 if (!trace_regblock_size
)
3745 regs
= alloca (trace_regblock_size
);
3747 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3749 while (pos
< cur_data_size
)
3751 gotten
= read (trace_fd
, &block_type
, 1);
3753 perror_with_name (trace_filename
);
3754 else if (gotten
< 1)
3755 error (_("Premature end of file while reading trace file"));
3761 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3763 perror_with_name (trace_filename
);
3764 else if (gotten
< trace_regblock_size
)
3765 error (_("Premature end of file while reading trace file"));
3767 /* Assume the block is laid out in GDB register number order,
3768 each register with the size that it has in GDB. */
3770 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3772 regsize
= register_size (gdbarch
, regn
);
3773 /* Make sure we stay within block bounds. */
3774 if (offset
+ regsize
>= trace_regblock_size
)
3776 if (!regcache_valid_p (regcache
, regn
))
3780 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3783 else if (regno
== -1)
3785 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3792 lseek (trace_fd
, 8, SEEK_CUR
);
3793 gotten
= read (trace_fd
, &mlen
, 2);
3795 perror_with_name (trace_filename
);
3796 else if (gotten
< 2)
3797 error (_("Premature end of file while reading trace file"));
3798 lseek (trace_fd
, mlen
, SEEK_CUR
);
3799 pos
+= (8 + 2 + mlen
);
3802 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3806 error ("Unknown block type '%c' (0x%x) in trace frame",
3807 block_type
, block_type
);
3812 /* We get here if no register data has been found. Although we
3813 don't like making up numbers, GDB has all manner of troubles when
3814 the target says some register is not available. Filling in with
3815 zeroes is a reasonable fallback. */
3816 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3817 regcache_raw_supply (regcache
, regn
, NULL
);
3819 /* We can often usefully guess that the PC is going to be the same
3820 as the address of the tracepoint. */
3821 pc_regno
= gdbarch_pc_regnum (gdbarch
);
3822 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
3824 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
3828 /* But don't try to guess if tracepoint is multi-location... */
3831 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3835 /* ... or does while-stepping. */
3836 if (tp
->step_count
> 0)
3838 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3843 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
3844 gdbarch_byte_order (gdbarch
),
3846 regcache_raw_supply (regcache
, pc_regno
, regs
);
3852 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3853 const char *annex
, gdb_byte
*readbuf
,
3854 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3858 ULONGEST maddr
, amt
;
3859 unsigned short mlen
;
3861 /* We're only doing regular memory for now. */
3862 if (object
!= TARGET_OBJECT_MEMORY
)
3865 if (readbuf
== NULL
)
3866 error ("tfile_xfer_partial: trace file is read-only");
3868 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3870 while (pos
< cur_data_size
)
3872 gotten
= read (trace_fd
, &block_type
, 1);
3874 perror_with_name (trace_filename
);
3875 else if (gotten
< 1)
3876 error (_("Premature end of file while reading trace file"));
3881 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3882 pos
+= trace_regblock_size
;
3885 gotten
= read (trace_fd
, &maddr
, 8);
3887 perror_with_name (trace_filename
);
3888 else if (gotten
< 8)
3889 error (_("Premature end of file while reading trace file"));
3891 gotten
= read (trace_fd
, &mlen
, 2);
3893 perror_with_name (trace_filename
);
3894 else if (gotten
< 2)
3895 error (_("Premature end of file while reading trace file"));
3896 /* If the block includes the first part of the desired
3897 range, return as much it has; GDB will re-request the
3898 remainder, which might be in a different block of this
3900 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
3902 amt
= (maddr
+ mlen
) - offset
;
3906 gotten
= read (trace_fd
, readbuf
, amt
);
3908 perror_with_name (trace_filename
);
3909 /* While it's acceptable to return less than was
3910 originally asked for, it's not acceptable to return
3911 less than what this block claims to contain. */
3912 else if (gotten
< amt
)
3913 error (_("Premature end of file while reading trace file"));
3916 lseek (trace_fd
, mlen
, SEEK_CUR
);
3917 pos
+= (8 + 2 + mlen
);
3920 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3924 error ("Unknown block type '%c' (0x%x) in traceframe",
3925 block_type
, block_type
);
3930 /* It's unduly pedantic to refuse to look at the executable for
3931 read-only pieces; so do the equivalent of readonly regions aka
3933 /* FIXME account for relocation at some point */
3940 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
3942 if ((s
->flags
& SEC_LOAD
) == 0 ||
3943 (s
->flags
& SEC_READONLY
) == 0)
3947 size
= bfd_get_section_size (s
);
3948 if (lma
<= offset
&& offset
< (lma
+ size
))
3950 amt
= (lma
+ size
) - offset
;
3954 amt
= bfd_get_section_contents (exec_bfd
, s
,
3955 readbuf
, offset
- lma
, amt
);
3961 /* Indicate failure to find the requested memory block. */
3965 /* Iterate through the blocks of a trace frame, looking for a 'V'
3966 block with a matching tsv number. */
3969 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3972 int pos
, vnum
, gotten
;
3973 unsigned short mlen
;
3975 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3977 while (pos
< cur_data_size
)
3979 gotten
= read (trace_fd
, &block_type
, 1);
3981 perror_with_name (trace_filename
);
3982 else if (gotten
< 1)
3983 error (_("Premature end of file while reading trace file"));
3988 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3989 pos
+= trace_regblock_size
;
3992 lseek (trace_fd
, 8, SEEK_CUR
);
3993 gotten
= read (trace_fd
, &mlen
, 2);
3995 perror_with_name (trace_filename
);
3996 else if (gotten
< 2)
3997 error (_("Premature end of file while reading trace file"));
3998 lseek (trace_fd
, mlen
, SEEK_CUR
);
3999 pos
+= (8 + 2 + mlen
);
4002 gotten
= read (trace_fd
, &vnum
, 4);
4004 perror_with_name (trace_filename
);
4005 else if (gotten
< 4)
4006 error (_("Premature end of file while reading trace file"));
4009 gotten
= read (trace_fd
, val
, 8);
4011 perror_with_name (trace_filename
);
4012 else if (gotten
< 8)
4013 error (_("Premature end of file while reading trace file"));
4016 lseek (trace_fd
, 8, SEEK_CUR
);
4020 error ("Unknown block type '%c' (0x%x) in traceframe",
4021 block_type
, block_type
);
4025 /* Didn't find anything. */
4030 tfile_has_all_memory (struct target_ops
*ops
)
4036 tfile_has_memory (struct target_ops
*ops
)
4042 tfile_has_stack (struct target_ops
*ops
)
4048 tfile_has_registers (struct target_ops
*ops
)
4054 init_tfile_ops (void)
4056 tfile_ops
.to_shortname
= "tfile";
4057 tfile_ops
.to_longname
= "Local trace dump file";
4059 "Use a trace file as a target. Specify the filename of the trace file.";
4060 tfile_ops
.to_open
= tfile_open
;
4061 tfile_ops
.to_close
= tfile_close
;
4062 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4063 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4064 tfile_ops
.to_files_info
= tfile_files_info
;
4065 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4066 tfile_ops
.to_trace_find
= tfile_trace_find
;
4067 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
4068 /* core_stratum might seem more logical, but GDB doesn't like having
4069 more than one core_stratum vector. */
4070 tfile_ops
.to_stratum
= process_stratum
;
4071 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4072 tfile_ops
.to_has_memory
= tfile_has_memory
;
4073 tfile_ops
.to_has_stack
= tfile_has_stack
;
4074 tfile_ops
.to_has_registers
= tfile_has_registers
;
4075 tfile_ops
.to_magic
= OPS_MAGIC
;
4078 /* module initialization */
4080 _initialize_tracepoint (void)
4082 struct cmd_list_element
*c
;
4084 traceframe_number
= -1;
4085 tracepoint_number
= -1;
4087 if (tracepoint_list
.list
== NULL
)
4089 tracepoint_list
.listsize
= 128;
4090 tracepoint_list
.list
= xmalloc
4091 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4093 if (tracepoint_list
.aexpr_list
== NULL
)
4095 tracepoint_list
.aexpr_listsize
= 128;
4096 tracepoint_list
.aexpr_list
= xmalloc
4097 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4100 if (stepping_list
.list
== NULL
)
4102 stepping_list
.listsize
= 128;
4103 stepping_list
.list
= xmalloc
4104 (stepping_list
.listsize
* sizeof (struct memrange
));
4107 if (stepping_list
.aexpr_list
== NULL
)
4109 stepping_list
.aexpr_listsize
= 128;
4110 stepping_list
.aexpr_list
= xmalloc
4111 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4114 add_info ("scope", scope_info
,
4115 _("List the variables local to a scope"));
4117 add_cmd ("tracepoints", class_trace
, NULL
,
4118 _("Tracing of program execution without stopping the program."),
4121 add_com ("tdump", class_trace
, trace_dump_command
,
4122 _("Print everything collected at the current tracepoint."));
4124 add_com ("tsave", class_trace
, trace_save_command
, _("\
4125 Save the trace data to a file.\n\
4126 Use the '-r' option to direct the target to save directly to the file,\n\
4127 using its own filesystem."));
4129 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4130 Define a trace state variable.\n\
4131 Argument is a $-prefixed name, optionally followed\n\
4132 by '=' and an expression that sets the initial value\n\
4133 at the start of tracing."));
4134 set_cmd_completer (c
, expression_completer
);
4136 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4137 Delete one or more trace state variables.\n\
4138 Arguments are the names of the variables to delete.\n\
4139 If no arguments are supplied, delete all variables."), &deletelist
);
4140 /* FIXME add a trace variable completer */
4142 add_info ("tvariables", tvariables_info
, _("\
4143 Status of trace state variables and their values.\n\
4146 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4147 Select a trace frame;\n\
4148 No argument means forward by one frame; '-' means backward by one frame."),
4149 &tfindlist
, "tfind ", 1, &cmdlist
);
4151 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4152 Select a trace frame whose PC is outside the given range (exclusive).\n\
4153 Usage: tfind outside addr1, addr2"),
4156 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4157 Select a trace frame whose PC is in the given range (inclusive).\n\
4158 Usage: tfind range addr1,addr2"),
4161 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4162 Select a trace frame by source line.\n\
4163 Argument can be a line number (with optional source file), \n\
4164 a function name, or '*' followed by an address.\n\
4165 Default argument is 'the next source line that was traced'."),
4168 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4169 Select a trace frame by tracepoint number.\n\
4170 Default is the tracepoint for the current trace frame."),
4173 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4174 Select a trace frame by PC.\n\
4175 Default is the current PC, or the PC of the current trace frame."),
4178 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4179 Synonym for 'none'.\n\
4180 De-select any trace frame and resume 'live' debugging."),
4183 add_cmd ("none", class_trace
, trace_find_none_command
,
4184 _("De-select any trace frame and resume 'live' debugging."),
4187 add_cmd ("start", class_trace
, trace_find_start_command
,
4188 _("Select the first trace frame in the trace buffer."),
4191 add_com ("tstatus", class_trace
, trace_status_command
,
4192 _("Display the status of the current trace data collection."));
4194 add_com ("tstop", class_trace
, trace_stop_command
,
4195 _("Stop trace data collection."));
4197 add_com ("tstart", class_trace
, trace_start_command
,
4198 _("Start trace data collection."));
4200 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4201 Ends a list of commands or actions.\n\
4202 Several GDB commands allow you to enter a list of commands or actions.\n\
4203 Entering \"end\" on a line by itself is the normal way to terminate\n\
4205 Note: the \"end\" command cannot be used at the gdb prompt."));
4207 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4208 Specify single-stepping behavior at a tracepoint.\n\
4209 Argument is number of instructions to trace in single-step mode\n\
4210 following the tracepoint. This command is normally followed by\n\
4211 one or more \"collect\" commands, to specify what to collect\n\
4212 while single-stepping.\n\n\
4213 Note: this command can only be used in a tracepoint \"actions\" list."));
4215 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4216 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4218 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4219 Specify one or more data items to be collected at a tracepoint.\n\
4220 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4221 collect all data (variables, registers) referenced by that expression.\n\
4222 Also accepts the following special arguments:\n\
4223 $regs -- all registers.\n\
4224 $args -- all function arguments.\n\
4225 $locals -- all variables local to the block/function scope.\n\
4226 Note: this command can only be used in a tracepoint \"actions\" list."));
4228 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4229 Specify one or more expressions to be evaluated at a tracepoint.\n\
4230 Accepts a comma-separated list of (one or more) expressions.\n\
4231 The result of each evaluation will be discarded.\n\
4232 Note: this command can only be used in a tracepoint \"actions\" list."));
4234 add_com ("actions", class_trace
, trace_actions_command
, _("\
4235 Specify the actions to be taken at a tracepoint.\n\
4236 Tracepoint actions may include collecting of specified data, \n\
4237 single-stepping, or enabling/disabling other tracepoints, \n\
4238 depending on target's capabilities."));
4240 default_collect
= xstrdup ("");
4241 add_setshow_string_cmd ("default-collect", class_trace
,
4242 &default_collect
, _("\
4243 Set the list of expressions to collect by default"), _("\
4244 Show the list of expressions to collect by default"), NULL
,
4246 &setlist
, &showlist
);
4248 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4249 &disconnected_tracing
, _("\
4250 Set whether tracing continues after GDB disconnects."), _("\
4251 Show whether tracing continues after GDB disconnects."), _("\
4252 Use this to continue a tracing run even if GDB disconnects\n\
4253 or detaches from the target. You can reconnect later and look at\n\
4254 trace data collected in the meantime."),
4255 set_disconnected_tracing
,
4260 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4261 &circular_trace_buffer
, _("\
4262 Set target's use of circular trace buffer."), _("\
4263 Show target's use of circular trace buffer."), _("\
4264 Use this to make the trace buffer into a circular buffer,\n\
4265 which will discard traceframes (oldest first) instead of filling\n\
4266 up and stopping the trace run."),
4267 set_circular_trace_buffer
,
4274 add_target (&tfile_ops
);