1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
29 #include "target-dcache.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
52 #include "cli/cli-utils.h"
55 #include "filestuff.h"
57 #include "tracefile.h"
61 /* readline include files */
62 #include "readline/readline.h"
63 #include "readline/history.h"
65 /* readline defines this. */
70 /* Maximum length of an agent aexpression.
71 This accounts for the fact that packets are limited to 400 bytes
72 (which includes everything -- including the checksum), and assumes
73 the worst case of maximum length for each of the pieces of a
76 NOTE: expressions get mem2hex'ed otherwise this would be twice as
77 large. (400 - 31)/2 == 184 */
78 #define MAX_AGENT_EXPR_LEN 184
80 /* A hook used to notify the UI of tracepoint operations. */
82 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
83 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
88 This module defines the following debugger commands:
89 trace : set a tracepoint on a function, line, or address.
90 info trace : list all debugger-defined tracepoints.
91 delete trace : delete one or more tracepoints.
92 enable trace : enable one or more tracepoints.
93 disable trace : disable one or more tracepoints.
94 actions : specify actions to be taken at a tracepoint.
95 passcount : specify a pass count for a tracepoint.
96 tstart : start a trace experiment.
97 tstop : stop a trace experiment.
98 tstatus : query the status of a trace experiment.
99 tfind : find a trace frame in the trace buffer.
100 tdump : print everything collected at the current tracepoint.
101 save-tracepoints : write tracepoint setup into a file.
103 This module defines the following user-visible debugger variables:
104 $trace_frame : sequence number of trace frame currently being debugged.
105 $trace_line : source line of trace frame currently being debugged.
106 $trace_file : source file of trace frame currently being debugged.
107 $tracepoint : tracepoint number of trace frame currently being debugged.
111 /* ======= Important global variables: ======= */
113 /* The list of all trace state variables. We don't retain pointers to
114 any of these for any reason - API is by name or number only - so it
115 works to have a vector of objects. */
117 typedef struct trace_state_variable tsv_s
;
120 static VEC(tsv_s
) *tvariables
;
122 /* The next integer to assign to a variable. */
124 static int next_tsv_number
= 1;
126 /* Number of last traceframe collected. */
127 static int traceframe_number
;
129 /* Tracepoint for last traceframe collected. */
130 static int tracepoint_number
;
132 /* The traceframe info of the current traceframe. NULL if we haven't
133 yet attempted to fetch it, or if the target does not support
134 fetching this object, or if we're not inspecting a traceframe
136 static struct traceframe_info
*traceframe_info
;
138 /* Tracing command lists. */
139 static struct cmd_list_element
*tfindlist
;
141 /* List of expressions to collect by default at each tracepoint hit. */
142 char *default_collect
= "";
144 static int disconnected_tracing
;
146 /* This variable controls whether we ask the target for a linear or
147 circular trace buffer. */
149 static int circular_trace_buffer
;
151 /* This variable is the requested trace buffer size, or -1 to indicate
152 that we don't care and leave it up to the target to set a size. */
154 static int trace_buffer_size
= -1;
156 /* Textual notes applying to the current and/or future trace runs. */
158 char *trace_user
= NULL
;
160 /* Textual notes applying to the current and/or future trace runs. */
162 char *trace_notes
= NULL
;
164 /* Textual notes applying to the stopping of a trace. */
166 char *trace_stop_notes
= NULL
;
168 /* ======= Important command functions: ======= */
169 static void trace_actions_command (char *, int);
170 static void trace_start_command (char *, int);
171 static void trace_stop_command (char *, int);
172 static void trace_status_command (char *, int);
173 static void trace_find_command (char *, int);
174 static void trace_find_pc_command (char *, int);
175 static void trace_find_tracepoint_command (char *, int);
176 static void trace_find_line_command (char *, int);
177 static void trace_find_range_command (char *, int);
178 static void trace_find_outside_command (char *, int);
179 static void trace_dump_command (char *, int);
181 /* support routines */
183 struct collection_list
;
184 static char *mem2hex (gdb_byte
*, char *, int);
186 static struct command_line
*
187 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
189 extern void _initialize_tracepoint (void);
191 static struct trace_status trace_status
;
193 const char *stop_reason_names
[] = {
203 struct trace_status
*
204 current_trace_status (void)
206 return &trace_status
;
212 free_traceframe_info (struct traceframe_info
*info
)
216 VEC_free (mem_range_s
, info
->memory
);
217 VEC_free (int, info
->tvars
);
223 /* Free and clear the traceframe info cache of the current
227 clear_traceframe_info (void)
229 free_traceframe_info (traceframe_info
);
230 traceframe_info
= NULL
;
233 /* Set traceframe number to NUM. */
235 set_traceframe_num (int num
)
237 traceframe_number
= num
;
238 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
241 /* Set tracepoint number to NUM. */
243 set_tracepoint_num (int num
)
245 tracepoint_number
= num
;
246 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
249 /* Set externally visible debug variables for querying/printing
250 the traceframe context (line, function, file). */
253 set_traceframe_context (struct frame_info
*trace_frame
)
256 struct symbol
*traceframe_fun
;
257 struct symtab_and_line traceframe_sal
;
259 /* Save as globals for internal use. */
260 if (trace_frame
!= NULL
261 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
263 traceframe_sal
= find_pc_line (trace_pc
, 0);
264 traceframe_fun
= find_pc_function (trace_pc
);
266 /* Save linenumber as "$trace_line", a debugger variable visible to
268 set_internalvar_integer (lookup_internalvar ("trace_line"),
269 traceframe_sal
.line
);
273 init_sal (&traceframe_sal
);
274 traceframe_fun
= NULL
;
275 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
278 /* Save func name as "$trace_func", a debugger variable visible to
280 if (traceframe_fun
== NULL
281 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
282 clear_internalvar (lookup_internalvar ("trace_func"));
284 set_internalvar_string (lookup_internalvar ("trace_func"),
285 SYMBOL_LINKAGE_NAME (traceframe_fun
));
287 /* Save file name as "$trace_file", a debugger variable visible to
289 if (traceframe_sal
.symtab
== NULL
)
290 clear_internalvar (lookup_internalvar ("trace_file"));
292 set_internalvar_string (lookup_internalvar ("trace_file"),
293 symtab_to_filename_for_display (traceframe_sal
.symtab
));
296 /* Create a new trace state variable with the given name. */
298 struct trace_state_variable
*
299 create_trace_state_variable (const char *name
)
301 struct trace_state_variable tsv
;
303 memset (&tsv
, 0, sizeof (tsv
));
304 tsv
.name
= xstrdup (name
);
305 tsv
.number
= next_tsv_number
++;
306 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
309 /* Look for a trace state variable of the given name. */
311 struct trace_state_variable
*
312 find_trace_state_variable (const char *name
)
314 struct trace_state_variable
*tsv
;
317 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
318 if (strcmp (name
, tsv
->name
) == 0)
324 /* Look for a trace state variable of the given number. Return NULL if
327 struct trace_state_variable
*
328 find_trace_state_variable_by_number (int number
)
330 struct trace_state_variable
*tsv
;
333 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
334 if (tsv
->number
== number
)
341 delete_trace_state_variable (const char *name
)
343 struct trace_state_variable
*tsv
;
346 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
347 if (strcmp (name
, tsv
->name
) == 0)
349 observer_notify_tsv_deleted (tsv
);
351 xfree ((void *)tsv
->name
);
352 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
357 warning (_("No trace variable named \"$%s\", not deleting"), name
);
360 /* Throws an error if NAME is not valid syntax for a trace state
364 validate_trace_state_variable_name (const char *name
)
369 error (_("Must supply a non-empty variable name"));
371 /* All digits in the name is reserved for value history
373 for (p
= name
; isdigit (*p
); p
++)
376 error (_("$%s is not a valid trace state variable name"), name
);
378 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
381 error (_("$%s is not a valid trace state variable name"), name
);
384 /* The 'tvariable' command collects a name and optional expression to
385 evaluate into an initial value. */
388 trace_variable_command (char *args
, int from_tty
)
390 struct cleanup
*old_chain
;
392 struct trace_state_variable
*tsv
;
396 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
398 /* Only allow two syntaxes; "$name" and "$name=value". */
399 p
= skip_spaces (args
);
402 error (_("Name of trace variable should start with '$'"));
405 while (isalnum (*p
) || *p
== '_')
407 name
= savestring (name
, p
- name
);
408 old_chain
= make_cleanup (xfree
, name
);
411 if (*p
!= '=' && *p
!= '\0')
412 error (_("Syntax must be $NAME [ = EXPR ]"));
414 validate_trace_state_variable_name (name
);
417 initval
= value_as_long (parse_and_eval (++p
));
419 /* If the variable already exists, just change its initial value. */
420 tsv
= find_trace_state_variable (name
);
423 if (tsv
->initial_value
!= initval
)
425 tsv
->initial_value
= initval
;
426 observer_notify_tsv_modified (tsv
);
428 printf_filtered (_("Trace state variable $%s "
429 "now has initial value %s.\n"),
430 tsv
->name
, plongest (tsv
->initial_value
));
431 do_cleanups (old_chain
);
435 /* Create a new variable. */
436 tsv
= create_trace_state_variable (name
);
437 tsv
->initial_value
= initval
;
439 observer_notify_tsv_created (tsv
);
441 printf_filtered (_("Trace state variable $%s "
442 "created, with initial value %s.\n"),
443 tsv
->name
, plongest (tsv
->initial_value
));
445 do_cleanups (old_chain
);
449 delete_trace_variable_command (char *args
, int from_tty
)
453 struct cleanup
*back_to
;
457 if (query (_("Delete all trace state variables? ")))
458 VEC_free (tsv_s
, tvariables
);
460 observer_notify_tsv_deleted (NULL
);
464 argv
= gdb_buildargv (args
);
465 back_to
= make_cleanup_freeargv (argv
);
467 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
469 if (*argv
[ix
] == '$')
470 delete_trace_state_variable (argv
[ix
] + 1);
472 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
475 do_cleanups (back_to
);
481 tvariables_info_1 (void)
483 struct trace_state_variable
*tsv
;
486 struct cleanup
*back_to
;
487 struct ui_out
*uiout
= current_uiout
;
489 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
491 printf_filtered (_("No trace state variables.\n"));
495 /* Try to acquire values from the target. */
496 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
497 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
500 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
501 count
, "trace-variables");
502 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
503 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
504 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
506 ui_out_table_body (uiout
);
508 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
510 struct cleanup
*back_to2
;
514 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
516 name
= concat ("$", tsv
->name
, (char *) NULL
);
517 make_cleanup (xfree
, name
);
518 ui_out_field_string (uiout
, "name", name
);
519 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
521 if (tsv
->value_known
)
522 c
= plongest (tsv
->value
);
523 else if (ui_out_is_mi_like_p (uiout
))
524 /* For MI, we prefer not to use magic string constants, but rather
525 omit the field completely. The difference between unknown and
526 undefined does not seem important enough to represent. */
528 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
529 /* The value is/was defined, but we don't have it. */
532 /* It is not meaningful to ask about the value. */
535 ui_out_field_string (uiout
, "current", c
);
536 ui_out_text (uiout
, "\n");
538 do_cleanups (back_to2
);
541 do_cleanups (back_to
);
544 /* List all the trace state variables. */
547 tvariables_info (char *args
, int from_tty
)
549 tvariables_info_1 ();
552 /* Stash definitions of tsvs into the given file. */
555 save_trace_state_variables (struct ui_file
*fp
)
557 struct trace_state_variable
*tsv
;
560 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
562 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
563 if (tsv
->initial_value
)
564 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
565 fprintf_unfiltered (fp
, "\n");
569 /* ACTIONS functions: */
571 /* The three functions:
572 collect_pseudocommand,
573 while_stepping_pseudocommand, and
574 end_actions_pseudocommand
575 are placeholders for "commands" that are actually ONLY to be used
576 within a tracepoint action list. If the actual function is ever called,
577 it means that somebody issued the "command" at the top level,
578 which is always an error. */
581 end_actions_pseudocommand (char *args
, int from_tty
)
583 error (_("This command cannot be used at the top level."));
587 while_stepping_pseudocommand (char *args
, int from_tty
)
589 error (_("This command can only be used in a tracepoint actions list."));
593 collect_pseudocommand (char *args
, int from_tty
)
595 error (_("This command can only be used in a tracepoint actions list."));
599 teval_pseudocommand (char *args
, int from_tty
)
601 error (_("This command can only be used in a tracepoint actions list."));
604 /* Parse any collection options, such as /s for strings. */
607 decode_agent_options (const char *exp
, int *trace_string
)
609 struct value_print_options opts
;
616 /* Call this to borrow the print elements default for collection
618 get_user_print_options (&opts
);
623 if (target_supports_string_tracing ())
625 /* Allow an optional decimal number giving an explicit maximum
626 string length, defaulting it to the "print elements" value;
627 so "collect/s80 mystr" gets at most 80 bytes of string. */
628 *trace_string
= opts
.print_max
;
630 if (*exp
>= '0' && *exp
<= '9')
631 *trace_string
= atoi (exp
);
632 while (*exp
>= '0' && *exp
<= '9')
636 error (_("Target does not support \"/s\" option for string tracing."));
639 error (_("Undefined collection format \"%c\"."), *exp
);
641 exp
= skip_spaces_const (exp
);
646 /* Enter a list of actions for a tracepoint. */
648 trace_actions_command (char *args
, int from_tty
)
650 struct tracepoint
*t
;
651 struct command_line
*l
;
653 t
= get_tracepoint_by_number (&args
, NULL
);
657 xstrprintf ("Enter actions for tracepoint %d, one per line.",
659 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
661 l
= read_command_lines (tmpbuf
, from_tty
, 1,
662 check_tracepoint_command
, t
);
663 do_cleanups (cleanups
);
664 breakpoint_set_commands (&t
->base
, l
);
666 /* else just return */
669 /* Report the results of checking the agent expression, as errors or
673 report_agent_reqs_errors (struct agent_expr
*aexpr
)
675 /* All of the "flaws" are serious bytecode generation issues that
676 should never occur. */
677 if (aexpr
->flaw
!= agent_flaw_none
)
678 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
680 /* If analysis shows a stack underflow, GDB must have done something
681 badly wrong in its bytecode generation. */
682 if (aexpr
->min_height
< 0)
683 internal_error (__FILE__
, __LINE__
,
684 _("expression has min height < 0"));
686 /* Issue this error if the stack is predicted to get too deep. The
687 limit is rather arbitrary; a better scheme might be for the
688 target to report how much stack it will have available. The
689 depth roughly corresponds to parenthesization, so a limit of 20
690 amounts to 20 levels of expression nesting, which is actually
691 a pretty big hairy expression. */
692 if (aexpr
->max_height
> 20)
693 error (_("Expression is too complicated."));
696 /* worker function */
698 validate_actionline (const char *line
, struct breakpoint
*b
)
700 struct cmd_list_element
*c
;
701 struct cleanup
*old_chain
= NULL
;
704 struct bp_location
*loc
;
705 struct tracepoint
*t
= (struct tracepoint
*) b
;
707 /* If EOF is typed, *line is NULL. */
711 p
= skip_spaces_const (line
);
713 /* Symbol lookup etc. */
714 if (*p
== '\0') /* empty line: just prompt for another line. */
717 if (*p
== '#') /* comment line */
720 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
722 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
724 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
726 int trace_string
= 0;
729 p
= decode_agent_options (p
, &trace_string
);
732 { /* Repeat over a comma-separated list. */
733 QUIT
; /* Allow user to bail out with ^C. */
734 p
= skip_spaces_const (p
);
736 if (*p
== '$') /* Look for special pseudo-symbols. */
738 if (0 == strncasecmp ("reg", p
+ 1, 3)
739 || 0 == strncasecmp ("arg", p
+ 1, 3)
740 || 0 == strncasecmp ("loc", p
+ 1, 3)
741 || 0 == strncasecmp ("_ret", p
+ 1, 4)
742 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
747 /* else fall thru, treat p as an expression and parse it! */
750 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
753 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
754 block_for_pc (loc
->address
), 1);
756 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
758 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
760 error (_("constant `%s' (value %s) "
761 "will not be collected."),
762 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
763 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
765 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
766 == LOC_OPTIMIZED_OUT
)
768 error (_("`%s' is optimized away "
769 "and cannot be collected."),
770 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
774 /* We have something to collect, make sure that the expr to
775 bytecode translator can handle it and that it's not too
777 agent_expr_up aexpr
= gen_trace_for_expr (loc
->address
,
781 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
782 error (_("Expression is too complicated."));
784 ax_reqs (aexpr
.get ());
786 report_agent_reqs_errors (aexpr
.get ());
789 while (p
&& *p
++ == ',');
792 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
795 { /* Repeat over a comma-separated list. */
796 QUIT
; /* Allow user to bail out with ^C. */
797 p
= skip_spaces_const (p
);
800 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
804 /* Only expressions are allowed for this action. */
805 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
806 block_for_pc (loc
->address
), 1);
808 /* We have something to evaluate, make sure that the expr to
809 bytecode translator can handle it and that it's not too
811 agent_expr_up aexpr
= gen_eval_for_expr (loc
->address
, exp
.get ());
813 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
814 error (_("Expression is too complicated."));
816 ax_reqs (aexpr
.get ());
817 report_agent_reqs_errors (aexpr
.get ());
820 while (p
&& *p
++ == ',');
823 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
827 p
= skip_spaces_const (p
);
828 t
->step_count
= strtol (p
, &endp
, 0);
829 if (endp
== p
|| t
->step_count
== 0)
830 error (_("while-stepping step count `%s' is malformed."), line
);
834 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
838 error (_("`%s' is not a supported tracepoint action."), line
);
842 memrange_absolute
= -1
845 /* MEMRANGE functions: */
847 /* Compare memranges for std::sort. */
850 memrange_comp (const memrange
&a
, const memrange
&b
)
852 if (a
.type
== b
.type
)
854 if (a
.type
== memrange_absolute
)
855 return (bfd_vma
) a
.start
< (bfd_vma
) b
.start
;
857 return a
.start
< b
.start
;
860 return a
.type
< b
.type
;
863 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
866 memrange_sortmerge (std::vector
<memrange
> &memranges
)
868 if (!memranges
.empty ())
872 std::sort (memranges
.begin (), memranges
.end (), memrange_comp
);
874 for (a
= 0, b
= 1; b
< memranges
.size (); b
++)
876 /* If memrange b overlaps or is adjacent to memrange a,
878 if (memranges
[a
].type
== memranges
[b
].type
879 && memranges
[b
].start
<= memranges
[a
].end
)
881 if (memranges
[b
].end
> memranges
[a
].end
)
882 memranges
[a
].end
= memranges
[b
].end
;
883 continue; /* next b, same a */
887 memranges
[a
] = memranges
[b
];
889 memranges
.resize (a
+ 1);
893 /* Add a register to a collection list. */
896 collection_list::add_register (unsigned int regno
)
899 printf_filtered ("collect register %d\n", regno
);
900 if (regno
>= (8 * sizeof (m_regs_mask
)))
901 error (_("Internal: register number %d too large for tracepoint"),
903 m_regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
906 /* Add a memrange to a collection list. */
909 collection_list::add_memrange (int type
, bfd_signed_vma base
,
914 printf_filtered ("(%d,", type
);
916 printf_filtered (",%ld)\n", len
);
919 /* type: memrange_absolute == memory, other n == basereg */
920 /* base: addr if memory, offset if reg relative. */
921 /* len: we actually save end (base + len) for convenience */
922 m_memranges
.emplace_back (type
, base
, base
+ len
);
924 if (type
!= memrange_absolute
) /* Better collect the base register! */
928 /* Add a symbol to a collection list. */
931 collection_list::collect_symbol (struct symbol
*sym
,
932 struct gdbarch
*gdbarch
,
933 long frame_regno
, long frame_offset
,
939 bfd_signed_vma offset
;
940 int treat_as_expr
= 0;
942 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
943 switch (SYMBOL_CLASS (sym
))
946 printf_filtered ("%s: don't know symbol class %d\n",
947 SYMBOL_PRINT_NAME (sym
),
951 printf_filtered ("constant %s (value %s) will not be collected.\n",
952 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
955 offset
= SYMBOL_VALUE_ADDRESS (sym
);
960 sprintf_vma (tmp
, offset
);
961 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
962 SYMBOL_PRINT_NAME (sym
), len
,
965 /* A struct may be a C++ class with static fields, go to general
966 expression handling. */
967 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
970 add_memrange (memrange_absolute
, offset
, len
);
973 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
975 printf_filtered ("LOC_REG[parm] %s: ",
976 SYMBOL_PRINT_NAME (sym
));
978 /* Check for doubles stored in two registers. */
979 /* FIXME: how about larger types stored in 3 or more regs? */
980 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
981 len
> register_size (gdbarch
, reg
))
982 add_register (reg
+ 1);
985 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
986 printf_filtered (" (will not collect %s)\n",
987 SYMBOL_PRINT_NAME (sym
));
991 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
994 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
995 SYMBOL_PRINT_NAME (sym
), len
);
997 printf_filtered (" from frame ptr reg %d\n", reg
);
999 add_memrange (reg
, offset
, len
);
1001 case LOC_REGPARM_ADDR
:
1002 reg
= SYMBOL_VALUE (sym
);
1006 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1007 SYMBOL_PRINT_NAME (sym
), len
);
1008 printf_vma (offset
);
1009 printf_filtered (" from reg %d\n", reg
);
1011 add_memrange (reg
, offset
, len
);
1015 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1018 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1019 SYMBOL_PRINT_NAME (sym
), len
);
1020 printf_vma (offset
);
1021 printf_filtered (" from frame ptr reg %d\n", reg
);
1023 add_memrange (reg
, offset
, len
);
1026 case LOC_UNRESOLVED
:
1030 case LOC_OPTIMIZED_OUT
:
1031 printf_filtered ("%s has been optimized out of existence.\n",
1032 SYMBOL_PRINT_NAME (sym
));
1040 /* Expressions are the most general case. */
1043 struct cleanup
*old_chain1
= NULL
;
1045 agent_expr_up aexpr
= gen_trace_for_var (scope
, gdbarch
,
1048 /* It can happen that the symbol is recorded as a computed
1049 location, but it's been optimized away and doesn't actually
1050 have a location expression. */
1053 printf_filtered ("%s has been optimized out of existence.\n",
1054 SYMBOL_PRINT_NAME (sym
));
1058 ax_reqs (aexpr
.get ());
1060 report_agent_reqs_errors (aexpr
.get ());
1062 /* Take care of the registers. */
1063 if (aexpr
->reg_mask_len
> 0)
1065 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1067 QUIT
; /* Allow user to bail out with ^C. */
1068 if (aexpr
->reg_mask
[ndx1
] != 0)
1070 /* Assume chars have 8 bits. */
1071 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1072 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1073 /* It's used -- record it. */
1074 add_register (ndx1
* 8 + ndx2
);
1079 add_aexpr (std::move (aexpr
));
1083 /* Data to be passed around in the calls to the locals and args
1086 struct add_local_symbols_data
1088 struct collection_list
*collect
;
1089 struct gdbarch
*gdbarch
;
1097 /* The callback for the locals and args iterators. */
1100 do_collect_symbol (const char *print_name
,
1104 struct add_local_symbols_data
*p
= (struct add_local_symbols_data
*) cb_data
;
1106 p
->collect
->collect_symbol (sym
, p
->gdbarch
, p
->frame_regno
,
1107 p
->frame_offset
, p
->pc
, p
->trace_string
);
1110 p
->collect
->add_wholly_collected (print_name
);
1114 collection_list::add_wholly_collected (const char *print_name
)
1116 m_wholly_collected
.push_back (print_name
);
1119 /* Add all locals (or args) symbols to collection list. */
1122 collection_list::add_local_symbols (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1123 long frame_regno
, long frame_offset
, int type
,
1126 const struct block
*block
;
1127 struct add_local_symbols_data cb_data
;
1129 cb_data
.collect
= this;
1130 cb_data
.gdbarch
= gdbarch
;
1132 cb_data
.frame_regno
= frame_regno
;
1133 cb_data
.frame_offset
= frame_offset
;
1135 cb_data
.trace_string
= trace_string
;
1139 block
= block_for_pc (pc
);
1142 warning (_("Can't collect locals; "
1143 "no symbol table info available.\n"));
1147 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1148 if (cb_data
.count
== 0)
1149 warning (_("No locals found in scope."));
1153 pc
= get_pc_function_start (pc
);
1154 block
= block_for_pc (pc
);
1157 warning (_("Can't collect args; no symbol table info available."));
1161 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1162 if (cb_data
.count
== 0)
1163 warning (_("No args found in scope."));
1168 collection_list::add_static_trace_data ()
1171 printf_filtered ("collect static trace data\n");
1172 m_strace_data
= true;
1175 collection_list::collection_list ()
1177 m_strace_data (false)
1179 m_memranges
.reserve (128);
1180 m_aexprs
.reserve (128);
1183 /* Reduce a collection list to string form (for gdb protocol). */
1186 collection_list::stringify ()
1188 char temp_buf
[2048];
1192 char *(*str_list
)[];
1196 count
= 1 + 1 + m_memranges
.size () + m_aexprs
.size () + 1;
1197 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1202 printf_filtered ("\nCollecting static trace data\n");
1205 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1209 for (i
= sizeof (m_regs_mask
) - 1; i
> 0; i
--)
1210 if (m_regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1212 if (m_regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1215 printf_filtered ("\nCollecting registers (mask): 0x");
1220 QUIT
; /* Allow user to bail out with ^C. */
1222 printf_filtered ("%02X", m_regs_mask
[i
]);
1223 sprintf (end
, "%02X", m_regs_mask
[i
]);
1226 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1230 printf_filtered ("\n");
1231 if (!m_memranges
.empty () && info_verbose
)
1232 printf_filtered ("Collecting memranges: \n");
1233 for (i
= 0, count
= 0, end
= temp_buf
; i
< m_memranges
.size (); i
++)
1235 QUIT
; /* Allow user to bail out with ^C. */
1236 sprintf_vma (tmp2
, m_memranges
[i
].start
);
1239 printf_filtered ("(%d, %s, %ld)\n",
1240 m_memranges
[i
].type
,
1242 (long) (m_memranges
[i
].end
1243 - m_memranges
[i
].start
));
1245 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1247 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1254 bfd_signed_vma length
1255 = m_memranges
[i
].end
- m_memranges
[i
].start
;
1257 /* The "%X" conversion specifier expects an unsigned argument,
1258 so passing -1 (memrange_absolute) to it directly gives you
1259 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1261 if (m_memranges
[i
].type
== memrange_absolute
)
1262 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1264 sprintf (end
, "M%X,%s,%lX", m_memranges
[i
].type
, tmp2
, (long) length
);
1267 count
+= strlen (end
);
1268 end
= temp_buf
+ count
;
1271 for (i
= 0; i
< m_aexprs
.size (); i
++)
1273 QUIT
; /* Allow user to bail out with ^C. */
1274 if ((count
+ 10 + 2 * m_aexprs
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1276 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1281 sprintf (end
, "X%08X,", m_aexprs
[i
]->len
);
1282 end
+= 10; /* 'X' + 8 hex digits + ',' */
1285 end
= mem2hex (m_aexprs
[i
]->buf
, end
, m_aexprs
[i
]->len
);
1286 count
+= 2 * m_aexprs
[i
]->len
;
1291 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1296 (*str_list
)[ndx
] = NULL
;
1307 /* Add the printed expression EXP to *LIST. */
1310 collection_list::append_exp (struct expression
*exp
)
1312 struct ui_file
*tmp_stream
= mem_fileopen ();
1314 print_expression (exp
, tmp_stream
);
1316 m_computed
.push_back (ui_file_as_string (tmp_stream
));
1317 ui_file_delete (tmp_stream
);
1321 collection_list::finish ()
1323 memrange_sortmerge (m_memranges
);
1327 encode_actions_1 (struct command_line
*action
,
1328 struct bp_location
*tloc
,
1330 LONGEST frame_offset
,
1331 struct collection_list
*collect
,
1332 struct collection_list
*stepping_list
)
1334 const char *action_exp
;
1336 struct value
*tempval
;
1337 struct cmd_list_element
*cmd
;
1339 for (; action
; action
= action
->next
)
1341 QUIT
; /* Allow user to bail out with ^C. */
1342 action_exp
= action
->line
;
1343 action_exp
= skip_spaces_const (action_exp
);
1345 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1347 error (_("Bad action list item: %s"), action_exp
);
1349 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1351 int trace_string
= 0;
1353 if (*action_exp
== '/')
1354 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1357 { /* Repeat over a comma-separated list. */
1358 QUIT
; /* Allow user to bail out with ^C. */
1359 action_exp
= skip_spaces_const (action_exp
);
1361 if (0 == strncasecmp ("$reg", action_exp
, 4))
1363 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
1364 collect
->add_register (i
);
1365 action_exp
= strchr (action_exp
, ','); /* more? */
1367 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1369 collect
->add_local_symbols (target_gdbarch (),
1375 action_exp
= strchr (action_exp
, ','); /* more? */
1377 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1379 collect
->add_local_symbols (target_gdbarch (),
1385 action_exp
= strchr (action_exp
, ','); /* more? */
1387 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1390 = gen_trace_for_return_address (tloc
->address
,
1394 ax_reqs (aexpr
.get ());
1395 report_agent_reqs_errors (aexpr
.get ());
1397 /* take care of the registers */
1398 if (aexpr
->reg_mask_len
> 0)
1400 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1402 QUIT
; /* allow user to bail out with ^C */
1403 if (aexpr
->reg_mask
[ndx1
] != 0)
1405 /* assume chars have 8 bits */
1406 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1407 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1409 /* It's used -- record it. */
1410 collect
->add_register (ndx1
* 8 + ndx2
);
1416 collect
->add_aexpr (std::move (aexpr
));
1417 action_exp
= strchr (action_exp
, ','); /* more? */
1419 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1421 collect
->add_static_trace_data ();
1422 action_exp
= strchr (action_exp
, ','); /* more? */
1427 struct cleanup
*old_chain1
= NULL
;
1429 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1430 block_for_pc (tloc
->address
),
1433 switch (exp
->elts
[0].opcode
)
1437 const char *name
= &exp
->elts
[2].string
;
1439 i
= user_reg_map_name_to_regnum (target_gdbarch (),
1440 name
, strlen (name
));
1442 internal_error (__FILE__
, __LINE__
,
1443 _("Register $%s not available"),
1446 printf_filtered ("OP_REGISTER: ");
1447 collect
->add_register (i
);
1452 /* Safe because we know it's a simple expression. */
1453 tempval
= evaluate_expression (exp
.get ());
1454 addr
= value_address (tempval
);
1455 /* Initialize the TYPE_LENGTH if it is a typedef. */
1456 check_typedef (exp
->elts
[1].type
);
1457 collect
->add_memrange (memrange_absolute
, addr
,
1458 TYPE_LENGTH (exp
->elts
[1].type
));
1459 collect
->append_exp (exp
.get ());
1464 struct symbol
*sym
= exp
->elts
[2].symbol
;
1465 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1467 collect
->collect_symbol (exp
->elts
[2].symbol
,
1473 collect
->add_wholly_collected (name
);
1477 default: /* Full-fledged expression. */
1478 agent_expr_up aexpr
= gen_trace_for_expr (tloc
->address
,
1482 ax_reqs (aexpr
.get ());
1484 report_agent_reqs_errors (aexpr
.get ());
1486 /* Take care of the registers. */
1487 if (aexpr
->reg_mask_len
> 0)
1489 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1491 QUIT
; /* Allow user to bail out with ^C. */
1492 if (aexpr
->reg_mask
[ndx1
] != 0)
1494 /* Assume chars have 8 bits. */
1495 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1496 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1498 /* It's used -- record it. */
1499 collect
->add_register (ndx1
* 8 + ndx2
);
1505 collect
->add_aexpr (std::move (aexpr
));
1506 collect
->append_exp (exp
.get ());
1511 while (action_exp
&& *action_exp
++ == ',');
1513 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1516 { /* Repeat over a comma-separated list. */
1517 QUIT
; /* Allow user to bail out with ^C. */
1518 action_exp
= skip_spaces_const (action_exp
);
1521 struct cleanup
*old_chain1
= NULL
;
1523 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1524 block_for_pc (tloc
->address
),
1527 agent_expr_up aexpr
= gen_eval_for_expr (tloc
->address
,
1530 ax_reqs (aexpr
.get ());
1531 report_agent_reqs_errors (aexpr
.get ());
1533 /* Even though we're not officially collecting, add
1534 to the collect list anyway. */
1535 collect
->add_aexpr (std::move (aexpr
));
1538 while (action_exp
&& *action_exp
++ == ',');
1540 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1542 /* We check against nested while-stepping when setting
1543 breakpoint action, so no way to run into nested
1545 gdb_assert (stepping_list
);
1547 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1548 frame_offset
, stepping_list
, NULL
);
1551 error (_("Invalid tracepoint command '%s'"), action
->line
);
1555 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1556 and STEPPING_LIST. */
1559 encode_actions (struct bp_location
*tloc
,
1560 struct collection_list
*tracepoint_list
,
1561 struct collection_list
*stepping_list
)
1563 struct command_line
*actions
;
1565 LONGEST frame_offset
;
1567 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1568 tloc
->address
, &frame_reg
, &frame_offset
);
1570 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1572 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1573 tracepoint_list
, stepping_list
);
1575 tracepoint_list
->finish ();
1576 stepping_list
->finish ();
1579 /* Render all actions into gdb protocol. */
1582 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1583 char ***stepping_actions
)
1585 struct collection_list tracepoint_list
, stepping_list
;
1587 *tdp_actions
= NULL
;
1588 *stepping_actions
= NULL
;
1590 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
1592 *tdp_actions
= tracepoint_list
.stringify ();
1593 *stepping_actions
= stepping_list
.stringify ();
1597 collection_list::add_aexpr (agent_expr_up aexpr
)
1599 m_aexprs
.push_back (std::move (aexpr
));
1603 process_tracepoint_on_disconnect (void)
1605 VEC(breakpoint_p
) *tp_vec
= NULL
;
1607 struct breakpoint
*b
;
1608 int has_pending_p
= 0;
1610 /* Check whether we still have pending tracepoint. If we have, warn the
1611 user that pending tracepoint will no longer work. */
1612 tp_vec
= all_tracepoints ();
1613 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1622 struct bp_location
*loc1
;
1624 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1626 if (loc1
->shlib_disabled
)
1637 VEC_free (breakpoint_p
, tp_vec
);
1640 warning (_("Pending tracepoints will not be resolved while"
1641 " GDB is disconnected\n"));
1644 /* Reset local state of tracing. */
1647 trace_reset_local_state (void)
1649 set_traceframe_num (-1);
1650 set_tracepoint_num (-1);
1651 set_traceframe_context (NULL
);
1652 clear_traceframe_info ();
1656 start_tracing (char *notes
)
1658 VEC(breakpoint_p
) *tp_vec
= NULL
;
1660 struct breakpoint
*b
;
1661 struct trace_state_variable
*tsv
;
1662 int any_enabled
= 0, num_to_download
= 0;
1665 tp_vec
= all_tracepoints ();
1667 /* No point in tracing without any tracepoints... */
1668 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1670 VEC_free (breakpoint_p
, tp_vec
);
1671 error (_("No tracepoints defined, not starting trace"));
1674 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1676 if (b
->enable_state
== bp_enabled
)
1679 if ((b
->type
== bp_fast_tracepoint
1680 ? may_insert_fast_tracepoints
1681 : may_insert_tracepoints
))
1684 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1685 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1690 if (target_supports_enable_disable_tracepoint ())
1691 warning (_("No tracepoints enabled"));
1694 /* No point in tracing with only disabled tracepoints that
1695 cannot be re-enabled. */
1696 VEC_free (breakpoint_p
, tp_vec
);
1697 error (_("No tracepoints enabled, not starting trace"));
1701 if (num_to_download
<= 0)
1703 VEC_free (breakpoint_p
, tp_vec
);
1704 error (_("No tracepoints that may be downloaded, not starting trace"));
1707 target_trace_init ();
1709 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1711 struct tracepoint
*t
= (struct tracepoint
*) b
;
1712 struct bp_location
*loc
;
1713 int bp_location_downloaded
= 0;
1715 /* Clear `inserted' flag. */
1716 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1719 if ((b
->type
== bp_fast_tracepoint
1720 ? !may_insert_fast_tracepoints
1721 : !may_insert_tracepoints
))
1724 t
->number_on_target
= 0;
1726 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1728 /* Since tracepoint locations are never duplicated, `inserted'
1729 flag should be zero. */
1730 gdb_assert (!loc
->inserted
);
1732 target_download_tracepoint (loc
);
1735 bp_location_downloaded
= 1;
1738 t
->number_on_target
= b
->number
;
1740 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1741 if (loc
->probe
.probe
!= NULL
1742 && loc
->probe
.probe
->pops
->set_semaphore
!= NULL
)
1743 loc
->probe
.probe
->pops
->set_semaphore (loc
->probe
.probe
,
1747 if (bp_location_downloaded
)
1748 observer_notify_breakpoint_modified (b
);
1750 VEC_free (breakpoint_p
, tp_vec
);
1752 /* Send down all the trace state variables too. */
1753 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1755 target_download_trace_state_variable (tsv
);
1758 /* Tell target to treat text-like sections as transparent. */
1759 target_trace_set_readonly_regions ();
1760 /* Set some mode flags. */
1761 target_set_disconnected_tracing (disconnected_tracing
);
1762 target_set_circular_trace_buffer (circular_trace_buffer
);
1763 target_set_trace_buffer_size (trace_buffer_size
);
1766 notes
= trace_notes
;
1767 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1769 if (!ret
&& (trace_user
|| notes
))
1770 warning (_("Target does not support trace user/notes, info ignored"));
1772 /* Now insert traps and begin collecting data. */
1773 target_trace_start ();
1775 /* Reset our local state. */
1776 trace_reset_local_state ();
1777 current_trace_status()->running
= 1;
1780 /* The tstart command requests the target to start a new trace run.
1781 The command passes any arguments it has to the target verbatim, as
1782 an optional "trace note". This is useful as for instance a warning
1783 to other users if the trace runs disconnected, and you don't want
1784 anybody else messing with the target. */
1787 trace_start_command (char *args
, int from_tty
)
1789 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1791 if (current_trace_status ()->running
)
1794 && !query (_("A trace is running already. Start a new run? ")))
1795 error (_("New trace run not started."));
1798 start_tracing (args
);
1801 /* The tstop command stops the tracing run. The command passes any
1802 supplied arguments to the target verbatim as a "stop note"; if the
1803 target supports trace notes, then it will be reported back as part
1804 of the trace run's status. */
1807 trace_stop_command (char *args
, int from_tty
)
1809 if (!current_trace_status ()->running
)
1810 error (_("Trace is not running."));
1812 stop_tracing (args
);
1816 stop_tracing (char *note
)
1819 VEC(breakpoint_p
) *tp_vec
= NULL
;
1821 struct breakpoint
*t
;
1823 target_trace_stop ();
1825 tp_vec
= all_tracepoints ();
1826 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1828 struct bp_location
*loc
;
1830 if ((t
->type
== bp_fast_tracepoint
1831 ? !may_insert_fast_tracepoints
1832 : !may_insert_tracepoints
))
1835 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1837 /* GDB can be totally absent in some disconnected trace scenarios,
1838 but we don't really care if this semaphore goes out of sync.
1839 That's why we are decrementing it here, but not taking care
1841 if (loc
->probe
.probe
!= NULL
1842 && loc
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
1843 loc
->probe
.probe
->pops
->clear_semaphore (loc
->probe
.probe
,
1849 VEC_free (breakpoint_p
, tp_vec
);
1852 note
= trace_stop_notes
;
1853 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1856 warning (_("Target does not support trace notes, note ignored"));
1858 /* Should change in response to reply? */
1859 current_trace_status ()->running
= 0;
1862 /* tstatus command */
1864 trace_status_command (char *args
, int from_tty
)
1866 struct trace_status
*ts
= current_trace_status ();
1868 VEC(breakpoint_p
) *tp_vec
= NULL
;
1869 struct breakpoint
*t
;
1871 status
= target_get_trace_status (ts
);
1875 if (ts
->filename
!= NULL
)
1876 printf_filtered (_("Using a trace file.\n"));
1879 printf_filtered (_("Trace can not be run on this target.\n"));
1884 if (!ts
->running_known
)
1886 printf_filtered (_("Run/stop status is unknown.\n"));
1888 else if (ts
->running
)
1890 printf_filtered (_("Trace is running on the target.\n"));
1894 switch (ts
->stop_reason
)
1896 case trace_never_run
:
1897 printf_filtered (_("No trace has been run on the target.\n"));
1901 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1904 printf_filtered (_("Trace stopped by a tstop command.\n"));
1906 case trace_buffer_full
:
1907 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1909 case trace_disconnected
:
1910 printf_filtered (_("Trace stopped because of disconnection.\n"));
1912 case tracepoint_passcount
:
1913 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1914 ts
->stopping_tracepoint
);
1916 case tracepoint_error
:
1917 if (ts
->stopping_tracepoint
)
1918 printf_filtered (_("Trace stopped by an "
1919 "error (%s, tracepoint %d).\n"),
1920 ts
->stop_desc
, ts
->stopping_tracepoint
);
1922 printf_filtered (_("Trace stopped by an error (%s).\n"),
1925 case trace_stop_reason_unknown
:
1926 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1929 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1935 if (ts
->traceframes_created
>= 0
1936 && ts
->traceframe_count
!= ts
->traceframes_created
)
1938 printf_filtered (_("Buffer contains %d trace "
1939 "frames (of %d created total).\n"),
1940 ts
->traceframe_count
, ts
->traceframes_created
);
1942 else if (ts
->traceframe_count
>= 0)
1944 printf_filtered (_("Collected %d trace frames.\n"),
1945 ts
->traceframe_count
);
1948 if (ts
->buffer_free
>= 0)
1950 if (ts
->buffer_size
>= 0)
1952 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1953 ts
->buffer_free
, ts
->buffer_size
);
1954 if (ts
->buffer_size
> 0)
1955 printf_filtered (_(" (%d%% full)"),
1956 ((int) ((((long long) (ts
->buffer_size
1957 - ts
->buffer_free
)) * 100)
1958 / ts
->buffer_size
)));
1959 printf_filtered (_(".\n"));
1962 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1966 if (ts
->disconnected_tracing
)
1967 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1969 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1971 if (ts
->circular_buffer
)
1972 printf_filtered (_("Trace buffer is circular.\n"));
1974 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1975 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1977 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1978 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1980 /* Now report on what we're doing with tfind. */
1981 if (traceframe_number
>= 0)
1982 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1983 traceframe_number
, tracepoint_number
);
1985 printf_filtered (_("Not looking at any trace frame.\n"));
1987 /* Report start/stop times if supplied. */
1992 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1994 /* Reporting a run time is more readable than two long numbers. */
1995 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1996 (long int) (ts
->start_time
/ 1000000),
1997 (long int) (ts
->start_time
% 1000000),
1998 (long int) (run_time
/ 1000000),
1999 (long int) (run_time
% 1000000));
2002 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2003 (long int) (ts
->start_time
/ 1000000),
2004 (long int) (ts
->start_time
% 1000000));
2006 else if (ts
->stop_time
)
2007 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2008 (long int) (ts
->stop_time
/ 1000000),
2009 (long int) (ts
->stop_time
% 1000000));
2011 /* Now report any per-tracepoint status available. */
2012 tp_vec
= all_tracepoints ();
2014 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2015 target_get_tracepoint_status (t
, NULL
);
2017 VEC_free (breakpoint_p
, tp_vec
);
2020 /* Report the trace status to uiout, in a way suitable for MI, and not
2021 suitable for CLI. If ON_STOP is true, suppress a few fields that
2022 are not meaningful in the -trace-stop response.
2024 The implementation is essentially parallel to trace_status_command, but
2025 merging them will result in unreadable code. */
2027 trace_status_mi (int on_stop
)
2029 struct ui_out
*uiout
= current_uiout
;
2030 struct trace_status
*ts
= current_trace_status ();
2033 status
= target_get_trace_status (ts
);
2035 if (status
== -1 && ts
->filename
== NULL
)
2037 ui_out_field_string (uiout
, "supported", "0");
2041 if (ts
->filename
!= NULL
)
2042 ui_out_field_string (uiout
, "supported", "file");
2044 ui_out_field_string (uiout
, "supported", "1");
2046 if (ts
->filename
!= NULL
)
2047 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2049 gdb_assert (ts
->running_known
);
2053 ui_out_field_string (uiout
, "running", "1");
2055 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2056 Given that the frontend gets the status either on -trace-stop, or from
2057 -trace-status after re-connection, it does not seem like this
2058 information is necessary for anything. It is not necessary for either
2059 figuring the vital state of the target nor for navigation of trace
2060 frames. If the frontend wants to show the current state is some
2061 configure dialog, it can request the value when such dialog is
2062 invoked by the user. */
2066 char *stop_reason
= NULL
;
2067 int stopping_tracepoint
= -1;
2070 ui_out_field_string (uiout
, "running", "0");
2072 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2074 switch (ts
->stop_reason
)
2077 stop_reason
= "request";
2079 case trace_buffer_full
:
2080 stop_reason
= "overflow";
2082 case trace_disconnected
:
2083 stop_reason
= "disconnection";
2085 case tracepoint_passcount
:
2086 stop_reason
= "passcount";
2087 stopping_tracepoint
= ts
->stopping_tracepoint
;
2089 case tracepoint_error
:
2090 stop_reason
= "error";
2091 stopping_tracepoint
= ts
->stopping_tracepoint
;
2097 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2098 if (stopping_tracepoint
!= -1)
2099 ui_out_field_int (uiout
, "stopping-tracepoint",
2100 stopping_tracepoint
);
2101 if (ts
->stop_reason
== tracepoint_error
)
2102 ui_out_field_string (uiout
, "error-description",
2108 if (ts
->traceframe_count
!= -1)
2109 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2110 if (ts
->traceframes_created
!= -1)
2111 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2112 if (ts
->buffer_size
!= -1)
2113 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2114 if (ts
->buffer_free
!= -1)
2115 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2117 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2118 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2120 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2121 ui_out_field_string (uiout
, "notes", ts
->notes
);
2126 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2127 (long int) (ts
->start_time
/ 1000000),
2128 (long int) (ts
->start_time
% 1000000));
2129 ui_out_field_string (uiout
, "start-time", buf
);
2130 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2131 (long int) (ts
->stop_time
/ 1000000),
2132 (long int) (ts
->stop_time
% 1000000));
2133 ui_out_field_string (uiout
, "stop-time", buf
);
2137 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2138 user if she really wants to detach. */
2141 query_if_trace_running (int from_tty
)
2146 /* It can happen that the target that was tracing went away on its
2147 own, and we didn't notice. Get a status update, and if the
2148 current target doesn't even do tracing, then assume it's not
2150 if (target_get_trace_status (current_trace_status ()) < 0)
2151 current_trace_status ()->running
= 0;
2153 /* If running interactively, give the user the option to cancel and
2154 then decide what to do differently with the run. Scripts are
2155 just going to disconnect and let the target deal with it,
2156 according to how it's been instructed previously via
2157 disconnected-tracing. */
2158 if (current_trace_status ()->running
)
2160 process_tracepoint_on_disconnect ();
2162 if (current_trace_status ()->disconnected_tracing
)
2164 if (!query (_("Trace is running and will "
2165 "continue after detach; detach anyway? ")))
2166 error (_("Not confirmed."));
2170 if (!query (_("Trace is running but will "
2171 "stop on detach; detach anyway? ")))
2172 error (_("Not confirmed."));
2177 /* This function handles the details of what to do about an ongoing
2178 tracing run if the user has asked to detach or otherwise disconnect
2182 disconnect_tracing (void)
2184 /* Also we want to be out of tfind mode, otherwise things can get
2185 confusing upon reconnection. Just use these calls instead of
2186 full tfind_1 behavior because we're in the middle of detaching,
2187 and there's no point to updating current stack frame etc. */
2188 trace_reset_local_state ();
2191 /* Worker function for the various flavors of the tfind command. */
2193 tfind_1 (enum trace_find_type type
, int num
,
2194 CORE_ADDR addr1
, CORE_ADDR addr2
,
2197 int target_frameno
= -1, target_tracept
= -1;
2198 struct frame_id old_frame_id
= null_frame_id
;
2199 struct tracepoint
*tp
;
2200 struct ui_out
*uiout
= current_uiout
;
2202 /* Only try to get the current stack frame if we have a chance of
2203 succeeding. In particular, if we're trying to get a first trace
2204 frame while all threads are running, it's not going to succeed,
2205 so leave it with a default value and let the frame comparison
2206 below (correctly) decide to print out the source location of the
2208 if (!(type
== tfind_number
&& num
== -1)
2209 && (has_stack_frames () || traceframe_number
>= 0))
2210 old_frame_id
= get_frame_id (get_current_frame ());
2212 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2215 if (type
== tfind_number
2217 && target_frameno
== -1)
2219 /* We told the target to get out of tfind mode, and it did. */
2221 else if (target_frameno
== -1)
2223 /* A request for a non-existent trace frame has failed.
2224 Our response will be different, depending on FROM_TTY:
2226 If FROM_TTY is true, meaning that this command was
2227 typed interactively by the user, then give an error
2228 and DO NOT change the state of traceframe_number etc.
2230 However if FROM_TTY is false, meaning that we're either
2231 in a script, a loop, or a user-defined command, then
2232 DON'T give an error, but DO change the state of
2233 traceframe_number etc. to invalid.
2235 The rationalle is that if you typed the command, you
2236 might just have committed a typo or something, and you'd
2237 like to NOT lose your current debugging state. However
2238 if you're in a user-defined command or especially in a
2239 loop, then you need a way to detect that the command
2240 failed WITHOUT aborting. This allows you to write
2241 scripts that search thru the trace buffer until the end,
2242 and then continue on to do something else. */
2245 error (_("Target failed to find requested trace frame."));
2249 printf_filtered ("End of trace buffer.\n");
2250 #if 0 /* dubious now? */
2251 /* The following will not recurse, since it's
2253 trace_find_command ("-1", from_tty
);
2258 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2260 reinit_frame_cache ();
2261 target_dcache_invalidate ();
2263 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2265 if (target_frameno
!= get_traceframe_number ())
2266 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2268 set_current_traceframe (target_frameno
);
2270 if (target_frameno
== -1)
2271 set_traceframe_context (NULL
);
2273 set_traceframe_context (get_current_frame ());
2275 if (traceframe_number
>= 0)
2277 /* Use different branches for MI and CLI to make CLI messages
2279 if (ui_out_is_mi_like_p (uiout
))
2281 ui_out_field_string (uiout
, "found", "1");
2282 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2283 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2287 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2288 traceframe_number
, tracepoint_number
);
2293 if (ui_out_is_mi_like_p (uiout
))
2294 ui_out_field_string (uiout
, "found", "0");
2295 else if (type
== tfind_number
&& num
== -1)
2296 printf_unfiltered (_("No longer looking at any trace frame\n"));
2297 else /* This case may never occur, check. */
2298 printf_unfiltered (_("No trace frame found\n"));
2301 /* If we're in nonstop mode and getting out of looking at trace
2302 frames, there won't be any current frame to go back to and
2305 && (has_stack_frames () || traceframe_number
>= 0))
2307 enum print_what print_what
;
2309 /* NOTE: in imitation of the step command, try to determine
2310 whether we have made a transition from one function to
2311 another. If so, we'll print the "stack frame" (ie. the new
2312 function and it's arguments) -- otherwise we'll just show the
2315 if (frame_id_eq (old_frame_id
,
2316 get_frame_id (get_current_frame ())))
2317 print_what
= SRC_LINE
;
2319 print_what
= SRC_AND_LOC
;
2321 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2326 /* Error on looking at traceframes while trace is running. */
2329 check_trace_running (struct trace_status
*status
)
2331 if (status
->running
&& status
->filename
== NULL
)
2332 error (_("May not look at trace frames while trace is running."));
2335 /* trace_find_command takes a trace frame number n,
2336 sends "QTFrame:<n>" to the target,
2337 and accepts a reply that may contain several optional pieces
2338 of information: a frame number, a tracepoint number, and an
2339 indication of whether this is a trap frame or a stepping frame.
2341 The minimal response is just "OK" (which indicates that the
2342 target does not give us a frame number or a tracepoint number).
2343 Instead of that, the target may send us a string containing
2345 F<hexnum> (gives the selected frame number)
2346 T<hexnum> (gives the selected tracepoint number)
2351 trace_find_command (char *args
, int from_tty
)
2352 { /* This should only be called with a numeric argument. */
2355 check_trace_running (current_trace_status ());
2357 if (args
== 0 || *args
== 0)
2358 { /* TFIND with no args means find NEXT trace frame. */
2359 if (traceframe_number
== -1)
2360 frameno
= 0; /* "next" is first one. */
2362 frameno
= traceframe_number
+ 1;
2364 else if (0 == strcmp (args
, "-"))
2366 if (traceframe_number
== -1)
2367 error (_("not debugging trace buffer"));
2368 else if (from_tty
&& traceframe_number
== 0)
2369 error (_("already at start of trace buffer"));
2371 frameno
= traceframe_number
- 1;
2373 /* A hack to work around eval's need for fp to have been collected. */
2374 else if (0 == strcmp (args
, "-1"))
2377 frameno
= parse_and_eval_long (args
);
2380 error (_("invalid input (%d is less than zero)"), frameno
);
2382 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2387 trace_find_end_command (char *args
, int from_tty
)
2389 trace_find_command ("-1", from_tty
);
2394 trace_find_start_command (char *args
, int from_tty
)
2396 trace_find_command ("0", from_tty
);
2399 /* tfind pc command */
2401 trace_find_pc_command (char *args
, int from_tty
)
2405 check_trace_running (current_trace_status ());
2407 if (args
== 0 || *args
== 0)
2408 pc
= regcache_read_pc (get_current_regcache ());
2410 pc
= parse_and_eval_address (args
);
2412 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2415 /* tfind tracepoint command */
2417 trace_find_tracepoint_command (char *args
, int from_tty
)
2420 struct tracepoint
*tp
;
2422 check_trace_running (current_trace_status ());
2424 if (args
== 0 || *args
== 0)
2426 if (tracepoint_number
== -1)
2427 error (_("No current tracepoint -- please supply an argument."));
2429 tdp
= tracepoint_number
; /* Default is current TDP. */
2432 tdp
= parse_and_eval_long (args
);
2434 /* If we have the tracepoint on hand, use the number that the
2435 target knows about (which may be different if we disconnected
2436 and reconnected). */
2437 tp
= get_tracepoint (tdp
);
2439 tdp
= tp
->number_on_target
;
2441 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2444 /* TFIND LINE command:
2446 This command will take a sourceline for argument, just like BREAK
2447 or TRACE (ie. anything that "decode_line_1" can handle).
2449 With no argument, this command will find the next trace frame
2450 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2453 trace_find_line_command (char *args
, int from_tty
)
2455 static CORE_ADDR start_pc
, end_pc
;
2456 struct symtabs_and_lines sals
;
2457 struct symtab_and_line sal
;
2458 struct cleanup
*old_chain
;
2460 check_trace_running (current_trace_status ());
2462 if (args
== 0 || *args
== 0)
2464 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2466 sals
.sals
= XNEW (struct symtab_and_line
);
2471 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2475 old_chain
= make_cleanup (xfree
, sals
.sals
);
2476 if (sal
.symtab
== 0)
2477 error (_("No line number information available."));
2479 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2481 if (start_pc
== end_pc
)
2483 printf_filtered ("Line %d of \"%s\"",
2485 symtab_to_filename_for_display (sal
.symtab
));
2487 printf_filtered (" is at address ");
2488 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2490 printf_filtered (" but contains no code.\n");
2491 sal
= find_pc_line (start_pc
, 0);
2493 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2494 && start_pc
!= end_pc
)
2495 printf_filtered ("Attempting to find line %d instead.\n",
2498 error (_("Cannot find a good line."));
2502 /* Is there any case in which we get here, and have an address
2503 which the user would want to see? If we have debugging
2504 symbols and no line numbers? */
2505 error (_("Line number %d is out of range for \"%s\"."),
2506 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2508 /* Find within range of stated line. */
2510 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2512 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2513 do_cleanups (old_chain
);
2516 /* tfind range command */
2518 trace_find_range_command (char *args
, int from_tty
)
2520 static CORE_ADDR start
, stop
;
2523 check_trace_running (current_trace_status ());
2525 if (args
== 0 || *args
== 0)
2526 { /* XXX FIXME: what should default behavior be? */
2527 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2531 if (0 != (tmp
= strchr (args
, ',')))
2533 *tmp
++ = '\0'; /* Terminate start address. */
2534 tmp
= skip_spaces (tmp
);
2535 start
= parse_and_eval_address (args
);
2536 stop
= parse_and_eval_address (tmp
);
2539 { /* No explicit end address? */
2540 start
= parse_and_eval_address (args
);
2541 stop
= start
+ 1; /* ??? */
2544 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2547 /* tfind outside command */
2549 trace_find_outside_command (char *args
, int from_tty
)
2551 CORE_ADDR start
, stop
;
2554 if (current_trace_status ()->running
2555 && current_trace_status ()->filename
== NULL
)
2556 error (_("May not look at trace frames while trace is running."));
2558 if (args
== 0 || *args
== 0)
2559 { /* XXX FIXME: what should default behavior be? */
2560 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2564 if (0 != (tmp
= strchr (args
, ',')))
2566 *tmp
++ = '\0'; /* Terminate start address. */
2567 tmp
= skip_spaces (tmp
);
2568 start
= parse_and_eval_address (args
);
2569 stop
= parse_and_eval_address (tmp
);
2572 { /* No explicit end address? */
2573 start
= parse_and_eval_address (args
);
2574 stop
= start
+ 1; /* ??? */
2577 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2580 /* info scope command: list the locals for a scope. */
2582 scope_info (char *args
, int from_tty
)
2584 struct symtabs_and_lines sals
;
2586 struct bound_minimal_symbol msym
;
2587 const struct block
*block
;
2588 const char *symname
;
2589 char *save_args
= args
;
2590 struct block_iterator iter
;
2592 struct gdbarch
*gdbarch
;
2594 struct event_location
*location
;
2595 struct cleanup
*back_to
;
2597 if (args
== 0 || *args
== 0)
2598 error (_("requires an argument (function, "
2599 "line or *addr) to define a scope"));
2601 location
= string_to_event_location (&args
, current_language
);
2602 back_to
= make_cleanup_delete_event_location (location
);
2603 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
, NULL
, 0);
2604 if (sals
.nelts
== 0)
2606 /* Presumably decode_line_1 has already warned. */
2607 do_cleanups (back_to
);
2611 /* Resolve line numbers to PC. */
2612 resolve_sal_pc (&sals
.sals
[0]);
2613 block
= block_for_pc (sals
.sals
[0].pc
);
2617 QUIT
; /* Allow user to bail out with ^C. */
2618 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2620 QUIT
; /* Allow user to bail out with ^C. */
2622 printf_filtered ("Scope for %s:\n", save_args
);
2625 symname
= SYMBOL_PRINT_NAME (sym
);
2626 if (symname
== NULL
|| *symname
== '\0')
2627 continue; /* Probably botched, certainly useless. */
2629 gdbarch
= symbol_arch (sym
);
2631 printf_filtered ("Symbol %s is ", symname
);
2633 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2634 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2635 BLOCK_START (block
),
2639 switch (SYMBOL_CLASS (sym
))
2642 case LOC_UNDEF
: /* Messed up symbol? */
2643 printf_filtered ("a bogus symbol, class %d.\n",
2644 SYMBOL_CLASS (sym
));
2645 count
--; /* Don't count this one. */
2648 printf_filtered ("a constant with value %s (%s)",
2649 plongest (SYMBOL_VALUE (sym
)),
2650 hex_string (SYMBOL_VALUE (sym
)));
2652 case LOC_CONST_BYTES
:
2653 printf_filtered ("constant bytes: ");
2654 if (SYMBOL_TYPE (sym
))
2655 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2656 fprintf_filtered (gdb_stdout
, " %02x",
2657 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2660 printf_filtered ("in static storage at address ");
2661 printf_filtered ("%s", paddress (gdbarch
,
2662 SYMBOL_VALUE_ADDRESS (sym
)));
2665 /* GDBARCH is the architecture associated with the objfile
2666 the symbol is defined in; the target architecture may be
2667 different, and may provide additional registers. However,
2668 we do not know the target architecture at this point.
2669 We assume the objfile architecture will contain all the
2670 standard registers that occur in debug info in that
2672 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2675 if (SYMBOL_IS_ARGUMENT (sym
))
2676 printf_filtered ("an argument in register $%s",
2677 gdbarch_register_name (gdbarch
, regno
));
2679 printf_filtered ("a local variable in register $%s",
2680 gdbarch_register_name (gdbarch
, regno
));
2683 printf_filtered ("an argument at stack/frame offset %s",
2684 plongest (SYMBOL_VALUE (sym
)));
2687 printf_filtered ("a local variable at frame offset %s",
2688 plongest (SYMBOL_VALUE (sym
)));
2691 printf_filtered ("a reference argument at offset %s",
2692 plongest (SYMBOL_VALUE (sym
)));
2694 case LOC_REGPARM_ADDR
:
2695 /* Note comment at LOC_REGISTER. */
2696 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2698 printf_filtered ("the address of an argument, in register $%s",
2699 gdbarch_register_name (gdbarch
, regno
));
2702 printf_filtered ("a typedef.\n");
2705 printf_filtered ("a label at address ");
2706 printf_filtered ("%s", paddress (gdbarch
,
2707 SYMBOL_VALUE_ADDRESS (sym
)));
2710 printf_filtered ("a function at address ");
2711 printf_filtered ("%s",
2712 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2714 case LOC_UNRESOLVED
:
2715 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2717 if (msym
.minsym
== NULL
)
2718 printf_filtered ("Unresolved Static");
2721 printf_filtered ("static storage at address ");
2722 printf_filtered ("%s",
2724 BMSYMBOL_VALUE_ADDRESS (msym
)));
2727 case LOC_OPTIMIZED_OUT
:
2728 printf_filtered ("optimized out.\n");
2731 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2734 if (SYMBOL_TYPE (sym
))
2735 printf_filtered (", length %d.\n",
2736 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2738 if (BLOCK_FUNCTION (block
))
2741 block
= BLOCK_SUPERBLOCK (block
);
2744 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2746 do_cleanups (back_to
);
2749 /* Helper for trace_dump_command. Dump the action list starting at
2750 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2751 actions of the body of a while-stepping action. STEPPING_FRAME is
2752 set if the current traceframe was determined to be a while-stepping
2756 trace_dump_actions (struct command_line
*action
,
2757 int stepping_actions
, int stepping_frame
,
2760 const char *action_exp
, *next_comma
;
2762 for (; action
!= NULL
; action
= action
->next
)
2764 struct cmd_list_element
*cmd
;
2766 QUIT
; /* Allow user to bail out with ^C. */
2767 action_exp
= action
->line
;
2768 action_exp
= skip_spaces_const (action_exp
);
2770 /* The collection actions to be done while stepping are
2771 bracketed by the commands "while-stepping" and "end". */
2773 if (*action_exp
== '#') /* comment line */
2776 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2778 error (_("Bad action list item: %s"), action_exp
);
2780 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2784 for (i
= 0; i
< action
->body_count
; ++i
)
2785 trace_dump_actions (action
->body_list
[i
],
2786 1, stepping_frame
, from_tty
);
2788 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2790 /* Display the collected data.
2791 For the trap frame, display only what was collected at
2792 the trap. Likewise for stepping frames, display only
2793 what was collected while stepping. This means that the
2794 two boolean variables, STEPPING_FRAME and
2795 STEPPING_ACTIONS should be equal. */
2796 if (stepping_frame
== stepping_actions
)
2799 struct cleanup
*old_chain
2800 = make_cleanup (free_current_contents
, &cmd
);
2801 int trace_string
= 0;
2803 if (*action_exp
== '/')
2804 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2807 { /* Repeat over a comma-separated list. */
2808 QUIT
; /* Allow user to bail out with ^C. */
2809 if (*action_exp
== ',')
2811 action_exp
= skip_spaces_const (action_exp
);
2813 next_comma
= strchr (action_exp
, ',');
2815 if (0 == strncasecmp (action_exp
, "$reg", 4))
2816 registers_info (NULL
, from_tty
);
2817 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2819 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2820 locals_info (NULL
, from_tty
);
2821 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2822 args_info (NULL
, from_tty
);
2825 if (next_comma
!= NULL
)
2827 size_t len
= next_comma
- action_exp
;
2829 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2830 memcpy (cmd
, action_exp
, len
);
2835 size_t len
= strlen (action_exp
);
2837 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2838 memcpy (cmd
, action_exp
, len
+ 1);
2841 printf_filtered ("%s = ", cmd
);
2842 output_command_const (cmd
, from_tty
);
2843 printf_filtered ("\n");
2845 action_exp
= next_comma
;
2847 while (action_exp
&& *action_exp
== ',');
2849 do_cleanups (old_chain
);
2855 /* Return bp_location of the tracepoint associated with the current
2856 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2857 is a stepping traceframe. */
2859 struct bp_location
*
2860 get_traceframe_location (int *stepping_frame_p
)
2862 struct tracepoint
*t
;
2863 struct bp_location
*tloc
;
2864 struct regcache
*regcache
;
2866 if (tracepoint_number
== -1)
2867 error (_("No current trace frame."));
2869 t
= get_tracepoint (tracepoint_number
);
2872 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2875 /* The current frame is a trap frame if the frame PC is equal to the
2876 tracepoint PC. If not, then the current frame was collected
2877 during single-stepping. */
2878 regcache
= get_current_regcache ();
2880 /* If the traceframe's address matches any of the tracepoint's
2881 locations, assume it is a direct hit rather than a while-stepping
2882 frame. (FIXME this is not reliable, should record each frame's
2884 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
2885 if (tloc
->address
== regcache_read_pc (regcache
))
2887 *stepping_frame_p
= 0;
2891 /* If this is a stepping frame, we don't know which location
2892 triggered. The first is as good (or bad) a guess as any... */
2893 *stepping_frame_p
= 1;
2897 /* Return all the actions, including default collect, of a tracepoint
2898 T. It constructs cleanups into the chain, and leaves the caller to
2899 handle them (call do_cleanups). */
2901 static struct command_line
*
2902 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
2904 struct command_line
*actions
;
2906 actions
= breakpoint_commands (t
);
2908 /* If there are default expressions to collect, make up a collect
2909 action and prepend to the action list to encode. Note that since
2910 validation is per-tracepoint (local var "xyz" might be valid for
2911 one tracepoint and not another, etc), we make up the action on
2912 the fly, and don't cache it. */
2913 if (*default_collect
)
2915 struct command_line
*default_collect_action
;
2916 char *default_collect_line
;
2918 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2919 make_cleanup (xfree
, default_collect_line
);
2921 validate_actionline (default_collect_line
, t
);
2922 default_collect_action
= XNEW (struct command_line
);
2923 make_cleanup (xfree
, default_collect_action
);
2924 default_collect_action
->next
= actions
;
2925 default_collect_action
->line
= default_collect_line
;
2926 actions
= default_collect_action
;
2932 /* The tdump command. */
2935 trace_dump_command (char *args
, int from_tty
)
2937 int stepping_frame
= 0;
2938 struct bp_location
*loc
;
2939 struct cleanup
*old_chain
;
2940 struct command_line
*actions
;
2942 /* This throws an error is not inspecting a trace frame. */
2943 loc
= get_traceframe_location (&stepping_frame
);
2945 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2946 tracepoint_number
, traceframe_number
);
2948 /* This command only makes sense for the current frame, not the
2950 old_chain
= make_cleanup_restore_current_thread ();
2951 select_frame (get_current_frame ());
2953 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
2955 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2957 do_cleanups (old_chain
);
2960 /* Encode a piece of a tracepoint's source-level definition in a form
2961 that is suitable for both protocol and saving in files. */
2962 /* This version does not do multiple encodes for long strings; it should
2963 return an offset to the next piece to encode. FIXME */
2966 encode_source_string (int tpnum
, ULONGEST addr
,
2967 char *srctype
, const char *src
, char *buf
, int buf_size
)
2969 if (80 + strlen (srctype
) > buf_size
)
2970 error (_("Buffer too small for source encoding"));
2971 sprintf (buf
, "%x:%s:%s:%x:%x:",
2972 tpnum
, phex_nz (addr
, sizeof (addr
)),
2973 srctype
, 0, (int) strlen (src
));
2974 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2975 error (_("Source string too long for buffer"));
2976 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
2980 /* Tell the target what to do with an ongoing tracing run if GDB
2981 disconnects for some reason. */
2984 set_disconnected_tracing (char *args
, int from_tty
,
2985 struct cmd_list_element
*c
)
2987 target_set_disconnected_tracing (disconnected_tracing
);
2991 set_circular_trace_buffer (char *args
, int from_tty
,
2992 struct cmd_list_element
*c
)
2994 target_set_circular_trace_buffer (circular_trace_buffer
);
2998 set_trace_buffer_size (char *args
, int from_tty
,
2999 struct cmd_list_element
*c
)
3001 target_set_trace_buffer_size (trace_buffer_size
);
3005 set_trace_user (char *args
, int from_tty
,
3006 struct cmd_list_element
*c
)
3010 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3013 warning (_("Target does not support trace notes, user ignored"));
3017 set_trace_notes (char *args
, int from_tty
,
3018 struct cmd_list_element
*c
)
3022 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3025 warning (_("Target does not support trace notes, note ignored"));
3029 set_trace_stop_notes (char *args
, int from_tty
,
3030 struct cmd_list_element
*c
)
3034 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3037 warning (_("Target does not support trace notes, stop note ignored"));
3040 /* Convert the memory pointed to by mem into hex, placing result in buf.
3041 * Return a pointer to the last char put in buf (null)
3042 * "stolen" from sparc-stub.c
3045 static const char hexchars
[] = "0123456789abcdef";
3048 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3056 *buf
++ = hexchars
[ch
>> 4];
3057 *buf
++ = hexchars
[ch
& 0xf];
3066 get_traceframe_number (void)
3068 return traceframe_number
;
3072 get_tracepoint_number (void)
3074 return tracepoint_number
;
3077 /* Make the traceframe NUM be the current trace frame. Does nothing
3078 if NUM is already current. */
3081 set_current_traceframe (int num
)
3085 if (traceframe_number
== num
)
3087 /* Nothing to do. */
3091 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3094 warning (_("could not change traceframe"));
3096 set_traceframe_num (newnum
);
3098 /* Changing the traceframe changes our view of registers and of the
3100 registers_changed ();
3102 clear_traceframe_info ();
3105 /* A cleanup used when switching away and back from tfind mode. */
3107 struct current_traceframe_cleanup
3109 /* The traceframe we were inspecting. */
3110 int traceframe_number
;
3114 do_restore_current_traceframe_cleanup (void *arg
)
3116 struct current_traceframe_cleanup
*old
3117 = (struct current_traceframe_cleanup
*) arg
;
3119 set_current_traceframe (old
->traceframe_number
);
3123 restore_current_traceframe_cleanup_dtor (void *arg
)
3125 struct current_traceframe_cleanup
*old
3126 = (struct current_traceframe_cleanup
*) arg
;
3132 make_cleanup_restore_current_traceframe (void)
3134 struct current_traceframe_cleanup
*old
=
3135 XNEW (struct current_traceframe_cleanup
);
3137 old
->traceframe_number
= traceframe_number
;
3139 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3140 restore_current_traceframe_cleanup_dtor
);
3143 /* Given a number and address, return an uploaded tracepoint with that
3144 number, creating if necessary. */
3146 struct uploaded_tp
*
3147 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3149 struct uploaded_tp
*utp
;
3151 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3152 if (utp
->number
== num
&& utp
->addr
== addr
)
3155 utp
= XCNEW (struct uploaded_tp
);
3158 utp
->actions
= NULL
;
3159 utp
->step_actions
= NULL
;
3160 utp
->cmd_strings
= NULL
;
3168 free_uploaded_tps (struct uploaded_tp
**utpp
)
3170 struct uploaded_tp
*next_one
;
3174 next_one
= (*utpp
)->next
;
3180 /* Given a number and address, return an uploaded tracepoint with that
3181 number, creating if necessary. */
3183 struct uploaded_tsv
*
3184 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3186 struct uploaded_tsv
*utsv
;
3188 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3189 if (utsv
->number
== num
)
3192 utsv
= XCNEW (struct uploaded_tsv
);
3194 utsv
->next
= *utsvp
;
3201 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3203 struct uploaded_tsv
*next_one
;
3207 next_one
= (*utsvp
)->next
;
3213 /* FIXME this function is heuristic and will miss the cases where the
3214 conditional is semantically identical but differs in whitespace,
3215 such as "x == 0" vs "x==0". */
3218 cond_string_is_same (char *str1
, char *str2
)
3220 if (str1
== NULL
|| str2
== NULL
)
3221 return (str1
== str2
);
3223 return (strcmp (str1
, str2
) == 0);
3226 /* Look for an existing tracepoint that seems similar enough to the
3227 uploaded one. Enablement isn't compared, because the user can
3228 toggle that freely, and may have done so in anticipation of the
3229 next trace run. Return the location of matched tracepoint. */
3231 static struct bp_location
*
3232 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3234 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3236 struct breakpoint
*b
;
3237 struct bp_location
*loc
;
3239 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3241 struct tracepoint
*t
= (struct tracepoint
*) b
;
3243 if (b
->type
== utp
->type
3244 && t
->step_count
== utp
->step
3245 && t
->pass_count
== utp
->pass
3246 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3247 /* FIXME also test actions. */
3250 /* Scan the locations for an address match. */
3251 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3253 if (loc
->address
== utp
->addr
)
3261 /* Given a list of tracepoints uploaded from a target, attempt to
3262 match them up with existing tracepoints, and create new ones if not
3266 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3268 struct uploaded_tp
*utp
;
3269 /* A set of tracepoints which are modified. */
3270 VEC(breakpoint_p
) *modified_tp
= NULL
;
3272 struct breakpoint
*b
;
3274 /* Look for GDB tracepoints that match up with our uploaded versions. */
3275 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3277 struct bp_location
*loc
;
3278 struct tracepoint
*t
;
3280 loc
= find_matching_tracepoint_location (utp
);
3285 /* Mark this location as already inserted. */
3287 t
= (struct tracepoint
*) loc
->owner
;
3288 printf_filtered (_("Assuming tracepoint %d is same "
3289 "as target's tracepoint %d at %s.\n"),
3290 loc
->owner
->number
, utp
->number
,
3291 paddress (loc
->gdbarch
, utp
->addr
));
3293 /* The tracepoint LOC->owner was modified (the location LOC
3294 was marked as inserted in the target). Save it in
3295 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3296 observers will be notified later once for each tracepoint
3297 saved in MODIFIED_TP. */
3299 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3301 if (b
== loc
->owner
)
3307 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3311 t
= create_tracepoint_from_upload (utp
);
3313 printf_filtered (_("Created tracepoint %d for "
3314 "target's tracepoint %d at %s.\n"),
3315 t
->base
.number
, utp
->number
,
3316 paddress (get_current_arch (), utp
->addr
));
3318 printf_filtered (_("Failed to create tracepoint for target's "
3319 "tracepoint %d at %s, skipping it.\n"),
3321 paddress (get_current_arch (), utp
->addr
));
3323 /* Whether found or created, record the number used by the
3324 target, to help with mapping target tracepoints back to their
3325 counterparts here. */
3327 t
->number_on_target
= utp
->number
;
3330 /* Notify 'breakpoint-modified' observer that at least one of B's
3331 locations was changed. */
3332 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3333 observer_notify_breakpoint_modified (b
);
3335 VEC_free (breakpoint_p
, modified_tp
);
3336 free_uploaded_tps (uploaded_tps
);
3339 /* Trace state variables don't have much to identify them beyond their
3340 name, so just use that to detect matches. */
3342 static struct trace_state_variable
*
3343 find_matching_tsv (struct uploaded_tsv
*utsv
)
3348 return find_trace_state_variable (utsv
->name
);
3351 static struct trace_state_variable
*
3352 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3354 const char *namebase
;
3357 struct trace_state_variable
*tsv
;
3358 struct cleanup
*old_chain
;
3362 namebase
= utsv
->name
;
3363 buf
= xstrprintf ("%s", namebase
);
3368 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3371 /* Fish for a name that is not in use. */
3372 /* (should check against all internal vars?) */
3373 while (find_trace_state_variable (buf
))
3376 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3379 old_chain
= make_cleanup (xfree
, buf
);
3381 /* We have an available name, create the variable. */
3382 tsv
= create_trace_state_variable (buf
);
3383 tsv
->initial_value
= utsv
->initial_value
;
3384 tsv
->builtin
= utsv
->builtin
;
3386 observer_notify_tsv_created (tsv
);
3388 do_cleanups (old_chain
);
3393 /* Given a list of uploaded trace state variables, try to match them
3394 up with existing variables, or create additional ones. */
3397 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3400 struct uploaded_tsv
*utsv
;
3401 struct trace_state_variable
*tsv
;
3404 /* Most likely some numbers will have to be reassigned as part of
3405 the merge, so clear them all in anticipation. */
3406 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3409 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3411 tsv
= find_matching_tsv (utsv
);
3415 printf_filtered (_("Assuming trace state variable $%s "
3416 "is same as target's variable %d.\n"),
3417 tsv
->name
, utsv
->number
);
3421 tsv
= create_tsv_from_upload (utsv
);
3423 printf_filtered (_("Created trace state variable "
3424 "$%s for target's variable %d.\n"),
3425 tsv
->name
, utsv
->number
);
3427 /* Give precedence to numberings that come from the target. */
3429 tsv
->number
= utsv
->number
;
3432 /* Renumber everything that didn't get a target-assigned number. */
3434 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3435 if (tsv
->number
> highest
)
3436 highest
= tsv
->number
;
3439 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3440 if (tsv
->number
== 0)
3441 tsv
->number
= highest
++;
3443 free_uploaded_tsvs (uploaded_tsvs
);
3446 /* Parse the part of trace status syntax that is shared between
3447 the remote protocol and the trace file reader. */
3450 parse_trace_status (char *line
, struct trace_status
*ts
)
3452 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3456 ts
->running_known
= 1;
3457 ts
->running
= (*p
++ == '1');
3458 ts
->stop_reason
= trace_stop_reason_unknown
;
3459 xfree (ts
->stop_desc
);
3460 ts
->stop_desc
= NULL
;
3461 ts
->traceframe_count
= -1;
3462 ts
->traceframes_created
= -1;
3463 ts
->buffer_free
= -1;
3464 ts
->buffer_size
= -1;
3465 ts
->disconnected_tracing
= 0;
3466 ts
->circular_buffer
= 0;
3467 xfree (ts
->user_name
);
3468 ts
->user_name
= NULL
;
3471 ts
->start_time
= ts
->stop_time
= 0;
3475 p1
= strchr (p
, ':');
3477 error (_("Malformed trace status, at %s\n\
3478 Status line: '%s'\n"), p
, line
);
3479 p3
= strchr (p
, ';');
3481 p3
= p
+ strlen (p
);
3482 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3484 p
= unpack_varlen_hex (++p1
, &val
);
3485 ts
->stop_reason
= trace_buffer_full
;
3487 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3489 p
= unpack_varlen_hex (++p1
, &val
);
3490 ts
->stop_reason
= trace_never_run
;
3492 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3495 p
= unpack_varlen_hex (++p1
, &val
);
3496 ts
->stop_reason
= tracepoint_passcount
;
3497 ts
->stopping_tracepoint
= val
;
3499 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3501 p2
= strchr (++p1
, ':');
3509 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3510 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3511 ts
->stop_desc
[end
] = '\0';
3514 ts
->stop_desc
= xstrdup ("");
3516 p
= unpack_varlen_hex (++p2
, &val
);
3517 ts
->stop_reason
= tstop_command
;
3519 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3521 p
= unpack_varlen_hex (++p1
, &val
);
3522 ts
->stop_reason
= trace_disconnected
;
3524 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3526 p2
= strchr (++p1
, ':');
3529 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3530 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3531 ts
->stop_desc
[end
] = '\0';
3534 ts
->stop_desc
= xstrdup ("");
3536 p
= unpack_varlen_hex (++p2
, &val
);
3537 ts
->stopping_tracepoint
= val
;
3538 ts
->stop_reason
= tracepoint_error
;
3540 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3542 p
= unpack_varlen_hex (++p1
, &val
);
3543 ts
->traceframe_count
= val
;
3545 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3547 p
= unpack_varlen_hex (++p1
, &val
);
3548 ts
->traceframes_created
= val
;
3550 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3552 p
= unpack_varlen_hex (++p1
, &val
);
3553 ts
->buffer_free
= val
;
3555 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3557 p
= unpack_varlen_hex (++p1
, &val
);
3558 ts
->buffer_size
= val
;
3560 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3562 p
= unpack_varlen_hex (++p1
, &val
);
3563 ts
->disconnected_tracing
= val
;
3565 else if (strncmp (p
, "circular", p1
- p
) == 0)
3567 p
= unpack_varlen_hex (++p1
, &val
);
3568 ts
->circular_buffer
= val
;
3570 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3572 p
= unpack_varlen_hex (++p1
, &val
);
3573 ts
->start_time
= val
;
3575 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3577 p
= unpack_varlen_hex (++p1
, &val
);
3578 ts
->stop_time
= val
;
3580 else if (strncmp (p
, "username", p1
- p
) == 0)
3583 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3584 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3585 ts
->user_name
[end
] = '\0';
3588 else if (strncmp (p
, "notes", p1
- p
) == 0)
3591 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3592 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3593 ts
->notes
[end
] = '\0';
3598 /* Silently skip unknown optional info. */
3599 p_temp
= strchr (p1
+ 1, ';');
3603 /* Must be at the end. */
3610 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3611 struct uploaded_tp
*utp
)
3614 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3616 p
= unpack_varlen_hex (p
, &uval
);
3618 tp
->base
.hit_count
+= uval
;
3620 utp
->hit_count
+= uval
;
3621 p
= unpack_varlen_hex (p
+ 1, &uval
);
3623 tp
->traceframe_usage
+= uval
;
3625 utp
->traceframe_usage
+= uval
;
3626 /* Ignore any extra, allowing for future extensions. */
3629 /* Given a line of text defining a part of a tracepoint, parse it into
3630 an "uploaded tracepoint". */
3633 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3637 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3640 char *cond
, *srctype
, *buf
;
3641 struct uploaded_tp
*utp
= NULL
;
3644 /* Both tracepoint and action definitions start with the same number
3645 and address sequence. */
3647 p
= unpack_varlen_hex (p
, &num
);
3648 p
++; /* skip a colon */
3649 p
= unpack_varlen_hex (p
, &addr
);
3650 p
++; /* skip a colon */
3653 enabled
= (*p
++ == 'E');
3654 p
++; /* skip a colon */
3655 p
= unpack_varlen_hex (p
, &step
);
3656 p
++; /* skip a colon */
3657 p
= unpack_varlen_hex (p
, &pass
);
3658 type
= bp_tracepoint
;
3660 /* Thumb through optional fields. */
3663 p
++; /* skip a colon */
3666 type
= bp_fast_tracepoint
;
3668 p
= unpack_varlen_hex (p
, &orig_size
);
3672 type
= bp_static_tracepoint
;
3678 p
= unpack_varlen_hex (p
, &xlen
);
3679 p
++; /* skip a comma */
3680 cond
= (char *) xmalloc (2 * xlen
+ 1);
3681 strncpy (cond
, p
, 2 * xlen
);
3682 cond
[2 * xlen
] = '\0';
3686 warning (_("Unrecognized char '%c' in tracepoint "
3687 "definition, skipping rest"), *p
);
3689 utp
= get_uploaded_tp (num
, addr
, utpp
);
3691 utp
->enabled
= enabled
;
3696 else if (piece
== 'A')
3698 utp
= get_uploaded_tp (num
, addr
, utpp
);
3699 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3701 else if (piece
== 'S')
3703 utp
= get_uploaded_tp (num
, addr
, utpp
);
3704 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3706 else if (piece
== 'Z')
3708 /* Parse a chunk of source form definition. */
3709 utp
= get_uploaded_tp (num
, addr
, utpp
);
3711 p
= strchr (p
, ':');
3712 p
++; /* skip a colon */
3713 p
= unpack_varlen_hex (p
, &start
);
3714 p
++; /* skip a colon */
3715 p
= unpack_varlen_hex (p
, &xlen
);
3716 p
++; /* skip a colon */
3718 buf
= (char *) alloca (strlen (line
));
3720 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3723 if (startswith (srctype
, "at:"))
3724 utp
->at_string
= xstrdup (buf
);
3725 else if (startswith (srctype
, "cond:"))
3726 utp
->cond_string
= xstrdup (buf
);
3727 else if (startswith (srctype
, "cmd:"))
3728 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3730 else if (piece
== 'V')
3732 utp
= get_uploaded_tp (num
, addr
, utpp
);
3734 parse_tracepoint_status (p
, NULL
, utp
);
3738 /* Don't error out, the target might be sending us optional
3739 info that we don't care about. */
3740 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3744 /* Convert a textual description of a trace state variable into an
3748 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3751 ULONGEST num
, initval
, builtin
;
3753 struct uploaded_tsv
*utsv
= NULL
;
3755 buf
= (char *) alloca (strlen (line
));
3758 p
= unpack_varlen_hex (p
, &num
);
3759 p
++; /* skip a colon */
3760 p
= unpack_varlen_hex (p
, &initval
);
3761 p
++; /* skip a colon */
3762 p
= unpack_varlen_hex (p
, &builtin
);
3763 p
++; /* skip a colon */
3764 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3767 utsv
= get_uploaded_tsv (num
, utsvp
);
3768 utsv
->initial_value
= initval
;
3769 utsv
->builtin
= builtin
;
3770 utsv
->name
= xstrdup (buf
);
3774 free_current_marker (void *arg
)
3776 struct static_tracepoint_marker
**marker_p
3777 = (struct static_tracepoint_marker
**) arg
;
3779 if (*marker_p
!= NULL
)
3781 release_static_tracepoint_marker (*marker_p
);
3788 /* Given a line of text defining a static tracepoint marker, parse it
3789 into a "static tracepoint marker" object. Throws an error is
3790 parsing fails. If PP is non-null, it points to one past the end of
3791 the parsed marker definition. */
3794 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
3795 struct static_tracepoint_marker
*marker
)
3802 p
= unpack_varlen_hex (p
, &addr
);
3803 p
++; /* skip a colon */
3805 marker
->gdbarch
= target_gdbarch ();
3806 marker
->address
= (CORE_ADDR
) addr
;
3808 endp
= strchr (p
, ':');
3810 error (_("bad marker definition: %s"), line
);
3812 marker
->str_id
= (char *) xmalloc (endp
- p
+ 1);
3813 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
3814 marker
->str_id
[end
] = '\0';
3817 p
++; /* skip a colon */
3819 marker
->extra
= (char *) xmalloc (strlen (p
) + 1);
3820 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
3821 marker
->extra
[end
] = '\0';
3827 /* Release a static tracepoint marker's contents. Note that the
3828 object itself isn't released here. There objects are usually on
3832 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
3834 xfree (marker
->str_id
);
3835 marker
->str_id
= NULL
;
3838 /* Print MARKER to gdb_stdout. */
3841 print_one_static_tracepoint_marker (int count
,
3842 struct static_tracepoint_marker
*marker
)
3846 char wrap_indent
[80];
3847 char extra_field_indent
[80];
3848 struct ui_out
*uiout
= current_uiout
;
3849 struct cleanup
*bkpt_chain
;
3850 VEC(breakpoint_p
) *tracepoints
;
3852 struct symtab_and_line sal
;
3856 sal
.pc
= marker
->address
;
3858 tracepoints
= static_tracepoints_here (marker
->address
);
3860 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
3862 /* A counter field to help readability. This is not a stable
3864 ui_out_field_int (uiout
, "count", count
);
3866 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
3868 ui_out_field_fmt (uiout
, "enabled", "%c",
3869 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
3870 ui_out_spaces (uiout
, 2);
3872 strcpy (wrap_indent
, " ");
3874 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
3875 strcat (wrap_indent
, " ");
3877 strcat (wrap_indent
, " ");
3879 strcpy (extra_field_indent
, " ");
3881 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
3883 sal
= find_pc_line (marker
->address
, 0);
3884 sym
= find_pc_sect_function (marker
->address
, NULL
);
3887 ui_out_text (uiout
, "in ");
3888 ui_out_field_string (uiout
, "func",
3889 SYMBOL_PRINT_NAME (sym
));
3890 ui_out_wrap_hint (uiout
, wrap_indent
);
3891 ui_out_text (uiout
, " at ");
3894 ui_out_field_skip (uiout
, "func");
3896 if (sal
.symtab
!= NULL
)
3898 ui_out_field_string (uiout
, "file",
3899 symtab_to_filename_for_display (sal
.symtab
));
3900 ui_out_text (uiout
, ":");
3902 if (ui_out_is_mi_like_p (uiout
))
3904 const char *fullname
= symtab_to_fullname (sal
.symtab
);
3906 ui_out_field_string (uiout
, "fullname", fullname
);
3909 ui_out_field_skip (uiout
, "fullname");
3911 ui_out_field_int (uiout
, "line", sal
.line
);
3915 ui_out_field_skip (uiout
, "fullname");
3916 ui_out_field_skip (uiout
, "line");
3919 ui_out_text (uiout
, "\n");
3920 ui_out_text (uiout
, extra_field_indent
);
3921 ui_out_text (uiout
, _("Data: \""));
3922 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
3923 ui_out_text (uiout
, "\"\n");
3925 if (!VEC_empty (breakpoint_p
, tracepoints
))
3927 struct cleanup
*cleanup_chain
;
3929 struct breakpoint
*b
;
3931 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
3934 ui_out_text (uiout
, extra_field_indent
);
3935 ui_out_text (uiout
, _("Probed by static tracepoints: "));
3936 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
3939 ui_out_text (uiout
, ", ");
3940 ui_out_text (uiout
, "#");
3941 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
3944 do_cleanups (cleanup_chain
);
3946 if (ui_out_is_mi_like_p (uiout
))
3947 ui_out_field_int (uiout
, "number-of-tracepoints",
3948 VEC_length(breakpoint_p
, tracepoints
));
3950 ui_out_text (uiout
, "\n");
3952 VEC_free (breakpoint_p
, tracepoints
);
3954 do_cleanups (bkpt_chain
);
3958 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
3960 VEC(static_tracepoint_marker_p
) *markers
;
3961 struct cleanup
*old_chain
;
3962 struct static_tracepoint_marker
*marker
;
3963 struct ui_out
*uiout
= current_uiout
;
3966 /* We don't have to check target_can_use_agent and agent's capability on
3967 static tracepoint here, in order to be compatible with older GDBserver.
3968 We don't check USE_AGENT is true or not, because static tracepoints
3969 don't work without in-process agent, so we don't bother users to type
3970 `set agent on' when to use static tracepoint. */
3973 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
3974 "StaticTracepointMarkersTable");
3976 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
3978 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
3980 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
3981 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3982 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
3984 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
3985 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
3987 ui_out_table_body (uiout
);
3989 markers
= target_static_tracepoint_markers_by_strid (NULL
);
3990 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
3993 VEC_iterate (static_tracepoint_marker_p
,
3994 markers
, i
, marker
);
3997 print_one_static_tracepoint_marker (i
+ 1, marker
);
3998 release_static_tracepoint_marker (marker
);
4001 do_cleanups (old_chain
);
4004 /* The $_sdata convenience variable is a bit special. We don't know
4005 for sure type of the value until we actually have a chance to fetch
4006 the data --- the size of the object depends on what has been
4007 collected. We solve this by making $_sdata be an internalvar that
4008 creates a new value on access. */
4010 /* Return a new value with the correct type for the sdata object of
4011 the current trace frame. Return a void value if there's no object
4014 static struct value
*
4015 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4021 /* We need to read the whole object before we know its size. */
4022 size
= target_read_alloc (¤t_target
,
4023 TARGET_OBJECT_STATIC_TRACE_DATA
,
4030 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4032 v
= allocate_value (type
);
4033 memcpy (value_contents_raw (v
), buf
, size
);
4038 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4041 #if !defined(HAVE_LIBEXPAT)
4043 struct traceframe_info
*
4044 parse_traceframe_info (const char *tframe_info
)
4046 static int have_warned
;
4051 warning (_("Can not parse XML trace frame info; XML support "
4052 "was disabled at compile time"));
4058 #else /* HAVE_LIBEXPAT */
4060 #include "xml-support.h"
4062 /* Handle the start of a <memory> element. */
4065 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4066 const struct gdb_xml_element
*element
,
4067 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4069 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
4070 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4071 ULONGEST
*start_p
, *length_p
;
4074 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
;
4076 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
;
4078 r
->start
= *start_p
;
4079 r
->length
= *length_p
;
4082 /* Handle the start of a <tvar> element. */
4085 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
4086 const struct gdb_xml_element
*element
,
4088 VEC(gdb_xml_value_s
) *attributes
)
4090 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
4091 const char *id_attrib
4092 = (const char *) xml_find_attribute (attributes
, "id")->value
;
4093 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
4095 VEC_safe_push (int, info
->tvars
, id
);
4098 /* Discard the constructed trace frame info (if an error occurs). */
4101 free_result (void *p
)
4103 struct traceframe_info
*result
= (struct traceframe_info
*) p
;
4105 free_traceframe_info (result
);
4108 /* The allowed elements and attributes for an XML memory map. */
4110 static const struct gdb_xml_attribute memory_attributes
[] = {
4111 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4112 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4113 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4116 static const struct gdb_xml_attribute tvar_attributes
[] = {
4117 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
4118 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4121 static const struct gdb_xml_element traceframe_info_children
[] = {
4122 { "memory", memory_attributes
, NULL
,
4123 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4124 traceframe_info_start_memory
, NULL
},
4125 { "tvar", tvar_attributes
, NULL
,
4126 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4127 traceframe_info_start_tvar
, NULL
},
4128 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4131 static const struct gdb_xml_element traceframe_info_elements
[] = {
4132 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4134 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4137 /* Parse a traceframe-info XML document. */
4139 struct traceframe_info
*
4140 parse_traceframe_info (const char *tframe_info
)
4142 struct traceframe_info
*result
;
4143 struct cleanup
*back_to
;
4145 result
= XCNEW (struct traceframe_info
);
4146 back_to
= make_cleanup (free_result
, result
);
4148 if (gdb_xml_parse_quick (_("trace frame info"),
4149 "traceframe-info.dtd", traceframe_info_elements
,
4150 tframe_info
, result
) == 0)
4152 /* Parsed successfully, keep the result. */
4153 discard_cleanups (back_to
);
4158 do_cleanups (back_to
);
4162 #endif /* HAVE_LIBEXPAT */
4164 /* Returns the traceframe_info object for the current traceframe.
4165 This is where we avoid re-fetching the object from the target if we
4166 already have it cached. */
4168 struct traceframe_info
*
4169 get_traceframe_info (void)
4171 if (traceframe_info
== NULL
)
4172 traceframe_info
= target_traceframe_info ();
4174 return traceframe_info
;
4177 /* If the target supports the query, return in RESULT the set of
4178 collected memory in the current traceframe, found within the LEN
4179 bytes range starting at MEMADDR. Returns true if the target
4180 supports the query, otherwise returns false, and RESULT is left
4184 traceframe_available_memory (VEC(mem_range_s
) **result
,
4185 CORE_ADDR memaddr
, ULONGEST len
)
4187 struct traceframe_info
*info
= get_traceframe_info ();
4191 struct mem_range
*r
;
4196 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4197 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4199 ULONGEST lo1
, hi1
, lo2
, hi2
;
4200 struct mem_range
*nr
;
4203 hi1
= memaddr
+ len
;
4206 hi2
= r
->start
+ r
->length
;
4208 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4210 nr
->start
= std::max (lo1
, lo2
);
4211 nr
->length
= std::min (hi1
, hi2
) - nr
->start
;
4214 normalize_mem_ranges (*result
);
4221 /* Implementation of `sdata' variable. */
4223 static const struct internalvar_funcs sdata_funcs
=
4230 /* module initialization */
4232 _initialize_tracepoint (void)
4234 struct cmd_list_element
*c
;
4236 /* Explicitly create without lookup, since that tries to create a
4237 value with a void typed value, and when we get here, gdbarch
4238 isn't initialized yet. At this point, we're quite sure there
4239 isn't another convenience variable of the same name. */
4240 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4242 traceframe_number
= -1;
4243 tracepoint_number
= -1;
4245 add_info ("scope", scope_info
,
4246 _("List the variables local to a scope"));
4248 add_cmd ("tracepoints", class_trace
, NULL
,
4249 _("Tracing of program execution without stopping the program."),
4252 add_com ("tdump", class_trace
, trace_dump_command
,
4253 _("Print everything collected at the current tracepoint."));
4255 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4256 Define a trace state variable.\n\
4257 Argument is a $-prefixed name, optionally followed\n\
4258 by '=' and an expression that sets the initial value\n\
4259 at the start of tracing."));
4260 set_cmd_completer (c
, expression_completer
);
4262 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4263 Delete one or more trace state variables.\n\
4264 Arguments are the names of the variables to delete.\n\
4265 If no arguments are supplied, delete all variables."), &deletelist
);
4266 /* FIXME add a trace variable completer. */
4268 add_info ("tvariables", tvariables_info
, _("\
4269 Status of trace state variables and their values.\n\
4272 add_info ("static-tracepoint-markers",
4273 info_static_tracepoint_markers_command
, _("\
4274 List target static tracepoints markers.\n\
4277 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4278 Select a trace frame;\n\
4279 No argument means forward by one frame; '-' means backward by one frame."),
4280 &tfindlist
, "tfind ", 1, &cmdlist
);
4282 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4283 Select a trace frame whose PC is outside the given range (exclusive).\n\
4284 Usage: tfind outside addr1, addr2"),
4287 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4288 Select a trace frame whose PC is in the given range (inclusive).\n\
4289 Usage: tfind range addr1,addr2"),
4292 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4293 Select a trace frame by source line.\n\
4294 Argument can be a line number (with optional source file),\n\
4295 a function name, or '*' followed by an address.\n\
4296 Default argument is 'the next source line that was traced'."),
4299 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4300 Select a trace frame by tracepoint number.\n\
4301 Default is the tracepoint for the current trace frame."),
4304 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4305 Select a trace frame by PC.\n\
4306 Default is the current PC, or the PC of the current trace frame."),
4309 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4310 De-select any trace frame and resume 'live' debugging."),
4313 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4315 add_cmd ("start", class_trace
, trace_find_start_command
,
4316 _("Select the first trace frame in the trace buffer."),
4319 add_com ("tstatus", class_trace
, trace_status_command
,
4320 _("Display the status of the current trace data collection."));
4322 add_com ("tstop", class_trace
, trace_stop_command
, _("\
4323 Stop trace data collection.\n\
4324 Usage: tstop [ <notes> ... ]\n\
4325 Any arguments supplied are recorded with the trace as a stop reason and\n\
4326 reported by tstatus (if the target supports trace notes)."));
4328 add_com ("tstart", class_trace
, trace_start_command
, _("\
4329 Start trace data collection.\n\
4330 Usage: tstart [ <notes> ... ]\n\
4331 Any arguments supplied are recorded with the trace as a note and\n\
4332 reported by tstatus (if the target supports trace notes)."));
4334 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4335 Ends a list of commands or actions.\n\
4336 Several GDB commands allow you to enter a list of commands or actions.\n\
4337 Entering \"end\" on a line by itself is the normal way to terminate\n\
4339 Note: the \"end\" command cannot be used at the gdb prompt."));
4341 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4342 Specify single-stepping behavior at a tracepoint.\n\
4343 Argument is number of instructions to trace in single-step mode\n\
4344 following the tracepoint. This command is normally followed by\n\
4345 one or more \"collect\" commands, to specify what to collect\n\
4346 while single-stepping.\n\n\
4347 Note: this command can only be used in a tracepoint \"actions\" list."));
4349 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4350 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4352 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4353 Specify one or more data items to be collected at a tracepoint.\n\
4354 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4355 collect all data (variables, registers) referenced by that expression.\n\
4356 Also accepts the following special arguments:\n\
4357 $regs -- all registers.\n\
4358 $args -- all function arguments.\n\
4359 $locals -- all variables local to the block/function scope.\n\
4360 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4361 Note: this command can only be used in a tracepoint \"actions\" list."));
4363 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4364 Specify one or more expressions to be evaluated at a tracepoint.\n\
4365 Accepts a comma-separated list of (one or more) expressions.\n\
4366 The result of each evaluation will be discarded.\n\
4367 Note: this command can only be used in a tracepoint \"actions\" list."));
4369 add_com ("actions", class_trace
, trace_actions_command
, _("\
4370 Specify the actions to be taken at a tracepoint.\n\
4371 Tracepoint actions may include collecting of specified data,\n\
4372 single-stepping, or enabling/disabling other tracepoints,\n\
4373 depending on target's capabilities."));
4375 default_collect
= xstrdup ("");
4376 add_setshow_string_cmd ("default-collect", class_trace
,
4377 &default_collect
, _("\
4378 Set the list of expressions to collect by default"), _("\
4379 Show the list of expressions to collect by default"), NULL
,
4381 &setlist
, &showlist
);
4383 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4384 &disconnected_tracing
, _("\
4385 Set whether tracing continues after GDB disconnects."), _("\
4386 Show whether tracing continues after GDB disconnects."), _("\
4387 Use this to continue a tracing run even if GDB disconnects\n\
4388 or detaches from the target. You can reconnect later and look at\n\
4389 trace data collected in the meantime."),
4390 set_disconnected_tracing
,
4395 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4396 &circular_trace_buffer
, _("\
4397 Set target's use of circular trace buffer."), _("\
4398 Show target's use of circular trace buffer."), _("\
4399 Use this to make the trace buffer into a circular buffer,\n\
4400 which will discard traceframes (oldest first) instead of filling\n\
4401 up and stopping the trace run."),
4402 set_circular_trace_buffer
,
4407 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4408 &trace_buffer_size
, _("\
4409 Set requested size of trace buffer."), _("\
4410 Show requested size of trace buffer."), _("\
4411 Use this to choose a size for the trace buffer. Some targets\n\
4412 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4413 disables any attempt to set the buffer size and lets the target choose."),
4414 set_trace_buffer_size
, NULL
,
4415 &setlist
, &showlist
);
4417 add_setshow_string_cmd ("trace-user", class_trace
,
4419 Set the user name to use for current and future trace runs"), _("\
4420 Show the user name to use for current and future trace runs"), NULL
,
4421 set_trace_user
, NULL
,
4422 &setlist
, &showlist
);
4424 add_setshow_string_cmd ("trace-notes", class_trace
,
4426 Set notes string to use for current and future trace runs"), _("\
4427 Show the notes string to use for current and future trace runs"), NULL
,
4428 set_trace_notes
, NULL
,
4429 &setlist
, &showlist
);
4431 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4432 &trace_stop_notes
, _("\
4433 Set notes string to use for future tstop commands"), _("\
4434 Show the notes string to use for future tstop commands"), NULL
,
4435 set_trace_stop_notes
, NULL
,
4436 &setlist
, &showlist
);