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
));
371 /* Create a new variable. */
372 tsv
= create_trace_state_variable (internalvar_name (intvar
));
373 tsv
->initial_value
= initval
;
375 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
376 tsv
->name
, plongest (tsv
->initial_value
));
378 do_cleanups (old_chain
);
382 delete_trace_variable_command (char *args
, int from_tty
)
386 struct cleanup
*back_to
;
387 struct trace_state_variable
*tsv
;
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 (i
= 0; argv
[i
] != NULL
; i
++)
403 delete_trace_state_variable (argv
[i
] + 1);
405 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
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
, 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
, struct agent_reqs
*areqs
)
564 /* All of the "flaws" are serious bytecode generation issues that
565 should never occur. */
566 if (areqs
->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 (areqs
->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 (areqs
->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
;
595 struct agent_reqs areqs
;
597 /* if EOF is typed, *line is NULL */
601 for (p
= *line
; isspace ((int) *p
);)
604 /* Symbol lookup etc. */
605 if (*p
== '\0') /* empty line: just prompt for another line. */
608 if (*p
== '#') /* comment line */
611 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
613 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
615 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
618 { /* repeat over a comma-separated list */
619 QUIT
; /* allow user to bail out with ^C */
620 while (isspace ((int) *p
))
623 if (*p
== '$') /* look for special pseudo-symbols */
625 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
626 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
627 (0 == strncasecmp ("loc", p
+ 1, 3)))
632 /* else fall thru, treat p as an expression and parse it! */
635 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
638 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
639 old_chain
= make_cleanup (free_current_contents
, &exp
);
641 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
643 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
645 error (_("constant `%s' (value %ld) will not be collected."),
646 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
647 SYMBOL_VALUE (exp
->elts
[2].symbol
));
649 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
651 error (_("`%s' is optimized away and cannot be collected."),
652 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
656 /* We have something to collect, make sure that the expr to
657 bytecode translator can handle it and that it's not too
659 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
660 make_cleanup_free_agent_expr (aexpr
);
662 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
663 error (_("Expression is too complicated."));
665 ax_reqs (aexpr
, &areqs
);
666 (void) make_cleanup (xfree
, areqs
.reg_mask
);
668 report_agent_reqs_errors (aexpr
, &areqs
);
670 do_cleanups (old_chain
);
673 while (p
&& *p
++ == ',');
676 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
679 { /* repeat over a comma-separated list */
680 QUIT
; /* allow user to bail out with ^C */
681 while (isspace ((int) *p
))
685 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
688 /* Only expressions are allowed for this action. */
689 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
690 old_chain
= make_cleanup (free_current_contents
, &exp
);
692 /* We have something to evaluate, make sure that the expr to
693 bytecode translator can handle it and that it's not too
695 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
696 make_cleanup_free_agent_expr (aexpr
);
698 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
699 error (_("Expression is too complicated."));
701 ax_reqs (aexpr
, &areqs
);
702 (void) make_cleanup (xfree
, areqs
.reg_mask
);
704 report_agent_reqs_errors (aexpr
, &areqs
);
706 do_cleanups (old_chain
);
709 while (p
&& *p
++ == ',');
712 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
714 char *steparg
; /* in case warning is necessary */
716 while (isspace ((int) *p
))
720 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
721 error (_("while-stepping step count `%s' is malformed."), *line
);
724 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
728 error (_("`%s' is not a supported tracepoint action."), *line
);
732 memrange_absolute
= -1
737 int type
; /* memrange_absolute for absolute memory range,
738 else basereg number */
739 bfd_signed_vma start
;
743 struct collection_list
745 unsigned char regs_mask
[32]; /* room for up to 256 regs */
748 struct memrange
*list
;
749 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
751 struct agent_expr
**aexpr_list
;
754 tracepoint_list
, stepping_list
;
756 /* MEMRANGE functions: */
758 static int memrange_cmp (const void *, const void *);
760 /* compare memranges for qsort */
762 memrange_cmp (const void *va
, const void *vb
)
764 const struct memrange
*a
= va
, *b
= vb
;
766 if (a
->type
< b
->type
)
768 if (a
->type
> b
->type
)
770 if (a
->type
== memrange_absolute
)
772 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
774 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
779 if (a
->start
< b
->start
)
781 if (a
->start
> b
->start
)
787 /* Sort the memrange list using qsort, and merge adjacent memranges. */
789 memrange_sortmerge (struct collection_list
*memranges
)
793 qsort (memranges
->list
, memranges
->next_memrange
,
794 sizeof (struct memrange
), memrange_cmp
);
795 if (memranges
->next_memrange
> 0)
797 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
799 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
800 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
803 /* memrange b starts before memrange a ends; merge them. */
804 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
805 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
806 continue; /* next b, same a */
810 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
811 sizeof (struct memrange
));
813 memranges
->next_memrange
= a
+ 1;
817 /* Add a register to a collection list. */
819 add_register (struct collection_list
*collection
, unsigned int regno
)
822 printf_filtered ("collect register %d\n", regno
);
823 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
824 error (_("Internal: register number %d too large for tracepoint"),
826 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
829 /* Add a memrange to a collection list */
831 add_memrange (struct collection_list
*memranges
,
832 int type
, bfd_signed_vma base
,
837 printf_filtered ("(%d,", type
);
839 printf_filtered (",%ld)\n", len
);
842 /* type: memrange_absolute == memory, other n == basereg */
843 memranges
->list
[memranges
->next_memrange
].type
= type
;
844 /* base: addr if memory, offset if reg relative. */
845 memranges
->list
[memranges
->next_memrange
].start
= base
;
846 /* len: we actually save end (base + len) for convenience */
847 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
848 memranges
->next_memrange
++;
849 if (memranges
->next_memrange
>= memranges
->listsize
)
851 memranges
->listsize
*= 2;
852 memranges
->list
= xrealloc (memranges
->list
,
853 memranges
->listsize
);
856 if (type
!= memrange_absolute
) /* Better collect the base register! */
857 add_register (memranges
, type
);
860 /* Add a symbol to a collection list. */
862 collect_symbol (struct collection_list
*collect
,
864 struct gdbarch
*gdbarch
,
865 long frame_regno
, long frame_offset
,
870 bfd_signed_vma offset
;
871 int treat_as_expr
= 0;
873 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
874 switch (SYMBOL_CLASS (sym
))
877 printf_filtered ("%s: don't know symbol class %d\n",
878 SYMBOL_PRINT_NAME (sym
),
882 printf_filtered ("constant %s (value %ld) will not be collected.\n",
883 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
886 offset
= SYMBOL_VALUE_ADDRESS (sym
);
891 sprintf_vma (tmp
, offset
);
892 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
893 SYMBOL_PRINT_NAME (sym
), len
,
896 /* A struct may be a C++ class with static fields, go to general
897 expression handling. */
898 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
901 add_memrange (collect
, memrange_absolute
, offset
, len
);
904 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
906 printf_filtered ("LOC_REG[parm] %s: ",
907 SYMBOL_PRINT_NAME (sym
));
908 add_register (collect
, reg
);
909 /* Check for doubles stored in two registers. */
910 /* FIXME: how about larger types stored in 3 or more regs? */
911 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
912 len
> register_size (gdbarch
, reg
))
913 add_register (collect
, reg
+ 1);
916 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
917 printf_filtered (" (will not collect %s)\n",
918 SYMBOL_PRINT_NAME (sym
));
922 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
925 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
926 SYMBOL_PRINT_NAME (sym
), len
);
928 printf_filtered (" from frame ptr reg %d\n", reg
);
930 add_memrange (collect
, reg
, offset
, len
);
932 case LOC_REGPARM_ADDR
:
933 reg
= SYMBOL_VALUE (sym
);
937 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
938 SYMBOL_PRINT_NAME (sym
), len
);
940 printf_filtered (" from reg %d\n", reg
);
942 add_memrange (collect
, reg
, offset
, len
);
946 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
949 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
950 SYMBOL_PRINT_NAME (sym
), len
);
952 printf_filtered (" from frame ptr reg %d\n", reg
);
954 add_memrange (collect
, reg
, offset
, len
);
961 case LOC_OPTIMIZED_OUT
:
962 printf_filtered ("%s has been optimized out of existence.\n",
963 SYMBOL_PRINT_NAME (sym
));
971 /* Expressions are the most general case. */
974 struct agent_expr
*aexpr
;
975 struct cleanup
*old_chain1
= NULL
;
976 struct agent_reqs areqs
;
978 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
980 /* It can happen that the symbol is recorded as a computed
981 location, but it's been optimized away and doesn't actually
982 have a location expression. */
985 printf_filtered ("%s has been optimized out of existence.\n",
986 SYMBOL_PRINT_NAME (sym
));
990 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
992 ax_reqs (aexpr
, &areqs
);
994 report_agent_reqs_errors (aexpr
, &areqs
);
996 discard_cleanups (old_chain1
);
997 add_aexpr (collect
, aexpr
);
999 /* take care of the registers */
1000 if (areqs
.reg_mask_len
> 0)
1004 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1006 QUIT
; /* allow user to bail out with ^C */
1007 if (areqs
.reg_mask
[ndx1
] != 0)
1009 /* assume chars have 8 bits */
1010 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1011 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1012 /* it's used -- record it */
1013 add_register (collect
, ndx1
* 8 + ndx2
);
1020 /* Data to be passed around in the calls to the locals and args
1023 struct add_local_symbols_data
1025 struct collection_list
*collect
;
1026 struct gdbarch
*gdbarch
;
1033 /* The callback for the locals and args iterators */
1036 do_collect_symbol (const char *print_name
,
1040 struct add_local_symbols_data
*p
= cb_data
;
1042 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1043 p
->frame_offset
, p
->pc
);
1047 /* Add all locals (or args) symbols to collection list */
1049 add_local_symbols (struct collection_list
*collect
,
1050 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1051 long frame_regno
, long frame_offset
, int type
)
1053 struct block
*block
;
1054 struct add_local_symbols_data cb_data
;
1056 cb_data
.collect
= collect
;
1057 cb_data
.gdbarch
= gdbarch
;
1059 cb_data
.frame_regno
= frame_regno
;
1060 cb_data
.frame_offset
= frame_offset
;
1065 block
= block_for_pc (pc
);
1068 warning (_("Can't collect locals; "
1069 "no symbol table info available.\n"));
1073 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1074 if (cb_data
.count
== 0)
1075 warning (_("No locals found in scope."));
1079 pc
= get_pc_function_start (pc
);
1080 block
= block_for_pc (pc
);
1083 warning (_("Can't collect args; no symbol table info available.\n"));
1087 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1088 if (cb_data
.count
== 0)
1089 warning (_("No args found in scope."));
1093 /* worker function */
1095 clear_collection_list (struct collection_list
*list
)
1099 list
->next_memrange
= 0;
1100 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1102 free_agent_expr (list
->aexpr_list
[ndx
]);
1103 list
->aexpr_list
[ndx
] = NULL
;
1105 list
->next_aexpr_elt
= 0;
1106 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1109 /* reduce a collection list to string form (for gdb protocol) */
1111 stringify_collection_list (struct collection_list
*list
, char *string
)
1113 char temp_buf
[2048];
1117 char *(*str_list
)[];
1121 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1122 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1124 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1125 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1127 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1130 printf_filtered ("\nCollecting registers (mask): 0x");
1135 QUIT
; /* allow user to bail out with ^C */
1137 printf_filtered ("%02X", list
->regs_mask
[i
]);
1138 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1141 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1145 printf_filtered ("\n");
1146 if (list
->next_memrange
> 0 && info_verbose
)
1147 printf_filtered ("Collecting memranges: \n");
1148 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1150 QUIT
; /* allow user to bail out with ^C */
1151 sprintf_vma (tmp2
, list
->list
[i
].start
);
1154 printf_filtered ("(%d, %s, %ld)\n",
1157 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1159 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1161 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1168 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1170 /* The "%X" conversion specifier expects an unsigned argument,
1171 so passing -1 (memrange_absolute) to it directly gives you
1172 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1174 if (list
->list
[i
].type
== memrange_absolute
)
1175 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1177 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1180 count
+= strlen (end
);
1181 end
= temp_buf
+ count
;
1184 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1186 QUIT
; /* allow user to bail out with ^C */
1187 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1189 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1194 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1195 end
+= 10; /* 'X' + 8 hex digits + ',' */
1198 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1199 end
, list
->aexpr_list
[i
]->len
);
1200 count
+= 2 * list
->aexpr_list
[i
]->len
;
1205 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1210 (*str_list
)[ndx
] = NULL
;
1223 encode_actions_1 (struct command_line
*action
,
1224 struct breakpoint
*t
,
1225 struct bp_location
*tloc
,
1227 LONGEST frame_offset
,
1228 struct collection_list
*collect
,
1229 struct collection_list
*stepping_list
)
1232 struct expression
*exp
= NULL
;
1233 struct command_line
*actions
;
1235 struct value
*tempval
;
1236 struct cmd_list_element
*cmd
;
1237 struct agent_expr
*aexpr
;
1239 for (; action
; action
= action
->next
)
1241 QUIT
; /* allow user to bail out with ^C */
1242 action_exp
= action
->line
;
1243 while (isspace ((int) *action_exp
))
1246 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1248 error (_("Bad action list item: %s"), action_exp
);
1250 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1253 { /* repeat over a comma-separated list */
1254 QUIT
; /* allow user to bail out with ^C */
1255 while (isspace ((int) *action_exp
))
1258 if (0 == strncasecmp ("$reg", action_exp
, 4))
1260 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1261 add_register (collect
, i
);
1262 action_exp
= strchr (action_exp
, ','); /* more? */
1264 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1266 add_local_symbols (collect
,
1272 action_exp
= strchr (action_exp
, ','); /* more? */
1274 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1276 add_local_symbols (collect
,
1282 action_exp
= strchr (action_exp
, ','); /* more? */
1286 unsigned long addr
, len
;
1287 struct cleanup
*old_chain
= NULL
;
1288 struct cleanup
*old_chain1
= NULL
;
1289 struct agent_reqs areqs
;
1291 exp
= parse_exp_1 (&action_exp
,
1292 block_for_pc (tloc
->address
), 1);
1293 old_chain
= make_cleanup (free_current_contents
, &exp
);
1295 switch (exp
->elts
[0].opcode
)
1299 const char *name
= &exp
->elts
[2].string
;
1301 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1302 name
, strlen (name
));
1304 internal_error (__FILE__
, __LINE__
,
1305 _("Register $%s not available"),
1308 printf_filtered ("OP_REGISTER: ");
1309 add_register (collect
, i
);
1314 /* safe because we know it's a simple expression */
1315 tempval
= evaluate_expression (exp
);
1316 addr
= value_address (tempval
);
1317 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1318 add_memrange (collect
, memrange_absolute
, addr
, len
);
1322 collect_symbol (collect
,
1323 exp
->elts
[2].symbol
,
1330 default: /* full-fledged expression */
1331 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1333 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1335 ax_reqs (aexpr
, &areqs
);
1337 report_agent_reqs_errors (aexpr
, &areqs
);
1339 discard_cleanups (old_chain1
);
1340 add_aexpr (collect
, aexpr
);
1342 /* take care of the registers */
1343 if (areqs
.reg_mask_len
> 0)
1348 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1350 QUIT
; /* allow user to bail out with ^C */
1351 if (areqs
.reg_mask
[ndx1
] != 0)
1353 /* assume chars have 8 bits */
1354 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1355 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1356 /* it's used -- record it */
1357 add_register (collect
,
1364 do_cleanups (old_chain
);
1367 while (action_exp
&& *action_exp
++ == ',');
1369 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1372 { /* repeat over a comma-separated list */
1373 QUIT
; /* allow user to bail out with ^C */
1374 while (isspace ((int) *action_exp
))
1378 unsigned long addr
, len
;
1379 struct cleanup
*old_chain
= NULL
;
1380 struct cleanup
*old_chain1
= NULL
;
1381 struct agent_reqs areqs
;
1383 exp
= parse_exp_1 (&action_exp
,
1384 block_for_pc (tloc
->address
), 1);
1385 old_chain
= make_cleanup (free_current_contents
, &exp
);
1387 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1388 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1390 ax_reqs (aexpr
, &areqs
);
1392 report_agent_reqs_errors (aexpr
, &areqs
);
1394 discard_cleanups (old_chain1
);
1395 /* Even though we're not officially collecting, add
1396 to the collect list anyway. */
1397 add_aexpr (collect
, aexpr
);
1399 do_cleanups (old_chain
);
1402 while (action_exp
&& *action_exp
++ == ',');
1404 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1406 /* We check against nested while-stepping when setting
1407 breakpoint action, so no way to run into nested
1409 gdb_assert (stepping_list
);
1411 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1412 stepping_list
, NULL
);
1415 error (_("Invalid tracepoint command '%s'"), action
->line
);
1419 /* Render all actions into gdb protocol. */
1421 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1422 char ***tdp_actions
, char ***stepping_actions
)
1424 static char tdp_buff
[2048], step_buff
[2048];
1425 char *default_collect_line
= NULL
;
1426 struct command_line
*actions
;
1427 struct command_line
*default_collect_action
= NULL
;
1429 LONGEST frame_offset
;
1430 struct cleanup
*back_to
;
1432 back_to
= make_cleanup (null_cleanup
, NULL
);
1434 clear_collection_list (&tracepoint_list
);
1435 clear_collection_list (&stepping_list
);
1437 *tdp_actions
= NULL
;
1438 *stepping_actions
= NULL
;
1440 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1441 t
->loc
->address
, &frame_reg
, &frame_offset
);
1443 actions
= breakpoint_commands (t
);
1445 /* If there are default expressions to collect, make up a collect
1446 action and prepend to the action list to encode. Note that since
1447 validation is per-tracepoint (local var "xyz" might be valid for
1448 one tracepoint and not another, etc), we make up the action on
1449 the fly, and don't cache it. */
1450 if (*default_collect
)
1454 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1455 make_cleanup (xfree
, default_collect_line
);
1457 line
= default_collect_line
;
1458 validate_actionline (&line
, t
);
1460 default_collect_action
= xmalloc (sizeof (struct command_line
));
1461 make_cleanup (xfree
, default_collect_action
);
1462 default_collect_action
->next
= actions
;
1463 default_collect_action
->line
= line
;
1464 actions
= default_collect_action
;
1466 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1467 &tracepoint_list
, &stepping_list
);
1469 memrange_sortmerge (&tracepoint_list
);
1470 memrange_sortmerge (&stepping_list
);
1472 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1474 *stepping_actions
= stringify_collection_list (&stepping_list
,
1477 do_cleanups (back_to
);
1481 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1483 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1485 collect
->aexpr_list
=
1486 xrealloc (collect
->aexpr_list
,
1487 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1488 collect
->aexpr_listsize
*= 2;
1490 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1491 collect
->next_aexpr_elt
++;
1496 start_tracing (void)
1499 VEC(breakpoint_p
) *tp_vec
= NULL
;
1501 struct breakpoint
*t
;
1502 struct trace_state_variable
*tsv
;
1503 int any_enabled
= 0;
1505 tp_vec
= all_tracepoints ();
1507 /* No point in tracing without any tracepoints... */
1508 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1510 VEC_free (breakpoint_p
, tp_vec
);
1511 error (_("No tracepoints defined, not starting trace"));
1514 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1516 if (t
->enable_state
== bp_enabled
)
1523 /* No point in tracing with only disabled tracepoints. */
1526 VEC_free (breakpoint_p
, tp_vec
);
1527 error (_("No tracepoints enabled, not starting trace"));
1530 target_trace_init ();
1532 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1534 t
->number_on_target
= 0;
1535 target_download_tracepoint (t
);
1536 t
->number_on_target
= t
->number
;
1538 VEC_free (breakpoint_p
, tp_vec
);
1540 /* Send down all the trace state variables too. */
1541 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1543 target_download_trace_state_variable (tsv
);
1546 /* Tell target to treat text-like sections as transparent. */
1547 target_trace_set_readonly_regions ();
1548 /* Set some mode flags. */
1549 target_set_disconnected_tracing (disconnected_tracing
);
1550 target_set_circular_trace_buffer (circular_trace_buffer
);
1552 /* Now insert traps and begin collecting data. */
1553 target_trace_start ();
1555 /* Reset our local state. */
1556 set_traceframe_num (-1);
1557 set_tracepoint_num (-1);
1558 set_traceframe_context (NULL
);
1559 current_trace_status()->running
= 1;
1564 Tell target to clear any previous trace experiment.
1565 Walk the list of tracepoints, and send them (and their actions)
1566 to the target. If no errors,
1567 Tell target to start a new trace experiment. */
1570 trace_start_command (char *args
, int from_tty
)
1572 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1574 if (current_trace_status ()->running
)
1577 && !query (_("A trace is running already. Start a new run? ")))
1578 error (_("New trace run not started."));
1586 trace_stop_command (char *args
, int from_tty
)
1588 if (!current_trace_status ()->running
)
1589 error (_("Trace is not running."));
1597 target_trace_stop ();
1598 /* should change in response to reply? */
1599 current_trace_status ()->running
= 0;
1602 /* tstatus command */
1604 trace_status_command (char *args
, int from_tty
)
1606 struct trace_status
*ts
= current_trace_status ();
1609 status
= target_get_trace_status (ts
);
1614 printf_filtered (_("Using a trace file.\n"));
1617 printf_filtered (_("Trace can not be run on this target.\n"));
1622 if (!ts
->running_known
)
1624 printf_filtered (_("Run/stop status is unknown.\n"));
1626 else if (ts
->running
)
1628 printf_filtered (_("Trace is running on the target.\n"));
1632 switch (ts
->stop_reason
)
1634 case trace_never_run
:
1635 printf_filtered (_("No trace has been run on the target.\n"));
1638 printf_filtered (_("Trace stopped by a tstop command.\n"));
1640 case trace_buffer_full
:
1641 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1643 case trace_disconnected
:
1644 printf_filtered (_("Trace stopped because of disconnection.\n"));
1646 case tracepoint_passcount
:
1647 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1648 ts
->stopping_tracepoint
);
1650 case tracepoint_error
:
1651 if (ts
->stopping_tracepoint
)
1652 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1653 ts
->error_desc
, ts
->stopping_tracepoint
);
1655 printf_filtered (_("Trace stopped by an error (%s).\n"),
1658 case trace_stop_reason_unknown
:
1659 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1662 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1668 if (ts
->traceframes_created
>= 0
1669 && ts
->traceframe_count
!= ts
->traceframes_created
)
1671 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1672 ts
->traceframe_count
, ts
->traceframes_created
);
1674 else if (ts
->traceframe_count
>= 0)
1676 printf_filtered (_("Collected %d trace frames.\n"),
1677 ts
->traceframe_count
);
1680 if (ts
->buffer_free
>= 0)
1682 if (ts
->buffer_size
>= 0)
1684 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1685 ts
->buffer_free
, ts
->buffer_size
);
1686 if (ts
->buffer_size
> 0)
1687 printf_filtered (_(" (%d%% full)"),
1688 ((int) ((((long long) (ts
->buffer_size
1689 - ts
->buffer_free
)) * 100)
1690 / ts
->buffer_size
)));
1691 printf_filtered (_(".\n"));
1694 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1698 if (ts
->disconnected_tracing
)
1699 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1701 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1703 if (ts
->circular_buffer
)
1704 printf_filtered (_("Trace buffer is circular.\n"));
1706 /* Now report on what we're doing with tfind. */
1707 if (traceframe_number
>= 0)
1708 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1709 traceframe_number
, tracepoint_number
);
1711 printf_filtered (_("Not looking at any trace frame.\n"));
1714 /* Report the trace status to uiout, in a way suitable for MI, and not
1715 suitable for CLI. If ON_STOP is true, suppress a few fields that
1716 are not meaningful in the -trace-stop response.
1718 The implementation is essentially parallel to trace_status_command, but
1719 merging them will result in unreadable code. */
1721 trace_status_mi (int on_stop
)
1723 struct trace_status
*ts
= current_trace_status ();
1725 char *string_status
;
1727 status
= target_get_trace_status (ts
);
1729 if (status
== -1 && !ts
->from_file
)
1731 ui_out_field_string (uiout
, "supported", "0");
1736 ui_out_field_string (uiout
, "supported", "file");
1738 ui_out_field_string (uiout
, "supported", "1");
1740 gdb_assert (ts
->running_known
);
1744 ui_out_field_string (uiout
, "running", "1");
1746 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1747 Given that the frontend gets the status either on -trace-stop, or from
1748 -trace-status after re-connection, it does not seem like this
1749 information is necessary for anything. It is not necessary for either
1750 figuring the vital state of the target nor for navigation of trace
1751 frames. If the frontend wants to show the current state is some
1752 configure dialog, it can request the value when such dialog is
1753 invoked by the user. */
1757 char *stop_reason
= NULL
;
1758 int stopping_tracepoint
= -1;
1761 ui_out_field_string (uiout
, "running", "0");
1763 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1765 switch (ts
->stop_reason
)
1768 stop_reason
= "request";
1770 case trace_buffer_full
:
1771 stop_reason
= "overflow";
1773 case trace_disconnected
:
1774 stop_reason
= "disconnection";
1776 case tracepoint_passcount
:
1777 stop_reason
= "passcount";
1778 stopping_tracepoint
= ts
->stopping_tracepoint
;
1780 case tracepoint_error
:
1781 stop_reason
= "error";
1782 stopping_tracepoint
= ts
->stopping_tracepoint
;
1788 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1789 if (stopping_tracepoint
!= -1)
1790 ui_out_field_int (uiout
, "stopping-tracepoint",
1791 stopping_tracepoint
);
1792 if (ts
->stop_reason
== tracepoint_error
)
1793 ui_out_field_string (uiout
, "error-description",
1799 if (ts
->traceframe_count
!= -1)
1800 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1801 if (ts
->traceframes_created
!= -1)
1802 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1803 if (ts
->buffer_size
!= -1)
1804 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1805 if (ts
->buffer_free
!= -1)
1806 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1808 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1809 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1812 /* This function handles the details of what to do about an ongoing
1813 tracing run if the user has asked to detach or otherwise disconnect
1816 disconnect_tracing (int from_tty
)
1818 /* It can happen that the target that was tracing went away on its
1819 own, and we didn't notice. Get a status update, and if the
1820 current target doesn't even do tracing, then assume it's not
1822 if (target_get_trace_status (current_trace_status ()) < 0)
1823 current_trace_status ()->running
= 0;
1825 /* If running interactively, give the user the option to cancel and
1826 then decide what to do differently with the run. Scripts are
1827 just going to disconnect and let the target deal with it,
1828 according to how it's been instructed previously via
1829 disconnected-tracing. */
1830 if (current_trace_status ()->running
&& from_tty
)
1832 if (current_trace_status ()->disconnected_tracing
)
1834 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1835 error (_("Not confirmed."));
1839 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1840 error (_("Not confirmed."));
1844 /* Also we want to be out of tfind mode, otherwise things can get
1845 confusing upon reconnection. Just use these calls instead of
1846 full tfind_1 behavior because we're in the middle of detaching,
1847 and there's no point to updating current stack frame etc. */
1848 set_traceframe_number (-1);
1849 set_traceframe_context (NULL
);
1852 /* Worker function for the various flavors of the tfind command. */
1854 tfind_1 (enum trace_find_type type
, int num
,
1855 ULONGEST addr1
, ULONGEST addr2
,
1858 int target_frameno
= -1, target_tracept
= -1;
1859 struct frame_id old_frame_id
= null_frame_id
;
1861 struct breakpoint
*tp
;
1863 /* Only try to get the current stack frame if we have a chance of
1864 succeeding. In particular, if we're trying to get a first trace
1865 frame while all threads are running, it's not going to succeed,
1866 so leave it with a default value and let the frame comparison
1867 below (correctly) decide to print out the source location of the
1869 if (!(type
== tfind_number
&& num
== -1)
1870 && (has_stack_frames () || traceframe_number
>= 0))
1871 old_frame_id
= get_frame_id (get_current_frame ());
1873 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1876 if (type
== tfind_number
1878 && target_frameno
== -1)
1880 /* We told the target to get out of tfind mode, and it did. */
1882 else if (target_frameno
== -1)
1884 /* A request for a non-existent trace frame has failed.
1885 Our response will be different, depending on FROM_TTY:
1887 If FROM_TTY is true, meaning that this command was
1888 typed interactively by the user, then give an error
1889 and DO NOT change the state of traceframe_number etc.
1891 However if FROM_TTY is false, meaning that we're either
1892 in a script, a loop, or a user-defined command, then
1893 DON'T give an error, but DO change the state of
1894 traceframe_number etc. to invalid.
1896 The rationalle is that if you typed the command, you
1897 might just have committed a typo or something, and you'd
1898 like to NOT lose your current debugging state. However
1899 if you're in a user-defined command or especially in a
1900 loop, then you need a way to detect that the command
1901 failed WITHOUT aborting. This allows you to write
1902 scripts that search thru the trace buffer until the end,
1903 and then continue on to do something else. */
1906 error (_("Target failed to find requested trace frame."));
1910 printf_filtered ("End of trace buffer.\n");
1911 #if 0 /* dubious now? */
1912 /* The following will not recurse, since it's
1914 trace_find_command ("-1", from_tty
);
1919 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1921 reinit_frame_cache ();
1922 registers_changed ();
1923 target_dcache_invalidate ();
1924 set_traceframe_num (target_frameno
);
1925 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1926 if (target_frameno
== -1)
1927 set_traceframe_context (NULL
);
1929 set_traceframe_context (get_current_frame ());
1931 if (traceframe_number
>= 0)
1933 /* Use different branches for MI and CLI to make CLI messages
1935 if (ui_out_is_mi_like_p (uiout
))
1937 ui_out_field_string (uiout
, "found", "1");
1938 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1939 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1943 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1944 traceframe_number
, tracepoint_number
);
1949 if (ui_out_is_mi_like_p (uiout
))
1950 ui_out_field_string (uiout
, "found", "0");
1952 printf_unfiltered (_("No trace frame found"));
1955 /* If we're in nonstop mode and getting out of looking at trace
1956 frames, there won't be any current frame to go back to and
1959 && (has_stack_frames () || traceframe_number
>= 0))
1961 enum print_what print_what
;
1963 /* NOTE: in imitation of the step command, try to determine
1964 whether we have made a transition from one function to
1965 another. If so, we'll print the "stack frame" (ie. the new
1966 function and it's arguments) -- otherwise we'll just show the
1969 if (frame_id_eq (old_frame_id
,
1970 get_frame_id (get_current_frame ())))
1971 print_what
= SRC_LINE
;
1973 print_what
= SRC_AND_LOC
;
1975 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1980 /* trace_find_command takes a trace frame number n,
1981 sends "QTFrame:<n>" to the target,
1982 and accepts a reply that may contain several optional pieces
1983 of information: a frame number, a tracepoint number, and an
1984 indication of whether this is a trap frame or a stepping frame.
1986 The minimal response is just "OK" (which indicates that the
1987 target does not give us a frame number or a tracepoint number).
1988 Instead of that, the target may send us a string containing
1990 F<hexnum> (gives the selected frame number)
1991 T<hexnum> (gives the selected tracepoint number)
1996 trace_find_command (char *args
, int from_tty
)
1997 { /* this should only be called with a numeric argument */
2000 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2001 error ("May not look at trace frames while trace is running.");
2003 if (args
== 0 || *args
== 0)
2004 { /* TFIND with no args means find NEXT trace frame. */
2005 if (traceframe_number
== -1)
2006 frameno
= 0; /* "next" is first one */
2008 frameno
= traceframe_number
+ 1;
2010 else if (0 == strcmp (args
, "-"))
2012 if (traceframe_number
== -1)
2013 error (_("not debugging trace buffer"));
2014 else if (from_tty
&& traceframe_number
== 0)
2015 error (_("already at start of trace buffer"));
2017 frameno
= traceframe_number
- 1;
2019 /* A hack to work around eval's need for fp to have been collected. */
2020 else if (0 == strcmp (args
, "-1"))
2023 frameno
= parse_and_eval_long (args
);
2026 error (_("invalid input (%d is less than zero)"), frameno
);
2028 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2033 trace_find_end_command (char *args
, int from_tty
)
2035 trace_find_command ("-1", from_tty
);
2040 trace_find_none_command (char *args
, int from_tty
)
2042 trace_find_command ("-1", from_tty
);
2047 trace_find_start_command (char *args
, int from_tty
)
2049 trace_find_command ("0", from_tty
);
2052 /* tfind pc command */
2054 trace_find_pc_command (char *args
, int from_tty
)
2059 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2060 error ("May not look at trace frames while trace is running.");
2062 if (args
== 0 || *args
== 0)
2063 pc
= regcache_read_pc (get_current_regcache ());
2065 pc
= parse_and_eval_address (args
);
2067 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2070 /* tfind tracepoint command */
2072 trace_find_tracepoint_command (char *args
, int from_tty
)
2075 struct breakpoint
*tp
;
2077 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2078 error ("May not look at trace frames while trace is running.");
2080 if (args
== 0 || *args
== 0)
2082 if (tracepoint_number
== -1)
2083 error (_("No current tracepoint -- please supply an argument."));
2085 tdp
= tracepoint_number
; /* default is current TDP */
2088 tdp
= parse_and_eval_long (args
);
2090 /* If we have the tracepoint on hand, use the number that the
2091 target knows about (which may be different if we disconnected
2092 and reconnected). */
2093 tp
= get_tracepoint (tdp
);
2095 tdp
= tp
->number_on_target
;
2097 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2100 /* TFIND LINE command:
2102 This command will take a sourceline for argument, just like BREAK
2103 or TRACE (ie. anything that "decode_line_1" can handle).
2105 With no argument, this command will find the next trace frame
2106 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2109 trace_find_line_command (char *args
, int from_tty
)
2111 static CORE_ADDR start_pc
, end_pc
;
2112 struct symtabs_and_lines sals
;
2113 struct symtab_and_line sal
;
2114 struct cleanup
*old_chain
;
2115 char startpc_str
[40], endpc_str
[40];
2117 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2118 error ("May not look at trace frames while trace is running.");
2120 if (args
== 0 || *args
== 0)
2122 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2124 sals
.sals
= (struct symtab_and_line
*)
2125 xmalloc (sizeof (struct symtab_and_line
));
2130 sals
= decode_line_spec (args
, 1);
2134 old_chain
= make_cleanup (xfree
, sals
.sals
);
2135 if (sal
.symtab
== 0)
2136 error (_("No line number information available."));
2138 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2140 if (start_pc
== end_pc
)
2142 printf_filtered ("Line %d of \"%s\"",
2143 sal
.line
, sal
.symtab
->filename
);
2145 printf_filtered (" is at address ");
2146 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2148 printf_filtered (" but contains no code.\n");
2149 sal
= find_pc_line (start_pc
, 0);
2151 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2152 && start_pc
!= end_pc
)
2153 printf_filtered ("Attempting to find line %d instead.\n",
2156 error (_("Cannot find a good line."));
2160 /* Is there any case in which we get here, and have an address
2161 which the user would want to see? If we have debugging
2162 symbols and no line numbers? */
2163 error (_("Line number %d is out of range for \"%s\"."),
2164 sal
.line
, sal
.symtab
->filename
);
2166 /* Find within range of stated line. */
2168 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2170 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2171 do_cleanups (old_chain
);
2174 /* tfind range command */
2176 trace_find_range_command (char *args
, int from_tty
)
2178 static CORE_ADDR start
, stop
;
2179 char start_str
[40], stop_str
[40];
2182 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2183 error ("May not look at trace frames while trace is running.");
2185 if (args
== 0 || *args
== 0)
2186 { /* XXX FIXME: what should default behavior be? */
2187 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2191 if (0 != (tmp
= strchr (args
, ',')))
2193 *tmp
++ = '\0'; /* terminate start address */
2194 while (isspace ((int) *tmp
))
2196 start
= parse_and_eval_address (args
);
2197 stop
= parse_and_eval_address (tmp
);
2200 { /* no explicit end address? */
2201 start
= parse_and_eval_address (args
);
2202 stop
= start
+ 1; /* ??? */
2205 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2208 /* tfind outside command */
2210 trace_find_outside_command (char *args
, int from_tty
)
2212 CORE_ADDR start
, stop
;
2213 char start_str
[40], stop_str
[40];
2216 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2217 error ("May not look at trace frames while trace is running.");
2219 if (args
== 0 || *args
== 0)
2220 { /* XXX FIXME: what should default behavior be? */
2221 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2225 if (0 != (tmp
= strchr (args
, ',')))
2227 *tmp
++ = '\0'; /* terminate start address */
2228 while (isspace ((int) *tmp
))
2230 start
= parse_and_eval_address (args
);
2231 stop
= parse_and_eval_address (tmp
);
2234 { /* no explicit end address? */
2235 start
= parse_and_eval_address (args
);
2236 stop
= start
+ 1; /* ??? */
2239 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2242 /* info scope command: list the locals for a scope. */
2244 scope_info (char *args
, int from_tty
)
2246 struct symtabs_and_lines sals
;
2248 struct minimal_symbol
*msym
;
2249 struct block
*block
;
2250 char **canonical
, *symname
, *save_args
= args
;
2251 struct dict_iterator iter
;
2253 struct gdbarch
*gdbarch
;
2256 if (args
== 0 || *args
== 0)
2257 error (_("requires an argument (function, line or *addr) to define a scope"));
2259 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2260 if (sals
.nelts
== 0)
2261 return; /* presumably decode_line_1 has already warned */
2263 /* Resolve line numbers to PC */
2264 resolve_sal_pc (&sals
.sals
[0]);
2265 block
= block_for_pc (sals
.sals
[0].pc
);
2269 QUIT
; /* allow user to bail out with ^C */
2270 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2272 QUIT
; /* allow user to bail out with ^C */
2274 printf_filtered ("Scope for %s:\n", save_args
);
2277 symname
= SYMBOL_PRINT_NAME (sym
);
2278 if (symname
== NULL
|| *symname
== '\0')
2279 continue; /* probably botched, certainly useless */
2281 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2283 printf_filtered ("Symbol %s is ", symname
);
2284 switch (SYMBOL_CLASS (sym
))
2287 case LOC_UNDEF
: /* messed up symbol? */
2288 printf_filtered ("a bogus symbol, class %d.\n",
2289 SYMBOL_CLASS (sym
));
2290 count
--; /* don't count this one */
2293 printf_filtered ("a constant with value %ld (0x%lx)",
2294 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2296 case LOC_CONST_BYTES
:
2297 printf_filtered ("constant bytes: ");
2298 if (SYMBOL_TYPE (sym
))
2299 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2300 fprintf_filtered (gdb_stdout
, " %02x",
2301 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2304 printf_filtered ("in static storage at address ");
2305 printf_filtered ("%s", paddress (gdbarch
,
2306 SYMBOL_VALUE_ADDRESS (sym
)));
2309 /* GDBARCH is the architecture associated with the objfile
2310 the symbol is defined in; the target architecture may be
2311 different, and may provide additional registers. However,
2312 we do not know the target architecture at this point.
2313 We assume the objfile architecture will contain all the
2314 standard registers that occur in debug info in that
2316 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2318 if (SYMBOL_IS_ARGUMENT (sym
))
2319 printf_filtered ("an argument in register $%s",
2320 gdbarch_register_name (gdbarch
, regno
));
2322 printf_filtered ("a local variable in register $%s",
2323 gdbarch_register_name (gdbarch
, regno
));
2326 printf_filtered ("an argument at stack/frame offset %ld",
2327 SYMBOL_VALUE (sym
));
2330 printf_filtered ("a local variable at frame offset %ld",
2331 SYMBOL_VALUE (sym
));
2334 printf_filtered ("a reference argument at offset %ld",
2335 SYMBOL_VALUE (sym
));
2337 case LOC_REGPARM_ADDR
:
2338 /* Note comment at LOC_REGISTER. */
2339 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2340 printf_filtered ("the address of an argument, in register $%s",
2341 gdbarch_register_name (gdbarch
, regno
));
2344 printf_filtered ("a typedef.\n");
2347 printf_filtered ("a label at address ");
2348 printf_filtered ("%s", paddress (gdbarch
,
2349 SYMBOL_VALUE_ADDRESS (sym
)));
2352 printf_filtered ("a function at address ");
2353 printf_filtered ("%s",
2354 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2356 case LOC_UNRESOLVED
:
2357 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2360 printf_filtered ("Unresolved Static");
2363 printf_filtered ("static storage at address ");
2364 printf_filtered ("%s",
2365 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2368 case LOC_OPTIMIZED_OUT
:
2369 printf_filtered ("optimized out.\n");
2372 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2375 if (SYMBOL_TYPE (sym
))
2376 printf_filtered (", length %d.\n",
2377 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2379 if (BLOCK_FUNCTION (block
))
2382 block
= BLOCK_SUPERBLOCK (block
);
2385 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2389 /* worker function (cleanup) */
2391 replace_comma (void *data
)
2398 /* Helper for trace_dump_command. Dump the action list starting at
2399 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2400 actions of the body of a while-stepping action. STEPPING_FRAME is
2401 set if the current traceframe was determined to be a while-stepping
2405 trace_dump_actions (struct command_line
*action
,
2406 int stepping_actions
, int stepping_frame
,
2409 char *action_exp
, *next_comma
;
2411 for (; action
!= NULL
; action
= action
->next
)
2413 struct cmd_list_element
*cmd
;
2415 QUIT
; /* allow user to bail out with ^C */
2416 action_exp
= action
->line
;
2417 while (isspace ((int) *action_exp
))
2420 /* The collection actions to be done while stepping are
2421 bracketed by the commands "while-stepping" and "end". */
2423 if (*action_exp
== '#') /* comment line */
2426 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2428 error (_("Bad action list item: %s"), action_exp
);
2430 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2434 for (i
= 0; i
< action
->body_count
; ++i
)
2435 trace_dump_actions (action
->body_list
[i
],
2436 1, stepping_frame
, from_tty
);
2438 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2440 /* Display the collected data.
2441 For the trap frame, display only what was collected at
2442 the trap. Likewise for stepping frames, display only
2443 what was collected while stepping. This means that the
2444 two boolean variables, STEPPING_FRAME and
2445 STEPPING_ACTIONS should be equal. */
2446 if (stepping_frame
== stepping_actions
)
2449 { /* repeat over a comma-separated list */
2450 QUIT
; /* allow user to bail out with ^C */
2451 if (*action_exp
== ',')
2453 while (isspace ((int) *action_exp
))
2456 next_comma
= strchr (action_exp
, ',');
2458 if (0 == strncasecmp (action_exp
, "$reg", 4))
2459 registers_info (NULL
, from_tty
);
2460 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2461 locals_info (NULL
, from_tty
);
2462 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2463 args_info (NULL
, from_tty
);
2468 make_cleanup (replace_comma
, next_comma
);
2471 printf_filtered ("%s = ", action_exp
);
2472 output_command (action_exp
, from_tty
);
2473 printf_filtered ("\n");
2477 action_exp
= next_comma
;
2479 while (action_exp
&& *action_exp
== ',');
2485 /* The tdump command. */
2488 trace_dump_command (char *args
, int from_tty
)
2490 struct regcache
*regcache
;
2491 struct breakpoint
*t
;
2492 int stepping_frame
= 0;
2493 struct bp_location
*loc
;
2494 char *line
, *default_collect_line
= NULL
;
2495 struct command_line
*actions
, *default_collect_action
= NULL
;
2496 struct cleanup
*old_chain
= NULL
;
2498 if (tracepoint_number
== -1)
2500 warning (_("No current trace frame."));
2504 t
= get_tracepoint (tracepoint_number
);
2507 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2510 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2511 tracepoint_number
, traceframe_number
);
2513 /* The current frame is a trap frame if the frame PC is equal
2514 to the tracepoint PC. If not, then the current frame was
2515 collected during single-stepping. */
2517 regcache
= get_current_regcache ();
2519 /* If the traceframe's address matches any of the tracepoint's
2520 locations, assume it is a direct hit rather than a while-stepping
2521 frame. (FIXME this is not reliable, should record each frame's
2524 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2525 if (loc
->address
== regcache_read_pc (regcache
))
2528 actions
= breakpoint_commands (t
);
2530 /* If there is a default-collect list, make up a collect command,
2531 prepend to the tracepoint's commands, and pass the whole mess to
2532 the trace dump scanner. We need to validate because
2533 default-collect might have been junked since the trace run. */
2534 if (*default_collect
)
2536 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2537 old_chain
= make_cleanup (xfree
, default_collect_line
);
2538 line
= default_collect_line
;
2539 validate_actionline (&line
, t
);
2540 default_collect_action
= xmalloc (sizeof (struct command_line
));
2541 make_cleanup (xfree
, default_collect_action
);
2542 default_collect_action
->next
= actions
;
2543 default_collect_action
->line
= line
;
2544 actions
= default_collect_action
;
2547 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2549 if (*default_collect
)
2550 do_cleanups (old_chain
);
2553 /* Encode a piece of a tracepoint's source-level definition in a form
2554 that is suitable for both protocol and saving in files. */
2555 /* This version does not do multiple encodes for long strings; it should
2556 return an offset to the next piece to encode. FIXME */
2559 encode_source_string (int tpnum
, ULONGEST addr
,
2560 char *srctype
, char *src
, char *buf
, int buf_size
)
2562 if (80 + strlen (srctype
) > buf_size
)
2563 error (_("Buffer too small for source encoding"));
2564 sprintf (buf
, "%x:%s:%s:%x:%x:",
2565 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2566 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2567 error (_("Source string too long for buffer"));
2568 bin2hex (src
, buf
+ strlen (buf
), 0);
2572 extern int trace_regblock_size
;
2574 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2575 non-zero, the save is performed on the target, otherwise GDB obtains all
2576 trace data and saves it locally. */
2579 trace_save (const char *filename
, int target_does_save
)
2581 struct cleanup
*cleanup
;
2583 struct trace_status
*ts
= current_trace_status ();
2586 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2587 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2591 ULONGEST offset
= 0;
2592 #define MAX_TRACE_UPLOAD 2000
2593 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2596 /* If the target is to save the data to a file on its own, then just
2597 send the command and be done with it. */
2598 if (target_does_save
)
2600 err
= target_save_trace_data (filename
);
2602 error (_("Target failed to save trace data to '%s'."),
2607 /* Get the trace status first before opening the file, so if the
2608 target is losing, we can get out without touching files. */
2609 status
= target_get_trace_status (ts
);
2611 pathname
= tilde_expand (filename
);
2612 cleanup
= make_cleanup (xfree
, pathname
);
2614 fp
= fopen (pathname
, "w");
2616 error (_("Unable to open file '%s' for saving trace data (%s)"),
2617 filename
, safe_strerror (errno
));
2618 make_cleanup_fclose (fp
);
2620 /* Write a file header, with a high-bit-set char to indicate a
2621 binary file, plus a hint as what this file is, and a version
2622 number in case of future needs. */
2623 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2625 perror_with_name (pathname
);
2627 /* Write descriptive info. */
2629 /* Write out the size of a register block. */
2630 fprintf (fp
, "R %x\n", trace_regblock_size
);
2632 /* Write out status of the tracing run (aka "tstatus" info). */
2633 fprintf (fp
, "status %c;%s",
2634 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2635 if (ts
->stop_reason
== tracepoint_error
)
2637 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2638 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2639 fprintf (fp
, ":%s", buf
);
2641 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2642 if (ts
->traceframe_count
>= 0)
2643 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2644 if (ts
->traceframes_created
>= 0)
2645 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2646 if (ts
->buffer_free
>= 0)
2647 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2648 if (ts
->buffer_size
>= 0)
2649 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2650 if (ts
->disconnected_tracing
)
2651 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2652 if (ts
->circular_buffer
)
2653 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2656 /* Note that we want to upload tracepoints and save those, rather
2657 than simply writing out the local ones, because the user may have
2658 changed tracepoints in GDB in preparation for a future tracing
2659 run, or maybe just mass-deleted all types of breakpoints as part
2660 of cleaning up. So as not to contaminate the session, leave the
2661 data in its uploaded form, don't make into real tracepoints. */
2663 /* Get trace state variables first, they may be checked when parsing
2664 uploaded commands. */
2666 target_upload_trace_state_variables (&uploaded_tsvs
);
2668 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2674 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2675 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2678 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2679 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2680 utsv
->builtin
, buf
);
2686 free_uploaded_tsvs (&uploaded_tsvs
);
2688 target_upload_tracepoints (&uploaded_tps
);
2690 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2692 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2693 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2694 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2695 if (utp
->type
== bp_fast_tracepoint
)
2696 fprintf (fp
, ":F%x", utp
->orig_size
);
2698 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2701 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2702 fprintf (fp
, "tp A%x:%s:%s\n",
2703 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2704 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2705 fprintf (fp
, "tp S%x:%s:%s\n",
2706 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2709 encode_source_string (utp
->number
, utp
->addr
,
2710 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2711 fprintf (fp
, "tp Z%s\n", buf
);
2713 if (utp
->cond_string
)
2715 encode_source_string (utp
->number
, utp
->addr
,
2716 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2717 fprintf (fp
, "tp Z%s\n", buf
);
2719 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2721 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2722 buf
, MAX_TRACE_UPLOAD
);
2723 fprintf (fp
, "tp Z%s\n", buf
);
2727 free_uploaded_tps (&uploaded_tps
);
2729 /* Mark the end of the definition section. */
2732 /* Get and write the trace data proper. We ask for big blocks, in
2733 the hopes of efficiency, but will take less if the target has
2734 packet size limitations or some such. */
2737 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2739 error (_("Failure to get requested trace buffer data"));
2740 /* No more data is forthcoming, we're done. */
2743 written
= fwrite (buf
, gotten
, 1, fp
);
2745 perror_with_name (pathname
);
2749 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2750 written
= fwrite (&gotten
, 4, 1, fp
);
2752 perror_with_name (pathname
);
2754 do_cleanups (cleanup
);
2758 trace_save_command (char *args
, int from_tty
)
2760 int target_does_save
= 0;
2762 char *filename
= NULL
;
2763 struct cleanup
*back_to
;
2766 error_no_arg (_("file in which to save trace data"));
2768 argv
= gdb_buildargv (args
);
2769 back_to
= make_cleanup_freeargv (argv
);
2771 for (; *argv
; ++argv
)
2773 if (strcmp (*argv
, "-r") == 0)
2774 target_does_save
= 1;
2775 else if (**argv
== '-')
2776 error (_("unknown option `%s'"), *argv
);
2782 error_no_arg (_("file in which to save trace data"));
2784 trace_save (filename
, target_does_save
);
2787 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2789 do_cleanups (back_to
);
2792 /* Tell the target what to do with an ongoing tracing run if GDB
2793 disconnects for some reason. */
2796 send_disconnected_tracing_value (int value
)
2798 target_set_disconnected_tracing (value
);
2802 set_disconnected_tracing (char *args
, int from_tty
,
2803 struct cmd_list_element
*c
)
2805 send_disconnected_tracing_value (disconnected_tracing
);
2809 set_circular_trace_buffer (char *args
, int from_tty
,
2810 struct cmd_list_element
*c
)
2812 target_set_circular_trace_buffer (circular_trace_buffer
);
2815 /* Convert the memory pointed to by mem into hex, placing result in buf.
2816 * Return a pointer to the last char put in buf (null)
2817 * "stolen" from sparc-stub.c
2820 static const char hexchars
[] = "0123456789abcdef";
2823 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2831 *buf
++ = hexchars
[ch
>> 4];
2832 *buf
++ = hexchars
[ch
& 0xf];
2841 get_traceframe_number (void)
2843 return traceframe_number
;
2846 /* Make the traceframe NUM be the current trace frame. Does nothing
2847 if NUM is already current. */
2850 set_traceframe_number (int num
)
2854 if (traceframe_number
== num
)
2856 /* Nothing to do. */
2860 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2863 warning (_("could not change traceframe"));
2865 traceframe_number
= newnum
;
2867 /* Changing the traceframe changes our view of registers and of the
2869 registers_changed ();
2872 /* A cleanup used when switching away and back from tfind mode. */
2874 struct current_traceframe_cleanup
2876 /* The traceframe we were inspecting. */
2877 int traceframe_number
;
2881 do_restore_current_traceframe_cleanup (void *arg
)
2883 struct current_traceframe_cleanup
*old
= arg
;
2885 set_traceframe_number (old
->traceframe_number
);
2889 restore_current_traceframe_cleanup_dtor (void *arg
)
2891 struct current_traceframe_cleanup
*old
= arg
;
2897 make_cleanup_restore_current_traceframe (void)
2899 struct current_traceframe_cleanup
*old
;
2901 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2902 old
->traceframe_number
= traceframe_number
;
2904 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2905 restore_current_traceframe_cleanup_dtor
);
2908 /* Given a number and address, return an uploaded tracepoint with that
2909 number, creating if necessary. */
2911 struct uploaded_tp
*
2912 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2914 struct uploaded_tp
*utp
;
2916 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2917 if (utp
->number
== num
&& utp
->addr
== addr
)
2919 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2920 memset (utp
, 0, sizeof (struct uploaded_tp
));
2923 utp
->actions
= NULL
;
2924 utp
->step_actions
= NULL
;
2925 utp
->cmd_strings
= NULL
;
2932 free_uploaded_tps (struct uploaded_tp
**utpp
)
2934 struct uploaded_tp
*next_one
;
2938 next_one
= (*utpp
)->next
;
2944 /* Given a number and address, return an uploaded tracepoint with that
2945 number, creating if necessary. */
2947 struct uploaded_tsv
*
2948 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2950 struct uploaded_tsv
*utsv
;
2952 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2953 if (utsv
->number
== num
)
2955 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2956 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2958 utsv
->next
= *utsvp
;
2964 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2966 struct uploaded_tsv
*next_one
;
2970 next_one
= (*utsvp
)->next
;
2976 /* Look for an existing tracepoint that seems similar enough to the
2977 uploaded one. Enablement isn't compared, because the user can
2978 toggle that freely, and may have done so in anticipation of the
2982 find_matching_tracepoint (struct uploaded_tp
*utp
)
2984 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2986 struct breakpoint
*t
;
2987 struct bp_location
*loc
;
2989 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2991 if (t
->type
== utp
->type
2992 && t
->step_count
== utp
->step
2993 && t
->pass_count
== utp
->pass
2994 /* FIXME also test conditionals and actions */
2997 /* Scan the locations for an address match. */
2998 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
3000 if (loc
->address
== utp
->addr
)
3008 /* Given a list of tracepoints uploaded from a target, attempt to
3009 match them up with existing tracepoints, and create new ones if not
3013 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3015 struct uploaded_tp
*utp
;
3016 struct breakpoint
*t
;
3018 /* Look for GDB tracepoints that match up with our uploaded versions. */
3019 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3021 t
= find_matching_tracepoint (utp
);
3023 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3024 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3027 t
= create_tracepoint_from_upload (utp
);
3029 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3030 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3032 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3033 utp
->number
, paddress (get_current_arch (), utp
->addr
));
3035 /* Whether found or created, record the number used by the
3036 target, to help with mapping target tracepoints back to their
3037 counterparts here. */
3039 t
->number_on_target
= utp
->number
;
3042 free_uploaded_tps (uploaded_tps
);
3045 /* Trace state variables don't have much to identify them beyond their
3046 name, so just use that to detect matches. */
3048 struct trace_state_variable
*
3049 find_matching_tsv (struct uploaded_tsv
*utsv
)
3054 return find_trace_state_variable (utsv
->name
);
3057 struct trace_state_variable
*
3058 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3060 const char *namebase
;
3063 struct trace_state_variable
*tsv
;
3067 namebase
= utsv
->name
;
3068 sprintf (buf
, "%s", namebase
);
3073 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3076 /* Fish for a name that is not in use. */
3077 /* (should check against all internal vars?) */
3078 while (find_trace_state_variable (buf
))
3079 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3081 /* We have an available name, create the variable. */
3082 tsv
= create_trace_state_variable (xstrdup (buf
));
3083 tsv
->initial_value
= utsv
->initial_value
;
3084 tsv
->builtin
= utsv
->builtin
;
3089 /* Given a list of uploaded trace state variables, try to match them
3090 up with existing variables, or create additional ones. */
3093 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3096 struct uploaded_tsv
*utsv
;
3097 struct trace_state_variable
*tsv
;
3100 /* Most likely some numbers will have to be reassigned as part of
3101 the merge, so clear them all in anticipation. */
3102 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3105 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3107 tsv
= find_matching_tsv (utsv
);
3109 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3110 tsv
->name
, utsv
->number
);
3113 tsv
= create_tsv_from_upload (utsv
);
3114 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3115 tsv
->name
, utsv
->number
);
3117 /* Give precedence to numberings that come from the target. */
3119 tsv
->number
= utsv
->number
;
3122 /* Renumber everything that didn't get a target-assigned number. */
3124 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3125 if (tsv
->number
> highest
)
3126 highest
= tsv
->number
;
3129 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3130 if (tsv
->number
== 0)
3131 tsv
->number
= highest
++;
3133 free_uploaded_tsvs (uploaded_tsvs
);
3136 /* target tfile command */
3138 struct target_ops tfile_ops
;
3140 /* Fill in tfile_ops with its defined operations and properties. */
3142 #define TRACE_HEADER_SIZE 8
3144 char *trace_filename
;
3146 off_t trace_frames_offset
;
3149 int trace_regblock_size
;
3151 static void tfile_interp_line (char *line
,
3152 struct uploaded_tp
**utpp
,
3153 struct uploaded_tsv
**utsvp
);
3156 tfile_open (char *filename
, int from_tty
)
3159 struct cleanup
*old_chain
;
3162 char header
[TRACE_HEADER_SIZE
];
3163 char linebuf
[1000]; /* should be max remote packet size or so */
3165 int bytes
, i
, gotten
;
3166 struct trace_status
*ts
;
3167 struct uploaded_tp
*uploaded_tps
= NULL
;
3168 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3170 target_preopen (from_tty
);
3172 error (_("No trace file specified."));
3174 filename
= tilde_expand (filename
);
3175 if (!IS_ABSOLUTE_PATH(filename
))
3177 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3182 old_chain
= make_cleanup (xfree
, filename
);
3184 flags
= O_BINARY
| O_LARGEFILE
;
3186 scratch_chan
= open (filename
, flags
, 0);
3187 if (scratch_chan
< 0)
3188 perror_with_name (filename
);
3190 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3192 discard_cleanups (old_chain
); /* Don't free filename any more */
3193 unpush_target (&tfile_ops
);
3195 push_target (&tfile_ops
);
3197 trace_filename
= xstrdup (filename
);
3198 trace_fd
= scratch_chan
;
3201 /* Read the file header and test for validity. */
3202 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3204 perror_with_name (trace_filename
);
3205 else if (gotten
< TRACE_HEADER_SIZE
)
3206 error (_("Premature end of file while reading trace file"));
3208 bytes
+= TRACE_HEADER_SIZE
;
3209 if (!(header
[0] == 0x7f
3210 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3211 error (_("File is not a valid trace file."));
3213 trace_regblock_size
= 0;
3214 ts
= current_trace_status ();
3215 /* We know we're working with a file. */
3217 /* Set defaults in case there is no status line. */
3218 ts
->running_known
= 0;
3219 ts
->stop_reason
= trace_stop_reason_unknown
;
3220 ts
->traceframe_count
= -1;
3221 ts
->buffer_free
= 0;
3222 ts
->disconnected_tracing
= 0;
3223 ts
->circular_buffer
= 0;
3225 /* Read through a section of newline-terminated lines that
3226 define things like tracepoints. */
3230 gotten
= read (trace_fd
, &byte
, 1);
3232 perror_with_name (trace_filename
);
3233 else if (gotten
< 1)
3234 error (_("Premature end of file while reading trace file"));
3239 /* Empty line marks end of the definition section. */
3244 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3247 linebuf
[i
++] = byte
;
3249 error (_("Excessively long lines in trace file"));
3252 /* Add the file's tracepoints and variables into the current mix. */
3254 /* Get trace state variables first, they may be checked when parsing
3255 uploaded commands. */
3256 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3258 merge_uploaded_tracepoints (&uploaded_tps
);
3260 /* Record the starting offset of the binary trace data. */
3261 trace_frames_offset
= bytes
;
3263 /* If we don't have a blocksize, we can't interpret the
3265 if (trace_regblock_size
== 0)
3266 error (_("No register block size recorded in trace file"));
3267 if (ts
->traceframe_count
<= 0)
3269 warning ("No traceframes present in this file.");
3273 #define TFILE_PID (1)
3274 inferior_appeared (current_inferior (), TFILE_PID
);
3275 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3276 add_thread_silent (inferior_ptid
);
3278 post_create_inferior (&tfile_ops
, from_tty
);
3281 /* FIXME this will get defined in MI patch submission */
3282 tfind_1 (tfind_number
, 0, 0, 0, 0);
3286 /* Interpret the given line from the definitions part of the trace
3290 tfile_interp_line (char *line
,
3291 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3295 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3298 trace_regblock_size
= strtol (p
, &p
, 16);
3300 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3302 p
+= strlen ("status ");
3303 parse_trace_status (p
, current_trace_status ());
3305 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3307 p
+= strlen ("tp ");
3308 parse_tracepoint_definition (p
, utpp
);
3310 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3312 p
+= strlen ("tsv ");
3313 parse_tsv_definition (p
, utsvp
);
3316 warning ("Ignoring trace file definition \"%s\"", line
);
3319 /* Parse the part of trace status syntax that is shared between
3320 the remote protocol and the trace file reader. */
3322 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3325 parse_trace_status (char *line
, struct trace_status
*ts
)
3327 char *p
= line
, *p1
, *p2
, *p_temp
;
3330 ts
->running_known
= 1;
3331 ts
->running
= (*p
++ == '1');
3332 ts
->stop_reason
= trace_stop_reason_unknown
;
3333 xfree (ts
->error_desc
);
3334 ts
->error_desc
= NULL
;
3335 ts
->traceframe_count
= -1;
3336 ts
->traceframes_created
= -1;
3337 ts
->buffer_free
= -1;
3338 ts
->buffer_size
= -1;
3339 ts
->disconnected_tracing
= 0;
3340 ts
->circular_buffer
= 0;
3344 p1
= strchr (p
, ':');
3346 error (_("Malformed trace status, at %s\n\
3347 Status line: '%s'\n"), p
, line
);
3348 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3350 p
= unpack_varlen_hex (++p1
, &val
);
3351 ts
->stop_reason
= trace_buffer_full
;
3353 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3355 p
= unpack_varlen_hex (++p1
, &val
);
3356 ts
->stop_reason
= trace_never_run
;
3358 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3360 p
= unpack_varlen_hex (++p1
, &val
);
3361 ts
->stop_reason
= tracepoint_passcount
;
3362 ts
->stopping_tracepoint
= val
;
3364 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3366 p
= unpack_varlen_hex (++p1
, &val
);
3367 ts
->stop_reason
= tstop_command
;
3369 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3371 p
= unpack_varlen_hex (++p1
, &val
);
3372 ts
->stop_reason
= trace_disconnected
;
3374 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3376 p2
= strchr (++p1
, ':');
3381 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3382 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3383 ts
->error_desc
[end
] = '\0';
3386 ts
->error_desc
= xstrdup ("");
3388 p
= unpack_varlen_hex (++p2
, &val
);
3389 ts
->stopping_tracepoint
= val
;
3390 ts
->stop_reason
= tracepoint_error
;
3392 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3394 p
= unpack_varlen_hex (++p1
, &val
);
3395 ts
->traceframe_count
= val
;
3397 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3399 p
= unpack_varlen_hex (++p1
, &val
);
3400 ts
->traceframes_created
= val
;
3402 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3404 p
= unpack_varlen_hex (++p1
, &val
);
3405 ts
->buffer_free
= val
;
3407 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3409 p
= unpack_varlen_hex (++p1
, &val
);
3410 ts
->buffer_size
= val
;
3412 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3414 p
= unpack_varlen_hex (++p1
, &val
);
3415 ts
->disconnected_tracing
= val
;
3417 else if (strncmp (p
, "circular", p1
- p
) == 0)
3419 p
= unpack_varlen_hex (++p1
, &val
);
3420 ts
->circular_buffer
= val
;
3424 /* Silently skip unknown optional info. */
3425 p_temp
= strchr (p1
+ 1, ';');
3429 /* Must be at the end. */
3435 /* Given a line of text defining a part of a tracepoint, parse it into
3436 an "uploaded tracepoint". */
3439 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3443 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3444 int enabled
, i
, end
;
3446 char *cond
, *srctype
, *src
, *buf
;
3447 struct uploaded_tp
*utp
= NULL
;
3450 /* Both tracepoint and action definitions start with the same number
3451 and address sequence. */
3453 p
= unpack_varlen_hex (p
, &num
);
3454 p
++; /* skip a colon */
3455 p
= unpack_varlen_hex (p
, &addr
);
3456 p
++; /* skip a colon */
3459 enabled
= (*p
++ == 'E');
3460 p
++; /* skip a colon */
3461 p
= unpack_varlen_hex (p
, &step
);
3462 p
++; /* skip a colon */
3463 p
= unpack_varlen_hex (p
, &pass
);
3464 type
= bp_tracepoint
;
3466 /* Thumb through optional fields. */
3469 p
++; /* skip a colon */
3472 type
= bp_fast_tracepoint
;
3474 p
= unpack_varlen_hex (p
, &orig_size
);
3479 p
= unpack_varlen_hex (p
, &xlen
);
3480 p
++; /* skip a comma */
3481 cond
= (char *) xmalloc (2 * xlen
+ 1);
3482 strncpy (cond
, p
, 2 * xlen
);
3483 cond
[2 * xlen
] = '\0';
3487 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3489 utp
= get_uploaded_tp (num
, addr
, utpp
);
3491 utp
->enabled
= enabled
;
3496 else if (piece
== 'A')
3498 utp
= get_uploaded_tp (num
, addr
, utpp
);
3499 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3501 else if (piece
== 'S')
3503 utp
= get_uploaded_tp (num
, addr
, utpp
);
3504 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3506 else if (piece
== 'Z')
3508 /* Parse a chunk of source form definition. */
3509 utp
= get_uploaded_tp (num
, addr
, utpp
);
3511 p
= strchr (p
, ':');
3512 p
++; /* skip a colon */
3513 p
= unpack_varlen_hex (p
, &start
);
3514 p
++; /* skip a colon */
3515 p
= unpack_varlen_hex (p
, &xlen
);
3516 p
++; /* skip a colon */
3518 buf
= alloca (strlen (line
));
3520 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3523 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3524 utp
->at_string
= xstrdup (buf
);
3525 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3526 utp
->cond_string
= xstrdup (buf
);
3527 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3528 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3532 /* Don't error out, the target might be sending us optional
3533 info that we don't care about. */
3534 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3538 /* Convert a textual description of a trace state variable into an
3542 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3545 ULONGEST num
, initval
, builtin
;
3547 struct uploaded_tsv
*utsv
= NULL
;
3549 buf
= alloca (strlen (line
));
3552 p
= unpack_varlen_hex (p
, &num
);
3553 p
++; /* skip a colon */
3554 p
= unpack_varlen_hex (p
, &initval
);
3555 p
++; /* skip a colon */
3556 p
= unpack_varlen_hex (p
, &builtin
);
3557 p
++; /* skip a colon */
3558 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3561 utsv
= get_uploaded_tsv (num
, utsvp
);
3562 utsv
->initial_value
= initval
;
3563 utsv
->builtin
= builtin
;
3564 utsv
->name
= xstrdup (buf
);
3567 /* Close the trace file and generally clean up. */
3570 tfile_close (int quitting
)
3577 pid
= ptid_get_pid (inferior_ptid
);
3578 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3579 exit_inferior_silent (pid
);
3584 xfree (trace_filename
);
3588 tfile_files_info (struct target_ops
*t
)
3590 /* (it would be useful to mention the name of the file) */
3591 printf_filtered ("Looking at a trace file.\n");
3594 /* The trace status for a file is that tracing can never be run. */
3597 tfile_get_trace_status (struct trace_status
*ts
)
3599 /* Other bits of trace status were collected as part of opening the
3600 trace files, so nothing to do here. */
3605 /* Given the position of a traceframe in the file, figure out what
3606 address the frame was collected at. This would normally be the
3607 value of a collected PC register, but if not available, we
3611 tfile_get_traceframe_address (off_t tframe_offset
)
3615 struct breakpoint
*tp
;
3616 off_t saved_offset
= cur_offset
;
3619 /* FIXME dig pc out of collected registers */
3621 /* Fall back to using tracepoint address. */
3622 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3623 gotten
= read (trace_fd
, &tpnum
, 2);
3625 perror_with_name (trace_filename
);
3626 else if (gotten
< 2)
3627 error (_("Premature end of file while reading trace file"));
3629 tp
= get_tracepoint_by_number_on_target (tpnum
);
3630 /* FIXME this is a poor heuristic if multiple locations */
3632 addr
= tp
->loc
->address
;
3634 /* Restore our seek position. */
3635 cur_offset
= saved_offset
;
3636 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3640 /* Given a type of search and some parameters, scan the collection of
3641 traceframes in the file looking for a match. When found, return
3642 both the traceframe and tracepoint number, otherwise -1 for
3646 tfile_trace_find (enum trace_find_type type
, int num
,
3647 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3650 int tfnum
= 0, found
= 0, gotten
;
3652 struct breakpoint
*tp
;
3653 off_t offset
, tframe_offset
;
3656 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3657 offset
= trace_frames_offset
;
3660 tframe_offset
= offset
;
3661 gotten
= read (trace_fd
, &tpnum
, 2);
3663 perror_with_name (trace_filename
);
3664 else if (gotten
< 2)
3665 error (_("Premature end of file while reading trace file"));
3669 gotten
= read (trace_fd
, &data_size
, 4);
3671 perror_with_name (trace_filename
);
3672 else if (gotten
< 4)
3673 error (_("Premature end of file while reading trace file"));
3682 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3683 if (tfaddr
== addr1
)
3687 tp
= get_tracepoint (num
);
3688 if (tp
&& tpnum
== tp
->number_on_target
)
3692 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3693 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3697 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3698 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3702 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3708 cur_offset
= offset
;
3709 cur_data_size
= data_size
;
3712 /* Skip past the traceframe's data. */
3713 lseek (trace_fd
, data_size
, SEEK_CUR
);
3714 offset
+= data_size
;
3715 /* Update our own count of traceframes. */
3718 /* Did not find what we were looking for. */
3724 /* Look for a block of saved registers in the traceframe, and get the
3725 requested register from it. */
3728 tfile_fetch_registers (struct target_ops
*ops
,
3729 struct regcache
*regcache
, int regno
)
3731 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3733 int i
, pos
, offset
, regn
, regsize
, gotten
, pc_regno
;
3734 unsigned short mlen
;
3737 /* An uninitialized reg size says we're not going to be
3738 successful at getting register blocks. */
3739 if (!trace_regblock_size
)
3742 regs
= alloca (trace_regblock_size
);
3744 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3746 while (pos
< cur_data_size
)
3748 gotten
= read (trace_fd
, &block_type
, 1);
3750 perror_with_name (trace_filename
);
3751 else if (gotten
< 1)
3752 error (_("Premature end of file while reading trace file"));
3758 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3760 perror_with_name (trace_filename
);
3761 else if (gotten
< trace_regblock_size
)
3762 error (_("Premature end of file while reading trace file"));
3764 /* Assume the block is laid out in GDB register number order,
3765 each register with the size that it has in GDB. */
3767 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3769 regsize
= register_size (gdbarch
, regn
);
3770 /* Make sure we stay within block bounds. */
3771 if (offset
+ regsize
>= trace_regblock_size
)
3773 if (!regcache_valid_p (regcache
, regn
))
3777 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3780 else if (regno
== -1)
3782 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3789 lseek (trace_fd
, 8, SEEK_CUR
);
3790 gotten
= read (trace_fd
, &mlen
, 2);
3792 perror_with_name (trace_filename
);
3793 else if (gotten
< 2)
3794 error (_("Premature end of file while reading trace file"));
3795 lseek (trace_fd
, mlen
, SEEK_CUR
);
3796 pos
+= (8 + 2 + mlen
);
3799 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3803 error ("Unknown block type '%c' (0x%x) in trace frame",
3804 block_type
, block_type
);
3809 /* We get here if no register data has been found. Although we
3810 don't like making up numbers, GDB has all manner of troubles when
3811 the target says some register is not available. Filling in with
3812 zeroes is a reasonable fallback. */
3813 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3814 regcache_raw_supply (regcache
, regn
, NULL
);
3816 /* We can often usefully guess that the PC is going to be the same
3817 as the address of the tracepoint. */
3818 pc_regno
= gdbarch_pc_regnum (gdbarch
);
3819 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
3821 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
3825 /* But don't try to guess if tracepoint is multi-location... */
3828 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3832 /* ... or does while-stepping. */
3833 if (tp
->step_count
> 0)
3835 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3840 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
3841 gdbarch_byte_order (gdbarch
),
3843 regcache_raw_supply (regcache
, pc_regno
, regs
);
3849 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3850 const char *annex
, gdb_byte
*readbuf
,
3851 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3855 ULONGEST maddr
, amt
;
3856 unsigned short mlen
;
3858 /* We're only doing regular memory for now. */
3859 if (object
!= TARGET_OBJECT_MEMORY
)
3862 if (readbuf
== NULL
)
3863 error ("tfile_xfer_partial: trace file is read-only");
3865 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3867 while (pos
< cur_data_size
)
3869 gotten
= read (trace_fd
, &block_type
, 1);
3871 perror_with_name (trace_filename
);
3872 else if (gotten
< 1)
3873 error (_("Premature end of file while reading trace file"));
3878 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3879 pos
+= trace_regblock_size
;
3882 gotten
= read (trace_fd
, &maddr
, 8);
3884 perror_with_name (trace_filename
);
3885 else if (gotten
< 8)
3886 error (_("Premature end of file while reading trace file"));
3888 gotten
= read (trace_fd
, &mlen
, 2);
3890 perror_with_name (trace_filename
);
3891 else if (gotten
< 2)
3892 error (_("Premature end of file while reading trace file"));
3893 /* If the block includes the first part of the desired
3894 range, return as much it has; GDB will re-request the
3895 remainder, which might be in a different block of this
3897 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
3899 amt
= (maddr
+ mlen
) - offset
;
3903 gotten
= read (trace_fd
, readbuf
, amt
);
3905 perror_with_name (trace_filename
);
3906 /* While it's acceptable to return less than was
3907 originally asked for, it's not acceptable to return
3908 less than what this block claims to contain. */
3909 else if (gotten
< amt
)
3910 error (_("Premature end of file while reading trace file"));
3913 lseek (trace_fd
, mlen
, SEEK_CUR
);
3914 pos
+= (8 + 2 + mlen
);
3917 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3921 error ("Unknown block type '%c' (0x%x) in traceframe",
3922 block_type
, block_type
);
3927 /* It's unduly pedantic to refuse to look at the executable for
3928 read-only pieces; so do the equivalent of readonly regions aka
3930 /* FIXME account for relocation at some point */
3937 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
3939 if ((s
->flags
& SEC_LOAD
) == 0 ||
3940 (s
->flags
& SEC_READONLY
) == 0)
3944 size
= bfd_get_section_size (s
);
3945 if (lma
<= offset
&& offset
< (lma
+ size
))
3947 amt
= (lma
+ size
) - offset
;
3951 amt
= bfd_get_section_contents (exec_bfd
, s
,
3952 readbuf
, offset
- lma
, amt
);
3958 /* Indicate failure to find the requested memory block. */
3962 /* Iterate through the blocks of a trace frame, looking for a 'V'
3963 block with a matching tsv number. */
3966 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3969 int pos
, vnum
, gotten
;
3970 unsigned short mlen
;
3972 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3974 while (pos
< cur_data_size
)
3976 gotten
= read (trace_fd
, &block_type
, 1);
3978 perror_with_name (trace_filename
);
3979 else if (gotten
< 1)
3980 error (_("Premature end of file while reading trace file"));
3985 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3986 pos
+= trace_regblock_size
;
3989 lseek (trace_fd
, 8, SEEK_CUR
);
3990 gotten
= read (trace_fd
, &mlen
, 2);
3992 perror_with_name (trace_filename
);
3993 else if (gotten
< 2)
3994 error (_("Premature end of file while reading trace file"));
3995 lseek (trace_fd
, mlen
, SEEK_CUR
);
3996 pos
+= (8 + 2 + mlen
);
3999 gotten
= read (trace_fd
, &vnum
, 4);
4001 perror_with_name (trace_filename
);
4002 else if (gotten
< 4)
4003 error (_("Premature end of file while reading trace file"));
4006 gotten
= read (trace_fd
, val
, 8);
4008 perror_with_name (trace_filename
);
4009 else if (gotten
< 8)
4010 error (_("Premature end of file while reading trace file"));
4013 lseek (trace_fd
, 8, SEEK_CUR
);
4017 error ("Unknown block type '%c' (0x%x) in traceframe",
4018 block_type
, block_type
);
4022 /* Didn't find anything. */
4027 tfile_has_all_memory (struct target_ops
*ops
)
4033 tfile_has_memory (struct target_ops
*ops
)
4039 tfile_has_stack (struct target_ops
*ops
)
4045 tfile_has_registers (struct target_ops
*ops
)
4051 init_tfile_ops (void)
4053 tfile_ops
.to_shortname
= "tfile";
4054 tfile_ops
.to_longname
= "Local trace dump file";
4056 "Use a trace file as a target. Specify the filename of the trace file.";
4057 tfile_ops
.to_open
= tfile_open
;
4058 tfile_ops
.to_close
= tfile_close
;
4059 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4060 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4061 tfile_ops
.to_files_info
= tfile_files_info
;
4062 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4063 tfile_ops
.to_trace_find
= tfile_trace_find
;
4064 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
4065 /* core_stratum might seem more logical, but GDB doesn't like having
4066 more than one core_stratum vector. */
4067 tfile_ops
.to_stratum
= process_stratum
;
4068 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4069 tfile_ops
.to_has_memory
= tfile_has_memory
;
4070 tfile_ops
.to_has_stack
= tfile_has_stack
;
4071 tfile_ops
.to_has_registers
= tfile_has_registers
;
4072 tfile_ops
.to_magic
= OPS_MAGIC
;
4075 /* module initialization */
4077 _initialize_tracepoint (void)
4079 struct cmd_list_element
*c
;
4081 traceframe_number
= -1;
4082 tracepoint_number
= -1;
4084 if (tracepoint_list
.list
== NULL
)
4086 tracepoint_list
.listsize
= 128;
4087 tracepoint_list
.list
= xmalloc
4088 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4090 if (tracepoint_list
.aexpr_list
== NULL
)
4092 tracepoint_list
.aexpr_listsize
= 128;
4093 tracepoint_list
.aexpr_list
= xmalloc
4094 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4097 if (stepping_list
.list
== NULL
)
4099 stepping_list
.listsize
= 128;
4100 stepping_list
.list
= xmalloc
4101 (stepping_list
.listsize
* sizeof (struct memrange
));
4104 if (stepping_list
.aexpr_list
== NULL
)
4106 stepping_list
.aexpr_listsize
= 128;
4107 stepping_list
.aexpr_list
= xmalloc
4108 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4111 add_info ("scope", scope_info
,
4112 _("List the variables local to a scope"));
4114 add_cmd ("tracepoints", class_trace
, NULL
,
4115 _("Tracing of program execution without stopping the program."),
4118 add_com ("tdump", class_trace
, trace_dump_command
,
4119 _("Print everything collected at the current tracepoint."));
4121 add_com ("tsave", class_trace
, trace_save_command
, _("\
4122 Save the trace data to a file.\n\
4123 Use the '-r' option to direct the target to save directly to the file,\n\
4124 using its own filesystem."));
4126 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4127 Define a trace state variable.\n\
4128 Argument is a $-prefixed name, optionally followed\n\
4129 by '=' and an expression that sets the initial value\n\
4130 at the start of tracing."));
4131 set_cmd_completer (c
, expression_completer
);
4133 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4134 Delete one or more trace state variables.\n\
4135 Arguments are the names of the variables to delete.\n\
4136 If no arguments are supplied, delete all variables."), &deletelist
);
4137 /* FIXME add a trace variable completer */
4139 add_info ("tvariables", tvariables_info
, _("\
4140 Status of trace state variables and their values.\n\
4143 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4144 Select a trace frame;\n\
4145 No argument means forward by one frame; '-' means backward by one frame."),
4146 &tfindlist
, "tfind ", 1, &cmdlist
);
4148 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4149 Select a trace frame whose PC is outside the given range (exclusive).\n\
4150 Usage: tfind outside addr1, addr2"),
4153 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4154 Select a trace frame whose PC is in the given range (inclusive).\n\
4155 Usage: tfind range addr1,addr2"),
4158 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4159 Select a trace frame by source line.\n\
4160 Argument can be a line number (with optional source file), \n\
4161 a function name, or '*' followed by an address.\n\
4162 Default argument is 'the next source line that was traced'."),
4165 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4166 Select a trace frame by tracepoint number.\n\
4167 Default is the tracepoint for the current trace frame."),
4170 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4171 Select a trace frame by PC.\n\
4172 Default is the current PC, or the PC of the current trace frame."),
4175 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4176 Synonym for 'none'.\n\
4177 De-select any trace frame and resume 'live' debugging."),
4180 add_cmd ("none", class_trace
, trace_find_none_command
,
4181 _("De-select any trace frame and resume 'live' debugging."),
4184 add_cmd ("start", class_trace
, trace_find_start_command
,
4185 _("Select the first trace frame in the trace buffer."),
4188 add_com ("tstatus", class_trace
, trace_status_command
,
4189 _("Display the status of the current trace data collection."));
4191 add_com ("tstop", class_trace
, trace_stop_command
,
4192 _("Stop trace data collection."));
4194 add_com ("tstart", class_trace
, trace_start_command
,
4195 _("Start trace data collection."));
4197 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4198 Ends a list of commands or actions.\n\
4199 Several GDB commands allow you to enter a list of commands or actions.\n\
4200 Entering \"end\" on a line by itself is the normal way to terminate\n\
4202 Note: the \"end\" command cannot be used at the gdb prompt."));
4204 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4205 Specify single-stepping behavior at a tracepoint.\n\
4206 Argument is number of instructions to trace in single-step mode\n\
4207 following the tracepoint. This command is normally followed by\n\
4208 one or more \"collect\" commands, to specify what to collect\n\
4209 while single-stepping.\n\n\
4210 Note: this command can only be used in a tracepoint \"actions\" list."));
4212 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4213 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4215 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4216 Specify one or more data items to be collected at a tracepoint.\n\
4217 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4218 collect all data (variables, registers) referenced by that expression.\n\
4219 Also accepts the following special arguments:\n\
4220 $regs -- all registers.\n\
4221 $args -- all function arguments.\n\
4222 $locals -- all variables local to the block/function scope.\n\
4223 Note: this command can only be used in a tracepoint \"actions\" list."));
4225 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4226 Specify one or more expressions to be evaluated at a tracepoint.\n\
4227 Accepts a comma-separated list of (one or more) expressions.\n\
4228 The result of each evaluation will be discarded.\n\
4229 Note: this command can only be used in a tracepoint \"actions\" list."));
4231 add_com ("actions", class_trace
, trace_actions_command
, _("\
4232 Specify the actions to be taken at a tracepoint.\n\
4233 Tracepoint actions may include collecting of specified data, \n\
4234 single-stepping, or enabling/disabling other tracepoints, \n\
4235 depending on target's capabilities."));
4237 default_collect
= xstrdup ("");
4238 add_setshow_string_cmd ("default-collect", class_trace
,
4239 &default_collect
, _("\
4240 Set the list of expressions to collect by default"), _("\
4241 Show the list of expressions to collect by default"), NULL
,
4243 &setlist
, &showlist
);
4245 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4246 &disconnected_tracing
, _("\
4247 Set whether tracing continues after GDB disconnects."), _("\
4248 Show whether tracing continues after GDB disconnects."), _("\
4249 Use this to continue a tracing run even if GDB disconnects\n\
4250 or detaches from the target. You can reconnect later and look at\n\
4251 trace data collected in the meantime."),
4252 set_disconnected_tracing
,
4257 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4258 &circular_trace_buffer
, _("\
4259 Set target's use of circular trace buffer."), _("\
4260 Show target's use of circular trace buffer."), _("\
4261 Use this to make the trace buffer into a circular buffer,\n\
4262 which will discard traceframes (oldest first) instead of filling\n\
4263 up and stopping the trace run."),
4264 set_circular_trace_buffer
,
4271 add_target (&tfile_ops
);