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"
53 /* readline include files */
54 #include "readline/readline.h"
55 #include "readline/history.h"
57 /* readline defines this. */
68 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
69 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
71 extern void stop_tracing ();
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
83 /* A hook used to notify the UI of tracepoint operations. */
85 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
86 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
88 extern void (*deprecated_readline_begin_hook
) (char *, ...);
89 extern char *(*deprecated_readline_hook
) (char *);
90 extern void (*deprecated_readline_end_hook
) (void);
92 /* GDB commands implemented in other modules:
95 extern void output_command (char *, int);
100 This module defines the following debugger commands:
101 trace : set a tracepoint on a function, line, or address.
102 info trace : list all debugger-defined tracepoints.
103 delete trace : delete one or more tracepoints.
104 enable trace : enable one or more tracepoints.
105 disable trace : disable one or more tracepoints.
106 actions : specify actions to be taken at a tracepoint.
107 passcount : specify a pass count for a tracepoint.
108 tstart : start a trace experiment.
109 tstop : stop a trace experiment.
110 tstatus : query the status of a trace experiment.
111 tfind : find a trace frame in the trace buffer.
112 tdump : print everything collected at the current tracepoint.
113 save-tracepoints : write tracepoint setup into a file.
115 This module defines the following user-visible debugger variables:
116 $trace_frame : sequence number of trace frame currently being debugged.
117 $trace_line : source line of trace frame currently being debugged.
118 $trace_file : source file of trace frame currently being debugged.
119 $tracepoint : tracepoint number of trace frame currently being debugged.
123 /* ======= Important global variables: ======= */
125 /* The list of all trace state variables. We don't retain pointers to
126 any of these for any reason - API is by name or number only - so it
127 works to have a vector of objects. */
129 typedef struct trace_state_variable tsv_s
;
132 static VEC(tsv_s
) *tvariables
;
134 /* The next integer to assign to a variable. */
136 static int next_tsv_number
= 1;
138 /* Number of last traceframe collected. */
139 static int traceframe_number
;
141 /* Tracepoint for last traceframe collected. */
142 static int tracepoint_number
;
144 /* Symbol for function for last traceframe collected */
145 static struct symbol
*traceframe_fun
;
147 /* Symtab and line for last traceframe collected */
148 static struct symtab_and_line traceframe_sal
;
150 /* Tracing command lists */
151 static struct cmd_list_element
*tfindlist
;
153 /* List of expressions to collect by default at each tracepoint hit. */
154 char *default_collect
= "";
156 static int disconnected_tracing
;
158 /* This variable controls whether we ask the target for a linear or
159 circular trace buffer. */
161 static int circular_trace_buffer
;
163 /* ======= Important command functions: ======= */
164 static void trace_actions_command (char *, int);
165 static void trace_start_command (char *, int);
166 static void trace_stop_command (char *, int);
167 static void trace_status_command (char *, int);
168 static void trace_find_command (char *, int);
169 static void trace_find_pc_command (char *, int);
170 static void trace_find_tracepoint_command (char *, int);
171 static void trace_find_line_command (char *, int);
172 static void trace_find_range_command (char *, int);
173 static void trace_find_outside_command (char *, int);
174 static void trace_dump_command (char *, int);
176 /* support routines */
178 struct collection_list
;
179 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
180 static char *mem2hex (gdb_byte
*, char *, int);
181 static void add_register (struct collection_list
*collection
,
184 extern void send_disconnected_tracing_value (int value
);
186 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
187 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
190 extern void _initialize_tracepoint (void);
192 static struct trace_status trace_status
;
194 char *stop_reason_names
[] = {
204 struct trace_status
*
205 current_trace_status ()
207 return &trace_status
;
210 /* Set traceframe number to NUM. */
212 set_traceframe_num (int num
)
214 traceframe_number
= num
;
215 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
218 /* Set tracepoint number to NUM. */
220 set_tracepoint_num (int num
)
222 tracepoint_number
= num
;
223 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
226 /* Set externally visible debug variables for querying/printing
227 the traceframe context (line, function, file) */
230 set_traceframe_context (struct frame_info
*trace_frame
)
234 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
237 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
238 traceframe_sal
.symtab
= NULL
;
239 clear_internalvar (lookup_internalvar ("trace_func"));
240 clear_internalvar (lookup_internalvar ("trace_file"));
241 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
245 /* Save as globals for internal use. */
246 trace_pc
= get_frame_pc (trace_frame
);
247 traceframe_sal
= find_pc_line (trace_pc
, 0);
248 traceframe_fun
= find_pc_function (trace_pc
);
250 /* Save linenumber as "$trace_line", a debugger variable visible to
252 set_internalvar_integer (lookup_internalvar ("trace_line"),
253 traceframe_sal
.line
);
255 /* Save func name as "$trace_func", a debugger variable visible to
257 if (traceframe_fun
== NULL
258 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
259 clear_internalvar (lookup_internalvar ("trace_func"));
261 set_internalvar_string (lookup_internalvar ("trace_func"),
262 SYMBOL_LINKAGE_NAME (traceframe_fun
));
264 /* Save file name as "$trace_file", a debugger variable visible to
266 if (traceframe_sal
.symtab
== NULL
267 || traceframe_sal
.symtab
->filename
== NULL
)
268 clear_internalvar (lookup_internalvar ("trace_file"));
270 set_internalvar_string (lookup_internalvar ("trace_file"),
271 traceframe_sal
.symtab
->filename
);
274 /* Create a new trace state variable with the given name. */
276 struct trace_state_variable
*
277 create_trace_state_variable (const char *name
)
279 struct trace_state_variable tsv
;
281 memset (&tsv
, 0, sizeof (tsv
));
282 tsv
.name
= xstrdup (name
);
283 tsv
.number
= next_tsv_number
++;
284 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
287 /* Look for a trace state variable of the given name. */
289 struct trace_state_variable
*
290 find_trace_state_variable (const char *name
)
292 struct trace_state_variable
*tsv
;
295 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
296 if (strcmp (name
, tsv
->name
) == 0)
303 delete_trace_state_variable (const char *name
)
305 struct trace_state_variable
*tsv
;
308 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
309 if (strcmp (name
, tsv
->name
) == 0)
311 xfree ((void *)tsv
->name
);
312 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
316 warning (_("No trace variable named \"$%s\", not deleting"), name
);
319 /* The 'tvariable' command collects a name and optional expression to
320 evaluate into an initial value. */
323 trace_variable_command (char *args
, int from_tty
)
325 struct expression
*expr
;
326 struct cleanup
*old_chain
;
327 struct internalvar
*intvar
= NULL
;
329 struct trace_state_variable
*tsv
;
332 error_no_arg (_("trace state variable name"));
334 /* All the possible valid arguments are expressions. */
335 expr
= parse_expression (args
);
336 old_chain
= make_cleanup (free_current_contents
, &expr
);
338 if (expr
->nelts
== 0)
339 error (_("No expression?"));
341 /* Only allow two syntaxes; "$name" and "$name=value". */
342 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
344 intvar
= expr
->elts
[1].internalvar
;
346 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
347 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
349 intvar
= expr
->elts
[2].internalvar
;
350 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
353 error (_("Syntax must be $NAME [ = EXPR ]"));
356 error (_("No name given"));
358 if (strlen (internalvar_name (intvar
)) <= 0)
359 error (_("Must supply a non-empty variable name"));
361 /* If the variable already exists, just change its initial value. */
362 tsv
= find_trace_state_variable (internalvar_name (intvar
));
365 tsv
->initial_value
= initval
;
366 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
367 tsv
->name
, plongest (tsv
->initial_value
));
368 do_cleanups (old_chain
);
372 /* Create a new variable. */
373 tsv
= create_trace_state_variable (internalvar_name (intvar
));
374 tsv
->initial_value
= initval
;
376 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
377 tsv
->name
, plongest (tsv
->initial_value
));
379 do_cleanups (old_chain
);
383 delete_trace_variable_command (char *args
, int from_tty
)
387 struct cleanup
*back_to
;
391 if (query (_("Delete all trace state variables? ")))
392 VEC_free (tsv_s
, tvariables
);
397 argv
= gdb_buildargv (args
);
398 back_to
= make_cleanup_freeargv (argv
);
400 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
402 if (*argv
[ix
] == '$')
403 delete_trace_state_variable (argv
[ix
] + 1);
405 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
408 do_cleanups (back_to
);
414 tvariables_info_1 (void)
416 struct trace_state_variable
*tsv
;
419 struct cleanup
*back_to
;
421 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
423 printf_filtered (_("No trace state variables.\n"));
427 /* Try to acquire values from the target. */
428 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
429 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
432 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
433 count
, "trace-variables");
434 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
435 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
436 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
438 ui_out_table_body (uiout
);
440 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
442 struct cleanup
*back_to2
;
446 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
448 name
= concat ("$", tsv
->name
, (char *) NULL
);
449 make_cleanup (xfree
, name
);
450 ui_out_field_string (uiout
, "name", name
);
451 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
453 if (tsv
->value_known
)
454 c
= plongest (tsv
->value
);
455 else if (ui_out_is_mi_like_p (uiout
))
456 /* For MI, we prefer not to use magic string constants, but rather
457 omit the field completely. The difference between unknown and
458 undefined does not seem important enough to represent. */
460 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
461 /* The value is/was defined, but we don't have it. */
464 /* It is not meaningful to ask about the value. */
467 ui_out_field_string (uiout
, "current", c
);
468 ui_out_text (uiout
, "\n");
470 do_cleanups (back_to2
);
473 do_cleanups (back_to
);
476 /* List all the trace state variables. */
479 tvariables_info (char *args
, int from_tty
)
481 tvariables_info_1 ();
484 /* Stash definitions of tsvs into the given file. */
487 save_trace_state_variables (struct ui_file
*fp
)
489 struct trace_state_variable
*tsv
;
492 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
494 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
495 if (tsv
->initial_value
)
496 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
497 fprintf_unfiltered (fp
, "\n");
501 /* ACTIONS functions: */
503 /* The three functions:
504 collect_pseudocommand,
505 while_stepping_pseudocommand, and
506 end_actions_pseudocommand
507 are placeholders for "commands" that are actually ONLY to be used
508 within a tracepoint action list. If the actual function is ever called,
509 it means that somebody issued the "command" at the top level,
510 which is always an error. */
513 end_actions_pseudocommand (char *args
, int from_tty
)
515 error (_("This command cannot be used at the top level."));
519 while_stepping_pseudocommand (char *args
, int from_tty
)
521 error (_("This command can only be used in a tracepoint actions list."));
525 collect_pseudocommand (char *args
, int from_tty
)
527 error (_("This command can only be used in a tracepoint actions list."));
531 teval_pseudocommand (char *args
, int from_tty
)
533 error (_("This command can only be used in a tracepoint actions list."));
536 /* Enter a list of actions for a tracepoint. */
538 trace_actions_command (char *args
, int from_tty
)
540 struct breakpoint
*t
;
541 struct command_line
*l
;
543 t
= get_tracepoint_by_number (&args
, 0, 1);
547 xstrprintf ("Enter actions for tracepoint %d, one per line.",
549 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
551 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
552 do_cleanups (cleanups
);
553 breakpoint_set_commands (t
, l
);
555 /* else just return */
558 /* Report the results of checking the agent expression, as errors or
562 report_agent_reqs_errors (struct agent_expr
*aexpr
)
564 /* All of the "flaws" are serious bytecode generation issues that
565 should never occur. */
566 if (aexpr
->flaw
!= agent_flaw_none
)
567 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
569 /* If analysis shows a stack underflow, GDB must have done something
570 badly wrong in its bytecode generation. */
571 if (aexpr
->min_height
< 0)
572 internal_error (__FILE__
, __LINE__
,
573 _("expression has min height < 0"));
575 /* Issue this error if the stack is predicted to get too deep. The
576 limit is rather arbitrary; a better scheme might be for the
577 target to report how much stack it will have available. The
578 depth roughly corresponds to parenthesization, so a limit of 20
579 amounts to 20 levels of expression nesting, which is actually
580 a pretty big hairy expression. */
581 if (aexpr
->max_height
> 20)
582 error (_("Expression is too complicated."));
585 /* worker function */
587 validate_actionline (char **line
, struct breakpoint
*t
)
589 struct cmd_list_element
*c
;
590 struct expression
*exp
= NULL
;
591 struct cleanup
*old_chain
= NULL
;
593 struct bp_location
*loc
;
594 struct agent_expr
*aexpr
;
596 /* if EOF is typed, *line is NULL */
600 for (p
= *line
; isspace ((int) *p
);)
603 /* Symbol lookup etc. */
604 if (*p
== '\0') /* empty line: just prompt for another line. */
607 if (*p
== '#') /* comment line */
610 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
612 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
614 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
617 { /* repeat over a comma-separated list */
618 QUIT
; /* allow user to bail out with ^C */
619 while (isspace ((int) *p
))
622 if (*p
== '$') /* look for special pseudo-symbols */
624 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
625 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
626 (0 == strncasecmp ("loc", p
+ 1, 3)))
631 /* else fall thru, treat p as an expression and parse it! */
634 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
637 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
638 old_chain
= make_cleanup (free_current_contents
, &exp
);
640 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
642 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
644 error (_("constant `%s' (value %ld) will not be collected."),
645 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
646 SYMBOL_VALUE (exp
->elts
[2].symbol
));
648 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
650 error (_("`%s' is optimized away and cannot be collected."),
651 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
655 /* We have something to collect, make sure that the expr to
656 bytecode translator can handle it and that it's not too
658 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
659 make_cleanup_free_agent_expr (aexpr
);
661 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
662 error (_("Expression is too complicated."));
666 report_agent_reqs_errors (aexpr
);
668 do_cleanups (old_chain
);
671 while (p
&& *p
++ == ',');
674 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
677 { /* repeat over a comma-separated list */
678 QUIT
; /* allow user to bail out with ^C */
679 while (isspace ((int) *p
))
683 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
686 /* Only expressions are allowed for this action. */
687 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
688 old_chain
= make_cleanup (free_current_contents
, &exp
);
690 /* We have something to evaluate, make sure that the expr to
691 bytecode translator can handle it and that it's not too
693 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
694 make_cleanup_free_agent_expr (aexpr
);
696 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
697 error (_("Expression is too complicated."));
700 report_agent_reqs_errors (aexpr
);
702 do_cleanups (old_chain
);
705 while (p
&& *p
++ == ',');
708 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
710 char *steparg
; /* in case warning is necessary */
712 while (isspace ((int) *p
))
716 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
717 error (_("while-stepping step count `%s' is malformed."), *line
);
720 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
724 error (_("`%s' is not a supported tracepoint action."), *line
);
728 memrange_absolute
= -1
733 int type
; /* memrange_absolute for absolute memory range,
734 else basereg number */
735 bfd_signed_vma start
;
739 struct collection_list
741 unsigned char regs_mask
[32]; /* room for up to 256 regs */
744 struct memrange
*list
;
745 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
747 struct agent_expr
**aexpr_list
;
750 tracepoint_list
, stepping_list
;
752 /* MEMRANGE functions: */
754 static int memrange_cmp (const void *, const void *);
756 /* compare memranges for qsort */
758 memrange_cmp (const void *va
, const void *vb
)
760 const struct memrange
*a
= va
, *b
= vb
;
762 if (a
->type
< b
->type
)
764 if (a
->type
> b
->type
)
766 if (a
->type
== memrange_absolute
)
768 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
770 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
775 if (a
->start
< b
->start
)
777 if (a
->start
> b
->start
)
783 /* Sort the memrange list using qsort, and merge adjacent memranges. */
785 memrange_sortmerge (struct collection_list
*memranges
)
789 qsort (memranges
->list
, memranges
->next_memrange
,
790 sizeof (struct memrange
), memrange_cmp
);
791 if (memranges
->next_memrange
> 0)
793 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
795 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
796 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
799 /* memrange b starts before memrange a ends; merge them. */
800 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
801 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
802 continue; /* next b, same a */
806 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
807 sizeof (struct memrange
));
809 memranges
->next_memrange
= a
+ 1;
813 /* Add a register to a collection list. */
815 add_register (struct collection_list
*collection
, unsigned int regno
)
818 printf_filtered ("collect register %d\n", regno
);
819 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
820 error (_("Internal: register number %d too large for tracepoint"),
822 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
825 /* Add a memrange to a collection list */
827 add_memrange (struct collection_list
*memranges
,
828 int type
, bfd_signed_vma base
,
833 printf_filtered ("(%d,", type
);
835 printf_filtered (",%ld)\n", len
);
838 /* type: memrange_absolute == memory, other n == basereg */
839 memranges
->list
[memranges
->next_memrange
].type
= type
;
840 /* base: addr if memory, offset if reg relative. */
841 memranges
->list
[memranges
->next_memrange
].start
= base
;
842 /* len: we actually save end (base + len) for convenience */
843 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
844 memranges
->next_memrange
++;
845 if (memranges
->next_memrange
>= memranges
->listsize
)
847 memranges
->listsize
*= 2;
848 memranges
->list
= xrealloc (memranges
->list
,
849 memranges
->listsize
);
852 if (type
!= memrange_absolute
) /* Better collect the base register! */
853 add_register (memranges
, type
);
856 /* Add a symbol to a collection list. */
858 collect_symbol (struct collection_list
*collect
,
860 struct gdbarch
*gdbarch
,
861 long frame_regno
, long frame_offset
,
866 bfd_signed_vma offset
;
867 int treat_as_expr
= 0;
869 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
870 switch (SYMBOL_CLASS (sym
))
873 printf_filtered ("%s: don't know symbol class %d\n",
874 SYMBOL_PRINT_NAME (sym
),
878 printf_filtered ("constant %s (value %ld) will not be collected.\n",
879 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
882 offset
= SYMBOL_VALUE_ADDRESS (sym
);
887 sprintf_vma (tmp
, offset
);
888 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
889 SYMBOL_PRINT_NAME (sym
), len
,
892 /* A struct may be a C++ class with static fields, go to general
893 expression handling. */
894 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
897 add_memrange (collect
, memrange_absolute
, offset
, len
);
900 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
902 printf_filtered ("LOC_REG[parm] %s: ",
903 SYMBOL_PRINT_NAME (sym
));
904 add_register (collect
, reg
);
905 /* Check for doubles stored in two registers. */
906 /* FIXME: how about larger types stored in 3 or more regs? */
907 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
908 len
> register_size (gdbarch
, reg
))
909 add_register (collect
, reg
+ 1);
912 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
913 printf_filtered (" (will not collect %s)\n",
914 SYMBOL_PRINT_NAME (sym
));
918 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
921 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
922 SYMBOL_PRINT_NAME (sym
), len
);
924 printf_filtered (" from frame ptr reg %d\n", reg
);
926 add_memrange (collect
, reg
, offset
, len
);
928 case LOC_REGPARM_ADDR
:
929 reg
= SYMBOL_VALUE (sym
);
933 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
934 SYMBOL_PRINT_NAME (sym
), len
);
936 printf_filtered (" from reg %d\n", reg
);
938 add_memrange (collect
, reg
, offset
, len
);
942 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
945 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
946 SYMBOL_PRINT_NAME (sym
), len
);
948 printf_filtered (" from frame ptr reg %d\n", reg
);
950 add_memrange (collect
, reg
, offset
, len
);
957 case LOC_OPTIMIZED_OUT
:
958 printf_filtered ("%s has been optimized out of existence.\n",
959 SYMBOL_PRINT_NAME (sym
));
967 /* Expressions are the most general case. */
970 struct agent_expr
*aexpr
;
971 struct cleanup
*old_chain1
= NULL
;
973 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
975 /* It can happen that the symbol is recorded as a computed
976 location, but it's been optimized away and doesn't actually
977 have a location expression. */
980 printf_filtered ("%s has been optimized out of existence.\n",
981 SYMBOL_PRINT_NAME (sym
));
985 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
989 report_agent_reqs_errors (aexpr
);
991 discard_cleanups (old_chain1
);
992 add_aexpr (collect
, aexpr
);
994 /* take care of the registers */
995 if (aexpr
->reg_mask_len
> 0)
999 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1001 QUIT
; /* allow user to bail out with ^C */
1002 if (aexpr
->reg_mask
[ndx1
] != 0)
1004 /* assume chars have 8 bits */
1005 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1006 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1007 /* it's used -- record it */
1008 add_register (collect
, ndx1
* 8 + ndx2
);
1015 /* Data to be passed around in the calls to the locals and args
1018 struct add_local_symbols_data
1020 struct collection_list
*collect
;
1021 struct gdbarch
*gdbarch
;
1028 /* The callback for the locals and args iterators */
1031 do_collect_symbol (const char *print_name
,
1035 struct add_local_symbols_data
*p
= cb_data
;
1037 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1038 p
->frame_offset
, p
->pc
);
1042 /* Add all locals (or args) symbols to collection list */
1044 add_local_symbols (struct collection_list
*collect
,
1045 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1046 long frame_regno
, long frame_offset
, int type
)
1048 struct block
*block
;
1049 struct add_local_symbols_data cb_data
;
1051 cb_data
.collect
= collect
;
1052 cb_data
.gdbarch
= gdbarch
;
1054 cb_data
.frame_regno
= frame_regno
;
1055 cb_data
.frame_offset
= frame_offset
;
1060 block
= block_for_pc (pc
);
1063 warning (_("Can't collect locals; "
1064 "no symbol table info available.\n"));
1068 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1069 if (cb_data
.count
== 0)
1070 warning (_("No locals found in scope."));
1074 pc
= get_pc_function_start (pc
);
1075 block
= block_for_pc (pc
);
1078 warning (_("Can't collect args; no symbol table info available.\n"));
1082 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1083 if (cb_data
.count
== 0)
1084 warning (_("No args found in scope."));
1088 /* worker function */
1090 clear_collection_list (struct collection_list
*list
)
1094 list
->next_memrange
= 0;
1095 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1097 free_agent_expr (list
->aexpr_list
[ndx
]);
1098 list
->aexpr_list
[ndx
] = NULL
;
1100 list
->next_aexpr_elt
= 0;
1101 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1104 /* reduce a collection list to string form (for gdb protocol) */
1106 stringify_collection_list (struct collection_list
*list
, char *string
)
1108 char temp_buf
[2048];
1112 char *(*str_list
)[];
1116 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1117 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1119 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1120 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1122 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1125 printf_filtered ("\nCollecting registers (mask): 0x");
1130 QUIT
; /* allow user to bail out with ^C */
1132 printf_filtered ("%02X", list
->regs_mask
[i
]);
1133 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1136 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1140 printf_filtered ("\n");
1141 if (list
->next_memrange
> 0 && info_verbose
)
1142 printf_filtered ("Collecting memranges: \n");
1143 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1145 QUIT
; /* allow user to bail out with ^C */
1146 sprintf_vma (tmp2
, list
->list
[i
].start
);
1149 printf_filtered ("(%d, %s, %ld)\n",
1152 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1154 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1156 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1163 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1165 /* The "%X" conversion specifier expects an unsigned argument,
1166 so passing -1 (memrange_absolute) to it directly gives you
1167 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1169 if (list
->list
[i
].type
== memrange_absolute
)
1170 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1172 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1175 count
+= strlen (end
);
1176 end
= temp_buf
+ count
;
1179 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1181 QUIT
; /* allow user to bail out with ^C */
1182 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1184 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1189 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1190 end
+= 10; /* 'X' + 8 hex digits + ',' */
1193 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1194 end
, list
->aexpr_list
[i
]->len
);
1195 count
+= 2 * list
->aexpr_list
[i
]->len
;
1200 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1205 (*str_list
)[ndx
] = NULL
;
1218 encode_actions_1 (struct command_line
*action
,
1219 struct breakpoint
*t
,
1220 struct bp_location
*tloc
,
1222 LONGEST frame_offset
,
1223 struct collection_list
*collect
,
1224 struct collection_list
*stepping_list
)
1227 struct expression
*exp
= NULL
;
1229 struct value
*tempval
;
1230 struct cmd_list_element
*cmd
;
1231 struct agent_expr
*aexpr
;
1233 for (; action
; action
= action
->next
)
1235 QUIT
; /* allow user to bail out with ^C */
1236 action_exp
= action
->line
;
1237 while (isspace ((int) *action_exp
))
1240 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1242 error (_("Bad action list item: %s"), action_exp
);
1244 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1247 { /* repeat over a comma-separated list */
1248 QUIT
; /* allow user to bail out with ^C */
1249 while (isspace ((int) *action_exp
))
1252 if (0 == strncasecmp ("$reg", action_exp
, 4))
1254 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1255 add_register (collect
, i
);
1256 action_exp
= strchr (action_exp
, ','); /* more? */
1258 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1260 add_local_symbols (collect
,
1266 action_exp
= strchr (action_exp
, ','); /* more? */
1268 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1270 add_local_symbols (collect
,
1276 action_exp
= strchr (action_exp
, ','); /* more? */
1280 unsigned long addr
, len
;
1281 struct cleanup
*old_chain
= NULL
;
1282 struct cleanup
*old_chain1
= NULL
;
1284 exp
= parse_exp_1 (&action_exp
,
1285 block_for_pc (tloc
->address
), 1);
1286 old_chain
= make_cleanup (free_current_contents
, &exp
);
1288 switch (exp
->elts
[0].opcode
)
1292 const char *name
= &exp
->elts
[2].string
;
1294 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1295 name
, strlen (name
));
1297 internal_error (__FILE__
, __LINE__
,
1298 _("Register $%s not available"),
1301 printf_filtered ("OP_REGISTER: ");
1302 add_register (collect
, i
);
1307 /* safe because we know it's a simple expression */
1308 tempval
= evaluate_expression (exp
);
1309 addr
= value_address (tempval
);
1310 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1311 add_memrange (collect
, memrange_absolute
, addr
, len
);
1315 collect_symbol (collect
,
1316 exp
->elts
[2].symbol
,
1323 default: /* full-fledged expression */
1324 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1326 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1330 report_agent_reqs_errors (aexpr
);
1332 discard_cleanups (old_chain1
);
1333 add_aexpr (collect
, aexpr
);
1335 /* take care of the registers */
1336 if (aexpr
->reg_mask_len
> 0)
1341 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1343 QUIT
; /* allow user to bail out with ^C */
1344 if (aexpr
->reg_mask
[ndx1
] != 0)
1346 /* assume chars have 8 bits */
1347 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1348 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1349 /* it's used -- record it */
1350 add_register (collect
,
1357 do_cleanups (old_chain
);
1360 while (action_exp
&& *action_exp
++ == ',');
1362 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1365 { /* repeat over a comma-separated list */
1366 QUIT
; /* allow user to bail out with ^C */
1367 while (isspace ((int) *action_exp
))
1371 struct cleanup
*old_chain
= NULL
;
1372 struct cleanup
*old_chain1
= NULL
;
1374 exp
= parse_exp_1 (&action_exp
,
1375 block_for_pc (tloc
->address
), 1);
1376 old_chain
= make_cleanup (free_current_contents
, &exp
);
1378 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1379 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1382 report_agent_reqs_errors (aexpr
);
1384 discard_cleanups (old_chain1
);
1385 /* Even though we're not officially collecting, add
1386 to the collect list anyway. */
1387 add_aexpr (collect
, aexpr
);
1389 do_cleanups (old_chain
);
1392 while (action_exp
&& *action_exp
++ == ',');
1394 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1396 /* We check against nested while-stepping when setting
1397 breakpoint action, so no way to run into nested
1399 gdb_assert (stepping_list
);
1401 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1402 frame_offset
, stepping_list
, NULL
);
1405 error (_("Invalid tracepoint command '%s'"), action
->line
);
1409 /* Render all actions into gdb protocol. */
1411 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1412 char ***tdp_actions
, char ***stepping_actions
)
1414 static char tdp_buff
[2048], step_buff
[2048];
1415 char *default_collect_line
= NULL
;
1416 struct command_line
*actions
;
1417 struct command_line
*default_collect_action
= NULL
;
1419 LONGEST frame_offset
;
1420 struct cleanup
*back_to
;
1422 back_to
= make_cleanup (null_cleanup
, NULL
);
1424 clear_collection_list (&tracepoint_list
);
1425 clear_collection_list (&stepping_list
);
1427 *tdp_actions
= NULL
;
1428 *stepping_actions
= NULL
;
1430 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1431 t
->loc
->address
, &frame_reg
, &frame_offset
);
1433 actions
= breakpoint_commands (t
);
1435 /* If there are default expressions to collect, make up a collect
1436 action and prepend to the action list to encode. Note that since
1437 validation is per-tracepoint (local var "xyz" might be valid for
1438 one tracepoint and not another, etc), we make up the action on
1439 the fly, and don't cache it. */
1440 if (*default_collect
)
1444 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1445 make_cleanup (xfree
, default_collect_line
);
1447 line
= default_collect_line
;
1448 validate_actionline (&line
, t
);
1450 default_collect_action
= xmalloc (sizeof (struct command_line
));
1451 make_cleanup (xfree
, default_collect_action
);
1452 default_collect_action
->next
= actions
;
1453 default_collect_action
->line
= line
;
1454 actions
= default_collect_action
;
1456 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1457 &tracepoint_list
, &stepping_list
);
1459 memrange_sortmerge (&tracepoint_list
);
1460 memrange_sortmerge (&stepping_list
);
1462 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1464 *stepping_actions
= stringify_collection_list (&stepping_list
,
1467 do_cleanups (back_to
);
1471 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1473 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1475 collect
->aexpr_list
=
1476 xrealloc (collect
->aexpr_list
,
1477 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1478 collect
->aexpr_listsize
*= 2;
1480 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1481 collect
->next_aexpr_elt
++;
1486 start_tracing (void)
1488 VEC(breakpoint_p
) *tp_vec
= NULL
;
1490 struct breakpoint
*t
;
1491 struct trace_state_variable
*tsv
;
1492 int any_enabled
= 0;
1494 tp_vec
= all_tracepoints ();
1496 /* No point in tracing without any tracepoints... */
1497 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1499 VEC_free (breakpoint_p
, tp_vec
);
1500 error (_("No tracepoints defined, not starting trace"));
1503 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1505 if (t
->enable_state
== bp_enabled
)
1512 /* No point in tracing with only disabled tracepoints. */
1515 VEC_free (breakpoint_p
, tp_vec
);
1516 error (_("No tracepoints enabled, not starting trace"));
1519 target_trace_init ();
1521 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1523 t
->number_on_target
= 0;
1524 target_download_tracepoint (t
);
1525 t
->number_on_target
= t
->number
;
1527 VEC_free (breakpoint_p
, tp_vec
);
1529 /* Send down all the trace state variables too. */
1530 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1532 target_download_trace_state_variable (tsv
);
1535 /* Tell target to treat text-like sections as transparent. */
1536 target_trace_set_readonly_regions ();
1537 /* Set some mode flags. */
1538 target_set_disconnected_tracing (disconnected_tracing
);
1539 target_set_circular_trace_buffer (circular_trace_buffer
);
1541 /* Now insert traps and begin collecting data. */
1542 target_trace_start ();
1544 /* Reset our local state. */
1545 set_traceframe_num (-1);
1546 set_tracepoint_num (-1);
1547 set_traceframe_context (NULL
);
1548 current_trace_status()->running
= 1;
1553 Tell target to clear any previous trace experiment.
1554 Walk the list of tracepoints, and send them (and their actions)
1555 to the target. If no errors,
1556 Tell target to start a new trace experiment. */
1559 trace_start_command (char *args
, int from_tty
)
1561 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1563 if (current_trace_status ()->running
)
1566 && !query (_("A trace is running already. Start a new run? ")))
1567 error (_("New trace run not started."));
1575 trace_stop_command (char *args
, int from_tty
)
1577 if (!current_trace_status ()->running
)
1578 error (_("Trace is not running."));
1586 target_trace_stop ();
1587 /* should change in response to reply? */
1588 current_trace_status ()->running
= 0;
1591 /* tstatus command */
1593 trace_status_command (char *args
, int from_tty
)
1595 struct trace_status
*ts
= current_trace_status ();
1598 status
= target_get_trace_status (ts
);
1603 printf_filtered (_("Using a trace file.\n"));
1606 printf_filtered (_("Trace can not be run on this target.\n"));
1611 if (!ts
->running_known
)
1613 printf_filtered (_("Run/stop status is unknown.\n"));
1615 else if (ts
->running
)
1617 printf_filtered (_("Trace is running on the target.\n"));
1621 switch (ts
->stop_reason
)
1623 case trace_never_run
:
1624 printf_filtered (_("No trace has been run on the target.\n"));
1627 printf_filtered (_("Trace stopped by a tstop command.\n"));
1629 case trace_buffer_full
:
1630 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1632 case trace_disconnected
:
1633 printf_filtered (_("Trace stopped because of disconnection.\n"));
1635 case tracepoint_passcount
:
1636 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1637 ts
->stopping_tracepoint
);
1639 case tracepoint_error
:
1640 if (ts
->stopping_tracepoint
)
1641 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1642 ts
->error_desc
, ts
->stopping_tracepoint
);
1644 printf_filtered (_("Trace stopped by an error (%s).\n"),
1647 case trace_stop_reason_unknown
:
1648 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1651 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1657 if (ts
->traceframes_created
>= 0
1658 && ts
->traceframe_count
!= ts
->traceframes_created
)
1660 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1661 ts
->traceframe_count
, ts
->traceframes_created
);
1663 else if (ts
->traceframe_count
>= 0)
1665 printf_filtered (_("Collected %d trace frames.\n"),
1666 ts
->traceframe_count
);
1669 if (ts
->buffer_free
>= 0)
1671 if (ts
->buffer_size
>= 0)
1673 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1674 ts
->buffer_free
, ts
->buffer_size
);
1675 if (ts
->buffer_size
> 0)
1676 printf_filtered (_(" (%d%% full)"),
1677 ((int) ((((long long) (ts
->buffer_size
1678 - ts
->buffer_free
)) * 100)
1679 / ts
->buffer_size
)));
1680 printf_filtered (_(".\n"));
1683 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1687 if (ts
->disconnected_tracing
)
1688 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1690 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1692 if (ts
->circular_buffer
)
1693 printf_filtered (_("Trace buffer is circular.\n"));
1695 /* Now report on what we're doing with tfind. */
1696 if (traceframe_number
>= 0)
1697 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1698 traceframe_number
, tracepoint_number
);
1700 printf_filtered (_("Not looking at any trace frame.\n"));
1703 /* Report the trace status to uiout, in a way suitable for MI, and not
1704 suitable for CLI. If ON_STOP is true, suppress a few fields that
1705 are not meaningful in the -trace-stop response.
1707 The implementation is essentially parallel to trace_status_command, but
1708 merging them will result in unreadable code. */
1710 trace_status_mi (int on_stop
)
1712 struct trace_status
*ts
= current_trace_status ();
1715 status
= target_get_trace_status (ts
);
1717 if (status
== -1 && !ts
->from_file
)
1719 ui_out_field_string (uiout
, "supported", "0");
1724 ui_out_field_string (uiout
, "supported", "file");
1726 ui_out_field_string (uiout
, "supported", "1");
1728 gdb_assert (ts
->running_known
);
1732 ui_out_field_string (uiout
, "running", "1");
1734 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1735 Given that the frontend gets the status either on -trace-stop, or from
1736 -trace-status after re-connection, it does not seem like this
1737 information is necessary for anything. It is not necessary for either
1738 figuring the vital state of the target nor for navigation of trace
1739 frames. If the frontend wants to show the current state is some
1740 configure dialog, it can request the value when such dialog is
1741 invoked by the user. */
1745 char *stop_reason
= NULL
;
1746 int stopping_tracepoint
= -1;
1749 ui_out_field_string (uiout
, "running", "0");
1751 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1753 switch (ts
->stop_reason
)
1756 stop_reason
= "request";
1758 case trace_buffer_full
:
1759 stop_reason
= "overflow";
1761 case trace_disconnected
:
1762 stop_reason
= "disconnection";
1764 case tracepoint_passcount
:
1765 stop_reason
= "passcount";
1766 stopping_tracepoint
= ts
->stopping_tracepoint
;
1768 case tracepoint_error
:
1769 stop_reason
= "error";
1770 stopping_tracepoint
= ts
->stopping_tracepoint
;
1776 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1777 if (stopping_tracepoint
!= -1)
1778 ui_out_field_int (uiout
, "stopping-tracepoint",
1779 stopping_tracepoint
);
1780 if (ts
->stop_reason
== tracepoint_error
)
1781 ui_out_field_string (uiout
, "error-description",
1787 if (ts
->traceframe_count
!= -1)
1788 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1789 if (ts
->traceframes_created
!= -1)
1790 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1791 if (ts
->buffer_size
!= -1)
1792 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1793 if (ts
->buffer_free
!= -1)
1794 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1796 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1797 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1800 /* This function handles the details of what to do about an ongoing
1801 tracing run if the user has asked to detach or otherwise disconnect
1804 disconnect_tracing (int from_tty
)
1806 /* It can happen that the target that was tracing went away on its
1807 own, and we didn't notice. Get a status update, and if the
1808 current target doesn't even do tracing, then assume it's not
1810 if (target_get_trace_status (current_trace_status ()) < 0)
1811 current_trace_status ()->running
= 0;
1813 /* If running interactively, give the user the option to cancel and
1814 then decide what to do differently with the run. Scripts are
1815 just going to disconnect and let the target deal with it,
1816 according to how it's been instructed previously via
1817 disconnected-tracing. */
1818 if (current_trace_status ()->running
&& from_tty
)
1820 if (current_trace_status ()->disconnected_tracing
)
1822 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1823 error (_("Not confirmed."));
1827 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1828 error (_("Not confirmed."));
1832 /* Also we want to be out of tfind mode, otherwise things can get
1833 confusing upon reconnection. Just use these calls instead of
1834 full tfind_1 behavior because we're in the middle of detaching,
1835 and there's no point to updating current stack frame etc. */
1836 set_traceframe_number (-1);
1837 set_traceframe_context (NULL
);
1840 /* Worker function for the various flavors of the tfind command. */
1842 tfind_1 (enum trace_find_type type
, int num
,
1843 ULONGEST addr1
, ULONGEST addr2
,
1846 int target_frameno
= -1, target_tracept
= -1;
1847 struct frame_id old_frame_id
= null_frame_id
;
1848 struct breakpoint
*tp
;
1850 /* Only try to get the current stack frame if we have a chance of
1851 succeeding. In particular, if we're trying to get a first trace
1852 frame while all threads are running, it's not going to succeed,
1853 so leave it with a default value and let the frame comparison
1854 below (correctly) decide to print out the source location of the
1856 if (!(type
== tfind_number
&& num
== -1)
1857 && (has_stack_frames () || traceframe_number
>= 0))
1858 old_frame_id
= get_frame_id (get_current_frame ());
1860 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1863 if (type
== tfind_number
1865 && target_frameno
== -1)
1867 /* We told the target to get out of tfind mode, and it did. */
1869 else if (target_frameno
== -1)
1871 /* A request for a non-existent trace frame has failed.
1872 Our response will be different, depending on FROM_TTY:
1874 If FROM_TTY is true, meaning that this command was
1875 typed interactively by the user, then give an error
1876 and DO NOT change the state of traceframe_number etc.
1878 However if FROM_TTY is false, meaning that we're either
1879 in a script, a loop, or a user-defined command, then
1880 DON'T give an error, but DO change the state of
1881 traceframe_number etc. to invalid.
1883 The rationalle is that if you typed the command, you
1884 might just have committed a typo or something, and you'd
1885 like to NOT lose your current debugging state. However
1886 if you're in a user-defined command or especially in a
1887 loop, then you need a way to detect that the command
1888 failed WITHOUT aborting. This allows you to write
1889 scripts that search thru the trace buffer until the end,
1890 and then continue on to do something else. */
1893 error (_("Target failed to find requested trace frame."));
1897 printf_filtered ("End of trace buffer.\n");
1898 #if 0 /* dubious now? */
1899 /* The following will not recurse, since it's
1901 trace_find_command ("-1", from_tty
);
1906 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1908 reinit_frame_cache ();
1909 registers_changed ();
1910 target_dcache_invalidate ();
1911 set_traceframe_num (target_frameno
);
1912 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1913 if (target_frameno
== -1)
1914 set_traceframe_context (NULL
);
1916 set_traceframe_context (get_current_frame ());
1918 if (traceframe_number
>= 0)
1920 /* Use different branches for MI and CLI to make CLI messages
1922 if (ui_out_is_mi_like_p (uiout
))
1924 ui_out_field_string (uiout
, "found", "1");
1925 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1926 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1930 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1931 traceframe_number
, tracepoint_number
);
1936 if (ui_out_is_mi_like_p (uiout
))
1937 ui_out_field_string (uiout
, "found", "0");
1938 else if (type
== tfind_number
&& num
== -1)
1939 printf_unfiltered (_("No longer looking at any trace frame\n"));
1940 else /* this case may never occur, check */
1941 printf_unfiltered (_("No trace frame found\n"));
1944 /* If we're in nonstop mode and getting out of looking at trace
1945 frames, there won't be any current frame to go back to and
1948 && (has_stack_frames () || traceframe_number
>= 0))
1950 enum print_what print_what
;
1952 /* NOTE: in imitation of the step command, try to determine
1953 whether we have made a transition from one function to
1954 another. If so, we'll print the "stack frame" (ie. the new
1955 function and it's arguments) -- otherwise we'll just show the
1958 if (frame_id_eq (old_frame_id
,
1959 get_frame_id (get_current_frame ())))
1960 print_what
= SRC_LINE
;
1962 print_what
= SRC_AND_LOC
;
1964 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1969 /* trace_find_command takes a trace frame number n,
1970 sends "QTFrame:<n>" to the target,
1971 and accepts a reply that may contain several optional pieces
1972 of information: a frame number, a tracepoint number, and an
1973 indication of whether this is a trap frame or a stepping frame.
1975 The minimal response is just "OK" (which indicates that the
1976 target does not give us a frame number or a tracepoint number).
1977 Instead of that, the target may send us a string containing
1979 F<hexnum> (gives the selected frame number)
1980 T<hexnum> (gives the selected tracepoint number)
1985 trace_find_command (char *args
, int from_tty
)
1986 { /* this should only be called with a numeric argument */
1989 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1990 error ("May not look at trace frames while trace is running.");
1992 if (args
== 0 || *args
== 0)
1993 { /* TFIND with no args means find NEXT trace frame. */
1994 if (traceframe_number
== -1)
1995 frameno
= 0; /* "next" is first one */
1997 frameno
= traceframe_number
+ 1;
1999 else if (0 == strcmp (args
, "-"))
2001 if (traceframe_number
== -1)
2002 error (_("not debugging trace buffer"));
2003 else if (from_tty
&& traceframe_number
== 0)
2004 error (_("already at start of trace buffer"));
2006 frameno
= traceframe_number
- 1;
2008 /* A hack to work around eval's need for fp to have been collected. */
2009 else if (0 == strcmp (args
, "-1"))
2012 frameno
= parse_and_eval_long (args
);
2015 error (_("invalid input (%d is less than zero)"), frameno
);
2017 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2022 trace_find_end_command (char *args
, int from_tty
)
2024 trace_find_command ("-1", from_tty
);
2029 trace_find_none_command (char *args
, int from_tty
)
2031 trace_find_command ("-1", from_tty
);
2036 trace_find_start_command (char *args
, int from_tty
)
2038 trace_find_command ("0", from_tty
);
2041 /* tfind pc command */
2043 trace_find_pc_command (char *args
, int from_tty
)
2047 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2048 error ("May not look at trace frames while trace is running.");
2050 if (args
== 0 || *args
== 0)
2051 pc
= regcache_read_pc (get_current_regcache ());
2053 pc
= parse_and_eval_address (args
);
2055 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2058 /* tfind tracepoint command */
2060 trace_find_tracepoint_command (char *args
, int from_tty
)
2063 struct breakpoint
*tp
;
2065 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2066 error ("May not look at trace frames while trace is running.");
2068 if (args
== 0 || *args
== 0)
2070 if (tracepoint_number
== -1)
2071 error (_("No current tracepoint -- please supply an argument."));
2073 tdp
= tracepoint_number
; /* default is current TDP */
2076 tdp
= parse_and_eval_long (args
);
2078 /* If we have the tracepoint on hand, use the number that the
2079 target knows about (which may be different if we disconnected
2080 and reconnected). */
2081 tp
= get_tracepoint (tdp
);
2083 tdp
= tp
->number_on_target
;
2085 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2088 /* TFIND LINE command:
2090 This command will take a sourceline for argument, just like BREAK
2091 or TRACE (ie. anything that "decode_line_1" can handle).
2093 With no argument, this command will find the next trace frame
2094 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2097 trace_find_line_command (char *args
, int from_tty
)
2099 static CORE_ADDR start_pc
, end_pc
;
2100 struct symtabs_and_lines sals
;
2101 struct symtab_and_line sal
;
2102 struct cleanup
*old_chain
;
2104 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2105 error ("May not look at trace frames while trace is running.");
2107 if (args
== 0 || *args
== 0)
2109 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2111 sals
.sals
= (struct symtab_and_line
*)
2112 xmalloc (sizeof (struct symtab_and_line
));
2117 sals
= decode_line_spec (args
, 1);
2121 old_chain
= make_cleanup (xfree
, sals
.sals
);
2122 if (sal
.symtab
== 0)
2123 error (_("No line number information available."));
2125 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2127 if (start_pc
== end_pc
)
2129 printf_filtered ("Line %d of \"%s\"",
2130 sal
.line
, sal
.symtab
->filename
);
2132 printf_filtered (" is at address ");
2133 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2135 printf_filtered (" but contains no code.\n");
2136 sal
= find_pc_line (start_pc
, 0);
2138 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2139 && start_pc
!= end_pc
)
2140 printf_filtered ("Attempting to find line %d instead.\n",
2143 error (_("Cannot find a good line."));
2147 /* Is there any case in which we get here, and have an address
2148 which the user would want to see? If we have debugging
2149 symbols and no line numbers? */
2150 error (_("Line number %d is out of range for \"%s\"."),
2151 sal
.line
, sal
.symtab
->filename
);
2153 /* Find within range of stated line. */
2155 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2157 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2158 do_cleanups (old_chain
);
2161 /* tfind range command */
2163 trace_find_range_command (char *args
, int from_tty
)
2165 static CORE_ADDR start
, stop
;
2168 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2169 error ("May not look at trace frames while trace is running.");
2171 if (args
== 0 || *args
== 0)
2172 { /* XXX FIXME: what should default behavior be? */
2173 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2177 if (0 != (tmp
= strchr (args
, ',')))
2179 *tmp
++ = '\0'; /* terminate start address */
2180 while (isspace ((int) *tmp
))
2182 start
= parse_and_eval_address (args
);
2183 stop
= parse_and_eval_address (tmp
);
2186 { /* no explicit end address? */
2187 start
= parse_and_eval_address (args
);
2188 stop
= start
+ 1; /* ??? */
2191 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2194 /* tfind outside command */
2196 trace_find_outside_command (char *args
, int from_tty
)
2198 CORE_ADDR start
, stop
;
2201 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2202 error ("May not look at trace frames while trace is running.");
2204 if (args
== 0 || *args
== 0)
2205 { /* XXX FIXME: what should default behavior be? */
2206 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2210 if (0 != (tmp
= strchr (args
, ',')))
2212 *tmp
++ = '\0'; /* terminate start address */
2213 while (isspace ((int) *tmp
))
2215 start
= parse_and_eval_address (args
);
2216 stop
= parse_and_eval_address (tmp
);
2219 { /* no explicit end address? */
2220 start
= parse_and_eval_address (args
);
2221 stop
= start
+ 1; /* ??? */
2224 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2227 /* info scope command: list the locals for a scope. */
2229 scope_info (char *args
, int from_tty
)
2231 struct symtabs_and_lines sals
;
2233 struct minimal_symbol
*msym
;
2234 struct block
*block
;
2235 char **canonical
, *symname
, *save_args
= args
;
2236 struct dict_iterator iter
;
2238 struct gdbarch
*gdbarch
;
2241 if (args
== 0 || *args
== 0)
2242 error (_("requires an argument (function, line or *addr) to define a scope"));
2244 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2245 if (sals
.nelts
== 0)
2246 return; /* presumably decode_line_1 has already warned */
2248 /* Resolve line numbers to PC */
2249 resolve_sal_pc (&sals
.sals
[0]);
2250 block
= block_for_pc (sals
.sals
[0].pc
);
2254 QUIT
; /* allow user to bail out with ^C */
2255 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2257 QUIT
; /* allow user to bail out with ^C */
2259 printf_filtered ("Scope for %s:\n", save_args
);
2262 symname
= SYMBOL_PRINT_NAME (sym
);
2263 if (symname
== NULL
|| *symname
== '\0')
2264 continue; /* probably botched, certainly useless */
2266 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2268 printf_filtered ("Symbol %s is ", symname
);
2269 switch (SYMBOL_CLASS (sym
))
2272 case LOC_UNDEF
: /* messed up symbol? */
2273 printf_filtered ("a bogus symbol, class %d.\n",
2274 SYMBOL_CLASS (sym
));
2275 count
--; /* don't count this one */
2278 printf_filtered ("a constant with value %ld (0x%lx)",
2279 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2281 case LOC_CONST_BYTES
:
2282 printf_filtered ("constant bytes: ");
2283 if (SYMBOL_TYPE (sym
))
2284 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2285 fprintf_filtered (gdb_stdout
, " %02x",
2286 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2289 printf_filtered ("in static storage at address ");
2290 printf_filtered ("%s", paddress (gdbarch
,
2291 SYMBOL_VALUE_ADDRESS (sym
)));
2294 /* GDBARCH is the architecture associated with the objfile
2295 the symbol is defined in; the target architecture may be
2296 different, and may provide additional registers. However,
2297 we do not know the target architecture at this point.
2298 We assume the objfile architecture will contain all the
2299 standard registers that occur in debug info in that
2301 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2303 if (SYMBOL_IS_ARGUMENT (sym
))
2304 printf_filtered ("an argument in register $%s",
2305 gdbarch_register_name (gdbarch
, regno
));
2307 printf_filtered ("a local variable in register $%s",
2308 gdbarch_register_name (gdbarch
, regno
));
2311 printf_filtered ("an argument at stack/frame offset %ld",
2312 SYMBOL_VALUE (sym
));
2315 printf_filtered ("a local variable at frame offset %ld",
2316 SYMBOL_VALUE (sym
));
2319 printf_filtered ("a reference argument at offset %ld",
2320 SYMBOL_VALUE (sym
));
2322 case LOC_REGPARM_ADDR
:
2323 /* Note comment at LOC_REGISTER. */
2324 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2325 printf_filtered ("the address of an argument, in register $%s",
2326 gdbarch_register_name (gdbarch
, regno
));
2329 printf_filtered ("a typedef.\n");
2332 printf_filtered ("a label at address ");
2333 printf_filtered ("%s", paddress (gdbarch
,
2334 SYMBOL_VALUE_ADDRESS (sym
)));
2337 printf_filtered ("a function at address ");
2338 printf_filtered ("%s",
2339 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2341 case LOC_UNRESOLVED
:
2342 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2345 printf_filtered ("Unresolved Static");
2348 printf_filtered ("static storage at address ");
2349 printf_filtered ("%s",
2350 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2353 case LOC_OPTIMIZED_OUT
:
2354 printf_filtered ("optimized out.\n");
2357 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2358 BLOCK_START (block
),
2362 if (SYMBOL_TYPE (sym
))
2363 printf_filtered (", length %d.\n",
2364 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2366 if (BLOCK_FUNCTION (block
))
2369 block
= BLOCK_SUPERBLOCK (block
);
2372 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2376 /* worker function (cleanup) */
2378 replace_comma (void *data
)
2385 /* Helper for trace_dump_command. Dump the action list starting at
2386 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2387 actions of the body of a while-stepping action. STEPPING_FRAME is
2388 set if the current traceframe was determined to be a while-stepping
2392 trace_dump_actions (struct command_line
*action
,
2393 int stepping_actions
, int stepping_frame
,
2396 char *action_exp
, *next_comma
;
2398 for (; action
!= NULL
; action
= action
->next
)
2400 struct cmd_list_element
*cmd
;
2402 QUIT
; /* allow user to bail out with ^C */
2403 action_exp
= action
->line
;
2404 while (isspace ((int) *action_exp
))
2407 /* The collection actions to be done while stepping are
2408 bracketed by the commands "while-stepping" and "end". */
2410 if (*action_exp
== '#') /* comment line */
2413 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2415 error (_("Bad action list item: %s"), action_exp
);
2417 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2421 for (i
= 0; i
< action
->body_count
; ++i
)
2422 trace_dump_actions (action
->body_list
[i
],
2423 1, stepping_frame
, from_tty
);
2425 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2427 /* Display the collected data.
2428 For the trap frame, display only what was collected at
2429 the trap. Likewise for stepping frames, display only
2430 what was collected while stepping. This means that the
2431 two boolean variables, STEPPING_FRAME and
2432 STEPPING_ACTIONS should be equal. */
2433 if (stepping_frame
== stepping_actions
)
2436 { /* repeat over a comma-separated list */
2437 QUIT
; /* allow user to bail out with ^C */
2438 if (*action_exp
== ',')
2440 while (isspace ((int) *action_exp
))
2443 next_comma
= strchr (action_exp
, ',');
2445 if (0 == strncasecmp (action_exp
, "$reg", 4))
2446 registers_info (NULL
, from_tty
);
2447 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2448 locals_info (NULL
, from_tty
);
2449 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2450 args_info (NULL
, from_tty
);
2455 make_cleanup (replace_comma
, next_comma
);
2458 printf_filtered ("%s = ", action_exp
);
2459 output_command (action_exp
, from_tty
);
2460 printf_filtered ("\n");
2464 action_exp
= next_comma
;
2466 while (action_exp
&& *action_exp
== ',');
2472 /* The tdump command. */
2475 trace_dump_command (char *args
, int from_tty
)
2477 struct regcache
*regcache
;
2478 struct breakpoint
*t
;
2479 int stepping_frame
= 0;
2480 struct bp_location
*loc
;
2481 char *line
, *default_collect_line
= NULL
;
2482 struct command_line
*actions
, *default_collect_action
= NULL
;
2483 struct cleanup
*old_chain
= NULL
;
2485 if (tracepoint_number
== -1)
2487 warning (_("No current trace frame."));
2491 t
= get_tracepoint (tracepoint_number
);
2494 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2497 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2498 tracepoint_number
, traceframe_number
);
2500 /* The current frame is a trap frame if the frame PC is equal
2501 to the tracepoint PC. If not, then the current frame was
2502 collected during single-stepping. */
2504 regcache
= get_current_regcache ();
2506 /* If the traceframe's address matches any of the tracepoint's
2507 locations, assume it is a direct hit rather than a while-stepping
2508 frame. (FIXME this is not reliable, should record each frame's
2511 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2512 if (loc
->address
== regcache_read_pc (regcache
))
2515 actions
= breakpoint_commands (t
);
2517 /* If there is a default-collect list, make up a collect command,
2518 prepend to the tracepoint's commands, and pass the whole mess to
2519 the trace dump scanner. We need to validate because
2520 default-collect might have been junked since the trace run. */
2521 if (*default_collect
)
2523 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2524 old_chain
= make_cleanup (xfree
, default_collect_line
);
2525 line
= default_collect_line
;
2526 validate_actionline (&line
, t
);
2527 default_collect_action
= xmalloc (sizeof (struct command_line
));
2528 make_cleanup (xfree
, default_collect_action
);
2529 default_collect_action
->next
= actions
;
2530 default_collect_action
->line
= line
;
2531 actions
= default_collect_action
;
2534 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2536 if (*default_collect
)
2537 do_cleanups (old_chain
);
2540 /* Encode a piece of a tracepoint's source-level definition in a form
2541 that is suitable for both protocol and saving in files. */
2542 /* This version does not do multiple encodes for long strings; it should
2543 return an offset to the next piece to encode. FIXME */
2546 encode_source_string (int tpnum
, ULONGEST addr
,
2547 char *srctype
, char *src
, char *buf
, int buf_size
)
2549 if (80 + strlen (srctype
) > buf_size
)
2550 error (_("Buffer too small for source encoding"));
2551 sprintf (buf
, "%x:%s:%s:%x:%x:",
2552 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2553 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2554 error (_("Source string too long for buffer"));
2555 bin2hex (src
, buf
+ strlen (buf
), 0);
2559 extern int trace_regblock_size
;
2561 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2562 non-zero, the save is performed on the target, otherwise GDB obtains all
2563 trace data and saves it locally. */
2566 trace_save (const char *filename
, int target_does_save
)
2568 struct cleanup
*cleanup
;
2570 struct trace_status
*ts
= current_trace_status ();
2573 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2574 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2578 ULONGEST offset
= 0;
2579 #define MAX_TRACE_UPLOAD 2000
2580 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2583 /* If the target is to save the data to a file on its own, then just
2584 send the command and be done with it. */
2585 if (target_does_save
)
2587 err
= target_save_trace_data (filename
);
2589 error (_("Target failed to save trace data to '%s'."),
2594 /* Get the trace status first before opening the file, so if the
2595 target is losing, we can get out without touching files. */
2596 status
= target_get_trace_status (ts
);
2598 pathname
= tilde_expand (filename
);
2599 cleanup
= make_cleanup (xfree
, pathname
);
2601 fp
= fopen (pathname
, "wb");
2603 error (_("Unable to open file '%s' for saving trace data (%s)"),
2604 filename
, safe_strerror (errno
));
2605 make_cleanup_fclose (fp
);
2607 /* Write a file header, with a high-bit-set char to indicate a
2608 binary file, plus a hint as what this file is, and a version
2609 number in case of future needs. */
2610 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2612 perror_with_name (pathname
);
2614 /* Write descriptive info. */
2616 /* Write out the size of a register block. */
2617 fprintf (fp
, "R %x\n", trace_regblock_size
);
2619 /* Write out status of the tracing run (aka "tstatus" info). */
2620 fprintf (fp
, "status %c;%s",
2621 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2622 if (ts
->stop_reason
== tracepoint_error
)
2624 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2626 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2627 fprintf (fp
, ":%s", buf
);
2629 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2630 if (ts
->traceframe_count
>= 0)
2631 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2632 if (ts
->traceframes_created
>= 0)
2633 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2634 if (ts
->buffer_free
>= 0)
2635 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2636 if (ts
->buffer_size
>= 0)
2637 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2638 if (ts
->disconnected_tracing
)
2639 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2640 if (ts
->circular_buffer
)
2641 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2644 /* Note that we want to upload tracepoints and save those, rather
2645 than simply writing out the local ones, because the user may have
2646 changed tracepoints in GDB in preparation for a future tracing
2647 run, or maybe just mass-deleted all types of breakpoints as part
2648 of cleaning up. So as not to contaminate the session, leave the
2649 data in its uploaded form, don't make into real tracepoints. */
2651 /* Get trace state variables first, they may be checked when parsing
2652 uploaded commands. */
2654 target_upload_trace_state_variables (&uploaded_tsvs
);
2656 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2662 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2663 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2666 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2667 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2668 utsv
->builtin
, buf
);
2674 free_uploaded_tsvs (&uploaded_tsvs
);
2676 target_upload_tracepoints (&uploaded_tps
);
2678 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2680 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2681 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2682 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2683 if (utp
->type
== bp_fast_tracepoint
)
2684 fprintf (fp
, ":F%x", utp
->orig_size
);
2686 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2689 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2690 fprintf (fp
, "tp A%x:%s:%s\n",
2691 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2692 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2693 fprintf (fp
, "tp S%x:%s:%s\n",
2694 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2697 encode_source_string (utp
->number
, utp
->addr
,
2698 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2699 fprintf (fp
, "tp Z%s\n", buf
);
2701 if (utp
->cond_string
)
2703 encode_source_string (utp
->number
, utp
->addr
,
2704 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2705 fprintf (fp
, "tp Z%s\n", buf
);
2707 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2709 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2710 buf
, MAX_TRACE_UPLOAD
);
2711 fprintf (fp
, "tp Z%s\n", buf
);
2715 free_uploaded_tps (&uploaded_tps
);
2717 /* Mark the end of the definition section. */
2720 /* Get and write the trace data proper. We ask for big blocks, in
2721 the hopes of efficiency, but will take less if the target has
2722 packet size limitations or some such. */
2725 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2727 error (_("Failure to get requested trace buffer data"));
2728 /* No more data is forthcoming, we're done. */
2731 written
= fwrite (buf
, gotten
, 1, fp
);
2733 perror_with_name (pathname
);
2737 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2738 written
= fwrite (&gotten
, 4, 1, fp
);
2740 perror_with_name (pathname
);
2742 do_cleanups (cleanup
);
2746 trace_save_command (char *args
, int from_tty
)
2748 int target_does_save
= 0;
2750 char *filename
= NULL
;
2751 struct cleanup
*back_to
;
2754 error_no_arg (_("file in which to save trace data"));
2756 argv
= gdb_buildargv (args
);
2757 back_to
= make_cleanup_freeargv (argv
);
2759 for (; *argv
; ++argv
)
2761 if (strcmp (*argv
, "-r") == 0)
2762 target_does_save
= 1;
2763 else if (**argv
== '-')
2764 error (_("unknown option `%s'"), *argv
);
2770 error_no_arg (_("file in which to save trace data"));
2772 trace_save (filename
, target_does_save
);
2775 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2777 do_cleanups (back_to
);
2780 /* Tell the target what to do with an ongoing tracing run if GDB
2781 disconnects for some reason. */
2784 send_disconnected_tracing_value (int value
)
2786 target_set_disconnected_tracing (value
);
2790 set_disconnected_tracing (char *args
, int from_tty
,
2791 struct cmd_list_element
*c
)
2793 send_disconnected_tracing_value (disconnected_tracing
);
2797 set_circular_trace_buffer (char *args
, int from_tty
,
2798 struct cmd_list_element
*c
)
2800 target_set_circular_trace_buffer (circular_trace_buffer
);
2803 /* Convert the memory pointed to by mem into hex, placing result in buf.
2804 * Return a pointer to the last char put in buf (null)
2805 * "stolen" from sparc-stub.c
2808 static const char hexchars
[] = "0123456789abcdef";
2811 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2819 *buf
++ = hexchars
[ch
>> 4];
2820 *buf
++ = hexchars
[ch
& 0xf];
2829 get_traceframe_number (void)
2831 return traceframe_number
;
2834 /* Make the traceframe NUM be the current trace frame. Does nothing
2835 if NUM is already current. */
2838 set_traceframe_number (int num
)
2842 if (traceframe_number
== num
)
2844 /* Nothing to do. */
2848 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2851 warning (_("could not change traceframe"));
2853 traceframe_number
= newnum
;
2855 /* Changing the traceframe changes our view of registers and of the
2857 registers_changed ();
2860 /* A cleanup used when switching away and back from tfind mode. */
2862 struct current_traceframe_cleanup
2864 /* The traceframe we were inspecting. */
2865 int traceframe_number
;
2869 do_restore_current_traceframe_cleanup (void *arg
)
2871 struct current_traceframe_cleanup
*old
= arg
;
2873 set_traceframe_number (old
->traceframe_number
);
2877 restore_current_traceframe_cleanup_dtor (void *arg
)
2879 struct current_traceframe_cleanup
*old
= arg
;
2885 make_cleanup_restore_current_traceframe (void)
2887 struct current_traceframe_cleanup
*old
;
2889 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2890 old
->traceframe_number
= traceframe_number
;
2892 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2893 restore_current_traceframe_cleanup_dtor
);
2896 /* Given a number and address, return an uploaded tracepoint with that
2897 number, creating if necessary. */
2899 struct uploaded_tp
*
2900 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2902 struct uploaded_tp
*utp
;
2904 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2905 if (utp
->number
== num
&& utp
->addr
== addr
)
2907 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2908 memset (utp
, 0, sizeof (struct uploaded_tp
));
2911 utp
->actions
= NULL
;
2912 utp
->step_actions
= NULL
;
2913 utp
->cmd_strings
= NULL
;
2920 free_uploaded_tps (struct uploaded_tp
**utpp
)
2922 struct uploaded_tp
*next_one
;
2926 next_one
= (*utpp
)->next
;
2932 /* Given a number and address, return an uploaded tracepoint with that
2933 number, creating if necessary. */
2935 struct uploaded_tsv
*
2936 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2938 struct uploaded_tsv
*utsv
;
2940 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2941 if (utsv
->number
== num
)
2943 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2944 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2946 utsv
->next
= *utsvp
;
2952 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2954 struct uploaded_tsv
*next_one
;
2958 next_one
= (*utsvp
)->next
;
2964 /* Look for an existing tracepoint that seems similar enough to the
2965 uploaded one. Enablement isn't compared, because the user can
2966 toggle that freely, and may have done so in anticipation of the
2970 find_matching_tracepoint (struct uploaded_tp
*utp
)
2972 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2974 struct breakpoint
*t
;
2975 struct bp_location
*loc
;
2977 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2979 if (t
->type
== utp
->type
2980 && t
->step_count
== utp
->step
2981 && t
->pass_count
== utp
->pass
2982 /* FIXME also test conditionals and actions */
2985 /* Scan the locations for an address match. */
2986 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2988 if (loc
->address
== utp
->addr
)
2996 /* Given a list of tracepoints uploaded from a target, attempt to
2997 match them up with existing tracepoints, and create new ones if not
3001 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3003 struct uploaded_tp
*utp
;
3004 struct breakpoint
*t
;
3006 /* Look for GDB tracepoints that match up with our uploaded versions. */
3007 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3009 t
= find_matching_tracepoint (utp
);
3011 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3012 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3015 t
= create_tracepoint_from_upload (utp
);
3017 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3018 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3020 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3021 utp
->number
, paddress (get_current_arch (), utp
->addr
));
3023 /* Whether found or created, record the number used by the
3024 target, to help with mapping target tracepoints back to their
3025 counterparts here. */
3027 t
->number_on_target
= utp
->number
;
3030 free_uploaded_tps (uploaded_tps
);
3033 /* Trace state variables don't have much to identify them beyond their
3034 name, so just use that to detect matches. */
3036 struct trace_state_variable
*
3037 find_matching_tsv (struct uploaded_tsv
*utsv
)
3042 return find_trace_state_variable (utsv
->name
);
3045 struct trace_state_variable
*
3046 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3048 const char *namebase
;
3051 struct trace_state_variable
*tsv
;
3055 namebase
= utsv
->name
;
3056 sprintf (buf
, "%s", namebase
);
3061 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3064 /* Fish for a name that is not in use. */
3065 /* (should check against all internal vars?) */
3066 while (find_trace_state_variable (buf
))
3067 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3069 /* We have an available name, create the variable. */
3070 tsv
= create_trace_state_variable (xstrdup (buf
));
3071 tsv
->initial_value
= utsv
->initial_value
;
3072 tsv
->builtin
= utsv
->builtin
;
3077 /* Given a list of uploaded trace state variables, try to match them
3078 up with existing variables, or create additional ones. */
3081 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3084 struct uploaded_tsv
*utsv
;
3085 struct trace_state_variable
*tsv
;
3088 /* Most likely some numbers will have to be reassigned as part of
3089 the merge, so clear them all in anticipation. */
3090 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3093 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3095 tsv
= find_matching_tsv (utsv
);
3097 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3098 tsv
->name
, utsv
->number
);
3101 tsv
= create_tsv_from_upload (utsv
);
3102 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3103 tsv
->name
, utsv
->number
);
3105 /* Give precedence to numberings that come from the target. */
3107 tsv
->number
= utsv
->number
;
3110 /* Renumber everything that didn't get a target-assigned number. */
3112 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3113 if (tsv
->number
> highest
)
3114 highest
= tsv
->number
;
3117 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3118 if (tsv
->number
== 0)
3119 tsv
->number
= highest
++;
3121 free_uploaded_tsvs (uploaded_tsvs
);
3124 /* target tfile command */
3126 struct target_ops tfile_ops
;
3128 /* Fill in tfile_ops with its defined operations and properties. */
3130 #define TRACE_HEADER_SIZE 8
3132 char *trace_filename
;
3134 off_t trace_frames_offset
;
3137 int trace_regblock_size
;
3139 static void tfile_interp_line (char *line
,
3140 struct uploaded_tp
**utpp
,
3141 struct uploaded_tsv
**utsvp
);
3144 tfile_open (char *filename
, int from_tty
)
3147 struct cleanup
*old_chain
;
3150 char header
[TRACE_HEADER_SIZE
];
3151 char linebuf
[1000]; /* should be max remote packet size or so */
3153 int bytes
, i
, gotten
;
3154 struct trace_status
*ts
;
3155 struct uploaded_tp
*uploaded_tps
= NULL
;
3156 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3158 target_preopen (from_tty
);
3160 error (_("No trace file specified."));
3162 filename
= tilde_expand (filename
);
3163 if (!IS_ABSOLUTE_PATH(filename
))
3165 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3170 old_chain
= make_cleanup (xfree
, filename
);
3172 flags
= O_BINARY
| O_LARGEFILE
;
3174 scratch_chan
= open (filename
, flags
, 0);
3175 if (scratch_chan
< 0)
3176 perror_with_name (filename
);
3178 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3180 discard_cleanups (old_chain
); /* Don't free filename any more */
3181 unpush_target (&tfile_ops
);
3183 push_target (&tfile_ops
);
3185 trace_filename
= xstrdup (filename
);
3186 trace_fd
= scratch_chan
;
3189 /* Read the file header and test for validity. */
3190 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3192 perror_with_name (trace_filename
);
3193 else if (gotten
< TRACE_HEADER_SIZE
)
3194 error (_("Premature end of file while reading trace file"));
3196 bytes
+= TRACE_HEADER_SIZE
;
3197 if (!(header
[0] == 0x7f
3198 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3199 error (_("File is not a valid trace file."));
3201 trace_regblock_size
= 0;
3202 ts
= current_trace_status ();
3203 /* We know we're working with a file. */
3205 /* Set defaults in case there is no status line. */
3206 ts
->running_known
= 0;
3207 ts
->stop_reason
= trace_stop_reason_unknown
;
3208 ts
->traceframe_count
= -1;
3209 ts
->buffer_free
= 0;
3210 ts
->disconnected_tracing
= 0;
3211 ts
->circular_buffer
= 0;
3213 /* Read through a section of newline-terminated lines that
3214 define things like tracepoints. */
3218 gotten
= read (trace_fd
, &byte
, 1);
3220 perror_with_name (trace_filename
);
3221 else if (gotten
< 1)
3222 error (_("Premature end of file while reading trace file"));
3227 /* Empty line marks end of the definition section. */
3232 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3235 linebuf
[i
++] = byte
;
3237 error (_("Excessively long lines in trace file"));
3240 /* Add the file's tracepoints and variables into the current mix. */
3242 /* Get trace state variables first, they may be checked when parsing
3243 uploaded commands. */
3244 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3246 merge_uploaded_tracepoints (&uploaded_tps
);
3248 /* Record the starting offset of the binary trace data. */
3249 trace_frames_offset
= bytes
;
3251 /* If we don't have a blocksize, we can't interpret the
3253 if (trace_regblock_size
== 0)
3254 error (_("No register block size recorded in trace file"));
3255 if (ts
->traceframe_count
<= 0)
3257 warning ("No traceframes present in this file.");
3261 #define TFILE_PID (1)
3262 inferior_appeared (current_inferior (), TFILE_PID
);
3263 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3264 add_thread_silent (inferior_ptid
);
3266 post_create_inferior (&tfile_ops
, from_tty
);
3269 /* FIXME this will get defined in MI patch submission */
3270 tfind_1 (tfind_number
, 0, 0, 0, 0);
3274 /* Interpret the given line from the definitions part of the trace
3278 tfile_interp_line (char *line
,
3279 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3283 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3286 trace_regblock_size
= strtol (p
, &p
, 16);
3288 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3290 p
+= strlen ("status ");
3291 parse_trace_status (p
, current_trace_status ());
3293 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3295 p
+= strlen ("tp ");
3296 parse_tracepoint_definition (p
, utpp
);
3298 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3300 p
+= strlen ("tsv ");
3301 parse_tsv_definition (p
, utsvp
);
3304 warning ("Ignoring trace file definition \"%s\"", line
);
3307 /* Parse the part of trace status syntax that is shared between
3308 the remote protocol and the trace file reader. */
3310 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3313 parse_trace_status (char *line
, struct trace_status
*ts
)
3315 char *p
= line
, *p1
, *p2
, *p_temp
;
3318 ts
->running_known
= 1;
3319 ts
->running
= (*p
++ == '1');
3320 ts
->stop_reason
= trace_stop_reason_unknown
;
3321 xfree (ts
->error_desc
);
3322 ts
->error_desc
= NULL
;
3323 ts
->traceframe_count
= -1;
3324 ts
->traceframes_created
= -1;
3325 ts
->buffer_free
= -1;
3326 ts
->buffer_size
= -1;
3327 ts
->disconnected_tracing
= 0;
3328 ts
->circular_buffer
= 0;
3332 p1
= strchr (p
, ':');
3334 error (_("Malformed trace status, at %s\n\
3335 Status line: '%s'\n"), p
, line
);
3336 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3338 p
= unpack_varlen_hex (++p1
, &val
);
3339 ts
->stop_reason
= trace_buffer_full
;
3341 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3343 p
= unpack_varlen_hex (++p1
, &val
);
3344 ts
->stop_reason
= trace_never_run
;
3346 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3348 p
= unpack_varlen_hex (++p1
, &val
);
3349 ts
->stop_reason
= tracepoint_passcount
;
3350 ts
->stopping_tracepoint
= val
;
3352 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3354 p
= unpack_varlen_hex (++p1
, &val
);
3355 ts
->stop_reason
= tstop_command
;
3357 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3359 p
= unpack_varlen_hex (++p1
, &val
);
3360 ts
->stop_reason
= trace_disconnected
;
3362 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3364 p2
= strchr (++p1
, ':');
3369 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3370 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3371 ts
->error_desc
[end
] = '\0';
3374 ts
->error_desc
= xstrdup ("");
3376 p
= unpack_varlen_hex (++p2
, &val
);
3377 ts
->stopping_tracepoint
= val
;
3378 ts
->stop_reason
= tracepoint_error
;
3380 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3382 p
= unpack_varlen_hex (++p1
, &val
);
3383 ts
->traceframe_count
= val
;
3385 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3387 p
= unpack_varlen_hex (++p1
, &val
);
3388 ts
->traceframes_created
= val
;
3390 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3392 p
= unpack_varlen_hex (++p1
, &val
);
3393 ts
->buffer_free
= val
;
3395 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3397 p
= unpack_varlen_hex (++p1
, &val
);
3398 ts
->buffer_size
= val
;
3400 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3402 p
= unpack_varlen_hex (++p1
, &val
);
3403 ts
->disconnected_tracing
= val
;
3405 else if (strncmp (p
, "circular", p1
- p
) == 0)
3407 p
= unpack_varlen_hex (++p1
, &val
);
3408 ts
->circular_buffer
= val
;
3412 /* Silently skip unknown optional info. */
3413 p_temp
= strchr (p1
+ 1, ';');
3417 /* Must be at the end. */
3423 /* Given a line of text defining a part of a tracepoint, parse it into
3424 an "uploaded tracepoint". */
3427 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3431 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3434 char *cond
, *srctype
, *buf
;
3435 struct uploaded_tp
*utp
= NULL
;
3438 /* Both tracepoint and action definitions start with the same number
3439 and address sequence. */
3441 p
= unpack_varlen_hex (p
, &num
);
3442 p
++; /* skip a colon */
3443 p
= unpack_varlen_hex (p
, &addr
);
3444 p
++; /* skip a colon */
3447 enabled
= (*p
++ == 'E');
3448 p
++; /* skip a colon */
3449 p
= unpack_varlen_hex (p
, &step
);
3450 p
++; /* skip a colon */
3451 p
= unpack_varlen_hex (p
, &pass
);
3452 type
= bp_tracepoint
;
3454 /* Thumb through optional fields. */
3457 p
++; /* skip a colon */
3460 type
= bp_fast_tracepoint
;
3462 p
= unpack_varlen_hex (p
, &orig_size
);
3467 p
= unpack_varlen_hex (p
, &xlen
);
3468 p
++; /* skip a comma */
3469 cond
= (char *) xmalloc (2 * xlen
+ 1);
3470 strncpy (cond
, p
, 2 * xlen
);
3471 cond
[2 * xlen
] = '\0';
3475 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3477 utp
= get_uploaded_tp (num
, addr
, utpp
);
3479 utp
->enabled
= enabled
;
3484 else if (piece
== 'A')
3486 utp
= get_uploaded_tp (num
, addr
, utpp
);
3487 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3489 else if (piece
== 'S')
3491 utp
= get_uploaded_tp (num
, addr
, utpp
);
3492 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3494 else if (piece
== 'Z')
3496 /* Parse a chunk of source form definition. */
3497 utp
= get_uploaded_tp (num
, addr
, utpp
);
3499 p
= strchr (p
, ':');
3500 p
++; /* skip a colon */
3501 p
= unpack_varlen_hex (p
, &start
);
3502 p
++; /* skip a colon */
3503 p
= unpack_varlen_hex (p
, &xlen
);
3504 p
++; /* skip a colon */
3506 buf
= alloca (strlen (line
));
3508 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3511 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3512 utp
->at_string
= xstrdup (buf
);
3513 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3514 utp
->cond_string
= xstrdup (buf
);
3515 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3516 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3520 /* Don't error out, the target might be sending us optional
3521 info that we don't care about. */
3522 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3526 /* Convert a textual description of a trace state variable into an
3530 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3533 ULONGEST num
, initval
, builtin
;
3535 struct uploaded_tsv
*utsv
= NULL
;
3537 buf
= alloca (strlen (line
));
3540 p
= unpack_varlen_hex (p
, &num
);
3541 p
++; /* skip a colon */
3542 p
= unpack_varlen_hex (p
, &initval
);
3543 p
++; /* skip a colon */
3544 p
= unpack_varlen_hex (p
, &builtin
);
3545 p
++; /* skip a colon */
3546 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3549 utsv
= get_uploaded_tsv (num
, utsvp
);
3550 utsv
->initial_value
= initval
;
3551 utsv
->builtin
= builtin
;
3552 utsv
->name
= xstrdup (buf
);
3555 /* Close the trace file and generally clean up. */
3558 tfile_close (int quitting
)
3565 pid
= ptid_get_pid (inferior_ptid
);
3566 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3567 exit_inferior_silent (pid
);
3572 xfree (trace_filename
);
3576 tfile_files_info (struct target_ops
*t
)
3578 /* (it would be useful to mention the name of the file) */
3579 printf_filtered ("Looking at a trace file.\n");
3582 /* The trace status for a file is that tracing can never be run. */
3585 tfile_get_trace_status (struct trace_status
*ts
)
3587 /* Other bits of trace status were collected as part of opening the
3588 trace files, so nothing to do here. */
3593 /* Given the position of a traceframe in the file, figure out what
3594 address the frame was collected at. This would normally be the
3595 value of a collected PC register, but if not available, we
3599 tfile_get_traceframe_address (off_t tframe_offset
)
3603 struct breakpoint
*tp
;
3604 off_t saved_offset
= cur_offset
;
3607 /* FIXME dig pc out of collected registers */
3609 /* Fall back to using tracepoint address. */
3610 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3611 gotten
= read (trace_fd
, &tpnum
, 2);
3613 perror_with_name (trace_filename
);
3614 else if (gotten
< 2)
3615 error (_("Premature end of file while reading trace file"));
3617 tp
= get_tracepoint_by_number_on_target (tpnum
);
3618 /* FIXME this is a poor heuristic if multiple locations */
3620 addr
= tp
->loc
->address
;
3622 /* Restore our seek position. */
3623 cur_offset
= saved_offset
;
3624 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3628 /* Given a type of search and some parameters, scan the collection of
3629 traceframes in the file looking for a match. When found, return
3630 both the traceframe and tracepoint number, otherwise -1 for
3634 tfile_trace_find (enum trace_find_type type
, int num
,
3635 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3638 int tfnum
= 0, found
= 0, gotten
;
3640 struct breakpoint
*tp
;
3641 off_t offset
, tframe_offset
;
3644 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3645 offset
= trace_frames_offset
;
3648 tframe_offset
= offset
;
3649 gotten
= read (trace_fd
, &tpnum
, 2);
3651 perror_with_name (trace_filename
);
3652 else if (gotten
< 2)
3653 error (_("Premature end of file while reading trace file"));
3657 gotten
= read (trace_fd
, &data_size
, 4);
3659 perror_with_name (trace_filename
);
3660 else if (gotten
< 4)
3661 error (_("Premature end of file while reading trace file"));
3670 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3671 if (tfaddr
== addr1
)
3675 tp
= get_tracepoint (num
);
3676 if (tp
&& tpnum
== tp
->number_on_target
)
3680 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3681 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3685 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3686 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3690 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3696 cur_offset
= offset
;
3697 cur_data_size
= data_size
;
3700 /* Skip past the traceframe's data. */
3701 lseek (trace_fd
, data_size
, SEEK_CUR
);
3702 offset
+= data_size
;
3703 /* Update our own count of traceframes. */
3706 /* Did not find what we were looking for. */
3712 /* Look for a block of saved registers in the traceframe, and get the
3713 requested register from it. */
3716 tfile_fetch_registers (struct target_ops
*ops
,
3717 struct regcache
*regcache
, int regno
)
3719 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3721 int pos
, offset
, regn
, regsize
, gotten
, pc_regno
;
3722 unsigned short mlen
;
3725 /* An uninitialized reg size says we're not going to be
3726 successful at getting register blocks. */
3727 if (!trace_regblock_size
)
3730 regs
= alloca (trace_regblock_size
);
3732 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3734 while (pos
< cur_data_size
)
3736 gotten
= read (trace_fd
, &block_type
, 1);
3738 perror_with_name (trace_filename
);
3739 else if (gotten
< 1)
3740 error (_("Premature end of file while reading trace file"));
3746 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3748 perror_with_name (trace_filename
);
3749 else if (gotten
< trace_regblock_size
)
3750 error (_("Premature end of file while reading trace file"));
3752 /* Assume the block is laid out in GDB register number order,
3753 each register with the size that it has in GDB. */
3755 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3757 regsize
= register_size (gdbarch
, regn
);
3758 /* Make sure we stay within block bounds. */
3759 if (offset
+ regsize
>= trace_regblock_size
)
3761 if (!regcache_valid_p (regcache
, regn
))
3765 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3768 else if (regno
== -1)
3770 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3777 lseek (trace_fd
, 8, SEEK_CUR
);
3778 gotten
= read (trace_fd
, &mlen
, 2);
3780 perror_with_name (trace_filename
);
3781 else if (gotten
< 2)
3782 error (_("Premature end of file while reading trace file"));
3783 lseek (trace_fd
, mlen
, SEEK_CUR
);
3784 pos
+= (8 + 2 + mlen
);
3787 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3791 error ("Unknown block type '%c' (0x%x) in trace frame",
3792 block_type
, block_type
);
3797 /* We get here if no register data has been found. Although we
3798 don't like making up numbers, GDB has all manner of troubles when
3799 the target says some register is not available. Filling in with
3800 zeroes is a reasonable fallback. */
3801 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3802 regcache_raw_supply (regcache
, regn
, NULL
);
3804 /* We can often usefully guess that the PC is going to be the same
3805 as the address of the tracepoint. */
3806 pc_regno
= gdbarch_pc_regnum (gdbarch
);
3807 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
3809 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
3813 /* But don't try to guess if tracepoint is multi-location... */
3816 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3820 /* ... or does while-stepping. */
3821 if (tp
->step_count
> 0)
3823 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3828 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
3829 gdbarch_byte_order (gdbarch
),
3831 regcache_raw_supply (regcache
, pc_regno
, regs
);
3837 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3838 const char *annex
, gdb_byte
*readbuf
,
3839 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3843 ULONGEST maddr
, amt
;
3844 unsigned short mlen
;
3846 /* We're only doing regular memory for now. */
3847 if (object
!= TARGET_OBJECT_MEMORY
)
3850 if (readbuf
== NULL
)
3851 error ("tfile_xfer_partial: trace file is read-only");
3853 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3855 while (pos
< cur_data_size
)
3857 gotten
= read (trace_fd
, &block_type
, 1);
3859 perror_with_name (trace_filename
);
3860 else if (gotten
< 1)
3861 error (_("Premature end of file while reading trace file"));
3866 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3867 pos
+= trace_regblock_size
;
3870 gotten
= read (trace_fd
, &maddr
, 8);
3872 perror_with_name (trace_filename
);
3873 else if (gotten
< 8)
3874 error (_("Premature end of file while reading trace file"));
3876 gotten
= read (trace_fd
, &mlen
, 2);
3878 perror_with_name (trace_filename
);
3879 else if (gotten
< 2)
3880 error (_("Premature end of file while reading trace file"));
3881 /* If the block includes the first part of the desired
3882 range, return as much it has; GDB will re-request the
3883 remainder, which might be in a different block of this
3885 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
3887 amt
= (maddr
+ mlen
) - offset
;
3891 gotten
= read (trace_fd
, readbuf
, amt
);
3893 perror_with_name (trace_filename
);
3894 /* While it's acceptable to return less than was
3895 originally asked for, it's not acceptable to return
3896 less than what this block claims to contain. */
3897 else if (gotten
< amt
)
3898 error (_("Premature end of file while reading trace file"));
3901 lseek (trace_fd
, mlen
, SEEK_CUR
);
3902 pos
+= (8 + 2 + mlen
);
3905 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3909 error ("Unknown block type '%c' (0x%x) in traceframe",
3910 block_type
, block_type
);
3915 /* It's unduly pedantic to refuse to look at the executable for
3916 read-only pieces; so do the equivalent of readonly regions aka
3918 /* FIXME account for relocation at some point */
3925 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
3927 if ((s
->flags
& SEC_LOAD
) == 0 ||
3928 (s
->flags
& SEC_READONLY
) == 0)
3932 size
= bfd_get_section_size (s
);
3933 if (lma
<= offset
&& offset
< (lma
+ size
))
3935 amt
= (lma
+ size
) - offset
;
3939 amt
= bfd_get_section_contents (exec_bfd
, s
,
3940 readbuf
, offset
- lma
, amt
);
3946 /* Indicate failure to find the requested memory block. */
3950 /* Iterate through the blocks of a trace frame, looking for a 'V'
3951 block with a matching tsv number. */
3954 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3957 int pos
, vnum
, gotten
;
3958 unsigned short mlen
;
3960 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3962 while (pos
< cur_data_size
)
3964 gotten
= read (trace_fd
, &block_type
, 1);
3966 perror_with_name (trace_filename
);
3967 else if (gotten
< 1)
3968 error (_("Premature end of file while reading trace file"));
3973 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3974 pos
+= trace_regblock_size
;
3977 lseek (trace_fd
, 8, SEEK_CUR
);
3978 gotten
= read (trace_fd
, &mlen
, 2);
3980 perror_with_name (trace_filename
);
3981 else if (gotten
< 2)
3982 error (_("Premature end of file while reading trace file"));
3983 lseek (trace_fd
, mlen
, SEEK_CUR
);
3984 pos
+= (8 + 2 + mlen
);
3987 gotten
= read (trace_fd
, &vnum
, 4);
3989 perror_with_name (trace_filename
);
3990 else if (gotten
< 4)
3991 error (_("Premature end of file while reading trace file"));
3994 gotten
= read (trace_fd
, val
, 8);
3996 perror_with_name (trace_filename
);
3997 else if (gotten
< 8)
3998 error (_("Premature end of file while reading trace file"));
4001 lseek (trace_fd
, 8, SEEK_CUR
);
4005 error ("Unknown block type '%c' (0x%x) in traceframe",
4006 block_type
, block_type
);
4010 /* Didn't find anything. */
4015 tfile_has_all_memory (struct target_ops
*ops
)
4021 tfile_has_memory (struct target_ops
*ops
)
4027 tfile_has_stack (struct target_ops
*ops
)
4033 tfile_has_registers (struct target_ops
*ops
)
4039 init_tfile_ops (void)
4041 tfile_ops
.to_shortname
= "tfile";
4042 tfile_ops
.to_longname
= "Local trace dump file";
4044 "Use a trace file as a target. Specify the filename of the trace file.";
4045 tfile_ops
.to_open
= tfile_open
;
4046 tfile_ops
.to_close
= tfile_close
;
4047 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4048 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4049 tfile_ops
.to_files_info
= tfile_files_info
;
4050 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4051 tfile_ops
.to_trace_find
= tfile_trace_find
;
4052 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
4053 /* core_stratum might seem more logical, but GDB doesn't like having
4054 more than one core_stratum vector. */
4055 tfile_ops
.to_stratum
= process_stratum
;
4056 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4057 tfile_ops
.to_has_memory
= tfile_has_memory
;
4058 tfile_ops
.to_has_stack
= tfile_has_stack
;
4059 tfile_ops
.to_has_registers
= tfile_has_registers
;
4060 tfile_ops
.to_magic
= OPS_MAGIC
;
4063 /* module initialization */
4065 _initialize_tracepoint (void)
4067 struct cmd_list_element
*c
;
4069 traceframe_number
= -1;
4070 tracepoint_number
= -1;
4072 if (tracepoint_list
.list
== NULL
)
4074 tracepoint_list
.listsize
= 128;
4075 tracepoint_list
.list
= xmalloc
4076 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4078 if (tracepoint_list
.aexpr_list
== NULL
)
4080 tracepoint_list
.aexpr_listsize
= 128;
4081 tracepoint_list
.aexpr_list
= xmalloc
4082 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4085 if (stepping_list
.list
== NULL
)
4087 stepping_list
.listsize
= 128;
4088 stepping_list
.list
= xmalloc
4089 (stepping_list
.listsize
* sizeof (struct memrange
));
4092 if (stepping_list
.aexpr_list
== NULL
)
4094 stepping_list
.aexpr_listsize
= 128;
4095 stepping_list
.aexpr_list
= xmalloc
4096 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4099 add_info ("scope", scope_info
,
4100 _("List the variables local to a scope"));
4102 add_cmd ("tracepoints", class_trace
, NULL
,
4103 _("Tracing of program execution without stopping the program."),
4106 add_com ("tdump", class_trace
, trace_dump_command
,
4107 _("Print everything collected at the current tracepoint."));
4109 add_com ("tsave", class_trace
, trace_save_command
, _("\
4110 Save the trace data to a file.\n\
4111 Use the '-r' option to direct the target to save directly to the file,\n\
4112 using its own filesystem."));
4114 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4115 Define a trace state variable.\n\
4116 Argument is a $-prefixed name, optionally followed\n\
4117 by '=' and an expression that sets the initial value\n\
4118 at the start of tracing."));
4119 set_cmd_completer (c
, expression_completer
);
4121 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4122 Delete one or more trace state variables.\n\
4123 Arguments are the names of the variables to delete.\n\
4124 If no arguments are supplied, delete all variables."), &deletelist
);
4125 /* FIXME add a trace variable completer */
4127 add_info ("tvariables", tvariables_info
, _("\
4128 Status of trace state variables and their values.\n\
4131 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4132 Select a trace frame;\n\
4133 No argument means forward by one frame; '-' means backward by one frame."),
4134 &tfindlist
, "tfind ", 1, &cmdlist
);
4136 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4137 Select a trace frame whose PC is outside the given range (exclusive).\n\
4138 Usage: tfind outside addr1, addr2"),
4141 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4142 Select a trace frame whose PC is in the given range (inclusive).\n\
4143 Usage: tfind range addr1,addr2"),
4146 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4147 Select a trace frame by source line.\n\
4148 Argument can be a line number (with optional source file), \n\
4149 a function name, or '*' followed by an address.\n\
4150 Default argument is 'the next source line that was traced'."),
4153 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4154 Select a trace frame by tracepoint number.\n\
4155 Default is the tracepoint for the current trace frame."),
4158 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4159 Select a trace frame by PC.\n\
4160 Default is the current PC, or the PC of the current trace frame."),
4163 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4164 Synonym for 'none'.\n\
4165 De-select any trace frame and resume 'live' debugging."),
4168 add_cmd ("none", class_trace
, trace_find_none_command
,
4169 _("De-select any trace frame and resume 'live' debugging."),
4172 add_cmd ("start", class_trace
, trace_find_start_command
,
4173 _("Select the first trace frame in the trace buffer."),
4176 add_com ("tstatus", class_trace
, trace_status_command
,
4177 _("Display the status of the current trace data collection."));
4179 add_com ("tstop", class_trace
, trace_stop_command
,
4180 _("Stop trace data collection."));
4182 add_com ("tstart", class_trace
, trace_start_command
,
4183 _("Start trace data collection."));
4185 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4186 Ends a list of commands or actions.\n\
4187 Several GDB commands allow you to enter a list of commands or actions.\n\
4188 Entering \"end\" on a line by itself is the normal way to terminate\n\
4190 Note: the \"end\" command cannot be used at the gdb prompt."));
4192 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4193 Specify single-stepping behavior at a tracepoint.\n\
4194 Argument is number of instructions to trace in single-step mode\n\
4195 following the tracepoint. This command is normally followed by\n\
4196 one or more \"collect\" commands, to specify what to collect\n\
4197 while single-stepping.\n\n\
4198 Note: this command can only be used in a tracepoint \"actions\" list."));
4200 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4201 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4203 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4204 Specify one or more data items to be collected at a tracepoint.\n\
4205 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4206 collect all data (variables, registers) referenced by that expression.\n\
4207 Also accepts the following special arguments:\n\
4208 $regs -- all registers.\n\
4209 $args -- all function arguments.\n\
4210 $locals -- all variables local to the block/function scope.\n\
4211 Note: this command can only be used in a tracepoint \"actions\" list."));
4213 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4214 Specify one or more expressions to be evaluated at a tracepoint.\n\
4215 Accepts a comma-separated list of (one or more) expressions.\n\
4216 The result of each evaluation will be discarded.\n\
4217 Note: this command can only be used in a tracepoint \"actions\" list."));
4219 add_com ("actions", class_trace
, trace_actions_command
, _("\
4220 Specify the actions to be taken at a tracepoint.\n\
4221 Tracepoint actions may include collecting of specified data, \n\
4222 single-stepping, or enabling/disabling other tracepoints, \n\
4223 depending on target's capabilities."));
4225 default_collect
= xstrdup ("");
4226 add_setshow_string_cmd ("default-collect", class_trace
,
4227 &default_collect
, _("\
4228 Set the list of expressions to collect by default"), _("\
4229 Show the list of expressions to collect by default"), NULL
,
4231 &setlist
, &showlist
);
4233 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4234 &disconnected_tracing
, _("\
4235 Set whether tracing continues after GDB disconnects."), _("\
4236 Show whether tracing continues after GDB disconnects."), _("\
4237 Use this to continue a tracing run even if GDB disconnects\n\
4238 or detaches from the target. You can reconnect later and look at\n\
4239 trace data collected in the meantime."),
4240 set_disconnected_tracing
,
4245 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4246 &circular_trace_buffer
, _("\
4247 Set target's use of circular trace buffer."), _("\
4248 Show target's use of circular trace buffer."), _("\
4249 Use this to make the trace buffer into a circular buffer,\n\
4250 which will discard traceframes (oldest first) instead of filling\n\
4251 up and stopping the trace run."),
4252 set_circular_trace_buffer
,
4259 add_target (&tfile_ops
);