1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2022 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"
39 #include "observable.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
52 #include "cli/cli-utils.h"
54 #include "gdbsupport/filestuff.h"
55 #include "gdbsupport/rsp-low.h"
56 #include "tracefile.h"
59 #include "cli/cli-style.h"
61 #include "gdbsupport/buildargv.h"
65 /* Maximum length of an agent aexpression.
66 This accounts for the fact that packets are limited to 400 bytes
67 (which includes everything -- including the checksum), and assumes
68 the worst case of maximum length for each of the pieces of a
71 NOTE: expressions get mem2hex'ed otherwise this would be twice as
72 large. (400 - 31)/2 == 184 */
73 #define MAX_AGENT_EXPR_LEN 184
75 /* A hook used to notify the UI of tracepoint operations. */
77 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
78 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
83 This module defines the following debugger commands:
84 trace : set a tracepoint on a function, line, or address.
85 info trace : list all debugger-defined tracepoints.
86 delete trace : delete one or more tracepoints.
87 enable trace : enable one or more tracepoints.
88 disable trace : disable one or more tracepoints.
89 actions : specify actions to be taken at a tracepoint.
90 passcount : specify a pass count for a tracepoint.
91 tstart : start a trace experiment.
92 tstop : stop a trace experiment.
93 tstatus : query the status of a trace experiment.
94 tfind : find a trace frame in the trace buffer.
95 tdump : print everything collected at the current tracepoint.
96 save-tracepoints : write tracepoint setup into a file.
98 This module defines the following user-visible debugger variables:
99 $trace_frame : sequence number of trace frame currently being debugged.
100 $trace_line : source line of trace frame currently being debugged.
101 $trace_file : source file of trace frame currently being debugged.
102 $tracepoint : tracepoint number of trace frame currently being debugged.
106 /* ======= Important global variables: ======= */
108 /* The list of all trace state variables. We don't retain pointers to
109 any of these for any reason - API is by name or number only - so it
110 works to have a vector of objects. */
112 static std::vector
<trace_state_variable
> tvariables
;
114 /* The next integer to assign to a variable. */
116 static int next_tsv_number
= 1;
118 /* Number of last traceframe collected. */
119 static int traceframe_number
;
121 /* Tracepoint for last traceframe collected. */
122 static int tracepoint_number
;
124 /* The traceframe info of the current traceframe. NULL if we haven't
125 yet attempted to fetch it, or if the target does not support
126 fetching this object, or if we're not inspecting a traceframe
128 static traceframe_info_up current_traceframe_info
;
130 /* Tracing command lists. */
131 static struct cmd_list_element
*tfindlist
;
133 /* List of expressions to collect by default at each tracepoint hit. */
134 std::string default_collect
;
136 static bool disconnected_tracing
;
138 /* This variable controls whether we ask the target for a linear or
139 circular trace buffer. */
141 static bool circular_trace_buffer
;
143 /* This variable is the requested trace buffer size, or -1 to indicate
144 that we don't care and leave it up to the target to set a size. */
146 static int trace_buffer_size
= -1;
148 /* Textual notes applying to the current and/or future trace runs. */
150 static std::string trace_user
;
152 /* Textual notes applying to the current and/or future trace runs. */
154 static std::string trace_notes
;
156 /* Textual notes applying to the stopping of a trace. */
158 static std::string trace_stop_notes
;
160 /* support routines */
162 struct collection_list
;
163 static char *mem2hex (gdb_byte
*, char *, int);
165 static counted_command_line
all_tracepoint_actions (struct breakpoint
*);
167 static struct trace_status trace_status
;
169 const char *stop_reason_names
[] = {
179 struct trace_status
*
180 current_trace_status (void)
182 return &trace_status
;
185 /* Free and clear the traceframe info cache of the current
189 clear_traceframe_info (void)
191 current_traceframe_info
= NULL
;
194 /* Set traceframe number to NUM. */
196 set_traceframe_num (int num
)
198 traceframe_number
= num
;
199 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
202 /* Set tracepoint number to NUM. */
204 set_tracepoint_num (int num
)
206 tracepoint_number
= num
;
207 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
210 /* Set externally visible debug variables for querying/printing
211 the traceframe context (line, function, file). */
214 set_traceframe_context (struct frame_info
*trace_frame
)
217 struct symbol
*traceframe_fun
;
218 symtab_and_line traceframe_sal
;
220 /* Save as globals for internal use. */
221 if (trace_frame
!= NULL
222 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
224 traceframe_sal
= find_pc_line (trace_pc
, 0);
225 traceframe_fun
= find_pc_function (trace_pc
);
227 /* Save linenumber as "$trace_line", a debugger variable visible to
229 set_internalvar_integer (lookup_internalvar ("trace_line"),
230 traceframe_sal
.line
);
234 traceframe_fun
= NULL
;
235 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
238 /* Save func name as "$trace_func", a debugger variable visible to
240 if (traceframe_fun
== NULL
241 || traceframe_fun
->linkage_name () == NULL
)
242 clear_internalvar (lookup_internalvar ("trace_func"));
244 set_internalvar_string (lookup_internalvar ("trace_func"),
245 traceframe_fun
->linkage_name ());
247 /* Save file name as "$trace_file", a debugger variable visible to
249 if (traceframe_sal
.symtab
== NULL
)
250 clear_internalvar (lookup_internalvar ("trace_file"));
252 set_internalvar_string (lookup_internalvar ("trace_file"),
253 symtab_to_filename_for_display (traceframe_sal
.symtab
));
256 /* Create a new trace state variable with the given name. */
258 struct trace_state_variable
*
259 create_trace_state_variable (const char *name
)
261 tvariables
.emplace_back (name
, next_tsv_number
++);
262 return &tvariables
.back ();
265 /* Look for a trace state variable of the given name. */
267 struct trace_state_variable
*
268 find_trace_state_variable (const char *name
)
270 for (trace_state_variable
&tsv
: tvariables
)
271 if (tsv
.name
== name
)
277 /* Look for a trace state variable of the given number. Return NULL if
280 struct trace_state_variable
*
281 find_trace_state_variable_by_number (int number
)
283 for (trace_state_variable
&tsv
: tvariables
)
284 if (tsv
.number
== number
)
291 delete_trace_state_variable (const char *name
)
293 for (auto it
= tvariables
.begin (); it
!= tvariables
.end (); it
++)
294 if (it
->name
== name
)
296 gdb::observers::tsv_deleted
.notify (&*it
);
297 tvariables
.erase (it
);
301 warning (_("No trace variable named \"$%s\", not deleting"), name
);
304 /* Throws an error if NAME is not valid syntax for a trace state
308 validate_trace_state_variable_name (const char *name
)
313 error (_("Must supply a non-empty variable name"));
315 /* All digits in the name is reserved for value history
317 for (p
= name
; isdigit (*p
); p
++)
320 error (_("$%s is not a valid trace state variable name"), name
);
322 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
325 error (_("$%s is not a valid trace state variable name"), name
);
328 /* The 'tvariable' command collects a name and optional expression to
329 evaluate into an initial value. */
332 trace_variable_command (const char *args
, int from_tty
)
335 struct trace_state_variable
*tsv
;
336 const char *name_start
, *p
;
339 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
341 /* Only allow two syntaxes; "$name" and "$name=value". */
342 p
= skip_spaces (args
);
345 error (_("Name of trace variable should start with '$'"));
348 while (isalnum (*p
) || *p
== '_')
350 std::string
name (name_start
, p
- name_start
);
353 if (*p
!= '=' && *p
!= '\0')
354 error (_("Syntax must be $NAME [ = EXPR ]"));
356 validate_trace_state_variable_name (name
.c_str ());
359 initval
= value_as_long (parse_and_eval (++p
));
361 /* If the variable already exists, just change its initial value. */
362 tsv
= find_trace_state_variable (name
.c_str ());
365 if (tsv
->initial_value
!= initval
)
367 tsv
->initial_value
= initval
;
368 gdb::observers::tsv_modified
.notify (tsv
);
370 printf_filtered (_("Trace state variable $%s "
371 "now has initial value %s.\n"),
372 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
376 /* Create a new variable. */
377 tsv
= create_trace_state_variable (name
.c_str ());
378 tsv
->initial_value
= initval
;
380 gdb::observers::tsv_created
.notify (tsv
);
382 printf_filtered (_("Trace state variable $%s "
383 "created, with initial value %s.\n"),
384 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
388 delete_trace_variable_command (const char *args
, int from_tty
)
392 if (query (_("Delete all trace state variables? ")))
395 gdb::observers::tsv_deleted
.notify (NULL
);
399 gdb_argv
argv (args
);
401 for (char *arg
: argv
)
404 delete_trace_state_variable (arg
+ 1);
406 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg
);
413 tvariables_info_1 (void)
415 struct ui_out
*uiout
= current_uiout
;
417 /* Try to acquire values from the target. */
418 for (trace_state_variable
&tsv
: tvariables
)
420 = target_get_trace_state_variable_value (tsv
.number
, &tsv
.value
);
423 ui_out_emit_table
table_emitter (uiout
, 3, tvariables
.size (),
425 uiout
->table_header (15, ui_left
, "name", "Name");
426 uiout
->table_header (11, ui_left
, "initial", "Initial");
427 uiout
->table_header (11, ui_left
, "current", "Current");
429 uiout
->table_body ();
431 for (const trace_state_variable
&tsv
: tvariables
)
435 ui_out_emit_tuple
tuple_emitter (uiout
, "variable");
437 uiout
->field_string ("name", std::string ("$") + tsv
.name
);
438 uiout
->field_string ("initial", plongest (tsv
.initial_value
));
442 c
= plongest (tsv
.value
);
443 else if (uiout
->is_mi_like_p ())
444 /* For MI, we prefer not to use magic string constants, but rather
445 omit the field completely. The difference between unknown and
446 undefined does not seem important enough to represent. */
448 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
450 /* The value is/was defined, but we don't have it. */
452 style
= metadata_style
.style ();
456 /* It is not meaningful to ask about the value. */
458 style
= metadata_style
.style ();
461 uiout
->field_string ("current", c
, style
);
466 if (tvariables
.empty ())
467 uiout
->text (_("No trace state variables.\n"));
470 /* List all the trace state variables. */
473 info_tvariables_command (const char *args
, int from_tty
)
475 tvariables_info_1 ();
478 /* Stash definitions of tsvs into the given file. */
481 save_trace_state_variables (struct ui_file
*fp
)
483 for (const trace_state_variable
&tsv
: tvariables
)
485 fprintf_unfiltered (fp
, "tvariable $%s", tsv
.name
.c_str ());
486 if (tsv
.initial_value
)
487 fprintf_unfiltered (fp
, " = %s", plongest (tsv
.initial_value
));
488 fprintf_unfiltered (fp
, "\n");
492 /* ACTIONS functions: */
494 /* The three functions:
495 collect_pseudocommand,
496 while_stepping_pseudocommand, and
497 end_actions_pseudocommand
498 are placeholders for "commands" that are actually ONLY to be used
499 within a tracepoint action list. If the actual function is ever called,
500 it means that somebody issued the "command" at the top level,
501 which is always an error. */
504 end_actions_pseudocommand (const char *args
, int from_tty
)
506 error (_("This command cannot be used at the top level."));
510 while_stepping_pseudocommand (const char *args
, int from_tty
)
512 error (_("This command can only be used in a tracepoint actions list."));
516 collect_pseudocommand (const char *args
, int from_tty
)
518 error (_("This command can only be used in a tracepoint actions list."));
522 teval_pseudocommand (const char *args
, int from_tty
)
524 error (_("This command can only be used in a tracepoint actions list."));
527 /* Parse any collection options, such as /s for strings. */
530 decode_agent_options (const char *exp
, int *trace_string
)
532 struct value_print_options opts
;
539 /* Call this to borrow the print elements default for collection
541 get_user_print_options (&opts
);
546 if (target_supports_string_tracing ())
548 /* Allow an optional decimal number giving an explicit maximum
549 string length, defaulting it to the "print elements" value;
550 so "collect/s80 mystr" gets at most 80 bytes of string. */
551 *trace_string
= opts
.print_max
;
553 if (*exp
>= '0' && *exp
<= '9')
554 *trace_string
= atoi (exp
);
555 while (*exp
>= '0' && *exp
<= '9')
559 error (_("Target does not support \"/s\" option for string tracing."));
562 error (_("Undefined collection format \"%c\"."), *exp
);
564 exp
= skip_spaces (exp
);
569 /* Enter a list of actions for a tracepoint. */
571 actions_command (const char *args
, int from_tty
)
573 struct tracepoint
*t
;
575 t
= get_tracepoint_by_number (&args
, NULL
);
579 string_printf ("Enter actions for tracepoint %d, one per line.",
582 counted_command_line l
= read_command_lines (tmpbuf
.c_str (),
584 [=] (const char *line
)
586 validate_actionline (line
, t
);
588 breakpoint_set_commands (t
, std::move (l
));
590 /* else just return */
593 /* Report the results of checking the agent expression, as errors or
597 report_agent_reqs_errors (struct agent_expr
*aexpr
)
599 /* All of the "flaws" are serious bytecode generation issues that
600 should never occur. */
601 if (aexpr
->flaw
!= agent_flaw_none
)
602 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
604 /* If analysis shows a stack underflow, GDB must have done something
605 badly wrong in its bytecode generation. */
606 if (aexpr
->min_height
< 0)
607 internal_error (__FILE__
, __LINE__
,
608 _("expression has min height < 0"));
610 /* Issue this error if the stack is predicted to get too deep. The
611 limit is rather arbitrary; a better scheme might be for the
612 target to report how much stack it will have available. The
613 depth roughly corresponds to parenthesization, so a limit of 20
614 amounts to 20 levels of expression nesting, which is actually
615 a pretty big hairy expression. */
616 if (aexpr
->max_height
> 20)
617 error (_("Expression is too complicated."));
620 /* Call ax_reqs on AEXPR and raise an error if something is wrong. */
623 finalize_tracepoint_aexpr (struct agent_expr
*aexpr
)
627 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
628 error (_("Expression is too complicated."));
630 report_agent_reqs_errors (aexpr
);
633 /* worker function */
635 validate_actionline (const char *line
, struct breakpoint
*b
)
637 struct cmd_list_element
*c
;
640 struct tracepoint
*t
= (struct tracepoint
*) b
;
642 /* If EOF is typed, *line is NULL. */
646 p
= skip_spaces (line
);
648 /* Symbol lookup etc. */
649 if (*p
== '\0') /* empty line: just prompt for another line. */
652 if (*p
== '#') /* comment line */
655 c
= lookup_cmd (&p
, cmdlist
, "", NULL
, -1, 1);
657 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
659 if (cmd_simple_func_eq (c
, collect_pseudocommand
))
661 int trace_string
= 0;
664 p
= decode_agent_options (p
, &trace_string
);
667 { /* Repeat over a comma-separated list. */
668 QUIT
; /* Allow user to bail out with ^C. */
671 if (*p
== '$') /* Look for special pseudo-symbols. */
673 if (0 == strncasecmp ("reg", p
+ 1, 3)
674 || 0 == strncasecmp ("arg", p
+ 1, 3)
675 || 0 == strncasecmp ("loc", p
+ 1, 3)
676 || 0 == strncasecmp ("_ret", p
+ 1, 4)
677 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
682 /* else fall thru, treat p as an expression and parse it! */
685 for (bp_location
*loc
: t
->locations ())
688 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
689 block_for_pc (loc
->address
), 1);
691 if (exp
->first_opcode () == OP_VAR_VALUE
)
694 expr::var_value_operation
*vvop
695 = (dynamic_cast<expr::var_value_operation
*>
697 sym
= vvop
->get_symbol ();
699 if (sym
->aclass () == LOC_CONST
)
701 error (_("constant `%s' (value %s) "
702 "will not be collected."),
704 plongest (SYMBOL_VALUE (sym
)));
706 else if (sym
->aclass () == LOC_OPTIMIZED_OUT
)
708 error (_("`%s' is optimized away "
709 "and cannot be collected."),
714 /* We have something to collect, make sure that the expr to
715 bytecode translator can handle it and that it's not too
717 agent_expr_up aexpr
= gen_trace_for_expr (loc
->address
,
721 finalize_tracepoint_aexpr (aexpr
.get ());
724 while (p
&& *p
++ == ',');
727 else if (cmd_simple_func_eq (c
, teval_pseudocommand
))
730 { /* Repeat over a comma-separated list. */
731 QUIT
; /* Allow user to bail out with ^C. */
735 for (bp_location
*loc
: t
->locations ())
739 /* Only expressions are allowed for this action. */
740 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
741 block_for_pc (loc
->address
), 1);
743 /* We have something to evaluate, make sure that the expr to
744 bytecode translator can handle it and that it's not too
746 agent_expr_up aexpr
= gen_eval_for_expr (loc
->address
, exp
.get ());
748 finalize_tracepoint_aexpr (aexpr
.get ());
751 while (p
&& *p
++ == ',');
754 else if (cmd_simple_func_eq (c
, while_stepping_pseudocommand
))
759 t
->step_count
= strtol (p
, &endp
, 0);
760 if (endp
== p
|| t
->step_count
== 0)
761 error (_("while-stepping step count `%s' is malformed."), line
);
765 else if (cmd_simple_func_eq (c
, end_actions_pseudocommand
))
769 error (_("`%s' is not a supported tracepoint action."), line
);
773 memrange_absolute
= -1
776 /* MEMRANGE functions: */
778 /* Compare memranges for std::sort. */
781 memrange_comp (const memrange
&a
, const memrange
&b
)
783 if (a
.type
== b
.type
)
785 if (a
.type
== memrange_absolute
)
786 return (bfd_vma
) a
.start
< (bfd_vma
) b
.start
;
788 return a
.start
< b
.start
;
791 return a
.type
< b
.type
;
794 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
797 memrange_sortmerge (std::vector
<memrange
> &memranges
)
799 if (!memranges
.empty ())
803 std::sort (memranges
.begin (), memranges
.end (), memrange_comp
);
805 for (a
= 0, b
= 1; b
< memranges
.size (); b
++)
807 /* If memrange b overlaps or is adjacent to memrange a,
809 if (memranges
[a
].type
== memranges
[b
].type
810 && memranges
[b
].start
<= memranges
[a
].end
)
812 if (memranges
[b
].end
> memranges
[a
].end
)
813 memranges
[a
].end
= memranges
[b
].end
;
814 continue; /* next b, same a */
818 memranges
[a
] = memranges
[b
];
820 memranges
.resize (a
+ 1);
824 /* Add remote register number REGNO to the collection list mask. */
827 collection_list::add_remote_register (unsigned int regno
)
830 printf_filtered ("collect register %d\n", regno
);
832 m_regs_mask
.at (regno
/ 8) |= 1 << (regno
% 8);
835 /* Add all the registers from the mask in AEXPR to the mask in the
836 collection list. Registers in the AEXPR mask are already remote
840 collection_list::add_ax_registers (struct agent_expr
*aexpr
)
842 if (aexpr
->reg_mask_len
> 0)
844 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
846 QUIT
; /* Allow user to bail out with ^C. */
847 if (aexpr
->reg_mask
[ndx1
] != 0)
849 /* Assume chars have 8 bits. */
850 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
851 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
852 /* It's used -- record it. */
853 add_remote_register (ndx1
* 8 + ndx2
);
859 /* If REGNO is raw, add its corresponding remote register number to
860 the mask. If REGNO is a pseudo-register, figure out the necessary
861 registers using a temporary agent expression, and add it to the
862 list if it needs more than just a mask. */
865 collection_list::add_local_register (struct gdbarch
*gdbarch
,
869 if (regno
< gdbarch_num_regs (gdbarch
))
871 int remote_regno
= gdbarch_remote_register_number (gdbarch
, regno
);
873 if (remote_regno
< 0)
874 error (_("Can't collect register %d"), regno
);
876 add_remote_register (remote_regno
);
880 agent_expr_up
aexpr (new agent_expr (gdbarch
, scope
));
882 ax_reg_mask (aexpr
.get (), regno
);
884 finalize_tracepoint_aexpr (aexpr
.get ());
886 add_ax_registers (aexpr
.get ());
888 /* Usually ax_reg_mask for a pseudo-regiser only sets the
889 corresponding raw registers in the ax mask, but if this isn't
890 the case add the expression that is generated to the
893 add_aexpr (std::move (aexpr
));
897 /* Add a memrange to a collection list. */
900 collection_list::add_memrange (struct gdbarch
*gdbarch
,
901 int type
, bfd_signed_vma base
,
902 unsigned long len
, CORE_ADDR scope
)
905 printf_filtered ("(%d,%s,%ld)\n", type
, paddress (gdbarch
, base
), len
);
907 /* type: memrange_absolute == memory, other n == basereg */
908 /* base: addr if memory, offset if reg relative. */
909 /* len: we actually save end (base + len) for convenience */
910 m_memranges
.emplace_back (type
, base
, base
+ len
);
912 if (type
!= memrange_absolute
) /* Better collect the base register! */
913 add_local_register (gdbarch
, type
, scope
);
916 /* Add a symbol to a collection list. */
919 collection_list::collect_symbol (struct symbol
*sym
,
920 struct gdbarch
*gdbarch
,
921 long frame_regno
, long frame_offset
,
927 bfd_signed_vma offset
;
928 int treat_as_expr
= 0;
930 len
= TYPE_LENGTH (check_typedef (sym
->type ()));
931 switch (sym
->aclass ())
934 printf_filtered ("%s: don't know symbol class %d\n",
935 sym
->print_name (), sym
->aclass ());
938 printf_filtered ("constant %s (value %s) will not be collected.\n",
939 sym
->print_name (), plongest (SYMBOL_VALUE (sym
)));
942 offset
= SYMBOL_VALUE_ADDRESS (sym
);
945 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
946 sym
->print_name (), len
,
947 paddress (gdbarch
, offset
));
949 /* A struct may be a C++ class with static fields, go to general
950 expression handling. */
951 if (sym
->type ()->code () == TYPE_CODE_STRUCT
)
954 add_memrange (gdbarch
, memrange_absolute
, offset
, len
, scope
);
957 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
959 printf_filtered ("LOC_REG[parm] %s: ", sym
->print_name ());
960 add_local_register (gdbarch
, reg
, scope
);
961 /* Check for doubles stored in two registers. */
962 /* FIXME: how about larger types stored in 3 or more regs? */
963 if (sym
->type ()->code () == TYPE_CODE_FLT
&&
964 len
> register_size (gdbarch
, reg
))
965 add_local_register (gdbarch
, reg
+ 1, scope
);
968 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
969 printf_filtered (" (will not collect %s)\n", sym
->print_name ());
973 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
976 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
977 " from frame ptr reg %d\n", sym
->print_name (), len
,
978 paddress (gdbarch
, offset
), reg
);
980 add_memrange (gdbarch
, reg
, offset
, len
, scope
);
982 case LOC_REGPARM_ADDR
:
983 reg
= SYMBOL_VALUE (sym
);
987 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
988 " from reg %d\n", sym
->print_name (), len
,
989 paddress (gdbarch
, offset
), reg
);
991 add_memrange (gdbarch
, reg
, offset
, len
, scope
);
995 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
998 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
999 " from frame ptr reg %d\n", sym
->print_name (), len
,
1000 paddress (gdbarch
, offset
), reg
);
1002 add_memrange (gdbarch
, reg
, offset
, len
, scope
);
1005 case LOC_UNRESOLVED
:
1009 case LOC_OPTIMIZED_OUT
:
1010 printf_filtered ("%s has been optimized out of existence.\n",
1011 sym
->print_name ());
1019 /* Expressions are the most general case. */
1022 agent_expr_up aexpr
= gen_trace_for_var (scope
, gdbarch
,
1025 /* It can happen that the symbol is recorded as a computed
1026 location, but it's been optimized away and doesn't actually
1027 have a location expression. */
1030 printf_filtered ("%s has been optimized out of existence.\n",
1031 sym
->print_name ());
1035 finalize_tracepoint_aexpr (aexpr
.get ());
1037 /* Take care of the registers. */
1038 add_ax_registers (aexpr
.get ());
1040 add_aexpr (std::move (aexpr
));
1044 /* Data to be passed around in the calls to the locals and args
1047 struct add_local_symbols_data
1049 struct collection_list
*collect
;
1050 struct gdbarch
*gdbarch
;
1058 /* The callback for the locals and args iterators. */
1061 do_collect_symbol (const char *print_name
,
1065 struct add_local_symbols_data
*p
= (struct add_local_symbols_data
*) cb_data
;
1067 p
->collect
->collect_symbol (sym
, p
->gdbarch
, p
->frame_regno
,
1068 p
->frame_offset
, p
->pc
, p
->trace_string
);
1071 p
->collect
->add_wholly_collected (print_name
);
1075 collection_list::add_wholly_collected (const char *print_name
)
1077 m_wholly_collected
.push_back (print_name
);
1080 /* Add all locals (or args) symbols to collection list. */
1083 collection_list::add_local_symbols (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1084 long frame_regno
, long frame_offset
, int type
,
1087 const struct block
*block
;
1088 struct add_local_symbols_data cb_data
;
1090 cb_data
.collect
= this;
1091 cb_data
.gdbarch
= gdbarch
;
1093 cb_data
.frame_regno
= frame_regno
;
1094 cb_data
.frame_offset
= frame_offset
;
1096 cb_data
.trace_string
= trace_string
;
1100 block
= block_for_pc (pc
);
1103 warning (_("Can't collect locals; "
1104 "no symbol table info available.\n"));
1108 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1109 if (cb_data
.count
== 0)
1110 warning (_("No locals found in scope."));
1114 pc
= get_pc_function_start (pc
);
1115 block
= block_for_pc (pc
);
1118 warning (_("Can't collect args; no symbol table info available."));
1122 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1123 if (cb_data
.count
== 0)
1124 warning (_("No args found in scope."));
1129 collection_list::add_static_trace_data ()
1132 printf_filtered ("collect static trace data\n");
1133 m_strace_data
= true;
1136 collection_list::collection_list ()
1137 : m_strace_data (false)
1139 int max_remote_regno
= 0;
1140 for (int i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
1142 int remote_regno
= (gdbarch_remote_register_number
1143 (target_gdbarch (), i
));
1145 if (remote_regno
>= 0 && remote_regno
> max_remote_regno
)
1146 max_remote_regno
= remote_regno
;
1149 m_regs_mask
.resize ((max_remote_regno
/ 8) + 1);
1151 m_memranges
.reserve (128);
1152 m_aexprs
.reserve (128);
1155 /* Reduce a collection list to string form (for gdb protocol). */
1157 std::vector
<std::string
>
1158 collection_list::stringify ()
1160 gdb::char_vector
temp_buf (2048);
1165 std::vector
<std::string
> str_list
;
1170 printf_filtered ("\nCollecting static trace data\n");
1171 end
= temp_buf
.data ();
1173 str_list
.emplace_back (temp_buf
.data (), end
- temp_buf
.data ());
1176 for (i
= m_regs_mask
.size () - 1; i
> 0; i
--)
1177 if (m_regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1179 if (m_regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1182 printf_filtered ("\nCollecting registers (mask): 0x");
1184 /* One char for 'R', one for the null terminator and two per
1186 std::size_t new_size
= (i
+ 1) * 2 + 2;
1187 if (new_size
> temp_buf
.size ())
1188 temp_buf
.resize (new_size
);
1190 end
= temp_buf
.data ();
1194 QUIT
; /* Allow user to bail out with ^C. */
1196 printf_filtered ("%02X", m_regs_mask
[i
]);
1198 end
= pack_hex_byte (end
, m_regs_mask
[i
]);
1202 str_list
.emplace_back (temp_buf
.data ());
1205 printf_filtered ("\n");
1206 if (!m_memranges
.empty () && info_verbose
)
1207 printf_filtered ("Collecting memranges: \n");
1208 for (i
= 0, count
= 0, end
= temp_buf
.data ();
1209 i
< m_memranges
.size (); i
++)
1211 QUIT
; /* Allow user to bail out with ^C. */
1214 printf_filtered ("(%d, %s, %ld)\n",
1215 m_memranges
[i
].type
,
1216 paddress (target_gdbarch (),
1217 m_memranges
[i
].start
),
1218 (long) (m_memranges
[i
].end
1219 - m_memranges
[i
].start
));
1221 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1223 str_list
.emplace_back (temp_buf
.data (), count
);
1225 end
= temp_buf
.data ();
1229 bfd_signed_vma length
1230 = m_memranges
[i
].end
- m_memranges
[i
].start
;
1232 /* The "%X" conversion specifier expects an unsigned argument,
1233 so passing -1 (memrange_absolute) to it directly gives you
1234 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1236 if (m_memranges
[i
].type
== memrange_absolute
)
1237 sprintf (end
, "M-1,%s,%lX", phex_nz (m_memranges
[i
].start
, 0),
1240 sprintf (end
, "M%X,%s,%lX", m_memranges
[i
].type
,
1241 phex_nz (m_memranges
[i
].start
, 0), (long) length
);
1244 count
+= strlen (end
);
1245 end
= temp_buf
.data () + count
;
1248 for (i
= 0; i
< m_aexprs
.size (); i
++)
1250 QUIT
; /* Allow user to bail out with ^C. */
1251 if ((count
+ 10 + 2 * m_aexprs
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1253 str_list
.emplace_back (temp_buf
.data (), count
);
1255 end
= temp_buf
.data ();
1257 sprintf (end
, "X%08X,", m_aexprs
[i
]->len
);
1258 end
+= 10; /* 'X' + 8 hex digits + ',' */
1261 end
= mem2hex (m_aexprs
[i
]->buf
, end
, m_aexprs
[i
]->len
);
1262 count
+= 2 * m_aexprs
[i
]->len
;
1267 str_list
.emplace_back (temp_buf
.data (), count
);
1269 end
= temp_buf
.data ();
1275 /* Add the expression STR to M_COMPUTED. */
1278 collection_list::append_exp (std::string
&&str
)
1280 m_computed
.push_back (std::move (str
));
1284 collection_list::finish ()
1286 memrange_sortmerge (m_memranges
);
1290 encode_actions_1 (struct command_line
*action
,
1291 struct bp_location
*tloc
,
1293 LONGEST frame_offset
,
1294 struct collection_list
*collect
,
1295 struct collection_list
*stepping_list
)
1297 const char *action_exp
;
1299 struct value
*tempval
;
1300 struct cmd_list_element
*cmd
;
1302 for (; action
; action
= action
->next
)
1304 QUIT
; /* Allow user to bail out with ^C. */
1305 action_exp
= action
->line
;
1306 action_exp
= skip_spaces (action_exp
);
1308 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", NULL
, -1, 1);
1310 error (_("Bad action list item: %s"), action_exp
);
1312 if (cmd_simple_func_eq (cmd
, collect_pseudocommand
))
1314 int trace_string
= 0;
1316 if (*action_exp
== '/')
1317 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1320 { /* Repeat over a comma-separated list. */
1321 QUIT
; /* Allow user to bail out with ^C. */
1322 action_exp
= skip_spaces (action_exp
);
1324 if (0 == strncasecmp ("$reg", action_exp
, 4))
1326 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ());
1329 int remote_regno
= (gdbarch_remote_register_number
1330 (target_gdbarch (), i
));
1332 /* Ignore arch regnos without a corresponding
1333 remote regno. This can happen for regnos not
1335 if (remote_regno
>= 0)
1336 collect
->add_remote_register (remote_regno
);
1338 action_exp
= strchr (action_exp
, ','); /* more? */
1340 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1342 collect
->add_local_symbols (target_gdbarch (),
1348 action_exp
= strchr (action_exp
, ','); /* more? */
1350 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1352 collect
->add_local_symbols (target_gdbarch (),
1358 action_exp
= strchr (action_exp
, ','); /* more? */
1360 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1363 = gen_trace_for_return_address (tloc
->address
,
1367 finalize_tracepoint_aexpr (aexpr
.get ());
1369 /* take care of the registers */
1370 collect
->add_ax_registers (aexpr
.get ());
1372 collect
->add_aexpr (std::move (aexpr
));
1373 action_exp
= strchr (action_exp
, ','); /* more? */
1375 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1377 collect
->add_static_trace_data ();
1378 action_exp
= strchr (action_exp
, ','); /* more? */
1384 const char *exp_start
= action_exp
;
1385 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1386 block_for_pc (tloc
->address
),
1389 switch (exp
->first_opcode ())
1393 expr::register_operation
*regop
1394 = (dynamic_cast<expr::register_operation
*>
1396 const char *name
= regop
->get_name ();
1398 i
= user_reg_map_name_to_regnum (target_gdbarch (),
1399 name
, strlen (name
));
1401 internal_error (__FILE__
, __LINE__
,
1402 _("Register $%s not available"),
1405 printf_filtered ("OP_REGISTER: ");
1406 collect
->add_local_register (target_gdbarch (),
1413 /* Safe because we know it's a simple expression. */
1414 tempval
= evaluate_expression (exp
.get ());
1415 addr
= value_address (tempval
);
1416 expr::unop_memval_operation
*memop
1417 = (dynamic_cast<expr::unop_memval_operation
*>
1419 struct type
*type
= memop
->get_type ();
1420 /* Initialize the TYPE_LENGTH if it is a typedef. */
1421 check_typedef (type
);
1422 collect
->add_memrange (target_gdbarch (),
1423 memrange_absolute
, addr
,
1426 collect
->append_exp (std::string (exp_start
,
1433 expr::var_value_operation
*vvo
1434 = (dynamic_cast<expr::var_value_operation
*>
1436 struct symbol
*sym
= vvo
->get_symbol ();
1437 const char *name
= sym
->natural_name ();
1439 collect
->collect_symbol (sym
,
1445 collect
->add_wholly_collected (name
);
1449 default: /* Full-fledged expression. */
1450 agent_expr_up aexpr
= gen_trace_for_expr (tloc
->address
,
1454 finalize_tracepoint_aexpr (aexpr
.get ());
1456 /* Take care of the registers. */
1457 collect
->add_ax_registers (aexpr
.get ());
1459 collect
->add_aexpr (std::move (aexpr
));
1460 collect
->append_exp (std::string (exp_start
,
1466 while (action_exp
&& *action_exp
++ == ',');
1468 else if (cmd_simple_func_eq (cmd
, teval_pseudocommand
))
1471 { /* Repeat over a comma-separated list. */
1472 QUIT
; /* Allow user to bail out with ^C. */
1473 action_exp
= skip_spaces (action_exp
);
1476 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1477 block_for_pc (tloc
->address
),
1480 agent_expr_up aexpr
= gen_eval_for_expr (tloc
->address
,
1483 finalize_tracepoint_aexpr (aexpr
.get ());
1485 /* Even though we're not officially collecting, add
1486 to the collect list anyway. */
1487 collect
->add_aexpr (std::move (aexpr
));
1490 while (action_exp
&& *action_exp
++ == ',');
1492 else if (cmd_simple_func_eq (cmd
, while_stepping_pseudocommand
))
1494 /* We check against nested while-stepping when setting
1495 breakpoint action, so no way to run into nested
1497 gdb_assert (stepping_list
);
1499 encode_actions_1 (action
->body_list_0
.get (), tloc
, frame_reg
,
1500 frame_offset
, stepping_list
, NULL
);
1503 error (_("Invalid tracepoint command '%s'"), action
->line
);
1507 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1508 and STEPPING_LIST. */
1511 encode_actions (struct bp_location
*tloc
,
1512 struct collection_list
*tracepoint_list
,
1513 struct collection_list
*stepping_list
)
1516 LONGEST frame_offset
;
1518 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1519 tloc
->address
, &frame_reg
, &frame_offset
);
1521 counted_command_line actions
= all_tracepoint_actions (tloc
->owner
);
1522 encode_actions_1 (actions
.get (), tloc
, frame_reg
, frame_offset
,
1523 tracepoint_list
, stepping_list
);
1524 encode_actions_1 (breakpoint_commands (tloc
->owner
), tloc
,
1525 frame_reg
, frame_offset
, tracepoint_list
, stepping_list
);
1527 tracepoint_list
->finish ();
1528 stepping_list
->finish ();
1531 /* Render all actions into gdb protocol. */
1534 encode_actions_rsp (struct bp_location
*tloc
,
1535 std::vector
<std::string
> *tdp_actions
,
1536 std::vector
<std::string
> *stepping_actions
)
1538 struct collection_list tracepoint_list
, stepping_list
;
1540 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
1542 *tdp_actions
= tracepoint_list
.stringify ();
1543 *stepping_actions
= stepping_list
.stringify ();
1547 collection_list::add_aexpr (agent_expr_up aexpr
)
1549 m_aexprs
.push_back (std::move (aexpr
));
1553 process_tracepoint_on_disconnect (void)
1555 int has_pending_p
= 0;
1557 /* Check whether we still have pending tracepoint. If we have, warn the
1558 user that pending tracepoint will no longer work. */
1559 for (breakpoint
*b
: all_tracepoints ())
1568 for (bp_location
*loc1
: b
->locations ())
1570 if (loc1
->shlib_disabled
)
1583 warning (_("Pending tracepoints will not be resolved while"
1584 " GDB is disconnected\n"));
1587 /* Reset local state of tracing. */
1590 trace_reset_local_state (void)
1592 set_traceframe_num (-1);
1593 set_tracepoint_num (-1);
1594 set_traceframe_context (NULL
);
1595 clear_traceframe_info ();
1599 start_tracing (const char *notes
)
1601 int any_enabled
= 0, num_to_download
= 0;
1604 auto tracepoint_range
= all_tracepoints ();
1606 /* No point in tracing without any tracepoints... */
1607 if (tracepoint_range
.begin () == tracepoint_range
.end ())
1608 error (_("No tracepoints defined, not starting trace"));
1610 for (breakpoint
*b
: tracepoint_range
)
1612 if (b
->enable_state
== bp_enabled
)
1615 if ((b
->type
== bp_fast_tracepoint
1616 ? may_insert_fast_tracepoints
1617 : may_insert_tracepoints
))
1620 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1621 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1626 if (target_supports_enable_disable_tracepoint ())
1627 warning (_("No tracepoints enabled"));
1630 /* No point in tracing with only disabled tracepoints that
1631 cannot be re-enabled. */
1632 error (_("No tracepoints enabled, not starting trace"));
1636 if (num_to_download
<= 0)
1637 error (_("No tracepoints that may be downloaded, not starting trace"));
1639 target_trace_init ();
1641 for (breakpoint
*b
: tracepoint_range
)
1643 struct tracepoint
*t
= (struct tracepoint
*) b
;
1644 int bp_location_downloaded
= 0;
1646 /* Clear `inserted' flag. */
1647 for (bp_location
*loc
: b
->locations ())
1650 if ((b
->type
== bp_fast_tracepoint
1651 ? !may_insert_fast_tracepoints
1652 : !may_insert_tracepoints
))
1655 t
->number_on_target
= 0;
1657 for (bp_location
*loc
: b
->locations ())
1659 /* Since tracepoint locations are never duplicated, `inserted'
1660 flag should be zero. */
1661 gdb_assert (!loc
->inserted
);
1663 target_download_tracepoint (loc
);
1666 bp_location_downloaded
= 1;
1669 t
->number_on_target
= b
->number
;
1671 for (bp_location
*loc
: b
->locations ())
1672 if (loc
->probe
.prob
!= NULL
)
1673 loc
->probe
.prob
->set_semaphore (loc
->probe
.objfile
,
1676 if (bp_location_downloaded
)
1677 gdb::observers::breakpoint_modified
.notify (b
);
1680 /* Send down all the trace state variables too. */
1681 for (const trace_state_variable
&tsv
: tvariables
)
1682 target_download_trace_state_variable (tsv
);
1684 /* Tell target to treat text-like sections as transparent. */
1685 target_trace_set_readonly_regions ();
1686 /* Set some mode flags. */
1687 target_set_disconnected_tracing (disconnected_tracing
);
1688 target_set_circular_trace_buffer (circular_trace_buffer
);
1689 target_set_trace_buffer_size (trace_buffer_size
);
1692 notes
= trace_notes
.c_str ();
1694 ret
= target_set_trace_notes (trace_user
.c_str (), notes
, NULL
);
1696 if (!ret
&& (!trace_user
.empty () || notes
))
1697 warning (_("Target does not support trace user/notes, info ignored"));
1699 /* Now insert traps and begin collecting data. */
1700 target_trace_start ();
1702 /* Reset our local state. */
1703 trace_reset_local_state ();
1704 current_trace_status()->running
= 1;
1707 /* The tstart command requests the target to start a new trace run.
1708 The command passes any arguments it has to the target verbatim, as
1709 an optional "trace note". This is useful as for instance a warning
1710 to other users if the trace runs disconnected, and you don't want
1711 anybody else messing with the target. */
1714 tstart_command (const char *args
, int from_tty
)
1716 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1718 if (current_trace_status ()->running
)
1721 && !query (_("A trace is running already. Start a new run? ")))
1722 error (_("New trace run not started."));
1725 start_tracing (args
);
1728 /* The tstop command stops the tracing run. The command passes any
1729 supplied arguments to the target verbatim as a "stop note"; if the
1730 target supports trace notes, then it will be reported back as part
1731 of the trace run's status. */
1734 tstop_command (const char *args
, int from_tty
)
1736 if (!current_trace_status ()->running
)
1737 error (_("Trace is not running."));
1739 stop_tracing (args
);
1743 stop_tracing (const char *note
)
1747 target_trace_stop ();
1749 for (breakpoint
*t
: all_tracepoints ())
1751 if ((t
->type
== bp_fast_tracepoint
1752 ? !may_insert_fast_tracepoints
1753 : !may_insert_tracepoints
))
1756 for (bp_location
*loc
: t
->locations ())
1758 /* GDB can be totally absent in some disconnected trace scenarios,
1759 but we don't really care if this semaphore goes out of sync.
1760 That's why we are decrementing it here, but not taking care
1762 if (loc
->probe
.prob
!= NULL
)
1763 loc
->probe
.prob
->clear_semaphore (loc
->probe
.objfile
,
1769 note
= trace_stop_notes
.c_str ();
1771 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1774 warning (_("Target does not support trace notes, note ignored"));
1776 /* Should change in response to reply? */
1777 current_trace_status ()->running
= 0;
1780 /* tstatus command */
1782 tstatus_command (const char *args
, int from_tty
)
1784 struct trace_status
*ts
= current_trace_status ();
1787 status
= target_get_trace_status (ts
);
1791 if (ts
->filename
!= NULL
)
1792 printf_filtered (_("Using a trace file.\n"));
1795 printf_filtered (_("Trace can not be run on this target.\n"));
1800 if (!ts
->running_known
)
1802 printf_filtered (_("Run/stop status is unknown.\n"));
1804 else if (ts
->running
)
1806 printf_filtered (_("Trace is running on the target.\n"));
1810 switch (ts
->stop_reason
)
1812 case trace_never_run
:
1813 printf_filtered (_("No trace has been run on the target.\n"));
1815 case trace_stop_command
:
1817 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1820 printf_filtered (_("Trace stopped by a tstop command.\n"));
1822 case trace_buffer_full
:
1823 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1825 case trace_disconnected
:
1826 printf_filtered (_("Trace stopped because of disconnection.\n"));
1828 case tracepoint_passcount
:
1829 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1830 ts
->stopping_tracepoint
);
1832 case tracepoint_error
:
1833 if (ts
->stopping_tracepoint
)
1834 printf_filtered (_("Trace stopped by an "
1835 "error (%s, tracepoint %d).\n"),
1836 ts
->stop_desc
, ts
->stopping_tracepoint
);
1838 printf_filtered (_("Trace stopped by an error (%s).\n"),
1841 case trace_stop_reason_unknown
:
1842 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1845 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1851 if (ts
->traceframes_created
>= 0
1852 && ts
->traceframe_count
!= ts
->traceframes_created
)
1854 printf_filtered (_("Buffer contains %d trace "
1855 "frames (of %d created total).\n"),
1856 ts
->traceframe_count
, ts
->traceframes_created
);
1858 else if (ts
->traceframe_count
>= 0)
1860 printf_filtered (_("Collected %d trace frames.\n"),
1861 ts
->traceframe_count
);
1864 if (ts
->buffer_free
>= 0)
1866 if (ts
->buffer_size
>= 0)
1868 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1869 ts
->buffer_free
, ts
->buffer_size
);
1870 if (ts
->buffer_size
> 0)
1871 printf_filtered (_(" (%d%% full)"),
1872 ((int) ((((long long) (ts
->buffer_size
1873 - ts
->buffer_free
)) * 100)
1874 / ts
->buffer_size
)));
1875 printf_filtered (_(".\n"));
1878 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1882 if (ts
->disconnected_tracing
)
1883 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1885 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1887 if (ts
->circular_buffer
)
1888 printf_filtered (_("Trace buffer is circular.\n"));
1890 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1891 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1893 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1894 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1896 /* Now report on what we're doing with tfind. */
1897 if (traceframe_number
>= 0)
1898 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1899 traceframe_number
, tracepoint_number
);
1901 printf_filtered (_("Not looking at any trace frame.\n"));
1903 /* Report start/stop times if supplied. */
1908 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1910 /* Reporting a run time is more readable than two long numbers. */
1911 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1912 (long int) (ts
->start_time
/ 1000000),
1913 (long int) (ts
->start_time
% 1000000),
1914 (long int) (run_time
/ 1000000),
1915 (long int) (run_time
% 1000000));
1918 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1919 (long int) (ts
->start_time
/ 1000000),
1920 (long int) (ts
->start_time
% 1000000));
1922 else if (ts
->stop_time
)
1923 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1924 (long int) (ts
->stop_time
/ 1000000),
1925 (long int) (ts
->stop_time
% 1000000));
1927 /* Now report any per-tracepoint status available. */
1928 for (breakpoint
*t
: all_tracepoints ())
1929 target_get_tracepoint_status (t
, NULL
);
1932 /* Report the trace status to uiout, in a way suitable for MI, and not
1933 suitable for CLI. If ON_STOP is true, suppress a few fields that
1934 are not meaningful in the -trace-stop response.
1936 The implementation is essentially parallel to trace_status_command, but
1937 merging them will result in unreadable code. */
1939 trace_status_mi (int on_stop
)
1941 struct ui_out
*uiout
= current_uiout
;
1942 struct trace_status
*ts
= current_trace_status ();
1945 status
= target_get_trace_status (ts
);
1947 if (status
== -1 && ts
->filename
== NULL
)
1949 uiout
->field_string ("supported", "0");
1953 if (ts
->filename
!= NULL
)
1954 uiout
->field_string ("supported", "file");
1956 uiout
->field_string ("supported", "1");
1958 if (ts
->filename
!= NULL
)
1959 uiout
->field_string ("trace-file", ts
->filename
);
1961 gdb_assert (ts
->running_known
);
1965 uiout
->field_string ("running", "1");
1967 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1968 Given that the frontend gets the status either on -trace-stop, or from
1969 -trace-status after re-connection, it does not seem like this
1970 information is necessary for anything. It is not necessary for either
1971 figuring the vital state of the target nor for navigation of trace
1972 frames. If the frontend wants to show the current state is some
1973 configure dialog, it can request the value when such dialog is
1974 invoked by the user. */
1978 const char *stop_reason
= NULL
;
1979 int stopping_tracepoint
= -1;
1982 uiout
->field_string ("running", "0");
1984 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1986 switch (ts
->stop_reason
)
1988 case trace_stop_command
:
1989 stop_reason
= "request";
1991 case trace_buffer_full
:
1992 stop_reason
= "overflow";
1994 case trace_disconnected
:
1995 stop_reason
= "disconnection";
1997 case tracepoint_passcount
:
1998 stop_reason
= "passcount";
1999 stopping_tracepoint
= ts
->stopping_tracepoint
;
2001 case tracepoint_error
:
2002 stop_reason
= "error";
2003 stopping_tracepoint
= ts
->stopping_tracepoint
;
2009 uiout
->field_string ("stop-reason", stop_reason
);
2010 if (stopping_tracepoint
!= -1)
2011 uiout
->field_signed ("stopping-tracepoint",
2012 stopping_tracepoint
);
2013 if (ts
->stop_reason
== tracepoint_error
)
2014 uiout
->field_string ("error-description",
2020 if (ts
->traceframe_count
!= -1)
2021 uiout
->field_signed ("frames", ts
->traceframe_count
);
2022 if (ts
->traceframes_created
!= -1)
2023 uiout
->field_signed ("frames-created", ts
->traceframes_created
);
2024 if (ts
->buffer_size
!= -1)
2025 uiout
->field_signed ("buffer-size", ts
->buffer_size
);
2026 if (ts
->buffer_free
!= -1)
2027 uiout
->field_signed ("buffer-free", ts
->buffer_free
);
2029 uiout
->field_signed ("disconnected", ts
->disconnected_tracing
);
2030 uiout
->field_signed ("circular", ts
->circular_buffer
);
2032 uiout
->field_string ("user-name", ts
->user_name
);
2033 uiout
->field_string ("notes", ts
->notes
);
2038 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2039 (long int) (ts
->start_time
/ 1000000),
2040 (long int) (ts
->start_time
% 1000000));
2041 uiout
->field_string ("start-time", buf
);
2042 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2043 (long int) (ts
->stop_time
/ 1000000),
2044 (long int) (ts
->stop_time
% 1000000));
2045 uiout
->field_string ("stop-time", buf
);
2049 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2050 user if she really wants to detach. */
2053 query_if_trace_running (int from_tty
)
2058 /* It can happen that the target that was tracing went away on its
2059 own, and we didn't notice. Get a status update, and if the
2060 current target doesn't even do tracing, then assume it's not
2062 if (target_get_trace_status (current_trace_status ()) < 0)
2063 current_trace_status ()->running
= 0;
2065 /* If running interactively, give the user the option to cancel and
2066 then decide what to do differently with the run. Scripts are
2067 just going to disconnect and let the target deal with it,
2068 according to how it's been instructed previously via
2069 disconnected-tracing. */
2070 if (current_trace_status ()->running
)
2072 process_tracepoint_on_disconnect ();
2074 if (current_trace_status ()->disconnected_tracing
)
2076 if (!query (_("Trace is running and will "
2077 "continue after detach; detach anyway? ")))
2078 error (_("Not confirmed."));
2082 if (!query (_("Trace is running but will "
2083 "stop on detach; detach anyway? ")))
2084 error (_("Not confirmed."));
2089 /* This function handles the details of what to do about an ongoing
2090 tracing run if the user has asked to detach or otherwise disconnect
2094 disconnect_tracing (void)
2096 /* Also we want to be out of tfind mode, otherwise things can get
2097 confusing upon reconnection. Just use these calls instead of
2098 full tfind_1 behavior because we're in the middle of detaching,
2099 and there's no point to updating current stack frame etc. */
2100 trace_reset_local_state ();
2103 /* Worker function for the various flavors of the tfind command. */
2105 tfind_1 (enum trace_find_type type
, int num
,
2106 CORE_ADDR addr1
, CORE_ADDR addr2
,
2109 int target_frameno
= -1, target_tracept
= -1;
2110 struct frame_id old_frame_id
= null_frame_id
;
2111 struct tracepoint
*tp
;
2112 struct ui_out
*uiout
= current_uiout
;
2114 /* Only try to get the current stack frame if we have a chance of
2115 succeeding. In particular, if we're trying to get a first trace
2116 frame while all threads are running, it's not going to succeed,
2117 so leave it with a default value and let the frame comparison
2118 below (correctly) decide to print out the source location of the
2120 if (!(type
== tfind_number
&& num
== -1)
2121 && (has_stack_frames () || traceframe_number
>= 0))
2122 old_frame_id
= get_frame_id (get_current_frame ());
2124 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2127 if (type
== tfind_number
2129 && target_frameno
== -1)
2131 /* We told the target to get out of tfind mode, and it did. */
2133 else if (target_frameno
== -1)
2135 /* A request for a non-existent trace frame has failed.
2136 Our response will be different, depending on FROM_TTY:
2138 If FROM_TTY is true, meaning that this command was
2139 typed interactively by the user, then give an error
2140 and DO NOT change the state of traceframe_number etc.
2142 However if FROM_TTY is false, meaning that we're either
2143 in a script, a loop, or a user-defined command, then
2144 DON'T give an error, but DO change the state of
2145 traceframe_number etc. to invalid.
2147 The rationale is that if you typed the command, you
2148 might just have committed a typo or something, and you'd
2149 like to NOT lose your current debugging state. However
2150 if you're in a user-defined command or especially in a
2151 loop, then you need a way to detect that the command
2152 failed WITHOUT aborting. This allows you to write
2153 scripts that search thru the trace buffer until the end,
2154 and then continue on to do something else. */
2157 error (_("Target failed to find requested trace frame."));
2161 printf_filtered ("End of trace buffer.\n");
2162 #if 0 /* dubious now? */
2163 /* The following will not recurse, since it's
2165 tfind_command ("-1", from_tty
);
2170 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2172 reinit_frame_cache ();
2173 target_dcache_invalidate ();
2175 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2177 if (target_frameno
!= get_traceframe_number ())
2178 gdb::observers::traceframe_changed
.notify (target_frameno
, tracepoint_number
);
2180 set_current_traceframe (target_frameno
);
2182 if (target_frameno
== -1)
2183 set_traceframe_context (NULL
);
2185 set_traceframe_context (get_current_frame ());
2187 if (traceframe_number
>= 0)
2189 /* Use different branches for MI and CLI to make CLI messages
2191 if (uiout
->is_mi_like_p ())
2193 uiout
->field_string ("found", "1");
2194 uiout
->field_signed ("tracepoint", tracepoint_number
);
2195 uiout
->field_signed ("traceframe", traceframe_number
);
2199 printf_filtered (_("Found trace frame %d, tracepoint %d\n"),
2200 traceframe_number
, tracepoint_number
);
2205 if (uiout
->is_mi_like_p ())
2206 uiout
->field_string ("found", "0");
2207 else if (type
== tfind_number
&& num
== -1)
2208 printf_filtered (_("No longer looking at any trace frame\n"));
2209 else /* This case may never occur, check. */
2210 printf_filtered (_("No trace frame found\n"));
2213 /* If we're in nonstop mode and getting out of looking at trace
2214 frames, there won't be any current frame to go back to and
2217 && (has_stack_frames () || traceframe_number
>= 0))
2219 enum print_what print_what
;
2221 /* NOTE: in imitation of the step command, try to determine
2222 whether we have made a transition from one function to
2223 another. If so, we'll print the "stack frame" (ie. the new
2224 function and it's arguments) -- otherwise we'll just show the
2227 if (frame_id_eq (old_frame_id
,
2228 get_frame_id (get_current_frame ())))
2229 print_what
= SRC_LINE
;
2231 print_what
= SRC_AND_LOC
;
2233 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2238 /* Error on looking at traceframes while trace is running. */
2241 check_trace_running (struct trace_status
*status
)
2243 if (status
->running
&& status
->filename
== NULL
)
2244 error (_("May not look at trace frames while trace is running."));
2247 /* trace_find_command takes a trace frame number n,
2248 sends "QTFrame:<n>" to the target,
2249 and accepts a reply that may contain several optional pieces
2250 of information: a frame number, a tracepoint number, and an
2251 indication of whether this is a trap frame or a stepping frame.
2253 The minimal response is just "OK" (which indicates that the
2254 target does not give us a frame number or a tracepoint number).
2255 Instead of that, the target may send us a string containing
2257 F<hexnum> (gives the selected frame number)
2258 T<hexnum> (gives the selected tracepoint number)
2263 tfind_command_1 (const char *args
, int from_tty
)
2264 { /* This should only be called with a numeric argument. */
2267 check_trace_running (current_trace_status ());
2269 if (args
== 0 || *args
== 0)
2270 { /* TFIND with no args means find NEXT trace frame. */
2271 if (traceframe_number
== -1)
2272 frameno
= 0; /* "next" is first one. */
2274 frameno
= traceframe_number
+ 1;
2276 else if (0 == strcmp (args
, "-"))
2278 if (traceframe_number
== -1)
2279 error (_("not debugging trace buffer"));
2280 else if (from_tty
&& traceframe_number
== 0)
2281 error (_("already at start of trace buffer"));
2283 frameno
= traceframe_number
- 1;
2285 /* A hack to work around eval's need for fp to have been collected. */
2286 else if (0 == strcmp (args
, "-1"))
2289 frameno
= parse_and_eval_long (args
);
2292 error (_("invalid input (%d is less than zero)"), frameno
);
2294 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2298 tfind_command (const char *args
, int from_tty
)
2300 tfind_command_1 (args
, from_tty
);
2305 tfind_end_command (const char *args
, int from_tty
)
2307 tfind_command_1 ("-1", from_tty
);
2312 tfind_start_command (const char *args
, int from_tty
)
2314 tfind_command_1 ("0", from_tty
);
2317 /* tfind pc command */
2319 tfind_pc_command (const char *args
, int from_tty
)
2323 check_trace_running (current_trace_status ());
2325 if (args
== 0 || *args
== 0)
2326 pc
= regcache_read_pc (get_current_regcache ());
2328 pc
= parse_and_eval_address (args
);
2330 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2333 /* tfind tracepoint command */
2335 tfind_tracepoint_command (const char *args
, int from_tty
)
2338 struct tracepoint
*tp
;
2340 check_trace_running (current_trace_status ());
2342 if (args
== 0 || *args
== 0)
2344 if (tracepoint_number
== -1)
2345 error (_("No current tracepoint -- please supply an argument."));
2347 tdp
= tracepoint_number
; /* Default is current TDP. */
2350 tdp
= parse_and_eval_long (args
);
2352 /* If we have the tracepoint on hand, use the number that the
2353 target knows about (which may be different if we disconnected
2354 and reconnected). */
2355 tp
= get_tracepoint (tdp
);
2357 tdp
= tp
->number_on_target
;
2359 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2362 /* TFIND LINE command:
2364 This command will take a sourceline for argument, just like BREAK
2365 or TRACE (ie. anything that "decode_line_1" can handle).
2367 With no argument, this command will find the next trace frame
2368 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2371 tfind_line_command (const char *args
, int from_tty
)
2373 check_trace_running (current_trace_status ());
2375 symtab_and_line sal
;
2376 if (args
== 0 || *args
== 0)
2378 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2382 std::vector
<symtab_and_line
> sals
2383 = decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2387 if (sal
.symtab
== 0)
2388 error (_("No line number information available."));
2390 CORE_ADDR start_pc
, end_pc
;
2391 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2393 if (start_pc
== end_pc
)
2395 printf_filtered ("Line %d of \"%s\"",
2397 symtab_to_filename_for_display (sal
.symtab
));
2398 gdb_stdout
->wrap_here (2);
2399 printf_filtered (" is at address ");
2400 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2401 gdb_stdout
->wrap_here (2);
2402 printf_filtered (" but contains no code.\n");
2403 sal
= find_pc_line (start_pc
, 0);
2405 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2406 && start_pc
!= end_pc
)
2407 printf_filtered ("Attempting to find line %d instead.\n",
2410 error (_("Cannot find a good line."));
2415 /* Is there any case in which we get here, and have an address
2416 which the user would want to see? If we have debugging
2417 symbols and no line numbers? */
2418 error (_("Line number %d is out of range for \"%s\"."),
2419 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2422 /* Find within range of stated line. */
2424 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2426 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2429 /* tfind range command */
2431 tfind_range_command (const char *args
, int from_tty
)
2433 static CORE_ADDR start
, stop
;
2436 check_trace_running (current_trace_status ());
2438 if (args
== 0 || *args
== 0)
2439 { /* XXX FIXME: what should default behavior be? */
2440 printf_filtered ("Usage: tfind range STARTADDR, ENDADDR\n");
2444 if (0 != (tmp
= strchr (args
, ',')))
2446 std::string
start_addr (args
, tmp
);
2448 tmp
= skip_spaces (tmp
);
2449 start
= parse_and_eval_address (start_addr
.c_str ());
2450 stop
= parse_and_eval_address (tmp
);
2453 { /* No explicit end address? */
2454 start
= parse_and_eval_address (args
);
2455 stop
= start
+ 1; /* ??? */
2458 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2461 /* tfind outside command */
2463 tfind_outside_command (const char *args
, int from_tty
)
2465 CORE_ADDR start
, stop
;
2468 if (current_trace_status ()->running
2469 && current_trace_status ()->filename
== NULL
)
2470 error (_("May not look at trace frames while trace is running."));
2472 if (args
== 0 || *args
== 0)
2473 { /* XXX FIXME: what should default behavior be? */
2474 printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n");
2478 if (0 != (tmp
= strchr (args
, ',')))
2480 std::string
start_addr (args
, tmp
);
2482 tmp
= skip_spaces (tmp
);
2483 start
= parse_and_eval_address (start_addr
.c_str ());
2484 stop
= parse_and_eval_address (tmp
);
2487 { /* No explicit end address? */
2488 start
= parse_and_eval_address (args
);
2489 stop
= start
+ 1; /* ??? */
2492 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2495 /* info scope command: list the locals for a scope. */
2497 info_scope_command (const char *args_in
, int from_tty
)
2500 struct bound_minimal_symbol msym
;
2501 const struct block
*block
;
2502 const char *symname
;
2503 const char *save_args
= args_in
;
2504 struct block_iterator iter
;
2506 struct gdbarch
*gdbarch
;
2508 const char *args
= args_in
;
2510 if (args
== 0 || *args
== 0)
2511 error (_("requires an argument (function, "
2512 "line or *addr) to define a scope"));
2514 event_location_up location
= string_to_event_location (&args
,
2516 std::vector
<symtab_and_line
> sals
2517 = decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
2521 /* Presumably decode_line_1 has already warned. */
2525 /* Resolve line numbers to PC. */
2526 resolve_sal_pc (&sals
[0]);
2527 block
= block_for_pc (sals
[0].pc
);
2531 QUIT
; /* Allow user to bail out with ^C. */
2532 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2534 QUIT
; /* Allow user to bail out with ^C. */
2536 printf_filtered ("Scope for %s:\n", save_args
);
2539 symname
= sym
->print_name ();
2540 if (symname
== NULL
|| *symname
== '\0')
2541 continue; /* Probably botched, certainly useless. */
2543 gdbarch
= symbol_arch (sym
);
2545 printf_filtered ("Symbol %s is ", symname
);
2547 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2548 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2549 BLOCK_ENTRY_PC (block
),
2553 switch (sym
->aclass ())
2556 case LOC_UNDEF
: /* Messed up symbol? */
2557 printf_filtered ("a bogus symbol, class %d.\n",
2559 count
--; /* Don't count this one. */
2562 printf_filtered ("a constant with value %s (%s)",
2563 plongest (SYMBOL_VALUE (sym
)),
2564 hex_string (SYMBOL_VALUE (sym
)));
2566 case LOC_CONST_BYTES
:
2567 printf_filtered ("constant bytes: ");
2569 for (j
= 0; j
< TYPE_LENGTH (sym
->type ()); j
++)
2570 printf_filtered (" %02x",
2571 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2574 printf_filtered ("in static storage at address ");
2575 printf_filtered ("%s", paddress (gdbarch
,
2576 SYMBOL_VALUE_ADDRESS (sym
)));
2579 /* GDBARCH is the architecture associated with the objfile
2580 the symbol is defined in; the target architecture may be
2581 different, and may provide additional registers. However,
2582 we do not know the target architecture at this point.
2583 We assume the objfile architecture will contain all the
2584 standard registers that occur in debug info in that
2586 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2589 if (sym
->is_argument ())
2590 printf_filtered ("an argument in register $%s",
2591 gdbarch_register_name (gdbarch
, regno
));
2593 printf_filtered ("a local variable in register $%s",
2594 gdbarch_register_name (gdbarch
, regno
));
2597 printf_filtered ("an argument at stack/frame offset %s",
2598 plongest (SYMBOL_VALUE (sym
)));
2601 printf_filtered ("a local variable at frame offset %s",
2602 plongest (SYMBOL_VALUE (sym
)));
2605 printf_filtered ("a reference argument at offset %s",
2606 plongest (SYMBOL_VALUE (sym
)));
2608 case LOC_REGPARM_ADDR
:
2609 /* Note comment at LOC_REGISTER. */
2610 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2612 printf_filtered ("the address of an argument, in register $%s",
2613 gdbarch_register_name (gdbarch
, regno
));
2616 printf_filtered ("a typedef.\n");
2619 printf_filtered ("a label at address ");
2620 printf_filtered ("%s", paddress (gdbarch
,
2621 SYMBOL_VALUE_ADDRESS (sym
)));
2624 printf_filtered ("a function at address ");
2625 printf_filtered ("%s",
2626 paddress (gdbarch
, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
))));
2628 case LOC_UNRESOLVED
:
2629 msym
= lookup_minimal_symbol (sym
->linkage_name (),
2631 if (msym
.minsym
== NULL
)
2632 printf_filtered ("Unresolved Static");
2635 printf_filtered ("static storage at address ");
2636 printf_filtered ("%s",
2638 BMSYMBOL_VALUE_ADDRESS (msym
)));
2641 case LOC_OPTIMIZED_OUT
:
2642 printf_filtered ("optimized out.\n");
2645 gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
2650 struct type
*t
= check_typedef (sym
->type ());
2652 printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t
)));
2655 if (BLOCK_FUNCTION (block
))
2658 block
= BLOCK_SUPERBLOCK (block
);
2661 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2665 /* Helper for trace_dump_command. Dump the action list starting at
2666 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2667 actions of the body of a while-stepping action. STEPPING_FRAME is
2668 set if the current traceframe was determined to be a while-stepping
2672 trace_dump_actions (struct command_line
*action
,
2673 int stepping_actions
, int stepping_frame
,
2676 const char *action_exp
, *next_comma
;
2678 for (; action
!= NULL
; action
= action
->next
)
2680 struct cmd_list_element
*cmd
;
2682 QUIT
; /* Allow user to bail out with ^C. */
2683 action_exp
= action
->line
;
2684 action_exp
= skip_spaces (action_exp
);
2686 /* The collection actions to be done while stepping are
2687 bracketed by the commands "while-stepping" and "end". */
2689 if (*action_exp
== '#') /* comment line */
2692 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", NULL
, -1, 1);
2694 error (_("Bad action list item: %s"), action_exp
);
2696 if (cmd_simple_func_eq (cmd
, while_stepping_pseudocommand
))
2698 gdb_assert (action
->body_list_1
== nullptr);
2699 trace_dump_actions (action
->body_list_0
.get (),
2700 1, stepping_frame
, from_tty
);
2702 else if (cmd_simple_func_eq (cmd
, collect_pseudocommand
))
2704 /* Display the collected data.
2705 For the trap frame, display only what was collected at
2706 the trap. Likewise for stepping frames, display only
2707 what was collected while stepping. This means that the
2708 two boolean variables, STEPPING_FRAME and
2709 STEPPING_ACTIONS should be equal. */
2710 if (stepping_frame
== stepping_actions
)
2712 int trace_string
= 0;
2714 if (*action_exp
== '/')
2715 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2718 { /* Repeat over a comma-separated list. */
2719 QUIT
; /* Allow user to bail out with ^C. */
2720 if (*action_exp
== ',')
2722 action_exp
= skip_spaces (action_exp
);
2724 next_comma
= strchr (action_exp
, ',');
2726 if (0 == strncasecmp (action_exp
, "$reg", 4))
2727 registers_info (NULL
, from_tty
);
2728 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2730 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2731 info_locals_command (NULL
, from_tty
);
2732 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2733 info_args_command (NULL
, from_tty
);
2736 std::string contents
;
2737 const char *exp
= action_exp
;
2738 if (next_comma
!= NULL
)
2740 size_t len
= next_comma
- action_exp
;
2741 contents
= std::string (action_exp
, len
);
2742 exp
= contents
.c_str ();
2745 printf_filtered ("%s = ", exp
);
2746 output_command (exp
, from_tty
);
2747 printf_filtered ("\n");
2749 action_exp
= next_comma
;
2751 while (action_exp
&& *action_exp
== ',');
2757 /* Return bp_location of the tracepoint associated with the current
2758 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2759 is a stepping traceframe. */
2761 struct bp_location
*
2762 get_traceframe_location (int *stepping_frame_p
)
2764 struct tracepoint
*t
;
2765 struct regcache
*regcache
;
2767 if (tracepoint_number
== -1)
2768 error (_("No current trace frame."));
2770 t
= get_tracepoint (tracepoint_number
);
2773 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2776 /* The current frame is a trap frame if the frame PC is equal to the
2777 tracepoint PC. If not, then the current frame was collected
2778 during single-stepping. */
2779 regcache
= get_current_regcache ();
2781 /* If the traceframe's address matches any of the tracepoint's
2782 locations, assume it is a direct hit rather than a while-stepping
2783 frame. (FIXME this is not reliable, should record each frame's
2785 for (bp_location
*tloc
: t
->locations ())
2786 if (tloc
->address
== regcache_read_pc (regcache
))
2788 *stepping_frame_p
= 0;
2792 /* If this is a stepping frame, we don't know which location
2793 triggered. The first is as good (or bad) a guess as any... */
2794 *stepping_frame_p
= 1;
2798 /* Return the default collect actions of a tracepoint T. */
2800 static counted_command_line
2801 all_tracepoint_actions (struct breakpoint
*t
)
2803 counted_command_line
actions (nullptr, command_lines_deleter ());
2805 /* If there are default expressions to collect, make up a collect
2806 action and prepend to the action list to encode. Note that since
2807 validation is per-tracepoint (local var "xyz" might be valid for
2808 one tracepoint and not another, etc), we make up the action on
2809 the fly, and don't cache it. */
2810 if (!default_collect
.empty ())
2812 gdb::unique_xmalloc_ptr
<char> default_collect_line
2813 = xstrprintf ("collect %s", default_collect
.c_str ());
2815 validate_actionline (default_collect_line
.get (), t
);
2816 actions
.reset (new struct command_line (simple_control
,
2817 default_collect_line
.release ()),
2818 command_lines_deleter ());
2824 /* The tdump command. */
2827 tdump_command (const char *args
, int from_tty
)
2829 int stepping_frame
= 0;
2830 struct bp_location
*loc
;
2832 /* This throws an error is not inspecting a trace frame. */
2833 loc
= get_traceframe_location (&stepping_frame
);
2835 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2836 tracepoint_number
, traceframe_number
);
2838 /* This command only makes sense for the current frame, not the
2840 scoped_restore_current_thread restore_thread
;
2842 select_frame (get_current_frame ());
2844 counted_command_line actions
= all_tracepoint_actions (loc
->owner
);
2846 trace_dump_actions (actions
.get (), 0, stepping_frame
, from_tty
);
2847 trace_dump_actions (breakpoint_commands (loc
->owner
), 0, stepping_frame
,
2851 /* Encode a piece of a tracepoint's source-level definition in a form
2852 that is suitable for both protocol and saving in files. */
2853 /* This version does not do multiple encodes for long strings; it should
2854 return an offset to the next piece to encode. FIXME */
2857 encode_source_string (int tpnum
, ULONGEST addr
,
2858 const char *srctype
, const char *src
,
2859 char *buf
, int buf_size
)
2861 if (80 + strlen (srctype
) > buf_size
)
2862 error (_("Buffer too small for source encoding"));
2863 sprintf (buf
, "%x:%s:%s:%x:%x:",
2864 tpnum
, phex_nz (addr
, sizeof (addr
)),
2865 srctype
, 0, (int) strlen (src
));
2866 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2867 error (_("Source string too long for buffer"));
2868 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
2872 /* Tell the target what to do with an ongoing tracing run if GDB
2873 disconnects for some reason. */
2876 set_disconnected_tracing (const char *args
, int from_tty
,
2877 struct cmd_list_element
*c
)
2879 target_set_disconnected_tracing (disconnected_tracing
);
2883 set_circular_trace_buffer (const char *args
, int from_tty
,
2884 struct cmd_list_element
*c
)
2886 target_set_circular_trace_buffer (circular_trace_buffer
);
2890 set_trace_buffer_size (const char *args
, int from_tty
,
2891 struct cmd_list_element
*c
)
2893 target_set_trace_buffer_size (trace_buffer_size
);
2897 set_trace_user (const char *args
, int from_tty
,
2898 struct cmd_list_element
*c
)
2902 ret
= target_set_trace_notes (trace_user
.c_str (), NULL
, NULL
);
2905 warning (_("Target does not support trace notes, user ignored"));
2909 set_trace_notes (const char *args
, int from_tty
,
2910 struct cmd_list_element
*c
)
2914 ret
= target_set_trace_notes (NULL
, trace_notes
.c_str (), NULL
);
2917 warning (_("Target does not support trace notes, note ignored"));
2921 set_trace_stop_notes (const char *args
, int from_tty
,
2922 struct cmd_list_element
*c
)
2926 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
.c_str ());
2929 warning (_("Target does not support trace notes, stop note ignored"));
2932 /* Convert the memory pointed to by mem into hex, placing result in buf.
2933 * Return a pointer to the last char put in buf (null)
2934 * "stolen" from sparc-stub.c
2937 static const char hexchars
[] = "0123456789abcdef";
2940 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2948 *buf
++ = hexchars
[ch
>> 4];
2949 *buf
++ = hexchars
[ch
& 0xf];
2958 get_traceframe_number (void)
2960 return traceframe_number
;
2964 get_tracepoint_number (void)
2966 return tracepoint_number
;
2969 /* Make the traceframe NUM be the current trace frame. Does nothing
2970 if NUM is already current. */
2973 set_current_traceframe (int num
)
2977 if (traceframe_number
== num
)
2979 /* Nothing to do. */
2983 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2986 warning (_("could not change traceframe"));
2988 set_traceframe_num (newnum
);
2990 /* Changing the traceframe changes our view of registers and of the
2992 registers_changed ();
2994 clear_traceframe_info ();
2997 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2998 : m_traceframe_number (traceframe_number
)
3001 /* Given a number and address, return an uploaded tracepoint with that
3002 number, creating if necessary. */
3004 struct uploaded_tp
*
3005 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3007 struct uploaded_tp
*utp
;
3009 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3010 if (utp
->number
== num
&& utp
->addr
== addr
)
3013 utp
= new uploaded_tp
;
3023 free_uploaded_tps (struct uploaded_tp
**utpp
)
3025 struct uploaded_tp
*next_one
;
3029 next_one
= (*utpp
)->next
;
3035 /* Given a number and address, return an uploaded tracepoint with that
3036 number, creating if necessary. */
3038 struct uploaded_tsv
*
3039 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3041 struct uploaded_tsv
*utsv
;
3043 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3044 if (utsv
->number
== num
)
3047 utsv
= XCNEW (struct uploaded_tsv
);
3049 utsv
->next
= *utsvp
;
3056 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3058 struct uploaded_tsv
*next_one
;
3062 next_one
= (*utsvp
)->next
;
3068 /* FIXME this function is heuristic and will miss the cases where the
3069 conditional is semantically identical but differs in whitespace,
3070 such as "x == 0" vs "x==0". */
3073 cond_string_is_same (char *str1
, char *str2
)
3075 if (str1
== NULL
|| str2
== NULL
)
3076 return (str1
== str2
);
3078 return (strcmp (str1
, str2
) == 0);
3081 /* Look for an existing tracepoint that seems similar enough to the
3082 uploaded one. Enablement isn't compared, because the user can
3083 toggle that freely, and may have done so in anticipation of the
3084 next trace run. Return the location of matched tracepoint. */
3086 static struct bp_location
*
3087 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3089 struct bp_location
*loc
;
3091 for (breakpoint
*b
: all_tracepoints ())
3093 struct tracepoint
*t
= (struct tracepoint
*) b
;
3095 if (b
->type
== utp
->type
3096 && t
->step_count
== utp
->step
3097 && t
->pass_count
== utp
->pass
3098 && cond_string_is_same (t
->cond_string
.get (),
3099 utp
->cond_string
.get ())
3100 /* FIXME also test actions. */
3103 /* Scan the locations for an address match. */
3104 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3106 if (loc
->address
== utp
->addr
)
3114 /* Given a list of tracepoints uploaded from a target, attempt to
3115 match them up with existing tracepoints, and create new ones if not
3119 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3121 struct uploaded_tp
*utp
;
3122 /* A set of tracepoints which are modified. */
3123 std::vector
<breakpoint
*> modified_tp
;
3125 /* Look for GDB tracepoints that match up with our uploaded versions. */
3126 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3128 struct bp_location
*loc
;
3129 struct tracepoint
*t
;
3131 loc
= find_matching_tracepoint_location (utp
);
3136 /* Mark this location as already inserted. */
3138 t
= (struct tracepoint
*) loc
->owner
;
3139 printf_filtered (_("Assuming tracepoint %d is same "
3140 "as target's tracepoint %d at %s.\n"),
3141 loc
->owner
->number
, utp
->number
,
3142 paddress (loc
->gdbarch
, utp
->addr
));
3144 /* The tracepoint LOC->owner was modified (the location LOC
3145 was marked as inserted in the target). Save it in
3146 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3147 observers will be notified later once for each tracepoint
3148 saved in MODIFIED_TP. */
3149 for (breakpoint
*b
: modified_tp
)
3150 if (b
== loc
->owner
)
3156 modified_tp
.push_back (loc
->owner
);
3160 t
= create_tracepoint_from_upload (utp
);
3162 printf_filtered (_("Created tracepoint %d for "
3163 "target's tracepoint %d at %s.\n"),
3164 t
->number
, utp
->number
,
3165 paddress (get_current_arch (), utp
->addr
));
3167 printf_filtered (_("Failed to create tracepoint for target's "
3168 "tracepoint %d at %s, skipping it.\n"),
3170 paddress (get_current_arch (), utp
->addr
));
3172 /* Whether found or created, record the number used by the
3173 target, to help with mapping target tracepoints back to their
3174 counterparts here. */
3176 t
->number_on_target
= utp
->number
;
3179 /* Notify 'breakpoint-modified' observer that at least one of B's
3180 locations was changed. */
3181 for (breakpoint
*b
: modified_tp
)
3182 gdb::observers::breakpoint_modified
.notify (b
);
3184 free_uploaded_tps (uploaded_tps
);
3187 /* Trace state variables don't have much to identify them beyond their
3188 name, so just use that to detect matches. */
3190 static struct trace_state_variable
*
3191 find_matching_tsv (struct uploaded_tsv
*utsv
)
3196 return find_trace_state_variable (utsv
->name
);
3199 static struct trace_state_variable
*
3200 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3202 const char *namebase
;
3205 struct trace_state_variable
*tsv
;
3209 namebase
= utsv
->name
;
3215 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3218 /* Fish for a name that is not in use. */
3219 /* (should check against all internal vars?) */
3220 while (find_trace_state_variable (buf
.c_str ()))
3221 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3223 /* We have an available name, create the variable. */
3224 tsv
= create_trace_state_variable (buf
.c_str ());
3225 tsv
->initial_value
= utsv
->initial_value
;
3226 tsv
->builtin
= utsv
->builtin
;
3228 gdb::observers::tsv_created
.notify (tsv
);
3233 /* Given a list of uploaded trace state variables, try to match them
3234 up with existing variables, or create additional ones. */
3237 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3239 struct uploaded_tsv
*utsv
;
3242 /* Most likely some numbers will have to be reassigned as part of
3243 the merge, so clear them all in anticipation. */
3244 for (trace_state_variable
&tsv
: tvariables
)
3247 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3249 struct trace_state_variable
*tsv
= find_matching_tsv (utsv
);
3253 printf_filtered (_("Assuming trace state variable $%s "
3254 "is same as target's variable %d.\n"),
3255 tsv
->name
.c_str (), utsv
->number
);
3259 tsv
= create_tsv_from_upload (utsv
);
3261 printf_filtered (_("Created trace state variable "
3262 "$%s for target's variable %d.\n"),
3263 tsv
->name
.c_str (), utsv
->number
);
3265 /* Give precedence to numberings that come from the target. */
3267 tsv
->number
= utsv
->number
;
3270 /* Renumber everything that didn't get a target-assigned number. */
3272 for (const trace_state_variable
&tsv
: tvariables
)
3273 highest
= std::max (tsv
.number
, highest
);
3276 for (trace_state_variable
&tsv
: tvariables
)
3277 if (tsv
.number
== 0)
3278 tsv
.number
= highest
++;
3280 free_uploaded_tsvs (uploaded_tsvs
);
3283 /* Parse the part of trace status syntax that is shared between
3284 the remote protocol and the trace file reader. */
3287 parse_trace_status (const char *line
, struct trace_status
*ts
)
3289 const char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3293 ts
->running_known
= 1;
3294 ts
->running
= (*p
++ == '1');
3295 ts
->stop_reason
= trace_stop_reason_unknown
;
3296 xfree (ts
->stop_desc
);
3297 ts
->stop_desc
= NULL
;
3298 ts
->traceframe_count
= -1;
3299 ts
->traceframes_created
= -1;
3300 ts
->buffer_free
= -1;
3301 ts
->buffer_size
= -1;
3302 ts
->disconnected_tracing
= 0;
3303 ts
->circular_buffer
= 0;
3304 xfree (ts
->user_name
);
3305 ts
->user_name
= NULL
;
3308 ts
->start_time
= ts
->stop_time
= 0;
3312 p1
= strchr (p
, ':');
3314 error (_("Malformed trace status, at %s\n\
3315 Status line: '%s'\n"), p
, line
);
3316 p3
= strchr (p
, ';');
3318 p3
= p
+ strlen (p
);
3319 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3321 p
= unpack_varlen_hex (++p1
, &val
);
3322 ts
->stop_reason
= trace_buffer_full
;
3324 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3326 p
= unpack_varlen_hex (++p1
, &val
);
3327 ts
->stop_reason
= trace_never_run
;
3329 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3332 p
= unpack_varlen_hex (++p1
, &val
);
3333 ts
->stop_reason
= tracepoint_passcount
;
3334 ts
->stopping_tracepoint
= val
;
3336 else if (strncmp (p
, stop_reason_names
[trace_stop_command
], p1
- p
) == 0)
3338 p2
= strchr (++p1
, ':');
3346 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3347 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3348 ts
->stop_desc
[end
] = '\0';
3351 ts
->stop_desc
= xstrdup ("");
3353 p
= unpack_varlen_hex (++p2
, &val
);
3354 ts
->stop_reason
= trace_stop_command
;
3356 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3358 p
= unpack_varlen_hex (++p1
, &val
);
3359 ts
->stop_reason
= trace_disconnected
;
3361 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3363 p2
= strchr (++p1
, ':');
3366 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3367 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3368 ts
->stop_desc
[end
] = '\0';
3371 ts
->stop_desc
= xstrdup ("");
3373 p
= unpack_varlen_hex (++p2
, &val
);
3374 ts
->stopping_tracepoint
= val
;
3375 ts
->stop_reason
= tracepoint_error
;
3377 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3379 p
= unpack_varlen_hex (++p1
, &val
);
3380 ts
->traceframe_count
= val
;
3382 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3384 p
= unpack_varlen_hex (++p1
, &val
);
3385 ts
->traceframes_created
= val
;
3387 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3389 p
= unpack_varlen_hex (++p1
, &val
);
3390 ts
->buffer_free
= val
;
3392 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3394 p
= unpack_varlen_hex (++p1
, &val
);
3395 ts
->buffer_size
= val
;
3397 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3399 p
= unpack_varlen_hex (++p1
, &val
);
3400 ts
->disconnected_tracing
= val
;
3402 else if (strncmp (p
, "circular", p1
- p
) == 0)
3404 p
= unpack_varlen_hex (++p1
, &val
);
3405 ts
->circular_buffer
= val
;
3407 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3409 p
= unpack_varlen_hex (++p1
, &val
);
3410 ts
->start_time
= val
;
3412 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3414 p
= unpack_varlen_hex (++p1
, &val
);
3415 ts
->stop_time
= val
;
3417 else if (strncmp (p
, "username", p1
- p
) == 0)
3420 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3421 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3422 ts
->user_name
[end
] = '\0';
3425 else if (strncmp (p
, "notes", p1
- p
) == 0)
3428 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3429 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3430 ts
->notes
[end
] = '\0';
3435 /* Silently skip unknown optional info. */
3436 p_temp
= strchr (p1
+ 1, ';');
3440 /* Must be at the end. */
3447 parse_tracepoint_status (const char *p
, struct breakpoint
*bp
,
3448 struct uploaded_tp
*utp
)
3451 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3453 p
= unpack_varlen_hex (p
, &uval
);
3455 tp
->hit_count
+= uval
;
3457 utp
->hit_count
+= uval
;
3458 p
= unpack_varlen_hex (p
+ 1, &uval
);
3460 tp
->traceframe_usage
+= uval
;
3462 utp
->traceframe_usage
+= uval
;
3463 /* Ignore any extra, allowing for future extensions. */
3466 /* Given a line of text defining a part of a tracepoint, parse it into
3467 an "uploaded tracepoint". */
3470 parse_tracepoint_definition (const char *line
, struct uploaded_tp
**utpp
)
3474 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3477 const char *srctype
;
3479 struct uploaded_tp
*utp
= NULL
;
3482 /* Both tracepoint and action definitions start with the same number
3483 and address sequence. */
3485 p
= unpack_varlen_hex (p
, &num
);
3486 p
++; /* skip a colon */
3487 p
= unpack_varlen_hex (p
, &addr
);
3488 p
++; /* skip a colon */
3491 gdb::unique_xmalloc_ptr
<char[]> cond
;
3493 enabled
= (*p
++ == 'E');
3494 p
++; /* skip a colon */
3495 p
= unpack_varlen_hex (p
, &step
);
3496 p
++; /* skip a colon */
3497 p
= unpack_varlen_hex (p
, &pass
);
3498 type
= bp_tracepoint
;
3499 /* Thumb through optional fields. */
3502 p
++; /* skip a colon */
3505 type
= bp_fast_tracepoint
;
3507 p
= unpack_varlen_hex (p
, &orig_size
);
3511 type
= bp_static_tracepoint
;
3517 p
= unpack_varlen_hex (p
, &xlen
);
3518 p
++; /* skip a comma */
3519 cond
.reset ((char *) xmalloc (2 * xlen
+ 1));
3520 strncpy (&cond
[0], p
, 2 * xlen
);
3521 cond
[2 * xlen
] = '\0';
3525 warning (_("Unrecognized char '%c' in tracepoint "
3526 "definition, skipping rest"), *p
);
3528 utp
= get_uploaded_tp (num
, addr
, utpp
);
3530 utp
->enabled
= enabled
;
3533 utp
->cond
= std::move (cond
);
3535 else if (piece
== 'A')
3537 utp
= get_uploaded_tp (num
, addr
, utpp
);
3538 utp
->actions
.emplace_back (xstrdup (p
));
3540 else if (piece
== 'S')
3542 utp
= get_uploaded_tp (num
, addr
, utpp
);
3543 utp
->step_actions
.emplace_back (xstrdup (p
));
3545 else if (piece
== 'Z')
3547 /* Parse a chunk of source form definition. */
3548 utp
= get_uploaded_tp (num
, addr
, utpp
);
3550 p
= strchr (p
, ':');
3551 p
++; /* skip a colon */
3552 p
= unpack_varlen_hex (p
, &start
);
3553 p
++; /* skip a colon */
3554 p
= unpack_varlen_hex (p
, &xlen
);
3555 p
++; /* skip a colon */
3557 buf
= (char *) alloca (strlen (line
));
3559 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3562 if (startswith (srctype
, "at:"))
3563 utp
->at_string
.reset (xstrdup (buf
));
3564 else if (startswith (srctype
, "cond:"))
3565 utp
->cond_string
.reset (xstrdup (buf
));
3566 else if (startswith (srctype
, "cmd:"))
3567 utp
->cmd_strings
.emplace_back (xstrdup (buf
));
3569 else if (piece
== 'V')
3571 utp
= get_uploaded_tp (num
, addr
, utpp
);
3573 parse_tracepoint_status (p
, NULL
, utp
);
3577 /* Don't error out, the target might be sending us optional
3578 info that we don't care about. */
3579 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3583 /* Convert a textual description of a trace state variable into an
3587 parse_tsv_definition (const char *line
, struct uploaded_tsv
**utsvp
)
3591 ULONGEST num
, initval
, builtin
;
3593 struct uploaded_tsv
*utsv
= NULL
;
3595 buf
= (char *) alloca (strlen (line
));
3598 p
= unpack_varlen_hex (p
, &num
);
3599 p
++; /* skip a colon */
3600 p
= unpack_varlen_hex (p
, &initval
);
3601 p
++; /* skip a colon */
3602 p
= unpack_varlen_hex (p
, &builtin
);
3603 p
++; /* skip a colon */
3604 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3607 utsv
= get_uploaded_tsv (num
, utsvp
);
3608 utsv
->initial_value
= initval
;
3609 utsv
->builtin
= builtin
;
3610 utsv
->name
= xstrdup (buf
);
3613 /* Given a line of text defining a static tracepoint marker, parse it
3614 into a "static tracepoint marker" object. Throws an error is
3615 parsing fails. If PP is non-null, it points to one past the end of
3616 the parsed marker definition. */
3619 parse_static_tracepoint_marker_definition (const char *line
, const char **pp
,
3620 static_tracepoint_marker
*marker
)
3622 const char *p
, *endp
;
3626 p
= unpack_varlen_hex (p
, &addr
);
3627 p
++; /* skip a colon */
3629 marker
->gdbarch
= target_gdbarch ();
3630 marker
->address
= (CORE_ADDR
) addr
;
3632 endp
= strchr (p
, ':');
3634 error (_("bad marker definition: %s"), line
);
3636 marker
->str_id
= hex2str (p
, (endp
- p
) / 2);
3639 p
++; /* skip a colon */
3641 /* This definition may be followed by another one, separated by a comma. */
3643 endp
= strchr (p
, ',');
3644 if (endp
!= nullptr)
3647 hex_len
= strlen (p
);
3649 marker
->extra
= hex2str (p
, hex_len
/ 2);
3655 /* Print MARKER to gdb_stdout. */
3658 print_one_static_tracepoint_marker (int count
,
3659 const static_tracepoint_marker
&marker
)
3663 struct ui_out
*uiout
= current_uiout
;
3665 symtab_and_line sal
;
3666 sal
.pc
= marker
.address
;
3668 std::vector
<breakpoint
*> tracepoints
3669 = static_tracepoints_here (marker
.address
);
3671 ui_out_emit_tuple
tuple_emitter (uiout
, "marker");
3673 /* A counter field to help readability. This is not a stable
3675 uiout
->field_signed ("count", count
);
3677 uiout
->field_string ("marker-id", marker
.str_id
);
3679 uiout
->field_fmt ("enabled", "%c",
3680 !tracepoints
.empty () ? 'y' : 'n');
3683 int wrap_indent
= 35;
3684 if (gdbarch_addr_bit (marker
.gdbarch
) <= 32)
3689 const char *extra_field_indent
= " ";
3691 uiout
->field_core_addr ("addr", marker
.gdbarch
, marker
.address
);
3693 sal
= find_pc_line (marker
.address
, 0);
3694 sym
= find_pc_sect_function (marker
.address
, NULL
);
3697 uiout
->text ("in ");
3698 uiout
->field_string ("func", sym
->print_name (),
3699 function_name_style
.style ());
3700 uiout
->wrap_hint (wrap_indent
);
3701 uiout
->text (" at ");
3704 uiout
->field_skip ("func");
3706 if (sal
.symtab
!= NULL
)
3708 uiout
->field_string ("file",
3709 symtab_to_filename_for_display (sal
.symtab
),
3710 file_name_style
.style ());
3713 if (uiout
->is_mi_like_p ())
3715 const char *fullname
= symtab_to_fullname (sal
.symtab
);
3717 uiout
->field_string ("fullname", fullname
);
3720 uiout
->field_skip ("fullname");
3722 uiout
->field_signed ("line", sal
.line
);
3726 uiout
->field_skip ("fullname");
3727 uiout
->field_skip ("line");
3731 uiout
->text (extra_field_indent
);
3732 uiout
->text (_("Data: \""));
3733 uiout
->field_string ("extra-data", marker
.extra
);
3734 uiout
->text ("\"\n");
3736 if (!tracepoints
.empty ())
3741 ui_out_emit_tuple
inner_tuple_emitter (uiout
, "tracepoints-at");
3743 uiout
->text (extra_field_indent
);
3744 uiout
->text (_("Probed by static tracepoints: "));
3745 for (ix
= 0; ix
< tracepoints
.size (); ix
++)
3750 uiout
->field_signed ("tracepoint-id", tracepoints
[ix
]->number
);
3754 if (uiout
->is_mi_like_p ())
3755 uiout
->field_signed ("number-of-tracepoints", tracepoints
.size ());
3762 info_static_tracepoint_markers_command (const char *arg
, int from_tty
)
3764 struct ui_out
*uiout
= current_uiout
;
3765 std::vector
<static_tracepoint_marker
> markers
3766 = target_static_tracepoint_markers_by_strid (NULL
);
3768 /* We don't have to check target_can_use_agent and agent's capability on
3769 static tracepoint here, in order to be compatible with older GDBserver.
3770 We don't check USE_AGENT is true or not, because static tracepoints
3771 don't work without in-process agent, so we don't bother users to type
3772 `set agent on' when to use static tracepoint. */
3774 ui_out_emit_table
table_emitter (uiout
, 5, -1,
3775 "StaticTracepointMarkersTable");
3777 uiout
->table_header (7, ui_left
, "counter", "Cnt");
3779 uiout
->table_header (40, ui_left
, "marker-id", "ID");
3781 uiout
->table_header (3, ui_left
, "enabled", "Enb");
3782 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3783 uiout
->table_header (10, ui_left
, "addr", "Address");
3785 uiout
->table_header (18, ui_left
, "addr", "Address");
3786 uiout
->table_header (40, ui_noalign
, "what", "What");
3788 uiout
->table_body ();
3790 for (int i
= 0; i
< markers
.size (); i
++)
3791 print_one_static_tracepoint_marker (i
+ 1, markers
[i
]);
3794 /* The $_sdata convenience variable is a bit special. We don't know
3795 for sure type of the value until we actually have a chance to fetch
3796 the data --- the size of the object depends on what has been
3797 collected. We solve this by making $_sdata be an internalvar that
3798 creates a new value on access. */
3800 /* Return a new value with the correct type for the sdata object of
3801 the current trace frame. Return a void value if there's no object
3804 static struct value
*
3805 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
3808 /* We need to read the whole object before we know its size. */
3809 gdb::optional
<gdb::byte_vector
> buf
3810 = target_read_alloc (current_inferior ()->top_target (),
3811 TARGET_OBJECT_STATIC_TRACE_DATA
,
3818 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
3820 v
= allocate_value (type
);
3821 memcpy (value_contents_raw (v
).data (), buf
->data (), buf
->size ());
3825 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
3828 #if !defined(HAVE_LIBEXPAT)
3830 struct std::unique_ptr
<traceframe_info
>
3831 parse_traceframe_info (const char *tframe_info
)
3833 static int have_warned
;
3838 warning (_("Can not parse XML trace frame info; XML support "
3839 "was disabled at compile time"));
3845 #else /* HAVE_LIBEXPAT */
3847 #include "xml-support.h"
3849 /* Handle the start of a <memory> element. */
3852 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
3853 const struct gdb_xml_element
*element
,
3855 std::vector
<gdb_xml_value
> &attributes
)
3857 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3858 ULONGEST
*start_p
, *length_p
;
3861 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
.get ();
3863 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
.get ();
3865 info
->memory
.emplace_back (*start_p
, *length_p
);
3868 /* Handle the start of a <tvar> element. */
3871 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
3872 const struct gdb_xml_element
*element
,
3874 std::vector
<gdb_xml_value
> &attributes
)
3876 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3877 const char *id_attrib
3878 = (const char *) xml_find_attribute (attributes
, "id")->value
.get ();
3879 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
3881 info
->tvars
.push_back (id
);
3884 /* The allowed elements and attributes for an XML memory map. */
3886 static const struct gdb_xml_attribute memory_attributes
[] = {
3887 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3888 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3889 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3892 static const struct gdb_xml_attribute tvar_attributes
[] = {
3893 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3894 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3897 static const struct gdb_xml_element traceframe_info_children
[] = {
3898 { "memory", memory_attributes
, NULL
,
3899 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3900 traceframe_info_start_memory
, NULL
},
3901 { "tvar", tvar_attributes
, NULL
,
3902 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3903 traceframe_info_start_tvar
, NULL
},
3904 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3907 static const struct gdb_xml_element traceframe_info_elements
[] = {
3908 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
3910 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3913 /* Parse a traceframe-info XML document. */
3916 parse_traceframe_info (const char *tframe_info
)
3918 traceframe_info_up
result (new traceframe_info
);
3920 if (gdb_xml_parse_quick (_("trace frame info"),
3921 "traceframe-info.dtd", traceframe_info_elements
,
3922 tframe_info
, result
.get ()) == 0)
3928 #endif /* HAVE_LIBEXPAT */
3930 /* Returns the traceframe_info object for the current traceframe.
3931 This is where we avoid re-fetching the object from the target if we
3932 already have it cached. */
3934 struct traceframe_info
*
3935 get_traceframe_info (void)
3937 if (current_traceframe_info
== NULL
)
3938 current_traceframe_info
= target_traceframe_info ();
3940 return current_traceframe_info
.get ();
3943 /* If the target supports the query, return in RESULT the set of
3944 collected memory in the current traceframe, found within the LEN
3945 bytes range starting at MEMADDR. Returns true if the target
3946 supports the query, otherwise returns false, and RESULT is left
3950 traceframe_available_memory (std::vector
<mem_range
> *result
,
3951 CORE_ADDR memaddr
, ULONGEST len
)
3953 struct traceframe_info
*info
= get_traceframe_info ();
3959 for (mem_range
&r
: info
->memory
)
3960 if (mem_ranges_overlap (r
.start
, r
.length
, memaddr
, len
))
3962 ULONGEST lo1
, hi1
, lo2
, hi2
;
3965 hi1
= memaddr
+ len
;
3968 hi2
= r
.start
+ r
.length
;
3970 CORE_ADDR start
= std::max (lo1
, lo2
);
3971 int length
= std::min (hi1
, hi2
) - start
;
3973 result
->emplace_back (start
, length
);
3976 normalize_mem_ranges (result
);
3983 /* Implementation of `sdata' variable. */
3985 static const struct internalvar_funcs sdata_funcs
=
3991 /* See tracepoint.h. */
3992 cmd_list_element
*while_stepping_cmd_element
= nullptr;
3994 /* module initialization */
3995 void _initialize_tracepoint ();
3997 _initialize_tracepoint ()
3999 struct cmd_list_element
*c
;
4001 /* Explicitly create without lookup, since that tries to create a
4002 value with a void typed value, and when we get here, gdbarch
4003 isn't initialized yet. At this point, we're quite sure there
4004 isn't another convenience variable of the same name. */
4005 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4007 traceframe_number
= -1;
4008 tracepoint_number
= -1;
4010 add_info ("scope", info_scope_command
,
4011 _("List the variables local to a scope."));
4013 add_cmd ("tracepoints", class_trace
,
4014 _("Tracing of program execution without stopping the program."),
4017 add_com ("tdump", class_trace
, tdump_command
,
4018 _("Print everything collected at the current tracepoint."));
4020 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4021 Define a trace state variable.\n\
4022 Argument is a $-prefixed name, optionally followed\n\
4023 by '=' and an expression that sets the initial value\n\
4024 at the start of tracing."));
4025 set_cmd_completer (c
, expression_completer
);
4027 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4028 Delete one or more trace state variables.\n\
4029 Arguments are the names of the variables to delete.\n\
4030 If no arguments are supplied, delete all variables."), &deletelist
);
4031 /* FIXME add a trace variable completer. */
4033 add_info ("tvariables", info_tvariables_command
, _("\
4034 Status of trace state variables and their values."));
4036 add_info ("static-tracepoint-markers",
4037 info_static_tracepoint_markers_command
, _("\
4038 List target static tracepoints markers."));
4040 add_prefix_cmd ("tfind", class_trace
, tfind_command
, _("\
4041 Select a trace frame.\n\
4042 No argument means forward by one frame; '-' means backward by one frame."),
4043 &tfindlist
, 1, &cmdlist
);
4045 add_cmd ("outside", class_trace
, tfind_outside_command
, _("\
4046 Select a trace frame whose PC is outside the given range (exclusive).\n\
4047 Usage: tfind outside ADDR1, ADDR2"),
4050 add_cmd ("range", class_trace
, tfind_range_command
, _("\
4051 Select a trace frame whose PC is in the given range (inclusive).\n\
4052 Usage: tfind range ADDR1, ADDR2"),
4055 add_cmd ("line", class_trace
, tfind_line_command
, _("\
4056 Select a trace frame by source line.\n\
4057 Argument can be a line number (with optional source file),\n\
4058 a function name, or '*' followed by an address.\n\
4059 Default argument is 'the next source line that was traced'."),
4062 add_cmd ("tracepoint", class_trace
, tfind_tracepoint_command
, _("\
4063 Select a trace frame by tracepoint number.\n\
4064 Default is the tracepoint for the current trace frame."),
4067 add_cmd ("pc", class_trace
, tfind_pc_command
, _("\
4068 Select a trace frame by PC.\n\
4069 Default is the current PC, or the PC of the current trace frame."),
4072 cmd_list_element
*tfind_end_cmd
4073 = add_cmd ("end", class_trace
, tfind_end_command
, _("\
4074 De-select any trace frame and resume 'live' debugging."), &tfindlist
);
4076 add_alias_cmd ("none", tfind_end_cmd
, class_trace
, 0, &tfindlist
);
4078 add_cmd ("start", class_trace
, tfind_start_command
,
4079 _("Select the first trace frame in the trace buffer."),
4082 add_com ("tstatus", class_trace
, tstatus_command
,
4083 _("Display the status of the current trace data collection."));
4085 add_com ("tstop", class_trace
, tstop_command
, _("\
4086 Stop trace data collection.\n\
4087 Usage: tstop [NOTES]...\n\
4088 Any arguments supplied are recorded with the trace as a stop reason and\n\
4089 reported by tstatus (if the target supports trace notes)."));
4091 add_com ("tstart", class_trace
, tstart_command
, _("\
4092 Start trace data collection.\n\
4093 Usage: tstart [NOTES]...\n\
4094 Any arguments supplied are recorded with the trace as a note and\n\
4095 reported by tstatus (if the target supports trace notes)."));
4097 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4098 Ends a list of commands or actions.\n\
4099 Several GDB commands allow you to enter a list of commands or actions.\n\
4100 Entering \"end\" on a line by itself is the normal way to terminate\n\
4102 Note: the \"end\" command cannot be used at the gdb prompt."));
4104 while_stepping_cmd_element
= add_com ("while-stepping", class_trace
,
4105 while_stepping_pseudocommand
, _("\
4106 Specify single-stepping behavior at a tracepoint.\n\
4107 Argument is number of instructions to trace in single-step mode\n\
4108 following the tracepoint. This command is normally followed by\n\
4109 one or more \"collect\" commands, to specify what to collect\n\
4110 while single-stepping.\n\n\
4111 Note: this command can only be used in a tracepoint \"actions\" list."));
4113 add_com_alias ("ws", while_stepping_cmd_element
, class_trace
, 0);
4114 add_com_alias ("stepping", while_stepping_cmd_element
, class_trace
, 0);
4116 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4117 Specify one or more data items to be collected at a tracepoint.\n\
4118 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4119 collect all data (variables, registers) referenced by that expression.\n\
4120 Also accepts the following special arguments:\n\
4121 $regs -- all registers.\n\
4122 $args -- all function arguments.\n\
4123 $locals -- all variables local to the block/function scope.\n\
4124 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4125 Note: this command can only be used in a tracepoint \"actions\" list."));
4127 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4128 Specify one or more expressions to be evaluated at a tracepoint.\n\
4129 Accepts a comma-separated list of (one or more) expressions.\n\
4130 The result of each evaluation will be discarded.\n\
4131 Note: this command can only be used in a tracepoint \"actions\" list."));
4133 add_com ("actions", class_trace
, actions_command
, _("\
4134 Specify the actions to be taken at a tracepoint.\n\
4135 Tracepoint actions may include collecting of specified data,\n\
4136 single-stepping, or enabling/disabling other tracepoints,\n\
4137 depending on target's capabilities."));
4139 add_setshow_string_cmd ("default-collect", class_trace
,
4140 &default_collect
, _("\
4141 Set the list of expressions to collect by default."), _("\
4142 Show the list of expressions to collect by default."), NULL
,
4144 &setlist
, &showlist
);
4146 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4147 &disconnected_tracing
, _("\
4148 Set whether tracing continues after GDB disconnects."), _("\
4149 Show whether tracing continues after GDB disconnects."), _("\
4150 Use this to continue a tracing run even if GDB disconnects\n\
4151 or detaches from the target. You can reconnect later and look at\n\
4152 trace data collected in the meantime."),
4153 set_disconnected_tracing
,
4158 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4159 &circular_trace_buffer
, _("\
4160 Set target's use of circular trace buffer."), _("\
4161 Show target's use of circular trace buffer."), _("\
4162 Use this to make the trace buffer into a circular buffer,\n\
4163 which will discard traceframes (oldest first) instead of filling\n\
4164 up and stopping the trace run."),
4165 set_circular_trace_buffer
,
4170 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4171 &trace_buffer_size
, _("\
4172 Set requested size of trace buffer."), _("\
4173 Show requested size of trace buffer."), _("\
4174 Use this to choose a size for the trace buffer. Some targets\n\
4175 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4176 disables any attempt to set the buffer size and lets the target choose."),
4177 set_trace_buffer_size
, NULL
,
4178 &setlist
, &showlist
);
4180 add_setshow_string_cmd ("trace-user", class_trace
,
4182 Set the user name to use for current and future trace runs."), _("\
4183 Show the user name to use for current and future trace runs."), NULL
,
4184 set_trace_user
, NULL
,
4185 &setlist
, &showlist
);
4187 add_setshow_string_cmd ("trace-notes", class_trace
,
4189 Set notes string to use for current and future trace runs."), _("\
4190 Show the notes string to use for current and future trace runs."), NULL
,
4191 set_trace_notes
, NULL
,
4192 &setlist
, &showlist
);
4194 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4195 &trace_stop_notes
, _("\
4196 Set notes string to use for future tstop commands."), _("\
4197 Show the notes string to use for future tstop commands."), NULL
,
4198 set_trace_stop_notes
, NULL
,
4199 &setlist
, &showlist
);