1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2017 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 actions_command (char *, int);
170 static void tstart_command (char *, int);
171 static void tstop_command (char *, int);
172 static void tstatus_command (char *, int);
173 static void tfind_pc_command (char *, int);
174 static void tfind_tracepoint_command (char *, int);
175 static void tfind_line_command (char *, int);
176 static void tfind_range_command (char *, int);
177 static void tfind_outside_command (char *, int);
178 static void tdump_command (char *, int);
180 /* support routines */
182 struct collection_list
;
183 static char *mem2hex (gdb_byte
*, char *, int);
185 static struct command_line
*
186 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
188 extern void _initialize_tracepoint (void);
190 static struct trace_status trace_status
;
192 const char *stop_reason_names
[] = {
202 struct trace_status
*
203 current_trace_status (void)
205 return &trace_status
;
211 free_traceframe_info (struct traceframe_info
*info
)
215 VEC_free (mem_range_s
, info
->memory
);
216 VEC_free (int, info
->tvars
);
222 /* Free and clear the traceframe info cache of the current
226 clear_traceframe_info (void)
228 free_traceframe_info (traceframe_info
);
229 traceframe_info
= NULL
;
232 /* Set traceframe number to NUM. */
234 set_traceframe_num (int num
)
236 traceframe_number
= num
;
237 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
240 /* Set tracepoint number to NUM. */
242 set_tracepoint_num (int num
)
244 tracepoint_number
= num
;
245 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
248 /* Set externally visible debug variables for querying/printing
249 the traceframe context (line, function, file). */
252 set_traceframe_context (struct frame_info
*trace_frame
)
255 struct symbol
*traceframe_fun
;
256 struct symtab_and_line traceframe_sal
;
258 /* Save as globals for internal use. */
259 if (trace_frame
!= NULL
260 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
262 traceframe_sal
= find_pc_line (trace_pc
, 0);
263 traceframe_fun
= find_pc_function (trace_pc
);
265 /* Save linenumber as "$trace_line", a debugger variable visible to
267 set_internalvar_integer (lookup_internalvar ("trace_line"),
268 traceframe_sal
.line
);
272 init_sal (&traceframe_sal
);
273 traceframe_fun
= NULL
;
274 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
277 /* Save func name as "$trace_func", a debugger variable visible to
279 if (traceframe_fun
== NULL
280 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
281 clear_internalvar (lookup_internalvar ("trace_func"));
283 set_internalvar_string (lookup_internalvar ("trace_func"),
284 SYMBOL_LINKAGE_NAME (traceframe_fun
));
286 /* Save file name as "$trace_file", a debugger variable visible to
288 if (traceframe_sal
.symtab
== NULL
)
289 clear_internalvar (lookup_internalvar ("trace_file"));
291 set_internalvar_string (lookup_internalvar ("trace_file"),
292 symtab_to_filename_for_display (traceframe_sal
.symtab
));
295 /* Create a new trace state variable with the given name. */
297 struct trace_state_variable
*
298 create_trace_state_variable (const char *name
)
300 struct trace_state_variable tsv
;
302 memset (&tsv
, 0, sizeof (tsv
));
303 tsv
.name
= xstrdup (name
);
304 tsv
.number
= next_tsv_number
++;
305 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
308 /* Look for a trace state variable of the given name. */
310 struct trace_state_variable
*
311 find_trace_state_variable (const char *name
)
313 struct trace_state_variable
*tsv
;
316 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
317 if (strcmp (name
, tsv
->name
) == 0)
323 /* Look for a trace state variable of the given number. Return NULL if
326 struct trace_state_variable
*
327 find_trace_state_variable_by_number (int number
)
329 struct trace_state_variable
*tsv
;
332 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
333 if (tsv
->number
== number
)
340 delete_trace_state_variable (const char *name
)
342 struct trace_state_variable
*tsv
;
345 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
346 if (strcmp (name
, tsv
->name
) == 0)
348 observer_notify_tsv_deleted (tsv
);
350 xfree ((void *)tsv
->name
);
351 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
356 warning (_("No trace variable named \"$%s\", not deleting"), name
);
359 /* Throws an error if NAME is not valid syntax for a trace state
363 validate_trace_state_variable_name (const char *name
)
368 error (_("Must supply a non-empty variable name"));
370 /* All digits in the name is reserved for value history
372 for (p
= name
; isdigit (*p
); p
++)
375 error (_("$%s is not a valid trace state variable name"), name
);
377 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
380 error (_("$%s is not a valid trace state variable name"), name
);
383 /* The 'tvariable' command collects a name and optional expression to
384 evaluate into an initial value. */
387 trace_variable_command (char *args
, int from_tty
)
389 struct cleanup
*old_chain
;
391 struct trace_state_variable
*tsv
;
395 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
397 /* Only allow two syntaxes; "$name" and "$name=value". */
398 p
= skip_spaces (args
);
401 error (_("Name of trace variable should start with '$'"));
404 while (isalnum (*p
) || *p
== '_')
406 name
= savestring (name
, p
- name
);
407 old_chain
= make_cleanup (xfree
, name
);
410 if (*p
!= '=' && *p
!= '\0')
411 error (_("Syntax must be $NAME [ = EXPR ]"));
413 validate_trace_state_variable_name (name
);
416 initval
= value_as_long (parse_and_eval (++p
));
418 /* If the variable already exists, just change its initial value. */
419 tsv
= find_trace_state_variable (name
);
422 if (tsv
->initial_value
!= initval
)
424 tsv
->initial_value
= initval
;
425 observer_notify_tsv_modified (tsv
);
427 printf_filtered (_("Trace state variable $%s "
428 "now has initial value %s.\n"),
429 tsv
->name
, plongest (tsv
->initial_value
));
430 do_cleanups (old_chain
);
434 /* Create a new variable. */
435 tsv
= create_trace_state_variable (name
);
436 tsv
->initial_value
= initval
;
438 observer_notify_tsv_created (tsv
);
440 printf_filtered (_("Trace state variable $%s "
441 "created, with initial value %s.\n"),
442 tsv
->name
, plongest (tsv
->initial_value
));
444 do_cleanups (old_chain
);
448 delete_trace_variable_command (char *args
, int from_tty
)
452 struct cleanup
*back_to
;
456 if (query (_("Delete all trace state variables? ")))
457 VEC_free (tsv_s
, tvariables
);
459 observer_notify_tsv_deleted (NULL
);
463 argv
= gdb_buildargv (args
);
464 back_to
= make_cleanup_freeargv (argv
);
466 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
468 if (*argv
[ix
] == '$')
469 delete_trace_state_variable (argv
[ix
] + 1);
471 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
474 do_cleanups (back_to
);
480 tvariables_info_1 (void)
482 struct trace_state_variable
*tsv
;
485 struct ui_out
*uiout
= current_uiout
;
487 if (VEC_length (tsv_s
, tvariables
) == 0 && !uiout
->is_mi_like_p ())
489 printf_filtered (_("No trace state variables.\n"));
493 /* Try to acquire values from the target. */
494 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
495 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
498 ui_out_emit_table
table_emitter (uiout
, 3, count
, "trace-variables");
499 uiout
->table_header (15, ui_left
, "name", "Name");
500 uiout
->table_header (11, ui_left
, "initial", "Initial");
501 uiout
->table_header (11, ui_left
, "current", "Current");
503 uiout
->table_body ();
505 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
509 ui_out_emit_tuple
tuple_emitter (uiout
, "variable");
511 std::string name
= std::string ("$") + tsv
->name
;
512 uiout
->field_string ("name", name
.c_str ());
513 uiout
->field_string ("initial", plongest (tsv
->initial_value
));
515 if (tsv
->value_known
)
516 c
= plongest (tsv
->value
);
517 else if (uiout
->is_mi_like_p ())
518 /* For MI, we prefer not to use magic string constants, but rather
519 omit the field completely. The difference between unknown and
520 undefined does not seem important enough to represent. */
522 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
523 /* The value is/was defined, but we don't have it. */
526 /* It is not meaningful to ask about the value. */
529 uiout
->field_string ("current", c
);
534 /* List all the trace state variables. */
537 tvariables_info (char *args
, int from_tty
)
539 tvariables_info_1 ();
542 /* Stash definitions of tsvs into the given file. */
545 save_trace_state_variables (struct ui_file
*fp
)
547 struct trace_state_variable
*tsv
;
550 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
552 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
553 if (tsv
->initial_value
)
554 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
555 fprintf_unfiltered (fp
, "\n");
559 /* ACTIONS functions: */
561 /* The three functions:
562 collect_pseudocommand,
563 while_stepping_pseudocommand, and
564 end_actions_pseudocommand
565 are placeholders for "commands" that are actually ONLY to be used
566 within a tracepoint action list. If the actual function is ever called,
567 it means that somebody issued the "command" at the top level,
568 which is always an error. */
571 end_actions_pseudocommand (char *args
, int from_tty
)
573 error (_("This command cannot be used at the top level."));
577 while_stepping_pseudocommand (char *args
, int from_tty
)
579 error (_("This command can only be used in a tracepoint actions list."));
583 collect_pseudocommand (char *args
, int from_tty
)
585 error (_("This command can only be used in a tracepoint actions list."));
589 teval_pseudocommand (char *args
, int from_tty
)
591 error (_("This command can only be used in a tracepoint actions list."));
594 /* Parse any collection options, such as /s for strings. */
597 decode_agent_options (const char *exp
, int *trace_string
)
599 struct value_print_options opts
;
606 /* Call this to borrow the print elements default for collection
608 get_user_print_options (&opts
);
613 if (target_supports_string_tracing ())
615 /* Allow an optional decimal number giving an explicit maximum
616 string length, defaulting it to the "print elements" value;
617 so "collect/s80 mystr" gets at most 80 bytes of string. */
618 *trace_string
= opts
.print_max
;
620 if (*exp
>= '0' && *exp
<= '9')
621 *trace_string
= atoi (exp
);
622 while (*exp
>= '0' && *exp
<= '9')
626 error (_("Target does not support \"/s\" option for string tracing."));
629 error (_("Undefined collection format \"%c\"."), *exp
);
631 exp
= skip_spaces_const (exp
);
636 /* Enter a list of actions for a tracepoint. */
638 actions_command (char *args
, int from_tty
)
640 struct tracepoint
*t
;
642 t
= get_tracepoint_by_number (&args
, NULL
);
646 string_printf ("Enter actions for tracepoint %d, one per line.",
649 command_line_up l
= read_command_lines (&tmpbuf
[0], from_tty
, 1,
650 check_tracepoint_command
, t
);
651 breakpoint_set_commands (t
, std::move (l
));
653 /* else just return */
656 /* Report the results of checking the agent expression, as errors or
660 report_agent_reqs_errors (struct agent_expr
*aexpr
)
662 /* All of the "flaws" are serious bytecode generation issues that
663 should never occur. */
664 if (aexpr
->flaw
!= agent_flaw_none
)
665 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
667 /* If analysis shows a stack underflow, GDB must have done something
668 badly wrong in its bytecode generation. */
669 if (aexpr
->min_height
< 0)
670 internal_error (__FILE__
, __LINE__
,
671 _("expression has min height < 0"));
673 /* Issue this error if the stack is predicted to get too deep. The
674 limit is rather arbitrary; a better scheme might be for the
675 target to report how much stack it will have available. The
676 depth roughly corresponds to parenthesization, so a limit of 20
677 amounts to 20 levels of expression nesting, which is actually
678 a pretty big hairy expression. */
679 if (aexpr
->max_height
> 20)
680 error (_("Expression is too complicated."));
683 /* worker function */
685 validate_actionline (const char *line
, struct breakpoint
*b
)
687 struct cmd_list_element
*c
;
688 struct cleanup
*old_chain
= NULL
;
691 struct bp_location
*loc
;
692 struct tracepoint
*t
= (struct tracepoint
*) b
;
694 /* If EOF is typed, *line is NULL. */
698 p
= skip_spaces_const (line
);
700 /* Symbol lookup etc. */
701 if (*p
== '\0') /* empty line: just prompt for another line. */
704 if (*p
== '#') /* comment line */
707 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
709 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
711 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
713 int trace_string
= 0;
716 p
= decode_agent_options (p
, &trace_string
);
719 { /* Repeat over a comma-separated list. */
720 QUIT
; /* Allow user to bail out with ^C. */
721 p
= skip_spaces_const (p
);
723 if (*p
== '$') /* Look for special pseudo-symbols. */
725 if (0 == strncasecmp ("reg", p
+ 1, 3)
726 || 0 == strncasecmp ("arg", p
+ 1, 3)
727 || 0 == strncasecmp ("loc", p
+ 1, 3)
728 || 0 == strncasecmp ("_ret", p
+ 1, 4)
729 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
734 /* else fall thru, treat p as an expression and parse it! */
737 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
740 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
741 block_for_pc (loc
->address
), 1);
743 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
745 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
747 error (_("constant `%s' (value %s) "
748 "will not be collected."),
749 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
750 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
752 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
753 == LOC_OPTIMIZED_OUT
)
755 error (_("`%s' is optimized away "
756 "and cannot be collected."),
757 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
761 /* We have something to collect, make sure that the expr to
762 bytecode translator can handle it and that it's not too
764 agent_expr_up aexpr
= gen_trace_for_expr (loc
->address
,
768 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
769 error (_("Expression is too complicated."));
771 ax_reqs (aexpr
.get ());
773 report_agent_reqs_errors (aexpr
.get ());
776 while (p
&& *p
++ == ',');
779 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
782 { /* Repeat over a comma-separated list. */
783 QUIT
; /* Allow user to bail out with ^C. */
784 p
= skip_spaces_const (p
);
787 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
791 /* Only expressions are allowed for this action. */
792 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
793 block_for_pc (loc
->address
), 1);
795 /* We have something to evaluate, make sure that the expr to
796 bytecode translator can handle it and that it's not too
798 agent_expr_up aexpr
= gen_eval_for_expr (loc
->address
, exp
.get ());
800 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
801 error (_("Expression is too complicated."));
803 ax_reqs (aexpr
.get ());
804 report_agent_reqs_errors (aexpr
.get ());
807 while (p
&& *p
++ == ',');
810 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
814 p
= skip_spaces_const (p
);
815 t
->step_count
= strtol (p
, &endp
, 0);
816 if (endp
== p
|| t
->step_count
== 0)
817 error (_("while-stepping step count `%s' is malformed."), line
);
821 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
825 error (_("`%s' is not a supported tracepoint action."), line
);
829 memrange_absolute
= -1
832 /* MEMRANGE functions: */
834 /* Compare memranges for std::sort. */
837 memrange_comp (const memrange
&a
, const memrange
&b
)
839 if (a
.type
== b
.type
)
841 if (a
.type
== memrange_absolute
)
842 return (bfd_vma
) a
.start
< (bfd_vma
) b
.start
;
844 return a
.start
< b
.start
;
847 return a
.type
< b
.type
;
850 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
853 memrange_sortmerge (std::vector
<memrange
> &memranges
)
855 if (!memranges
.empty ())
859 std::sort (memranges
.begin (), memranges
.end (), memrange_comp
);
861 for (a
= 0, b
= 1; b
< memranges
.size (); b
++)
863 /* If memrange b overlaps or is adjacent to memrange a,
865 if (memranges
[a
].type
== memranges
[b
].type
866 && memranges
[b
].start
<= memranges
[a
].end
)
868 if (memranges
[b
].end
> memranges
[a
].end
)
869 memranges
[a
].end
= memranges
[b
].end
;
870 continue; /* next b, same a */
874 memranges
[a
] = memranges
[b
];
876 memranges
.resize (a
+ 1);
880 /* Add a register to a collection list. */
883 collection_list::add_register (unsigned int regno
)
886 printf_filtered ("collect register %d\n", regno
);
887 if (regno
>= (8 * sizeof (m_regs_mask
)))
888 error (_("Internal: register number %d too large for tracepoint"),
890 m_regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
893 /* Add a memrange to a collection list. */
896 collection_list::add_memrange (struct gdbarch
*gdbarch
,
897 int type
, bfd_signed_vma base
,
901 printf_filtered ("(%d,%s,%ld)\n", type
, paddress (gdbarch
, base
), len
);
903 /* type: memrange_absolute == memory, other n == basereg */
904 /* base: addr if memory, offset if reg relative. */
905 /* len: we actually save end (base + len) for convenience */
906 m_memranges
.emplace_back (type
, base
, base
+ len
);
908 if (type
!= memrange_absolute
) /* Better collect the base register! */
912 /* Add a symbol to a collection list. */
915 collection_list::collect_symbol (struct symbol
*sym
,
916 struct gdbarch
*gdbarch
,
917 long frame_regno
, long frame_offset
,
923 bfd_signed_vma offset
;
924 int treat_as_expr
= 0;
926 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
927 switch (SYMBOL_CLASS (sym
))
930 printf_filtered ("%s: don't know symbol class %d\n",
931 SYMBOL_PRINT_NAME (sym
),
935 printf_filtered ("constant %s (value %s) will not be collected.\n",
936 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
939 offset
= SYMBOL_VALUE_ADDRESS (sym
);
942 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
943 SYMBOL_PRINT_NAME (sym
), len
,
944 paddress (gdbarch
, offset
));
946 /* A struct may be a C++ class with static fields, go to general
947 expression handling. */
948 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
951 add_memrange (gdbarch
, memrange_absolute
, offset
, len
);
954 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
956 printf_filtered ("LOC_REG[parm] %s: ",
957 SYMBOL_PRINT_NAME (sym
));
959 /* Check for doubles stored in two registers. */
960 /* FIXME: how about larger types stored in 3 or more regs? */
961 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
962 len
> register_size (gdbarch
, reg
))
963 add_register (reg
+ 1);
966 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
967 printf_filtered (" (will not collect %s)\n",
968 SYMBOL_PRINT_NAME (sym
));
972 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
975 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
976 " from frame ptr reg %d\n",
977 SYMBOL_PRINT_NAME (sym
), len
,
978 paddress (gdbarch
, offset
), reg
);
980 add_memrange (gdbarch
, reg
, offset
, len
);
982 case LOC_REGPARM_ADDR
:
983 reg
= SYMBOL_VALUE (sym
);
987 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
989 SYMBOL_PRINT_NAME (sym
), len
,
990 paddress (gdbarch
, offset
), reg
);
992 add_memrange (gdbarch
, reg
, offset
, len
);
996 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
999 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
1000 " from frame ptr reg %d\n",
1001 SYMBOL_PRINT_NAME (sym
), len
,
1002 paddress (gdbarch
, offset
), reg
);
1004 add_memrange (gdbarch
, reg
, offset
, len
);
1007 case LOC_UNRESOLVED
:
1011 case LOC_OPTIMIZED_OUT
:
1012 printf_filtered ("%s has been optimized out of existence.\n",
1013 SYMBOL_PRINT_NAME (sym
));
1021 /* Expressions are the most general case. */
1024 struct cleanup
*old_chain1
= NULL
;
1026 agent_expr_up aexpr
= gen_trace_for_var (scope
, gdbarch
,
1029 /* It can happen that the symbol is recorded as a computed
1030 location, but it's been optimized away and doesn't actually
1031 have a location expression. */
1034 printf_filtered ("%s has been optimized out of existence.\n",
1035 SYMBOL_PRINT_NAME (sym
));
1039 ax_reqs (aexpr
.get ());
1041 report_agent_reqs_errors (aexpr
.get ());
1043 /* Take care of the registers. */
1044 if (aexpr
->reg_mask_len
> 0)
1046 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1048 QUIT
; /* Allow user to bail out with ^C. */
1049 if (aexpr
->reg_mask
[ndx1
] != 0)
1051 /* Assume chars have 8 bits. */
1052 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1053 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1054 /* It's used -- record it. */
1055 add_register (ndx1
* 8 + ndx2
);
1060 add_aexpr (std::move (aexpr
));
1064 /* Data to be passed around in the calls to the locals and args
1067 struct add_local_symbols_data
1069 struct collection_list
*collect
;
1070 struct gdbarch
*gdbarch
;
1078 /* The callback for the locals and args iterators. */
1081 do_collect_symbol (const char *print_name
,
1085 struct add_local_symbols_data
*p
= (struct add_local_symbols_data
*) cb_data
;
1087 p
->collect
->collect_symbol (sym
, p
->gdbarch
, p
->frame_regno
,
1088 p
->frame_offset
, p
->pc
, p
->trace_string
);
1091 p
->collect
->add_wholly_collected (print_name
);
1095 collection_list::add_wholly_collected (const char *print_name
)
1097 m_wholly_collected
.push_back (print_name
);
1100 /* Add all locals (or args) symbols to collection list. */
1103 collection_list::add_local_symbols (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1104 long frame_regno
, long frame_offset
, int type
,
1107 const struct block
*block
;
1108 struct add_local_symbols_data cb_data
;
1110 cb_data
.collect
= this;
1111 cb_data
.gdbarch
= gdbarch
;
1113 cb_data
.frame_regno
= frame_regno
;
1114 cb_data
.frame_offset
= frame_offset
;
1116 cb_data
.trace_string
= trace_string
;
1120 block
= block_for_pc (pc
);
1123 warning (_("Can't collect locals; "
1124 "no symbol table info available.\n"));
1128 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1129 if (cb_data
.count
== 0)
1130 warning (_("No locals found in scope."));
1134 pc
= get_pc_function_start (pc
);
1135 block
= block_for_pc (pc
);
1138 warning (_("Can't collect args; no symbol table info available."));
1142 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1143 if (cb_data
.count
== 0)
1144 warning (_("No args found in scope."));
1149 collection_list::add_static_trace_data ()
1152 printf_filtered ("collect static trace data\n");
1153 m_strace_data
= true;
1156 collection_list::collection_list ()
1158 m_strace_data (false)
1160 m_memranges
.reserve (128);
1161 m_aexprs
.reserve (128);
1164 /* Reduce a collection list to string form (for gdb protocol). */
1167 collection_list::stringify ()
1169 char temp_buf
[2048];
1172 char *(*str_list
)[];
1176 count
= 1 + 1 + m_memranges
.size () + m_aexprs
.size () + 1;
1177 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1182 printf_filtered ("\nCollecting static trace data\n");
1185 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1189 for (i
= sizeof (m_regs_mask
) - 1; i
> 0; i
--)
1190 if (m_regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1192 if (m_regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1195 printf_filtered ("\nCollecting registers (mask): 0x");
1200 QUIT
; /* Allow user to bail out with ^C. */
1202 printf_filtered ("%02X", m_regs_mask
[i
]);
1203 sprintf (end
, "%02X", m_regs_mask
[i
]);
1206 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1210 printf_filtered ("\n");
1211 if (!m_memranges
.empty () && info_verbose
)
1212 printf_filtered ("Collecting memranges: \n");
1213 for (i
= 0, count
= 0, end
= temp_buf
; i
< m_memranges
.size (); i
++)
1215 QUIT
; /* Allow user to bail out with ^C. */
1218 printf_filtered ("(%d, %s, %ld)\n",
1219 m_memranges
[i
].type
,
1220 paddress (target_gdbarch (),
1221 m_memranges
[i
].start
),
1222 (long) (m_memranges
[i
].end
1223 - m_memranges
[i
].start
));
1225 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1227 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1234 bfd_signed_vma length
1235 = m_memranges
[i
].end
- m_memranges
[i
].start
;
1237 /* The "%X" conversion specifier expects an unsigned argument,
1238 so passing -1 (memrange_absolute) to it directly gives you
1239 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1241 if (m_memranges
[i
].type
== memrange_absolute
)
1242 sprintf (end
, "M-1,%s,%lX", phex_nz (m_memranges
[i
].start
, 0),
1245 sprintf (end
, "M%X,%s,%lX", m_memranges
[i
].type
,
1246 phex_nz (m_memranges
[i
].start
, 0), (long) length
);
1249 count
+= strlen (end
);
1250 end
= temp_buf
+ count
;
1253 for (i
= 0; i
< m_aexprs
.size (); i
++)
1255 QUIT
; /* Allow user to bail out with ^C. */
1256 if ((count
+ 10 + 2 * m_aexprs
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1258 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1263 sprintf (end
, "X%08X,", m_aexprs
[i
]->len
);
1264 end
+= 10; /* 'X' + 8 hex digits + ',' */
1267 end
= mem2hex (m_aexprs
[i
]->buf
, end
, m_aexprs
[i
]->len
);
1268 count
+= 2 * m_aexprs
[i
]->len
;
1273 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1278 (*str_list
)[ndx
] = NULL
;
1289 /* Add the printed expression EXP to *LIST. */
1292 collection_list::append_exp (struct expression
*exp
)
1294 string_file tmp_stream
;
1296 print_expression (exp
, &tmp_stream
);
1298 m_computed
.push_back (std::move (tmp_stream
.string ()));
1302 collection_list::finish ()
1304 memrange_sortmerge (m_memranges
);
1308 encode_actions_1 (struct command_line
*action
,
1309 struct bp_location
*tloc
,
1311 LONGEST frame_offset
,
1312 struct collection_list
*collect
,
1313 struct collection_list
*stepping_list
)
1315 const char *action_exp
;
1317 struct value
*tempval
;
1318 struct cmd_list_element
*cmd
;
1320 for (; action
; action
= action
->next
)
1322 QUIT
; /* Allow user to bail out with ^C. */
1323 action_exp
= action
->line
;
1324 action_exp
= skip_spaces_const (action_exp
);
1326 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1328 error (_("Bad action list item: %s"), action_exp
);
1330 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1332 int trace_string
= 0;
1334 if (*action_exp
== '/')
1335 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1338 { /* Repeat over a comma-separated list. */
1339 QUIT
; /* Allow user to bail out with ^C. */
1340 action_exp
= skip_spaces_const (action_exp
);
1342 if (0 == strncasecmp ("$reg", action_exp
, 4))
1344 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
1345 collect
->add_register (i
);
1346 action_exp
= strchr (action_exp
, ','); /* more? */
1348 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1350 collect
->add_local_symbols (target_gdbarch (),
1356 action_exp
= strchr (action_exp
, ','); /* more? */
1358 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1360 collect
->add_local_symbols (target_gdbarch (),
1366 action_exp
= strchr (action_exp
, ','); /* more? */
1368 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1371 = gen_trace_for_return_address (tloc
->address
,
1375 ax_reqs (aexpr
.get ());
1376 report_agent_reqs_errors (aexpr
.get ());
1378 /* take care of the registers */
1379 if (aexpr
->reg_mask_len
> 0)
1381 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1383 QUIT
; /* allow user to bail out with ^C */
1384 if (aexpr
->reg_mask
[ndx1
] != 0)
1386 /* assume chars have 8 bits */
1387 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1388 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1390 /* It's used -- record it. */
1391 collect
->add_register (ndx1
* 8 + ndx2
);
1397 collect
->add_aexpr (std::move (aexpr
));
1398 action_exp
= strchr (action_exp
, ','); /* more? */
1400 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1402 collect
->add_static_trace_data ();
1403 action_exp
= strchr (action_exp
, ','); /* more? */
1408 struct cleanup
*old_chain1
= NULL
;
1410 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1411 block_for_pc (tloc
->address
),
1414 switch (exp
->elts
[0].opcode
)
1418 const char *name
= &exp
->elts
[2].string
;
1420 i
= user_reg_map_name_to_regnum (target_gdbarch (),
1421 name
, strlen (name
));
1423 internal_error (__FILE__
, __LINE__
,
1424 _("Register $%s not available"),
1427 printf_filtered ("OP_REGISTER: ");
1428 collect
->add_register (i
);
1433 /* Safe because we know it's a simple expression. */
1434 tempval
= evaluate_expression (exp
.get ());
1435 addr
= value_address (tempval
);
1436 /* Initialize the TYPE_LENGTH if it is a typedef. */
1437 check_typedef (exp
->elts
[1].type
);
1438 collect
->add_memrange (target_gdbarch (),
1439 memrange_absolute
, addr
,
1440 TYPE_LENGTH (exp
->elts
[1].type
));
1441 collect
->append_exp (exp
.get ());
1446 struct symbol
*sym
= exp
->elts
[2].symbol
;
1447 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1449 collect
->collect_symbol (exp
->elts
[2].symbol
,
1455 collect
->add_wholly_collected (name
);
1459 default: /* Full-fledged expression. */
1460 agent_expr_up aexpr
= gen_trace_for_expr (tloc
->address
,
1464 ax_reqs (aexpr
.get ());
1466 report_agent_reqs_errors (aexpr
.get ());
1468 /* Take care of the registers. */
1469 if (aexpr
->reg_mask_len
> 0)
1471 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1473 QUIT
; /* Allow user to bail out with ^C. */
1474 if (aexpr
->reg_mask
[ndx1
] != 0)
1476 /* Assume chars have 8 bits. */
1477 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1478 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1480 /* It's used -- record it. */
1481 collect
->add_register (ndx1
* 8 + ndx2
);
1487 collect
->add_aexpr (std::move (aexpr
));
1488 collect
->append_exp (exp
.get ());
1493 while (action_exp
&& *action_exp
++ == ',');
1495 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1498 { /* Repeat over a comma-separated list. */
1499 QUIT
; /* Allow user to bail out with ^C. */
1500 action_exp
= skip_spaces_const (action_exp
);
1503 struct cleanup
*old_chain1
= NULL
;
1505 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1506 block_for_pc (tloc
->address
),
1509 agent_expr_up aexpr
= gen_eval_for_expr (tloc
->address
,
1512 ax_reqs (aexpr
.get ());
1513 report_agent_reqs_errors (aexpr
.get ());
1515 /* Even though we're not officially collecting, add
1516 to the collect list anyway. */
1517 collect
->add_aexpr (std::move (aexpr
));
1520 while (action_exp
&& *action_exp
++ == ',');
1522 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1524 /* We check against nested while-stepping when setting
1525 breakpoint action, so no way to run into nested
1527 gdb_assert (stepping_list
);
1529 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1530 frame_offset
, stepping_list
, NULL
);
1533 error (_("Invalid tracepoint command '%s'"), action
->line
);
1537 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1538 and STEPPING_LIST. */
1541 encode_actions (struct bp_location
*tloc
,
1542 struct collection_list
*tracepoint_list
,
1543 struct collection_list
*stepping_list
)
1545 struct command_line
*actions
;
1547 LONGEST frame_offset
;
1549 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1550 tloc
->address
, &frame_reg
, &frame_offset
);
1552 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1554 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1555 tracepoint_list
, stepping_list
);
1557 tracepoint_list
->finish ();
1558 stepping_list
->finish ();
1561 /* Render all actions into gdb protocol. */
1564 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1565 char ***stepping_actions
)
1567 struct collection_list tracepoint_list
, stepping_list
;
1569 *tdp_actions
= NULL
;
1570 *stepping_actions
= NULL
;
1572 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
1574 *tdp_actions
= tracepoint_list
.stringify ();
1575 *stepping_actions
= stepping_list
.stringify ();
1579 collection_list::add_aexpr (agent_expr_up aexpr
)
1581 m_aexprs
.push_back (std::move (aexpr
));
1585 process_tracepoint_on_disconnect (void)
1587 VEC(breakpoint_p
) *tp_vec
= NULL
;
1589 struct breakpoint
*b
;
1590 int has_pending_p
= 0;
1592 /* Check whether we still have pending tracepoint. If we have, warn the
1593 user that pending tracepoint will no longer work. */
1594 tp_vec
= all_tracepoints ();
1595 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1604 struct bp_location
*loc1
;
1606 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1608 if (loc1
->shlib_disabled
)
1619 VEC_free (breakpoint_p
, tp_vec
);
1622 warning (_("Pending tracepoints will not be resolved while"
1623 " GDB is disconnected\n"));
1626 /* Reset local state of tracing. */
1629 trace_reset_local_state (void)
1631 set_traceframe_num (-1);
1632 set_tracepoint_num (-1);
1633 set_traceframe_context (NULL
);
1634 clear_traceframe_info ();
1638 start_tracing (char *notes
)
1640 VEC(breakpoint_p
) *tp_vec
= NULL
;
1642 struct breakpoint
*b
;
1643 struct trace_state_variable
*tsv
;
1644 int any_enabled
= 0, num_to_download
= 0;
1647 tp_vec
= all_tracepoints ();
1649 /* No point in tracing without any tracepoints... */
1650 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1652 VEC_free (breakpoint_p
, tp_vec
);
1653 error (_("No tracepoints defined, not starting trace"));
1656 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1658 if (b
->enable_state
== bp_enabled
)
1661 if ((b
->type
== bp_fast_tracepoint
1662 ? may_insert_fast_tracepoints
1663 : may_insert_tracepoints
))
1666 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1667 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1672 if (target_supports_enable_disable_tracepoint ())
1673 warning (_("No tracepoints enabled"));
1676 /* No point in tracing with only disabled tracepoints that
1677 cannot be re-enabled. */
1678 VEC_free (breakpoint_p
, tp_vec
);
1679 error (_("No tracepoints enabled, not starting trace"));
1683 if (num_to_download
<= 0)
1685 VEC_free (breakpoint_p
, tp_vec
);
1686 error (_("No tracepoints that may be downloaded, not starting trace"));
1689 target_trace_init ();
1691 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1693 struct tracepoint
*t
= (struct tracepoint
*) b
;
1694 struct bp_location
*loc
;
1695 int bp_location_downloaded
= 0;
1697 /* Clear `inserted' flag. */
1698 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1701 if ((b
->type
== bp_fast_tracepoint
1702 ? !may_insert_fast_tracepoints
1703 : !may_insert_tracepoints
))
1706 t
->number_on_target
= 0;
1708 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1710 /* Since tracepoint locations are never duplicated, `inserted'
1711 flag should be zero. */
1712 gdb_assert (!loc
->inserted
);
1714 target_download_tracepoint (loc
);
1717 bp_location_downloaded
= 1;
1720 t
->number_on_target
= b
->number
;
1722 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1723 if (loc
->probe
.probe
!= NULL
1724 && loc
->probe
.probe
->pops
->set_semaphore
!= NULL
)
1725 loc
->probe
.probe
->pops
->set_semaphore (loc
->probe
.probe
,
1729 if (bp_location_downloaded
)
1730 observer_notify_breakpoint_modified (b
);
1732 VEC_free (breakpoint_p
, tp_vec
);
1734 /* Send down all the trace state variables too. */
1735 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1737 target_download_trace_state_variable (tsv
);
1740 /* Tell target to treat text-like sections as transparent. */
1741 target_trace_set_readonly_regions ();
1742 /* Set some mode flags. */
1743 target_set_disconnected_tracing (disconnected_tracing
);
1744 target_set_circular_trace_buffer (circular_trace_buffer
);
1745 target_set_trace_buffer_size (trace_buffer_size
);
1748 notes
= trace_notes
;
1749 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1751 if (!ret
&& (trace_user
|| notes
))
1752 warning (_("Target does not support trace user/notes, info ignored"));
1754 /* Now insert traps and begin collecting data. */
1755 target_trace_start ();
1757 /* Reset our local state. */
1758 trace_reset_local_state ();
1759 current_trace_status()->running
= 1;
1762 /* The tstart command requests the target to start a new trace run.
1763 The command passes any arguments it has to the target verbatim, as
1764 an optional "trace note". This is useful as for instance a warning
1765 to other users if the trace runs disconnected, and you don't want
1766 anybody else messing with the target. */
1769 tstart_command (char *args
, int from_tty
)
1771 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1773 if (current_trace_status ()->running
)
1776 && !query (_("A trace is running already. Start a new run? ")))
1777 error (_("New trace run not started."));
1780 start_tracing (args
);
1783 /* The tstop command stops the tracing run. The command passes any
1784 supplied arguments to the target verbatim as a "stop note"; if the
1785 target supports trace notes, then it will be reported back as part
1786 of the trace run's status. */
1789 tstop_command (char *args
, int from_tty
)
1791 if (!current_trace_status ()->running
)
1792 error (_("Trace is not running."));
1794 stop_tracing (args
);
1798 stop_tracing (char *note
)
1801 VEC(breakpoint_p
) *tp_vec
= NULL
;
1803 struct breakpoint
*t
;
1805 target_trace_stop ();
1807 tp_vec
= all_tracepoints ();
1808 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1810 struct bp_location
*loc
;
1812 if ((t
->type
== bp_fast_tracepoint
1813 ? !may_insert_fast_tracepoints
1814 : !may_insert_tracepoints
))
1817 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1819 /* GDB can be totally absent in some disconnected trace scenarios,
1820 but we don't really care if this semaphore goes out of sync.
1821 That's why we are decrementing it here, but not taking care
1823 if (loc
->probe
.probe
!= NULL
1824 && loc
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
1825 loc
->probe
.probe
->pops
->clear_semaphore (loc
->probe
.probe
,
1831 VEC_free (breakpoint_p
, tp_vec
);
1834 note
= trace_stop_notes
;
1835 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1838 warning (_("Target does not support trace notes, note ignored"));
1840 /* Should change in response to reply? */
1841 current_trace_status ()->running
= 0;
1844 /* tstatus command */
1846 tstatus_command (char *args
, int from_tty
)
1848 struct trace_status
*ts
= current_trace_status ();
1850 VEC(breakpoint_p
) *tp_vec
= NULL
;
1851 struct breakpoint
*t
;
1853 status
= target_get_trace_status (ts
);
1857 if (ts
->filename
!= NULL
)
1858 printf_filtered (_("Using a trace file.\n"));
1861 printf_filtered (_("Trace can not be run on this target.\n"));
1866 if (!ts
->running_known
)
1868 printf_filtered (_("Run/stop status is unknown.\n"));
1870 else if (ts
->running
)
1872 printf_filtered (_("Trace is running on the target.\n"));
1876 switch (ts
->stop_reason
)
1878 case trace_never_run
:
1879 printf_filtered (_("No trace has been run on the target.\n"));
1881 case trace_stop_command
:
1883 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1886 printf_filtered (_("Trace stopped by a tstop command.\n"));
1888 case trace_buffer_full
:
1889 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1891 case trace_disconnected
:
1892 printf_filtered (_("Trace stopped because of disconnection.\n"));
1894 case tracepoint_passcount
:
1895 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1896 ts
->stopping_tracepoint
);
1898 case tracepoint_error
:
1899 if (ts
->stopping_tracepoint
)
1900 printf_filtered (_("Trace stopped by an "
1901 "error (%s, tracepoint %d).\n"),
1902 ts
->stop_desc
, ts
->stopping_tracepoint
);
1904 printf_filtered (_("Trace stopped by an error (%s).\n"),
1907 case trace_stop_reason_unknown
:
1908 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1911 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1917 if (ts
->traceframes_created
>= 0
1918 && ts
->traceframe_count
!= ts
->traceframes_created
)
1920 printf_filtered (_("Buffer contains %d trace "
1921 "frames (of %d created total).\n"),
1922 ts
->traceframe_count
, ts
->traceframes_created
);
1924 else if (ts
->traceframe_count
>= 0)
1926 printf_filtered (_("Collected %d trace frames.\n"),
1927 ts
->traceframe_count
);
1930 if (ts
->buffer_free
>= 0)
1932 if (ts
->buffer_size
>= 0)
1934 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1935 ts
->buffer_free
, ts
->buffer_size
);
1936 if (ts
->buffer_size
> 0)
1937 printf_filtered (_(" (%d%% full)"),
1938 ((int) ((((long long) (ts
->buffer_size
1939 - ts
->buffer_free
)) * 100)
1940 / ts
->buffer_size
)));
1941 printf_filtered (_(".\n"));
1944 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1948 if (ts
->disconnected_tracing
)
1949 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1951 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1953 if (ts
->circular_buffer
)
1954 printf_filtered (_("Trace buffer is circular.\n"));
1956 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1957 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1959 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1960 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1962 /* Now report on what we're doing with tfind. */
1963 if (traceframe_number
>= 0)
1964 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1965 traceframe_number
, tracepoint_number
);
1967 printf_filtered (_("Not looking at any trace frame.\n"));
1969 /* Report start/stop times if supplied. */
1974 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1976 /* Reporting a run time is more readable than two long numbers. */
1977 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1978 (long int) (ts
->start_time
/ 1000000),
1979 (long int) (ts
->start_time
% 1000000),
1980 (long int) (run_time
/ 1000000),
1981 (long int) (run_time
% 1000000));
1984 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1985 (long int) (ts
->start_time
/ 1000000),
1986 (long int) (ts
->start_time
% 1000000));
1988 else if (ts
->stop_time
)
1989 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1990 (long int) (ts
->stop_time
/ 1000000),
1991 (long int) (ts
->stop_time
% 1000000));
1993 /* Now report any per-tracepoint status available. */
1994 tp_vec
= all_tracepoints ();
1996 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1997 target_get_tracepoint_status (t
, NULL
);
1999 VEC_free (breakpoint_p
, tp_vec
);
2002 /* Report the trace status to uiout, in a way suitable for MI, and not
2003 suitable for CLI. If ON_STOP is true, suppress a few fields that
2004 are not meaningful in the -trace-stop response.
2006 The implementation is essentially parallel to trace_status_command, but
2007 merging them will result in unreadable code. */
2009 trace_status_mi (int on_stop
)
2011 struct ui_out
*uiout
= current_uiout
;
2012 struct trace_status
*ts
= current_trace_status ();
2015 status
= target_get_trace_status (ts
);
2017 if (status
== -1 && ts
->filename
== NULL
)
2019 uiout
->field_string ("supported", "0");
2023 if (ts
->filename
!= NULL
)
2024 uiout
->field_string ("supported", "file");
2026 uiout
->field_string ("supported", "1");
2028 if (ts
->filename
!= NULL
)
2029 uiout
->field_string ("trace-file", ts
->filename
);
2031 gdb_assert (ts
->running_known
);
2035 uiout
->field_string ("running", "1");
2037 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2038 Given that the frontend gets the status either on -trace-stop, or from
2039 -trace-status after re-connection, it does not seem like this
2040 information is necessary for anything. It is not necessary for either
2041 figuring the vital state of the target nor for navigation of trace
2042 frames. If the frontend wants to show the current state is some
2043 configure dialog, it can request the value when such dialog is
2044 invoked by the user. */
2048 const char *stop_reason
= NULL
;
2049 int stopping_tracepoint
= -1;
2052 uiout
->field_string ("running", "0");
2054 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2056 switch (ts
->stop_reason
)
2058 case trace_stop_command
:
2059 stop_reason
= "request";
2061 case trace_buffer_full
:
2062 stop_reason
= "overflow";
2064 case trace_disconnected
:
2065 stop_reason
= "disconnection";
2067 case tracepoint_passcount
:
2068 stop_reason
= "passcount";
2069 stopping_tracepoint
= ts
->stopping_tracepoint
;
2071 case tracepoint_error
:
2072 stop_reason
= "error";
2073 stopping_tracepoint
= ts
->stopping_tracepoint
;
2079 uiout
->field_string ("stop-reason", stop_reason
);
2080 if (stopping_tracepoint
!= -1)
2081 uiout
->field_int ("stopping-tracepoint",
2082 stopping_tracepoint
);
2083 if (ts
->stop_reason
== tracepoint_error
)
2084 uiout
->field_string ("error-description",
2090 if (ts
->traceframe_count
!= -1)
2091 uiout
->field_int ("frames", ts
->traceframe_count
);
2092 if (ts
->traceframes_created
!= -1)
2093 uiout
->field_int ("frames-created", ts
->traceframes_created
);
2094 if (ts
->buffer_size
!= -1)
2095 uiout
->field_int ("buffer-size", ts
->buffer_size
);
2096 if (ts
->buffer_free
!= -1)
2097 uiout
->field_int ("buffer-free", ts
->buffer_free
);
2099 uiout
->field_int ("disconnected", ts
->disconnected_tracing
);
2100 uiout
->field_int ("circular", ts
->circular_buffer
);
2102 uiout
->field_string ("user-name", ts
->user_name
);
2103 uiout
->field_string ("notes", ts
->notes
);
2108 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2109 (long int) (ts
->start_time
/ 1000000),
2110 (long int) (ts
->start_time
% 1000000));
2111 uiout
->field_string ("start-time", buf
);
2112 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2113 (long int) (ts
->stop_time
/ 1000000),
2114 (long int) (ts
->stop_time
% 1000000));
2115 uiout
->field_string ("stop-time", buf
);
2119 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2120 user if she really wants to detach. */
2123 query_if_trace_running (int from_tty
)
2128 /* It can happen that the target that was tracing went away on its
2129 own, and we didn't notice. Get a status update, and if the
2130 current target doesn't even do tracing, then assume it's not
2132 if (target_get_trace_status (current_trace_status ()) < 0)
2133 current_trace_status ()->running
= 0;
2135 /* If running interactively, give the user the option to cancel and
2136 then decide what to do differently with the run. Scripts are
2137 just going to disconnect and let the target deal with it,
2138 according to how it's been instructed previously via
2139 disconnected-tracing. */
2140 if (current_trace_status ()->running
)
2142 process_tracepoint_on_disconnect ();
2144 if (current_trace_status ()->disconnected_tracing
)
2146 if (!query (_("Trace is running and will "
2147 "continue after detach; detach anyway? ")))
2148 error (_("Not confirmed."));
2152 if (!query (_("Trace is running but will "
2153 "stop on detach; detach anyway? ")))
2154 error (_("Not confirmed."));
2159 /* This function handles the details of what to do about an ongoing
2160 tracing run if the user has asked to detach or otherwise disconnect
2164 disconnect_tracing (void)
2166 /* Also we want to be out of tfind mode, otherwise things can get
2167 confusing upon reconnection. Just use these calls instead of
2168 full tfind_1 behavior because we're in the middle of detaching,
2169 and there's no point to updating current stack frame etc. */
2170 trace_reset_local_state ();
2173 /* Worker function for the various flavors of the tfind command. */
2175 tfind_1 (enum trace_find_type type
, int num
,
2176 CORE_ADDR addr1
, CORE_ADDR addr2
,
2179 int target_frameno
= -1, target_tracept
= -1;
2180 struct frame_id old_frame_id
= null_frame_id
;
2181 struct tracepoint
*tp
;
2182 struct ui_out
*uiout
= current_uiout
;
2184 /* Only try to get the current stack frame if we have a chance of
2185 succeeding. In particular, if we're trying to get a first trace
2186 frame while all threads are running, it's not going to succeed,
2187 so leave it with a default value and let the frame comparison
2188 below (correctly) decide to print out the source location of the
2190 if (!(type
== tfind_number
&& num
== -1)
2191 && (has_stack_frames () || traceframe_number
>= 0))
2192 old_frame_id
= get_frame_id (get_current_frame ());
2194 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2197 if (type
== tfind_number
2199 && target_frameno
== -1)
2201 /* We told the target to get out of tfind mode, and it did. */
2203 else if (target_frameno
== -1)
2205 /* A request for a non-existent trace frame has failed.
2206 Our response will be different, depending on FROM_TTY:
2208 If FROM_TTY is true, meaning that this command was
2209 typed interactively by the user, then give an error
2210 and DO NOT change the state of traceframe_number etc.
2212 However if FROM_TTY is false, meaning that we're either
2213 in a script, a loop, or a user-defined command, then
2214 DON'T give an error, but DO change the state of
2215 traceframe_number etc. to invalid.
2217 The rationalle is that if you typed the command, you
2218 might just have committed a typo or something, and you'd
2219 like to NOT lose your current debugging state. However
2220 if you're in a user-defined command or especially in a
2221 loop, then you need a way to detect that the command
2222 failed WITHOUT aborting. This allows you to write
2223 scripts that search thru the trace buffer until the end,
2224 and then continue on to do something else. */
2227 error (_("Target failed to find requested trace frame."));
2231 printf_filtered ("End of trace buffer.\n");
2232 #if 0 /* dubious now? */
2233 /* The following will not recurse, since it's
2235 tfind_command ("-1", from_tty
);
2240 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2242 reinit_frame_cache ();
2243 target_dcache_invalidate ();
2245 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2247 if (target_frameno
!= get_traceframe_number ())
2248 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2250 set_current_traceframe (target_frameno
);
2252 if (target_frameno
== -1)
2253 set_traceframe_context (NULL
);
2255 set_traceframe_context (get_current_frame ());
2257 if (traceframe_number
>= 0)
2259 /* Use different branches for MI and CLI to make CLI messages
2261 if (uiout
->is_mi_like_p ())
2263 uiout
->field_string ("found", "1");
2264 uiout
->field_int ("tracepoint", tracepoint_number
);
2265 uiout
->field_int ("traceframe", traceframe_number
);
2269 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2270 traceframe_number
, tracepoint_number
);
2275 if (uiout
->is_mi_like_p ())
2276 uiout
->field_string ("found", "0");
2277 else if (type
== tfind_number
&& num
== -1)
2278 printf_unfiltered (_("No longer looking at any trace frame\n"));
2279 else /* This case may never occur, check. */
2280 printf_unfiltered (_("No trace frame found\n"));
2283 /* If we're in nonstop mode and getting out of looking at trace
2284 frames, there won't be any current frame to go back to and
2287 && (has_stack_frames () || traceframe_number
>= 0))
2289 enum print_what print_what
;
2291 /* NOTE: in imitation of the step command, try to determine
2292 whether we have made a transition from one function to
2293 another. If so, we'll print the "stack frame" (ie. the new
2294 function and it's arguments) -- otherwise we'll just show the
2297 if (frame_id_eq (old_frame_id
,
2298 get_frame_id (get_current_frame ())))
2299 print_what
= SRC_LINE
;
2301 print_what
= SRC_AND_LOC
;
2303 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2308 /* Error on looking at traceframes while trace is running. */
2311 check_trace_running (struct trace_status
*status
)
2313 if (status
->running
&& status
->filename
== NULL
)
2314 error (_("May not look at trace frames while trace is running."));
2317 /* trace_find_command takes a trace frame number n,
2318 sends "QTFrame:<n>" to the target,
2319 and accepts a reply that may contain several optional pieces
2320 of information: a frame number, a tracepoint number, and an
2321 indication of whether this is a trap frame or a stepping frame.
2323 The minimal response is just "OK" (which indicates that the
2324 target does not give us a frame number or a tracepoint number).
2325 Instead of that, the target may send us a string containing
2327 F<hexnum> (gives the selected frame number)
2328 T<hexnum> (gives the selected tracepoint number)
2333 tfind_command_1 (const char *args
, int from_tty
)
2334 { /* This should only be called with a numeric argument. */
2337 check_trace_running (current_trace_status ());
2339 if (args
== 0 || *args
== 0)
2340 { /* TFIND with no args means find NEXT trace frame. */
2341 if (traceframe_number
== -1)
2342 frameno
= 0; /* "next" is first one. */
2344 frameno
= traceframe_number
+ 1;
2346 else if (0 == strcmp (args
, "-"))
2348 if (traceframe_number
== -1)
2349 error (_("not debugging trace buffer"));
2350 else if (from_tty
&& traceframe_number
== 0)
2351 error (_("already at start of trace buffer"));
2353 frameno
= traceframe_number
- 1;
2355 /* A hack to work around eval's need for fp to have been collected. */
2356 else if (0 == strcmp (args
, "-1"))
2359 frameno
= parse_and_eval_long (args
);
2362 error (_("invalid input (%d is less than zero)"), frameno
);
2364 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2368 tfind_command (char *args
, int from_tty
)
2370 tfind_command_1 (const_cast<char *> (args
), from_tty
);
2375 tfind_end_command (char *args
, int from_tty
)
2377 tfind_command_1 ("-1", from_tty
);
2382 tfind_start_command (char *args
, int from_tty
)
2384 tfind_command_1 ("0", from_tty
);
2387 /* tfind pc command */
2389 tfind_pc_command (char *args
, int from_tty
)
2393 check_trace_running (current_trace_status ());
2395 if (args
== 0 || *args
== 0)
2396 pc
= regcache_read_pc (get_current_regcache ());
2398 pc
= parse_and_eval_address (args
);
2400 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2403 /* tfind tracepoint command */
2405 tfind_tracepoint_command (char *args
, int from_tty
)
2408 struct tracepoint
*tp
;
2410 check_trace_running (current_trace_status ());
2412 if (args
== 0 || *args
== 0)
2414 if (tracepoint_number
== -1)
2415 error (_("No current tracepoint -- please supply an argument."));
2417 tdp
= tracepoint_number
; /* Default is current TDP. */
2420 tdp
= parse_and_eval_long (args
);
2422 /* If we have the tracepoint on hand, use the number that the
2423 target knows about (which may be different if we disconnected
2424 and reconnected). */
2425 tp
= get_tracepoint (tdp
);
2427 tdp
= tp
->number_on_target
;
2429 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2432 /* TFIND LINE command:
2434 This command will take a sourceline for argument, just like BREAK
2435 or TRACE (ie. anything that "decode_line_1" can handle).
2437 With no argument, this command will find the next trace frame
2438 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2441 tfind_line_command (char *args
, int from_tty
)
2443 static CORE_ADDR start_pc
, end_pc
;
2444 struct symtabs_and_lines sals
;
2445 struct symtab_and_line sal
;
2446 struct cleanup
*old_chain
;
2448 check_trace_running (current_trace_status ());
2450 if (args
== 0 || *args
== 0)
2452 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2454 sals
.sals
= XNEW (struct symtab_and_line
);
2459 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2463 old_chain
= make_cleanup (xfree
, sals
.sals
);
2464 if (sal
.symtab
== 0)
2465 error (_("No line number information available."));
2467 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2469 if (start_pc
== end_pc
)
2471 printf_filtered ("Line %d of \"%s\"",
2473 symtab_to_filename_for_display (sal
.symtab
));
2475 printf_filtered (" is at address ");
2476 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2478 printf_filtered (" but contains no code.\n");
2479 sal
= find_pc_line (start_pc
, 0);
2481 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2482 && start_pc
!= end_pc
)
2483 printf_filtered ("Attempting to find line %d instead.\n",
2486 error (_("Cannot find a good line."));
2490 /* Is there any case in which we get here, and have an address
2491 which the user would want to see? If we have debugging
2492 symbols and no line numbers? */
2493 error (_("Line number %d is out of range for \"%s\"."),
2494 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2496 /* Find within range of stated line. */
2498 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2500 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2501 do_cleanups (old_chain
);
2504 /* tfind range command */
2506 tfind_range_command (char *args
, int from_tty
)
2508 static CORE_ADDR start
, stop
;
2511 check_trace_running (current_trace_status ());
2513 if (args
== 0 || *args
== 0)
2514 { /* XXX FIXME: what should default behavior be? */
2515 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2519 if (0 != (tmp
= strchr (args
, ',')))
2521 *tmp
++ = '\0'; /* Terminate start address. */
2522 tmp
= skip_spaces (tmp
);
2523 start
= parse_and_eval_address (args
);
2524 stop
= parse_and_eval_address (tmp
);
2527 { /* No explicit end address? */
2528 start
= parse_and_eval_address (args
);
2529 stop
= start
+ 1; /* ??? */
2532 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2535 /* tfind outside command */
2537 tfind_outside_command (char *args
, int from_tty
)
2539 CORE_ADDR start
, stop
;
2542 if (current_trace_status ()->running
2543 && current_trace_status ()->filename
== NULL
)
2544 error (_("May not look at trace frames while trace is running."));
2546 if (args
== 0 || *args
== 0)
2547 { /* XXX FIXME: what should default behavior be? */
2548 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2552 if (0 != (tmp
= strchr (args
, ',')))
2554 *tmp
++ = '\0'; /* Terminate start address. */
2555 tmp
= skip_spaces (tmp
);
2556 start
= parse_and_eval_address (args
);
2557 stop
= parse_and_eval_address (tmp
);
2560 { /* No explicit end address? */
2561 start
= parse_and_eval_address (args
);
2562 stop
= start
+ 1; /* ??? */
2565 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2568 /* info scope command: list the locals for a scope. */
2570 scope_info (char *args
, int from_tty
)
2572 struct symtabs_and_lines sals
;
2574 struct bound_minimal_symbol msym
;
2575 const struct block
*block
;
2576 const char *symname
;
2577 char *save_args
= args
;
2578 struct block_iterator iter
;
2580 struct gdbarch
*gdbarch
;
2583 if (args
== 0 || *args
== 0)
2584 error (_("requires an argument (function, "
2585 "line or *addr) to define a scope"));
2587 event_location_up location
= string_to_event_location (&args
,
2589 sals
= decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
2591 if (sals
.nelts
== 0)
2593 /* Presumably decode_line_1 has already warned. */
2597 /* Resolve line numbers to PC. */
2598 resolve_sal_pc (&sals
.sals
[0]);
2599 block
= block_for_pc (sals
.sals
[0].pc
);
2603 QUIT
; /* Allow user to bail out with ^C. */
2604 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2606 QUIT
; /* Allow user to bail out with ^C. */
2608 printf_filtered ("Scope for %s:\n", save_args
);
2611 symname
= SYMBOL_PRINT_NAME (sym
);
2612 if (symname
== NULL
|| *symname
== '\0')
2613 continue; /* Probably botched, certainly useless. */
2615 gdbarch
= symbol_arch (sym
);
2617 printf_filtered ("Symbol %s is ", symname
);
2619 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2620 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2621 BLOCK_START (block
),
2625 switch (SYMBOL_CLASS (sym
))
2628 case LOC_UNDEF
: /* Messed up symbol? */
2629 printf_filtered ("a bogus symbol, class %d.\n",
2630 SYMBOL_CLASS (sym
));
2631 count
--; /* Don't count this one. */
2634 printf_filtered ("a constant with value %s (%s)",
2635 plongest (SYMBOL_VALUE (sym
)),
2636 hex_string (SYMBOL_VALUE (sym
)));
2638 case LOC_CONST_BYTES
:
2639 printf_filtered ("constant bytes: ");
2640 if (SYMBOL_TYPE (sym
))
2641 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2642 fprintf_filtered (gdb_stdout
, " %02x",
2643 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2646 printf_filtered ("in static storage at address ");
2647 printf_filtered ("%s", paddress (gdbarch
,
2648 SYMBOL_VALUE_ADDRESS (sym
)));
2651 /* GDBARCH is the architecture associated with the objfile
2652 the symbol is defined in; the target architecture may be
2653 different, and may provide additional registers. However,
2654 we do not know the target architecture at this point.
2655 We assume the objfile architecture will contain all the
2656 standard registers that occur in debug info in that
2658 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2661 if (SYMBOL_IS_ARGUMENT (sym
))
2662 printf_filtered ("an argument in register $%s",
2663 gdbarch_register_name (gdbarch
, regno
));
2665 printf_filtered ("a local variable in register $%s",
2666 gdbarch_register_name (gdbarch
, regno
));
2669 printf_filtered ("an argument at stack/frame offset %s",
2670 plongest (SYMBOL_VALUE (sym
)));
2673 printf_filtered ("a local variable at frame offset %s",
2674 plongest (SYMBOL_VALUE (sym
)));
2677 printf_filtered ("a reference argument at offset %s",
2678 plongest (SYMBOL_VALUE (sym
)));
2680 case LOC_REGPARM_ADDR
:
2681 /* Note comment at LOC_REGISTER. */
2682 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2684 printf_filtered ("the address of an argument, in register $%s",
2685 gdbarch_register_name (gdbarch
, regno
));
2688 printf_filtered ("a typedef.\n");
2691 printf_filtered ("a label at address ");
2692 printf_filtered ("%s", paddress (gdbarch
,
2693 SYMBOL_VALUE_ADDRESS (sym
)));
2696 printf_filtered ("a function at address ");
2697 printf_filtered ("%s",
2698 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2700 case LOC_UNRESOLVED
:
2701 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2703 if (msym
.minsym
== NULL
)
2704 printf_filtered ("Unresolved Static");
2707 printf_filtered ("static storage at address ");
2708 printf_filtered ("%s",
2710 BMSYMBOL_VALUE_ADDRESS (msym
)));
2713 case LOC_OPTIMIZED_OUT
:
2714 printf_filtered ("optimized out.\n");
2717 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2720 if (SYMBOL_TYPE (sym
))
2721 printf_filtered (", length %d.\n",
2722 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2724 if (BLOCK_FUNCTION (block
))
2727 block
= BLOCK_SUPERBLOCK (block
);
2730 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2734 /* Helper for trace_dump_command. Dump the action list starting at
2735 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2736 actions of the body of a while-stepping action. STEPPING_FRAME is
2737 set if the current traceframe was determined to be a while-stepping
2741 trace_dump_actions (struct command_line
*action
,
2742 int stepping_actions
, int stepping_frame
,
2745 const char *action_exp
, *next_comma
;
2747 for (; action
!= NULL
; action
= action
->next
)
2749 struct cmd_list_element
*cmd
;
2751 QUIT
; /* Allow user to bail out with ^C. */
2752 action_exp
= action
->line
;
2753 action_exp
= skip_spaces_const (action_exp
);
2755 /* The collection actions to be done while stepping are
2756 bracketed by the commands "while-stepping" and "end". */
2758 if (*action_exp
== '#') /* comment line */
2761 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2763 error (_("Bad action list item: %s"), action_exp
);
2765 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2769 for (i
= 0; i
< action
->body_count
; ++i
)
2770 trace_dump_actions (action
->body_list
[i
],
2771 1, stepping_frame
, from_tty
);
2773 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2775 /* Display the collected data.
2776 For the trap frame, display only what was collected at
2777 the trap. Likewise for stepping frames, display only
2778 what was collected while stepping. This means that the
2779 two boolean variables, STEPPING_FRAME and
2780 STEPPING_ACTIONS should be equal. */
2781 if (stepping_frame
== stepping_actions
)
2784 struct cleanup
*old_chain
2785 = make_cleanup (free_current_contents
, &cmd
);
2786 int trace_string
= 0;
2788 if (*action_exp
== '/')
2789 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2792 { /* Repeat over a comma-separated list. */
2793 QUIT
; /* Allow user to bail out with ^C. */
2794 if (*action_exp
== ',')
2796 action_exp
= skip_spaces_const (action_exp
);
2798 next_comma
= strchr (action_exp
, ',');
2800 if (0 == strncasecmp (action_exp
, "$reg", 4))
2801 registers_info (NULL
, from_tty
);
2802 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2804 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2805 locals_info (NULL
, from_tty
);
2806 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2807 args_info (NULL
, from_tty
);
2810 if (next_comma
!= NULL
)
2812 size_t len
= next_comma
- action_exp
;
2814 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2815 memcpy (cmd
, action_exp
, len
);
2820 size_t len
= strlen (action_exp
);
2822 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2823 memcpy (cmd
, action_exp
, len
+ 1);
2826 printf_filtered ("%s = ", cmd
);
2827 output_command_const (cmd
, from_tty
);
2828 printf_filtered ("\n");
2830 action_exp
= next_comma
;
2832 while (action_exp
&& *action_exp
== ',');
2834 do_cleanups (old_chain
);
2840 /* Return bp_location of the tracepoint associated with the current
2841 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2842 is a stepping traceframe. */
2844 struct bp_location
*
2845 get_traceframe_location (int *stepping_frame_p
)
2847 struct tracepoint
*t
;
2848 struct bp_location
*tloc
;
2849 struct regcache
*regcache
;
2851 if (tracepoint_number
== -1)
2852 error (_("No current trace frame."));
2854 t
= get_tracepoint (tracepoint_number
);
2857 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2860 /* The current frame is a trap frame if the frame PC is equal to the
2861 tracepoint PC. If not, then the current frame was collected
2862 during single-stepping. */
2863 regcache
= get_current_regcache ();
2865 /* If the traceframe's address matches any of the tracepoint's
2866 locations, assume it is a direct hit rather than a while-stepping
2867 frame. (FIXME this is not reliable, should record each frame's
2869 for (tloc
= t
->loc
; tloc
; tloc
= tloc
->next
)
2870 if (tloc
->address
== regcache_read_pc (regcache
))
2872 *stepping_frame_p
= 0;
2876 /* If this is a stepping frame, we don't know which location
2877 triggered. The first is as good (or bad) a guess as any... */
2878 *stepping_frame_p
= 1;
2882 /* Return all the actions, including default collect, of a tracepoint
2883 T. It constructs cleanups into the chain, and leaves the caller to
2884 handle them (call do_cleanups). */
2886 static struct command_line
*
2887 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
2889 struct command_line
*actions
;
2891 actions
= breakpoint_commands (t
);
2893 /* If there are default expressions to collect, make up a collect
2894 action and prepend to the action list to encode. Note that since
2895 validation is per-tracepoint (local var "xyz" might be valid for
2896 one tracepoint and not another, etc), we make up the action on
2897 the fly, and don't cache it. */
2898 if (*default_collect
)
2900 struct command_line
*default_collect_action
;
2901 char *default_collect_line
;
2903 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2904 make_cleanup (xfree
, default_collect_line
);
2906 validate_actionline (default_collect_line
, t
);
2907 default_collect_action
= XNEW (struct command_line
);
2908 make_cleanup (xfree
, default_collect_action
);
2909 default_collect_action
->next
= actions
;
2910 default_collect_action
->line
= default_collect_line
;
2911 actions
= default_collect_action
;
2917 /* The tdump command. */
2920 tdump_command (char *args
, int from_tty
)
2922 int stepping_frame
= 0;
2923 struct bp_location
*loc
;
2924 struct command_line
*actions
;
2926 /* This throws an error is not inspecting a trace frame. */
2927 loc
= get_traceframe_location (&stepping_frame
);
2929 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2930 tracepoint_number
, traceframe_number
);
2932 /* This command only makes sense for the current frame, not the
2934 scoped_restore_current_thread restore_thread
;
2936 select_frame (get_current_frame ());
2938 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
2940 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2943 /* Encode a piece of a tracepoint's source-level definition in a form
2944 that is suitable for both protocol and saving in files. */
2945 /* This version does not do multiple encodes for long strings; it should
2946 return an offset to the next piece to encode. FIXME */
2949 encode_source_string (int tpnum
, ULONGEST addr
,
2950 const char *srctype
, const char *src
,
2951 char *buf
, int buf_size
)
2953 if (80 + strlen (srctype
) > buf_size
)
2954 error (_("Buffer too small for source encoding"));
2955 sprintf (buf
, "%x:%s:%s:%x:%x:",
2956 tpnum
, phex_nz (addr
, sizeof (addr
)),
2957 srctype
, 0, (int) strlen (src
));
2958 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2959 error (_("Source string too long for buffer"));
2960 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
2964 /* Tell the target what to do with an ongoing tracing run if GDB
2965 disconnects for some reason. */
2968 set_disconnected_tracing (char *args
, int from_tty
,
2969 struct cmd_list_element
*c
)
2971 target_set_disconnected_tracing (disconnected_tracing
);
2975 set_circular_trace_buffer (char *args
, int from_tty
,
2976 struct cmd_list_element
*c
)
2978 target_set_circular_trace_buffer (circular_trace_buffer
);
2982 set_trace_buffer_size (char *args
, int from_tty
,
2983 struct cmd_list_element
*c
)
2985 target_set_trace_buffer_size (trace_buffer_size
);
2989 set_trace_user (char *args
, int from_tty
,
2990 struct cmd_list_element
*c
)
2994 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
2997 warning (_("Target does not support trace notes, user ignored"));
3001 set_trace_notes (char *args
, int from_tty
,
3002 struct cmd_list_element
*c
)
3006 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3009 warning (_("Target does not support trace notes, note ignored"));
3013 set_trace_stop_notes (char *args
, int from_tty
,
3014 struct cmd_list_element
*c
)
3018 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3021 warning (_("Target does not support trace notes, stop note ignored"));
3024 /* Convert the memory pointed to by mem into hex, placing result in buf.
3025 * Return a pointer to the last char put in buf (null)
3026 * "stolen" from sparc-stub.c
3029 static const char hexchars
[] = "0123456789abcdef";
3032 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3040 *buf
++ = hexchars
[ch
>> 4];
3041 *buf
++ = hexchars
[ch
& 0xf];
3050 get_traceframe_number (void)
3052 return traceframe_number
;
3056 get_tracepoint_number (void)
3058 return tracepoint_number
;
3061 /* Make the traceframe NUM be the current trace frame. Does nothing
3062 if NUM is already current. */
3065 set_current_traceframe (int num
)
3069 if (traceframe_number
== num
)
3071 /* Nothing to do. */
3075 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3078 warning (_("could not change traceframe"));
3080 set_traceframe_num (newnum
);
3082 /* Changing the traceframe changes our view of registers and of the
3084 registers_changed ();
3086 clear_traceframe_info ();
3089 /* A cleanup used when switching away and back from tfind mode. */
3091 struct current_traceframe_cleanup
3093 /* The traceframe we were inspecting. */
3094 int traceframe_number
;
3098 do_restore_current_traceframe_cleanup (void *arg
)
3100 struct current_traceframe_cleanup
*old
3101 = (struct current_traceframe_cleanup
*) arg
;
3103 set_current_traceframe (old
->traceframe_number
);
3107 restore_current_traceframe_cleanup_dtor (void *arg
)
3109 struct current_traceframe_cleanup
*old
3110 = (struct current_traceframe_cleanup
*) arg
;
3116 make_cleanup_restore_current_traceframe (void)
3118 struct current_traceframe_cleanup
*old
=
3119 XNEW (struct current_traceframe_cleanup
);
3121 old
->traceframe_number
= traceframe_number
;
3123 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3124 restore_current_traceframe_cleanup_dtor
);
3127 /* Given a number and address, return an uploaded tracepoint with that
3128 number, creating if necessary. */
3130 struct uploaded_tp
*
3131 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3133 struct uploaded_tp
*utp
;
3135 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3136 if (utp
->number
== num
&& utp
->addr
== addr
)
3139 utp
= XCNEW (struct uploaded_tp
);
3142 utp
->actions
= NULL
;
3143 utp
->step_actions
= NULL
;
3144 utp
->cmd_strings
= NULL
;
3152 free_uploaded_tps (struct uploaded_tp
**utpp
)
3154 struct uploaded_tp
*next_one
;
3158 next_one
= (*utpp
)->next
;
3164 /* Given a number and address, return an uploaded tracepoint with that
3165 number, creating if necessary. */
3167 struct uploaded_tsv
*
3168 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3170 struct uploaded_tsv
*utsv
;
3172 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3173 if (utsv
->number
== num
)
3176 utsv
= XCNEW (struct uploaded_tsv
);
3178 utsv
->next
= *utsvp
;
3185 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3187 struct uploaded_tsv
*next_one
;
3191 next_one
= (*utsvp
)->next
;
3197 /* FIXME this function is heuristic and will miss the cases where the
3198 conditional is semantically identical but differs in whitespace,
3199 such as "x == 0" vs "x==0". */
3202 cond_string_is_same (char *str1
, char *str2
)
3204 if (str1
== NULL
|| str2
== NULL
)
3205 return (str1
== str2
);
3207 return (strcmp (str1
, str2
) == 0);
3210 /* Look for an existing tracepoint that seems similar enough to the
3211 uploaded one. Enablement isn't compared, because the user can
3212 toggle that freely, and may have done so in anticipation of the
3213 next trace run. Return the location of matched tracepoint. */
3215 static struct bp_location
*
3216 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3218 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3220 struct breakpoint
*b
;
3221 struct bp_location
*loc
;
3223 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3225 struct tracepoint
*t
= (struct tracepoint
*) b
;
3227 if (b
->type
== utp
->type
3228 && t
->step_count
== utp
->step
3229 && t
->pass_count
== utp
->pass
3230 && cond_string_is_same (t
->cond_string
, utp
->cond_string
)
3231 /* FIXME also test actions. */
3234 /* Scan the locations for an address match. */
3235 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3237 if (loc
->address
== utp
->addr
)
3245 /* Given a list of tracepoints uploaded from a target, attempt to
3246 match them up with existing tracepoints, and create new ones if not
3250 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3252 struct uploaded_tp
*utp
;
3253 /* A set of tracepoints which are modified. */
3254 VEC(breakpoint_p
) *modified_tp
= NULL
;
3256 struct breakpoint
*b
;
3258 /* Look for GDB tracepoints that match up with our uploaded versions. */
3259 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3261 struct bp_location
*loc
;
3262 struct tracepoint
*t
;
3264 loc
= find_matching_tracepoint_location (utp
);
3269 /* Mark this location as already inserted. */
3271 t
= (struct tracepoint
*) loc
->owner
;
3272 printf_filtered (_("Assuming tracepoint %d is same "
3273 "as target's tracepoint %d at %s.\n"),
3274 loc
->owner
->number
, utp
->number
,
3275 paddress (loc
->gdbarch
, utp
->addr
));
3277 /* The tracepoint LOC->owner was modified (the location LOC
3278 was marked as inserted in the target). Save it in
3279 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3280 observers will be notified later once for each tracepoint
3281 saved in MODIFIED_TP. */
3283 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3285 if (b
== loc
->owner
)
3291 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3295 t
= create_tracepoint_from_upload (utp
);
3297 printf_filtered (_("Created tracepoint %d for "
3298 "target's tracepoint %d at %s.\n"),
3299 t
->number
, utp
->number
,
3300 paddress (get_current_arch (), utp
->addr
));
3302 printf_filtered (_("Failed to create tracepoint for target's "
3303 "tracepoint %d at %s, skipping it.\n"),
3305 paddress (get_current_arch (), utp
->addr
));
3307 /* Whether found or created, record the number used by the
3308 target, to help with mapping target tracepoints back to their
3309 counterparts here. */
3311 t
->number_on_target
= utp
->number
;
3314 /* Notify 'breakpoint-modified' observer that at least one of B's
3315 locations was changed. */
3316 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3317 observer_notify_breakpoint_modified (b
);
3319 VEC_free (breakpoint_p
, modified_tp
);
3320 free_uploaded_tps (uploaded_tps
);
3323 /* Trace state variables don't have much to identify them beyond their
3324 name, so just use that to detect matches. */
3326 static struct trace_state_variable
*
3327 find_matching_tsv (struct uploaded_tsv
*utsv
)
3332 return find_trace_state_variable (utsv
->name
);
3335 static struct trace_state_variable
*
3336 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3338 const char *namebase
;
3341 struct trace_state_variable
*tsv
;
3342 struct cleanup
*old_chain
;
3346 namebase
= utsv
->name
;
3347 buf
= xstrprintf ("%s", namebase
);
3352 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3355 /* Fish for a name that is not in use. */
3356 /* (should check against all internal vars?) */
3357 while (find_trace_state_variable (buf
))
3360 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3363 old_chain
= make_cleanup (xfree
, buf
);
3365 /* We have an available name, create the variable. */
3366 tsv
= create_trace_state_variable (buf
);
3367 tsv
->initial_value
= utsv
->initial_value
;
3368 tsv
->builtin
= utsv
->builtin
;
3370 observer_notify_tsv_created (tsv
);
3372 do_cleanups (old_chain
);
3377 /* Given a list of uploaded trace state variables, try to match them
3378 up with existing variables, or create additional ones. */
3381 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3384 struct uploaded_tsv
*utsv
;
3385 struct trace_state_variable
*tsv
;
3388 /* Most likely some numbers will have to be reassigned as part of
3389 the merge, so clear them all in anticipation. */
3390 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3393 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3395 tsv
= find_matching_tsv (utsv
);
3399 printf_filtered (_("Assuming trace state variable $%s "
3400 "is same as target's variable %d.\n"),
3401 tsv
->name
, utsv
->number
);
3405 tsv
= create_tsv_from_upload (utsv
);
3407 printf_filtered (_("Created trace state variable "
3408 "$%s for target's variable %d.\n"),
3409 tsv
->name
, utsv
->number
);
3411 /* Give precedence to numberings that come from the target. */
3413 tsv
->number
= utsv
->number
;
3416 /* Renumber everything that didn't get a target-assigned number. */
3418 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3419 if (tsv
->number
> highest
)
3420 highest
= tsv
->number
;
3423 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3424 if (tsv
->number
== 0)
3425 tsv
->number
= highest
++;
3427 free_uploaded_tsvs (uploaded_tsvs
);
3430 /* Parse the part of trace status syntax that is shared between
3431 the remote protocol and the trace file reader. */
3434 parse_trace_status (char *line
, struct trace_status
*ts
)
3436 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3440 ts
->running_known
= 1;
3441 ts
->running
= (*p
++ == '1');
3442 ts
->stop_reason
= trace_stop_reason_unknown
;
3443 xfree (ts
->stop_desc
);
3444 ts
->stop_desc
= NULL
;
3445 ts
->traceframe_count
= -1;
3446 ts
->traceframes_created
= -1;
3447 ts
->buffer_free
= -1;
3448 ts
->buffer_size
= -1;
3449 ts
->disconnected_tracing
= 0;
3450 ts
->circular_buffer
= 0;
3451 xfree (ts
->user_name
);
3452 ts
->user_name
= NULL
;
3455 ts
->start_time
= ts
->stop_time
= 0;
3459 p1
= strchr (p
, ':');
3461 error (_("Malformed trace status, at %s\n\
3462 Status line: '%s'\n"), p
, line
);
3463 p3
= strchr (p
, ';');
3465 p3
= p
+ strlen (p
);
3466 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3468 p
= unpack_varlen_hex (++p1
, &val
);
3469 ts
->stop_reason
= trace_buffer_full
;
3471 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3473 p
= unpack_varlen_hex (++p1
, &val
);
3474 ts
->stop_reason
= trace_never_run
;
3476 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3479 p
= unpack_varlen_hex (++p1
, &val
);
3480 ts
->stop_reason
= tracepoint_passcount
;
3481 ts
->stopping_tracepoint
= val
;
3483 else if (strncmp (p
, stop_reason_names
[trace_stop_command
], p1
- p
) == 0)
3485 p2
= strchr (++p1
, ':');
3493 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3494 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3495 ts
->stop_desc
[end
] = '\0';
3498 ts
->stop_desc
= xstrdup ("");
3500 p
= unpack_varlen_hex (++p2
, &val
);
3501 ts
->stop_reason
= trace_stop_command
;
3503 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3505 p
= unpack_varlen_hex (++p1
, &val
);
3506 ts
->stop_reason
= trace_disconnected
;
3508 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3510 p2
= strchr (++p1
, ':');
3513 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3514 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3515 ts
->stop_desc
[end
] = '\0';
3518 ts
->stop_desc
= xstrdup ("");
3520 p
= unpack_varlen_hex (++p2
, &val
);
3521 ts
->stopping_tracepoint
= val
;
3522 ts
->stop_reason
= tracepoint_error
;
3524 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3526 p
= unpack_varlen_hex (++p1
, &val
);
3527 ts
->traceframe_count
= val
;
3529 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3531 p
= unpack_varlen_hex (++p1
, &val
);
3532 ts
->traceframes_created
= val
;
3534 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3536 p
= unpack_varlen_hex (++p1
, &val
);
3537 ts
->buffer_free
= val
;
3539 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3541 p
= unpack_varlen_hex (++p1
, &val
);
3542 ts
->buffer_size
= val
;
3544 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3546 p
= unpack_varlen_hex (++p1
, &val
);
3547 ts
->disconnected_tracing
= val
;
3549 else if (strncmp (p
, "circular", p1
- p
) == 0)
3551 p
= unpack_varlen_hex (++p1
, &val
);
3552 ts
->circular_buffer
= val
;
3554 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3556 p
= unpack_varlen_hex (++p1
, &val
);
3557 ts
->start_time
= val
;
3559 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3561 p
= unpack_varlen_hex (++p1
, &val
);
3562 ts
->stop_time
= val
;
3564 else if (strncmp (p
, "username", p1
- p
) == 0)
3567 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3568 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3569 ts
->user_name
[end
] = '\0';
3572 else if (strncmp (p
, "notes", p1
- p
) == 0)
3575 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3576 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3577 ts
->notes
[end
] = '\0';
3582 /* Silently skip unknown optional info. */
3583 p_temp
= strchr (p1
+ 1, ';');
3587 /* Must be at the end. */
3594 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3595 struct uploaded_tp
*utp
)
3598 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3600 p
= unpack_varlen_hex (p
, &uval
);
3602 tp
->hit_count
+= uval
;
3604 utp
->hit_count
+= uval
;
3605 p
= unpack_varlen_hex (p
+ 1, &uval
);
3607 tp
->traceframe_usage
+= uval
;
3609 utp
->traceframe_usage
+= uval
;
3610 /* Ignore any extra, allowing for future extensions. */
3613 /* Given a line of text defining a part of a tracepoint, parse it into
3614 an "uploaded tracepoint". */
3617 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3621 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3624 char *cond
, *srctype
, *buf
;
3625 struct uploaded_tp
*utp
= NULL
;
3628 /* Both tracepoint and action definitions start with the same number
3629 and address sequence. */
3631 p
= unpack_varlen_hex (p
, &num
);
3632 p
++; /* skip a colon */
3633 p
= unpack_varlen_hex (p
, &addr
);
3634 p
++; /* skip a colon */
3637 enabled
= (*p
++ == 'E');
3638 p
++; /* skip a colon */
3639 p
= unpack_varlen_hex (p
, &step
);
3640 p
++; /* skip a colon */
3641 p
= unpack_varlen_hex (p
, &pass
);
3642 type
= bp_tracepoint
;
3644 /* Thumb through optional fields. */
3647 p
++; /* skip a colon */
3650 type
= bp_fast_tracepoint
;
3652 p
= unpack_varlen_hex (p
, &orig_size
);
3656 type
= bp_static_tracepoint
;
3662 p
= unpack_varlen_hex (p
, &xlen
);
3663 p
++; /* skip a comma */
3664 cond
= (char *) xmalloc (2 * xlen
+ 1);
3665 strncpy (cond
, p
, 2 * xlen
);
3666 cond
[2 * xlen
] = '\0';
3670 warning (_("Unrecognized char '%c' in tracepoint "
3671 "definition, skipping rest"), *p
);
3673 utp
= get_uploaded_tp (num
, addr
, utpp
);
3675 utp
->enabled
= enabled
;
3680 else if (piece
== 'A')
3682 utp
= get_uploaded_tp (num
, addr
, utpp
);
3683 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3685 else if (piece
== 'S')
3687 utp
= get_uploaded_tp (num
, addr
, utpp
);
3688 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3690 else if (piece
== 'Z')
3692 /* Parse a chunk of source form definition. */
3693 utp
= get_uploaded_tp (num
, addr
, utpp
);
3695 p
= strchr (p
, ':');
3696 p
++; /* skip a colon */
3697 p
= unpack_varlen_hex (p
, &start
);
3698 p
++; /* skip a colon */
3699 p
= unpack_varlen_hex (p
, &xlen
);
3700 p
++; /* skip a colon */
3702 buf
= (char *) alloca (strlen (line
));
3704 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3707 if (startswith (srctype
, "at:"))
3708 utp
->at_string
= xstrdup (buf
);
3709 else if (startswith (srctype
, "cond:"))
3710 utp
->cond_string
= xstrdup (buf
);
3711 else if (startswith (srctype
, "cmd:"))
3712 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3714 else if (piece
== 'V')
3716 utp
= get_uploaded_tp (num
, addr
, utpp
);
3718 parse_tracepoint_status (p
, NULL
, utp
);
3722 /* Don't error out, the target might be sending us optional
3723 info that we don't care about. */
3724 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3728 /* Convert a textual description of a trace state variable into an
3732 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3735 ULONGEST num
, initval
, builtin
;
3737 struct uploaded_tsv
*utsv
= NULL
;
3739 buf
= (char *) alloca (strlen (line
));
3742 p
= unpack_varlen_hex (p
, &num
);
3743 p
++; /* skip a colon */
3744 p
= unpack_varlen_hex (p
, &initval
);
3745 p
++; /* skip a colon */
3746 p
= unpack_varlen_hex (p
, &builtin
);
3747 p
++; /* skip a colon */
3748 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3751 utsv
= get_uploaded_tsv (num
, utsvp
);
3752 utsv
->initial_value
= initval
;
3753 utsv
->builtin
= builtin
;
3754 utsv
->name
= xstrdup (buf
);
3758 free_current_marker (void *arg
)
3760 struct static_tracepoint_marker
**marker_p
3761 = (struct static_tracepoint_marker
**) arg
;
3763 if (*marker_p
!= NULL
)
3765 release_static_tracepoint_marker (*marker_p
);
3772 /* Given a line of text defining a static tracepoint marker, parse it
3773 into a "static tracepoint marker" object. Throws an error is
3774 parsing fails. If PP is non-null, it points to one past the end of
3775 the parsed marker definition. */
3778 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
3779 struct static_tracepoint_marker
*marker
)
3786 p
= unpack_varlen_hex (p
, &addr
);
3787 p
++; /* skip a colon */
3789 marker
->gdbarch
= target_gdbarch ();
3790 marker
->address
= (CORE_ADDR
) addr
;
3792 endp
= strchr (p
, ':');
3794 error (_("bad marker definition: %s"), line
);
3796 marker
->str_id
= (char *) xmalloc (endp
- p
+ 1);
3797 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
3798 marker
->str_id
[end
] = '\0';
3801 p
++; /* skip a colon */
3803 marker
->extra
= (char *) xmalloc (strlen (p
) + 1);
3804 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
3805 marker
->extra
[end
] = '\0';
3811 /* Release a static tracepoint marker's contents. Note that the
3812 object itself isn't released here. There objects are usually on
3816 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
3818 xfree (marker
->str_id
);
3819 marker
->str_id
= NULL
;
3822 /* Print MARKER to gdb_stdout. */
3825 print_one_static_tracepoint_marker (int count
,
3826 struct static_tracepoint_marker
*marker
)
3830 char wrap_indent
[80];
3831 char extra_field_indent
[80];
3832 struct ui_out
*uiout
= current_uiout
;
3833 VEC(breakpoint_p
) *tracepoints
;
3835 struct symtab_and_line sal
;
3839 sal
.pc
= marker
->address
;
3841 tracepoints
= static_tracepoints_here (marker
->address
);
3843 ui_out_emit_tuple
tuple_emitter (uiout
, "marker");
3845 /* A counter field to help readability. This is not a stable
3847 uiout
->field_int ("count", count
);
3849 uiout
->field_string ("marker-id", marker
->str_id
);
3851 uiout
->field_fmt ("enabled", "%c",
3852 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
3855 strcpy (wrap_indent
, " ");
3857 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
3858 strcat (wrap_indent
, " ");
3860 strcat (wrap_indent
, " ");
3862 strcpy (extra_field_indent
, " ");
3864 uiout
->field_core_addr ("addr", marker
->gdbarch
, marker
->address
);
3866 sal
= find_pc_line (marker
->address
, 0);
3867 sym
= find_pc_sect_function (marker
->address
, NULL
);
3870 uiout
->text ("in ");
3871 uiout
->field_string ("func",
3872 SYMBOL_PRINT_NAME (sym
));
3873 uiout
->wrap_hint (wrap_indent
);
3874 uiout
->text (" at ");
3877 uiout
->field_skip ("func");
3879 if (sal
.symtab
!= NULL
)
3881 uiout
->field_string ("file",
3882 symtab_to_filename_for_display (sal
.symtab
));
3885 if (uiout
->is_mi_like_p ())
3887 const char *fullname
= symtab_to_fullname (sal
.symtab
);
3889 uiout
->field_string ("fullname", fullname
);
3892 uiout
->field_skip ("fullname");
3894 uiout
->field_int ("line", sal
.line
);
3898 uiout
->field_skip ("fullname");
3899 uiout
->field_skip ("line");
3903 uiout
->text (extra_field_indent
);
3904 uiout
->text (_("Data: \""));
3905 uiout
->field_string ("extra-data", marker
->extra
);
3906 uiout
->text ("\"\n");
3908 if (!VEC_empty (breakpoint_p
, tracepoints
))
3911 struct breakpoint
*b
;
3914 ui_out_emit_tuple
tuple_emitter (uiout
, "tracepoints-at");
3916 uiout
->text (extra_field_indent
);
3917 uiout
->text (_("Probed by static tracepoints: "));
3918 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
3923 uiout
->field_int ("tracepoint-id", b
->number
);
3927 if (uiout
->is_mi_like_p ())
3928 uiout
->field_int ("number-of-tracepoints",
3929 VEC_length(breakpoint_p
, tracepoints
));
3933 VEC_free (breakpoint_p
, tracepoints
);
3937 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
3939 VEC(static_tracepoint_marker_p
) *markers
;
3940 struct cleanup
*old_chain
;
3941 struct static_tracepoint_marker
*marker
;
3942 struct ui_out
*uiout
= current_uiout
;
3945 /* We don't have to check target_can_use_agent and agent's capability on
3946 static tracepoint here, in order to be compatible with older GDBserver.
3947 We don't check USE_AGENT is true or not, because static tracepoints
3948 don't work without in-process agent, so we don't bother users to type
3949 `set agent on' when to use static tracepoint. */
3951 ui_out_emit_table
table_emitter (uiout
, 5, -1,
3952 "StaticTracepointMarkersTable");
3954 uiout
->table_header (7, ui_left
, "counter", "Cnt");
3956 uiout
->table_header (40, ui_left
, "marker-id", "ID");
3958 uiout
->table_header (3, ui_left
, "enabled", "Enb");
3959 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3960 uiout
->table_header (10, ui_left
, "addr", "Address");
3962 uiout
->table_header (18, ui_left
, "addr", "Address");
3963 uiout
->table_header (40, ui_noalign
, "what", "What");
3965 uiout
->table_body ();
3967 markers
= target_static_tracepoint_markers_by_strid (NULL
);
3968 old_chain
= make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
3971 VEC_iterate (static_tracepoint_marker_p
,
3972 markers
, i
, marker
);
3975 print_one_static_tracepoint_marker (i
+ 1, marker
);
3976 release_static_tracepoint_marker (marker
);
3979 do_cleanups (old_chain
);
3982 /* The $_sdata convenience variable is a bit special. We don't know
3983 for sure type of the value until we actually have a chance to fetch
3984 the data --- the size of the object depends on what has been
3985 collected. We solve this by making $_sdata be an internalvar that
3986 creates a new value on access. */
3988 /* Return a new value with the correct type for the sdata object of
3989 the current trace frame. Return a void value if there's no object
3992 static struct value
*
3993 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
3999 /* We need to read the whole object before we know its size. */
4000 size
= target_read_alloc (¤t_target
,
4001 TARGET_OBJECT_STATIC_TRACE_DATA
,
4008 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4010 v
= allocate_value (type
);
4011 memcpy (value_contents_raw (v
), buf
, size
);
4016 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4019 #if !defined(HAVE_LIBEXPAT)
4021 struct traceframe_info
*
4022 parse_traceframe_info (const char *tframe_info
)
4024 static int have_warned
;
4029 warning (_("Can not parse XML trace frame info; XML support "
4030 "was disabled at compile time"));
4036 #else /* HAVE_LIBEXPAT */
4038 #include "xml-support.h"
4040 /* Handle the start of a <memory> element. */
4043 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4044 const struct gdb_xml_element
*element
,
4045 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4047 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
4048 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4049 ULONGEST
*start_p
, *length_p
;
4052 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
;
4054 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
;
4056 r
->start
= *start_p
;
4057 r
->length
= *length_p
;
4060 /* Handle the start of a <tvar> element. */
4063 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
4064 const struct gdb_xml_element
*element
,
4066 VEC(gdb_xml_value_s
) *attributes
)
4068 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
4069 const char *id_attrib
4070 = (const char *) xml_find_attribute (attributes
, "id")->value
;
4071 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
4073 VEC_safe_push (int, info
->tvars
, id
);
4076 /* Discard the constructed trace frame info (if an error occurs). */
4079 free_result (void *p
)
4081 struct traceframe_info
*result
= (struct traceframe_info
*) p
;
4083 free_traceframe_info (result
);
4086 /* The allowed elements and attributes for an XML memory map. */
4088 static const struct gdb_xml_attribute memory_attributes
[] = {
4089 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4090 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4091 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4094 static const struct gdb_xml_attribute tvar_attributes
[] = {
4095 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
4096 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4099 static const struct gdb_xml_element traceframe_info_children
[] = {
4100 { "memory", memory_attributes
, NULL
,
4101 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4102 traceframe_info_start_memory
, NULL
},
4103 { "tvar", tvar_attributes
, NULL
,
4104 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4105 traceframe_info_start_tvar
, NULL
},
4106 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4109 static const struct gdb_xml_element traceframe_info_elements
[] = {
4110 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4112 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4115 /* Parse a traceframe-info XML document. */
4117 struct traceframe_info
*
4118 parse_traceframe_info (const char *tframe_info
)
4120 struct traceframe_info
*result
;
4121 struct cleanup
*back_to
;
4123 result
= XCNEW (struct traceframe_info
);
4124 back_to
= make_cleanup (free_result
, result
);
4126 if (gdb_xml_parse_quick (_("trace frame info"),
4127 "traceframe-info.dtd", traceframe_info_elements
,
4128 tframe_info
, result
) == 0)
4130 /* Parsed successfully, keep the result. */
4131 discard_cleanups (back_to
);
4136 do_cleanups (back_to
);
4140 #endif /* HAVE_LIBEXPAT */
4142 /* Returns the traceframe_info object for the current traceframe.
4143 This is where we avoid re-fetching the object from the target if we
4144 already have it cached. */
4146 struct traceframe_info
*
4147 get_traceframe_info (void)
4149 if (traceframe_info
== NULL
)
4150 traceframe_info
= target_traceframe_info ();
4152 return traceframe_info
;
4155 /* If the target supports the query, return in RESULT the set of
4156 collected memory in the current traceframe, found within the LEN
4157 bytes range starting at MEMADDR. Returns true if the target
4158 supports the query, otherwise returns false, and RESULT is left
4162 traceframe_available_memory (VEC(mem_range_s
) **result
,
4163 CORE_ADDR memaddr
, ULONGEST len
)
4165 struct traceframe_info
*info
= get_traceframe_info ();
4169 struct mem_range
*r
;
4174 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4175 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4177 ULONGEST lo1
, hi1
, lo2
, hi2
;
4178 struct mem_range
*nr
;
4181 hi1
= memaddr
+ len
;
4184 hi2
= r
->start
+ r
->length
;
4186 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4188 nr
->start
= std::max (lo1
, lo2
);
4189 nr
->length
= std::min (hi1
, hi2
) - nr
->start
;
4192 normalize_mem_ranges (*result
);
4199 /* Implementation of `sdata' variable. */
4201 static const struct internalvar_funcs sdata_funcs
=
4208 /* module initialization */
4210 _initialize_tracepoint (void)
4212 struct cmd_list_element
*c
;
4214 /* Explicitly create without lookup, since that tries to create a
4215 value with a void typed value, and when we get here, gdbarch
4216 isn't initialized yet. At this point, we're quite sure there
4217 isn't another convenience variable of the same name. */
4218 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4220 traceframe_number
= -1;
4221 tracepoint_number
= -1;
4223 add_info ("scope", scope_info
,
4224 _("List the variables local to a scope"));
4226 add_cmd ("tracepoints", class_trace
, NULL
,
4227 _("Tracing of program execution without stopping the program."),
4230 add_com ("tdump", class_trace
, tdump_command
,
4231 _("Print everything collected at the current tracepoint."));
4233 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4234 Define a trace state variable.\n\
4235 Argument is a $-prefixed name, optionally followed\n\
4236 by '=' and an expression that sets the initial value\n\
4237 at the start of tracing."));
4238 set_cmd_completer (c
, expression_completer
);
4240 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4241 Delete one or more trace state variables.\n\
4242 Arguments are the names of the variables to delete.\n\
4243 If no arguments are supplied, delete all variables."), &deletelist
);
4244 /* FIXME add a trace variable completer. */
4246 add_info ("tvariables", tvariables_info
, _("\
4247 Status of trace state variables and their values.\n\
4250 add_info ("static-tracepoint-markers",
4251 info_static_tracepoint_markers_command
, _("\
4252 List target static tracepoints markers.\n\
4255 add_prefix_cmd ("tfind", class_trace
, tfind_command
, _("\
4256 Select a trace frame;\n\
4257 No argument means forward by one frame; '-' means backward by one frame."),
4258 &tfindlist
, "tfind ", 1, &cmdlist
);
4260 add_cmd ("outside", class_trace
, tfind_outside_command
, _("\
4261 Select a trace frame whose PC is outside the given range (exclusive).\n\
4262 Usage: tfind outside addr1, addr2"),
4265 add_cmd ("range", class_trace
, tfind_range_command
, _("\
4266 Select a trace frame whose PC is in the given range (inclusive).\n\
4267 Usage: tfind range addr1,addr2"),
4270 add_cmd ("line", class_trace
, tfind_line_command
, _("\
4271 Select a trace frame by source line.\n\
4272 Argument can be a line number (with optional source file),\n\
4273 a function name, or '*' followed by an address.\n\
4274 Default argument is 'the next source line that was traced'."),
4277 add_cmd ("tracepoint", class_trace
, tfind_tracepoint_command
, _("\
4278 Select a trace frame by tracepoint number.\n\
4279 Default is the tracepoint for the current trace frame."),
4282 add_cmd ("pc", class_trace
, tfind_pc_command
, _("\
4283 Select a trace frame by PC.\n\
4284 Default is the current PC, or the PC of the current trace frame."),
4287 add_cmd ("end", class_trace
, tfind_end_command
, _("\
4288 De-select any trace frame and resume 'live' debugging."),
4291 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4293 add_cmd ("start", class_trace
, tfind_start_command
,
4294 _("Select the first trace frame in the trace buffer."),
4297 add_com ("tstatus", class_trace
, tstatus_command
,
4298 _("Display the status of the current trace data collection."));
4300 add_com ("tstop", class_trace
, tstop_command
, _("\
4301 Stop trace data collection.\n\
4302 Usage: tstop [ <notes> ... ]\n\
4303 Any arguments supplied are recorded with the trace as a stop reason and\n\
4304 reported by tstatus (if the target supports trace notes)."));
4306 add_com ("tstart", class_trace
, tstart_command
, _("\
4307 Start trace data collection.\n\
4308 Usage: tstart [ <notes> ... ]\n\
4309 Any arguments supplied are recorded with the trace as a note and\n\
4310 reported by tstatus (if the target supports trace notes)."));
4312 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4313 Ends a list of commands or actions.\n\
4314 Several GDB commands allow you to enter a list of commands or actions.\n\
4315 Entering \"end\" on a line by itself is the normal way to terminate\n\
4317 Note: the \"end\" command cannot be used at the gdb prompt."));
4319 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4320 Specify single-stepping behavior at a tracepoint.\n\
4321 Argument is number of instructions to trace in single-step mode\n\
4322 following the tracepoint. This command is normally followed by\n\
4323 one or more \"collect\" commands, to specify what to collect\n\
4324 while single-stepping.\n\n\
4325 Note: this command can only be used in a tracepoint \"actions\" list."));
4327 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4328 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4330 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4331 Specify one or more data items to be collected at a tracepoint.\n\
4332 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4333 collect all data (variables, registers) referenced by that expression.\n\
4334 Also accepts the following special arguments:\n\
4335 $regs -- all registers.\n\
4336 $args -- all function arguments.\n\
4337 $locals -- all variables local to the block/function scope.\n\
4338 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4339 Note: this command can only be used in a tracepoint \"actions\" list."));
4341 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4342 Specify one or more expressions to be evaluated at a tracepoint.\n\
4343 Accepts a comma-separated list of (one or more) expressions.\n\
4344 The result of each evaluation will be discarded.\n\
4345 Note: this command can only be used in a tracepoint \"actions\" list."));
4347 add_com ("actions", class_trace
, actions_command
, _("\
4348 Specify the actions to be taken at a tracepoint.\n\
4349 Tracepoint actions may include collecting of specified data,\n\
4350 single-stepping, or enabling/disabling other tracepoints,\n\
4351 depending on target's capabilities."));
4353 default_collect
= xstrdup ("");
4354 add_setshow_string_cmd ("default-collect", class_trace
,
4355 &default_collect
, _("\
4356 Set the list of expressions to collect by default"), _("\
4357 Show the list of expressions to collect by default"), NULL
,
4359 &setlist
, &showlist
);
4361 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4362 &disconnected_tracing
, _("\
4363 Set whether tracing continues after GDB disconnects."), _("\
4364 Show whether tracing continues after GDB disconnects."), _("\
4365 Use this to continue a tracing run even if GDB disconnects\n\
4366 or detaches from the target. You can reconnect later and look at\n\
4367 trace data collected in the meantime."),
4368 set_disconnected_tracing
,
4373 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4374 &circular_trace_buffer
, _("\
4375 Set target's use of circular trace buffer."), _("\
4376 Show target's use of circular trace buffer."), _("\
4377 Use this to make the trace buffer into a circular buffer,\n\
4378 which will discard traceframes (oldest first) instead of filling\n\
4379 up and stopping the trace run."),
4380 set_circular_trace_buffer
,
4385 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4386 &trace_buffer_size
, _("\
4387 Set requested size of trace buffer."), _("\
4388 Show requested size of trace buffer."), _("\
4389 Use this to choose a size for the trace buffer. Some targets\n\
4390 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4391 disables any attempt to set the buffer size and lets the target choose."),
4392 set_trace_buffer_size
, NULL
,
4393 &setlist
, &showlist
);
4395 add_setshow_string_cmd ("trace-user", class_trace
,
4397 Set the user name to use for current and future trace runs"), _("\
4398 Show the user name to use for current and future trace runs"), NULL
,
4399 set_trace_user
, NULL
,
4400 &setlist
, &showlist
);
4402 add_setshow_string_cmd ("trace-notes", class_trace
,
4404 Set notes string to use for current and future trace runs"), _("\
4405 Show the notes string to use for current and future trace runs"), NULL
,
4406 set_trace_notes
, NULL
,
4407 &setlist
, &showlist
);
4409 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4410 &trace_stop_notes
, _("\
4411 Set notes string to use for future tstop commands"), _("\
4412 Show the notes string to use for future tstop commands"), NULL
,
4413 set_trace_stop_notes
, NULL
,
4414 &setlist
, &showlist
);