1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2021 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"
64 /* Maximum length of an agent aexpression.
65 This accounts for the fact that packets are limited to 400 bytes
66 (which includes everything -- including the checksum), and assumes
67 the worst case of maximum length for each of the pieces of a
70 NOTE: expressions get mem2hex'ed otherwise this would be twice as
71 large. (400 - 31)/2 == 184 */
72 #define MAX_AGENT_EXPR_LEN 184
74 /* A hook used to notify the UI of tracepoint operations. */
76 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
77 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
82 This module defines the following debugger commands:
83 trace : set a tracepoint on a function, line, or address.
84 info trace : list all debugger-defined tracepoints.
85 delete trace : delete one or more tracepoints.
86 enable trace : enable one or more tracepoints.
87 disable trace : disable one or more tracepoints.
88 actions : specify actions to be taken at a tracepoint.
89 passcount : specify a pass count for a tracepoint.
90 tstart : start a trace experiment.
91 tstop : stop a trace experiment.
92 tstatus : query the status of a trace experiment.
93 tfind : find a trace frame in the trace buffer.
94 tdump : print everything collected at the current tracepoint.
95 save-tracepoints : write tracepoint setup into a file.
97 This module defines the following user-visible debugger variables:
98 $trace_frame : sequence number of trace frame currently being debugged.
99 $trace_line : source line of trace frame currently being debugged.
100 $trace_file : source file of trace frame currently being debugged.
101 $tracepoint : tracepoint number of trace frame currently being debugged.
105 /* ======= Important global variables: ======= */
107 /* The list of all trace state variables. We don't retain pointers to
108 any of these for any reason - API is by name or number only - so it
109 works to have a vector of objects. */
111 static std::vector
<trace_state_variable
> tvariables
;
113 /* The next integer to assign to a variable. */
115 static int next_tsv_number
= 1;
117 /* Number of last traceframe collected. */
118 static int traceframe_number
;
120 /* Tracepoint for last traceframe collected. */
121 static int tracepoint_number
;
123 /* The traceframe info of the current traceframe. NULL if we haven't
124 yet attempted to fetch it, or if the target does not support
125 fetching this object, or if we're not inspecting a traceframe
127 static traceframe_info_up current_traceframe_info
;
129 /* Tracing command lists. */
130 static struct cmd_list_element
*tfindlist
;
132 /* List of expressions to collect by default at each tracepoint hit. */
133 char *default_collect
;
135 static bool disconnected_tracing
;
137 /* This variable controls whether we ask the target for a linear or
138 circular trace buffer. */
140 static bool circular_trace_buffer
;
142 /* This variable is the requested trace buffer size, or -1 to indicate
143 that we don't care and leave it up to the target to set a size. */
145 static int trace_buffer_size
= -1;
147 /* Textual notes applying to the current and/or future trace runs. */
149 static char *trace_user
= NULL
;
151 /* Textual notes applying to the current and/or future trace runs. */
153 static char *trace_notes
= NULL
;
155 /* Textual notes applying to the stopping of a trace. */
157 static char *trace_stop_notes
= NULL
;
159 /* support routines */
161 struct collection_list
;
162 static char *mem2hex (gdb_byte
*, char *, int);
164 static counted_command_line
all_tracepoint_actions (struct breakpoint
*);
166 static struct trace_status trace_status
;
168 const char *stop_reason_names
[] = {
178 struct trace_status
*
179 current_trace_status (void)
181 return &trace_status
;
184 /* Free and clear the traceframe info cache of the current
188 clear_traceframe_info (void)
190 current_traceframe_info
= NULL
;
193 /* Set traceframe number to NUM. */
195 set_traceframe_num (int num
)
197 traceframe_number
= num
;
198 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
201 /* Set tracepoint number to NUM. */
203 set_tracepoint_num (int num
)
205 tracepoint_number
= num
;
206 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
209 /* Set externally visible debug variables for querying/printing
210 the traceframe context (line, function, file). */
213 set_traceframe_context (struct frame_info
*trace_frame
)
216 struct symbol
*traceframe_fun
;
217 symtab_and_line traceframe_sal
;
219 /* Save as globals for internal use. */
220 if (trace_frame
!= NULL
221 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
223 traceframe_sal
= find_pc_line (trace_pc
, 0);
224 traceframe_fun
= find_pc_function (trace_pc
);
226 /* Save linenumber as "$trace_line", a debugger variable visible to
228 set_internalvar_integer (lookup_internalvar ("trace_line"),
229 traceframe_sal
.line
);
233 traceframe_fun
= NULL
;
234 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
237 /* Save func name as "$trace_func", a debugger variable visible to
239 if (traceframe_fun
== NULL
240 || traceframe_fun
->linkage_name () == NULL
)
241 clear_internalvar (lookup_internalvar ("trace_func"));
243 set_internalvar_string (lookup_internalvar ("trace_func"),
244 traceframe_fun
->linkage_name ());
246 /* Save file name as "$trace_file", a debugger variable visible to
248 if (traceframe_sal
.symtab
== NULL
)
249 clear_internalvar (lookup_internalvar ("trace_file"));
251 set_internalvar_string (lookup_internalvar ("trace_file"),
252 symtab_to_filename_for_display (traceframe_sal
.symtab
));
255 /* Create a new trace state variable with the given name. */
257 struct trace_state_variable
*
258 create_trace_state_variable (const char *name
)
260 tvariables
.emplace_back (name
, next_tsv_number
++);
261 return &tvariables
.back ();
264 /* Look for a trace state variable of the given name. */
266 struct trace_state_variable
*
267 find_trace_state_variable (const char *name
)
269 for (trace_state_variable
&tsv
: tvariables
)
270 if (tsv
.name
== name
)
276 /* Look for a trace state variable of the given number. Return NULL if
279 struct trace_state_variable
*
280 find_trace_state_variable_by_number (int number
)
282 for (trace_state_variable
&tsv
: tvariables
)
283 if (tsv
.number
== number
)
290 delete_trace_state_variable (const char *name
)
292 for (auto it
= tvariables
.begin (); it
!= tvariables
.end (); it
++)
293 if (it
->name
== name
)
295 gdb::observers::tsv_deleted
.notify (&*it
);
296 tvariables
.erase (it
);
300 warning (_("No trace variable named \"$%s\", not deleting"), name
);
303 /* Throws an error if NAME is not valid syntax for a trace state
307 validate_trace_state_variable_name (const char *name
)
312 error (_("Must supply a non-empty variable name"));
314 /* All digits in the name is reserved for value history
316 for (p
= name
; isdigit (*p
); p
++)
319 error (_("$%s is not a valid trace state variable name"), name
);
321 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
324 error (_("$%s is not a valid trace state variable name"), name
);
327 /* The 'tvariable' command collects a name and optional expression to
328 evaluate into an initial value. */
331 trace_variable_command (const char *args
, int from_tty
)
334 struct trace_state_variable
*tsv
;
335 const char *name_start
, *p
;
338 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
340 /* Only allow two syntaxes; "$name" and "$name=value". */
341 p
= skip_spaces (args
);
344 error (_("Name of trace variable should start with '$'"));
347 while (isalnum (*p
) || *p
== '_')
349 std::string
name (name_start
, p
- name_start
);
352 if (*p
!= '=' && *p
!= '\0')
353 error (_("Syntax must be $NAME [ = EXPR ]"));
355 validate_trace_state_variable_name (name
.c_str ());
358 initval
= value_as_long (parse_and_eval (++p
));
360 /* If the variable already exists, just change its initial value. */
361 tsv
= find_trace_state_variable (name
.c_str ());
364 if (tsv
->initial_value
!= initval
)
366 tsv
->initial_value
= initval
;
367 gdb::observers::tsv_modified
.notify (tsv
);
369 printf_filtered (_("Trace state variable $%s "
370 "now has initial value %s.\n"),
371 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
375 /* Create a new variable. */
376 tsv
= create_trace_state_variable (name
.c_str ());
377 tsv
->initial_value
= initval
;
379 gdb::observers::tsv_created
.notify (tsv
);
381 printf_filtered (_("Trace state variable $%s "
382 "created, with initial value %s.\n"),
383 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
387 delete_trace_variable_command (const char *args
, int from_tty
)
391 if (query (_("Delete all trace state variables? ")))
394 gdb::observers::tsv_deleted
.notify (NULL
);
398 gdb_argv
argv (args
);
400 for (char *arg
: argv
)
403 delete_trace_state_variable (arg
+ 1);
405 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg
);
412 tvariables_info_1 (void)
414 struct ui_out
*uiout
= current_uiout
;
416 /* Try to acquire values from the target. */
417 for (trace_state_variable
&tsv
: tvariables
)
419 = target_get_trace_state_variable_value (tsv
.number
, &tsv
.value
);
422 ui_out_emit_table
table_emitter (uiout
, 3, tvariables
.size (),
424 uiout
->table_header (15, ui_left
, "name", "Name");
425 uiout
->table_header (11, ui_left
, "initial", "Initial");
426 uiout
->table_header (11, ui_left
, "current", "Current");
428 uiout
->table_body ();
430 for (const trace_state_variable
&tsv
: tvariables
)
434 ui_out_emit_tuple
tuple_emitter (uiout
, "variable");
436 uiout
->field_string ("name", std::string ("$") + tsv
.name
);
437 uiout
->field_string ("initial", plongest (tsv
.initial_value
));
441 c
= plongest (tsv
.value
);
442 else if (uiout
->is_mi_like_p ())
443 /* For MI, we prefer not to use magic string constants, but rather
444 omit the field completely. The difference between unknown and
445 undefined does not seem important enough to represent. */
447 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
449 /* The value is/was defined, but we don't have it. */
451 style
= metadata_style
.style ();
455 /* It is not meaningful to ask about the value. */
457 style
= metadata_style
.style ();
460 uiout
->field_string ("current", c
, style
);
465 if (tvariables
.empty ())
466 uiout
->text (_("No trace state variables.\n"));
469 /* List all the trace state variables. */
472 info_tvariables_command (const char *args
, int from_tty
)
474 tvariables_info_1 ();
477 /* Stash definitions of tsvs into the given file. */
480 save_trace_state_variables (struct ui_file
*fp
)
482 for (const trace_state_variable
&tsv
: tvariables
)
484 fprintf_unfiltered (fp
, "tvariable $%s", tsv
.name
.c_str ());
485 if (tsv
.initial_value
)
486 fprintf_unfiltered (fp
, " = %s", plongest (tsv
.initial_value
));
487 fprintf_unfiltered (fp
, "\n");
491 /* ACTIONS functions: */
493 /* The three functions:
494 collect_pseudocommand,
495 while_stepping_pseudocommand, and
496 end_actions_pseudocommand
497 are placeholders for "commands" that are actually ONLY to be used
498 within a tracepoint action list. If the actual function is ever called,
499 it means that somebody issued the "command" at the top level,
500 which is always an error. */
503 end_actions_pseudocommand (const char *args
, int from_tty
)
505 error (_("This command cannot be used at the top level."));
509 while_stepping_pseudocommand (const char *args
, int from_tty
)
511 error (_("This command can only be used in a tracepoint actions list."));
515 collect_pseudocommand (const char *args
, int from_tty
)
517 error (_("This command can only be used in a tracepoint actions list."));
521 teval_pseudocommand (const char *args
, int from_tty
)
523 error (_("This command can only be used in a tracepoint actions list."));
526 /* Parse any collection options, such as /s for strings. */
529 decode_agent_options (const char *exp
, int *trace_string
)
531 struct value_print_options opts
;
538 /* Call this to borrow the print elements default for collection
540 get_user_print_options (&opts
);
545 if (target_supports_string_tracing ())
547 /* Allow an optional decimal number giving an explicit maximum
548 string length, defaulting it to the "print elements" value;
549 so "collect/s80 mystr" gets at most 80 bytes of string. */
550 *trace_string
= opts
.print_max
;
552 if (*exp
>= '0' && *exp
<= '9')
553 *trace_string
= atoi (exp
);
554 while (*exp
>= '0' && *exp
<= '9')
558 error (_("Target does not support \"/s\" option for string tracing."));
561 error (_("Undefined collection format \"%c\"."), *exp
);
563 exp
= skip_spaces (exp
);
568 /* Enter a list of actions for a tracepoint. */
570 actions_command (const char *args
, int from_tty
)
572 struct tracepoint
*t
;
574 t
= get_tracepoint_by_number (&args
, NULL
);
578 string_printf ("Enter actions for tracepoint %d, one per line.",
581 counted_command_line l
= read_command_lines (tmpbuf
.c_str (),
583 [=] (const char *line
)
585 validate_actionline (line
, t
);
587 breakpoint_set_commands (t
, std::move (l
));
589 /* else just return */
592 /* Report the results of checking the agent expression, as errors or
596 report_agent_reqs_errors (struct agent_expr
*aexpr
)
598 /* All of the "flaws" are serious bytecode generation issues that
599 should never occur. */
600 if (aexpr
->flaw
!= agent_flaw_none
)
601 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
603 /* If analysis shows a stack underflow, GDB must have done something
604 badly wrong in its bytecode generation. */
605 if (aexpr
->min_height
< 0)
606 internal_error (__FILE__
, __LINE__
,
607 _("expression has min height < 0"));
609 /* Issue this error if the stack is predicted to get too deep. The
610 limit is rather arbitrary; a better scheme might be for the
611 target to report how much stack it will have available. The
612 depth roughly corresponds to parenthesization, so a limit of 20
613 amounts to 20 levels of expression nesting, which is actually
614 a pretty big hairy expression. */
615 if (aexpr
->max_height
> 20)
616 error (_("Expression is too complicated."));
619 /* Call ax_reqs on AEXPR and raise an error if something is wrong. */
622 finalize_tracepoint_aexpr (struct agent_expr
*aexpr
)
626 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
627 error (_("Expression is too complicated."));
629 report_agent_reqs_errors (aexpr
);
632 /* worker function */
634 validate_actionline (const char *line
, struct breakpoint
*b
)
636 struct cmd_list_element
*c
;
639 struct bp_location
*loc
;
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_cfunc_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 (loc
= t
->loc
; loc
; loc
= loc
->next
)
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 (SYMBOL_CLASS (sym
) == LOC_CONST
)
701 error (_("constant `%s' (value %s) "
702 "will not be collected."),
704 plongest (SYMBOL_VALUE (sym
)));
706 else if (SYMBOL_CLASS (sym
) == 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_cfunc_eq (c
, teval_pseudocommand
))
730 { /* Repeat over a comma-separated list. */
731 QUIT
; /* Allow user to bail out with ^C. */
735 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
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_cfunc_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_cfunc_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 (SYMBOL_TYPE (sym
)));
931 switch (SYMBOL_CLASS (sym
))
934 printf_filtered ("%s: don't know symbol class %d\n",
935 sym
->print_name (), SYMBOL_CLASS (sym
));
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 (SYMBOL_TYPE (sym
)->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 (SYMBOL_TYPE (sym
)->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_cfunc_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_cfunc_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_cfunc_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 struct bp_location
*loc1
;
1570 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1572 if (loc1
->shlib_disabled
)
1585 warning (_("Pending tracepoints will not be resolved while"
1586 " GDB is disconnected\n"));
1589 /* Reset local state of tracing. */
1592 trace_reset_local_state (void)
1594 set_traceframe_num (-1);
1595 set_tracepoint_num (-1);
1596 set_traceframe_context (NULL
);
1597 clear_traceframe_info ();
1601 start_tracing (const char *notes
)
1603 int any_enabled
= 0, num_to_download
= 0;
1606 std::vector
<breakpoint
*> tp_vec
= all_tracepoints ();
1608 /* No point in tracing without any tracepoints... */
1609 if (tp_vec
.empty ())
1610 error (_("No tracepoints defined, not starting trace"));
1612 for (breakpoint
*b
: tp_vec
)
1614 if (b
->enable_state
== bp_enabled
)
1617 if ((b
->type
== bp_fast_tracepoint
1618 ? may_insert_fast_tracepoints
1619 : may_insert_tracepoints
))
1622 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1623 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1628 if (target_supports_enable_disable_tracepoint ())
1629 warning (_("No tracepoints enabled"));
1632 /* No point in tracing with only disabled tracepoints that
1633 cannot be re-enabled. */
1634 error (_("No tracepoints enabled, not starting trace"));
1638 if (num_to_download
<= 0)
1639 error (_("No tracepoints that may be downloaded, not starting trace"));
1641 target_trace_init ();
1643 for (breakpoint
*b
: tp_vec
)
1645 struct tracepoint
*t
= (struct tracepoint
*) b
;
1646 struct bp_location
*loc
;
1647 int bp_location_downloaded
= 0;
1649 /* Clear `inserted' flag. */
1650 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1653 if ((b
->type
== bp_fast_tracepoint
1654 ? !may_insert_fast_tracepoints
1655 : !may_insert_tracepoints
))
1658 t
->number_on_target
= 0;
1660 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1662 /* Since tracepoint locations are never duplicated, `inserted'
1663 flag should be zero. */
1664 gdb_assert (!loc
->inserted
);
1666 target_download_tracepoint (loc
);
1669 bp_location_downloaded
= 1;
1672 t
->number_on_target
= b
->number
;
1674 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1675 if (loc
->probe
.prob
!= NULL
)
1676 loc
->probe
.prob
->set_semaphore (loc
->probe
.objfile
,
1679 if (bp_location_downloaded
)
1680 gdb::observers::breakpoint_modified
.notify (b
);
1683 /* Send down all the trace state variables too. */
1684 for (const trace_state_variable
&tsv
: tvariables
)
1685 target_download_trace_state_variable (tsv
);
1687 /* Tell target to treat text-like sections as transparent. */
1688 target_trace_set_readonly_regions ();
1689 /* Set some mode flags. */
1690 target_set_disconnected_tracing (disconnected_tracing
);
1691 target_set_circular_trace_buffer (circular_trace_buffer
);
1692 target_set_trace_buffer_size (trace_buffer_size
);
1695 notes
= trace_notes
;
1696 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1698 if (!ret
&& (trace_user
|| notes
))
1699 warning (_("Target does not support trace user/notes, info ignored"));
1701 /* Now insert traps and begin collecting data. */
1702 target_trace_start ();
1704 /* Reset our local state. */
1705 trace_reset_local_state ();
1706 current_trace_status()->running
= 1;
1709 /* The tstart command requests the target to start a new trace run.
1710 The command passes any arguments it has to the target verbatim, as
1711 an optional "trace note". This is useful as for instance a warning
1712 to other users if the trace runs disconnected, and you don't want
1713 anybody else messing with the target. */
1716 tstart_command (const char *args
, int from_tty
)
1718 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1720 if (current_trace_status ()->running
)
1723 && !query (_("A trace is running already. Start a new run? ")))
1724 error (_("New trace run not started."));
1727 start_tracing (args
);
1730 /* The tstop command stops the tracing run. The command passes any
1731 supplied arguments to the target verbatim as a "stop note"; if the
1732 target supports trace notes, then it will be reported back as part
1733 of the trace run's status. */
1736 tstop_command (const char *args
, int from_tty
)
1738 if (!current_trace_status ()->running
)
1739 error (_("Trace is not running."));
1741 stop_tracing (args
);
1745 stop_tracing (const char *note
)
1749 target_trace_stop ();
1751 for (breakpoint
*t
: all_tracepoints ())
1753 struct bp_location
*loc
;
1755 if ((t
->type
== bp_fast_tracepoint
1756 ? !may_insert_fast_tracepoints
1757 : !may_insert_tracepoints
))
1760 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1762 /* GDB can be totally absent in some disconnected trace scenarios,
1763 but we don't really care if this semaphore goes out of sync.
1764 That's why we are decrementing it here, but not taking care
1766 if (loc
->probe
.prob
!= NULL
)
1767 loc
->probe
.prob
->clear_semaphore (loc
->probe
.objfile
,
1773 note
= trace_stop_notes
;
1774 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1777 warning (_("Target does not support trace notes, note ignored"));
1779 /* Should change in response to reply? */
1780 current_trace_status ()->running
= 0;
1783 /* tstatus command */
1785 tstatus_command (const char *args
, int from_tty
)
1787 struct trace_status
*ts
= current_trace_status ();
1790 status
= target_get_trace_status (ts
);
1794 if (ts
->filename
!= NULL
)
1795 printf_filtered (_("Using a trace file.\n"));
1798 printf_filtered (_("Trace can not be run on this target.\n"));
1803 if (!ts
->running_known
)
1805 printf_filtered (_("Run/stop status is unknown.\n"));
1807 else if (ts
->running
)
1809 printf_filtered (_("Trace is running on the target.\n"));
1813 switch (ts
->stop_reason
)
1815 case trace_never_run
:
1816 printf_filtered (_("No trace has been run on the target.\n"));
1818 case trace_stop_command
:
1820 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1823 printf_filtered (_("Trace stopped by a tstop command.\n"));
1825 case trace_buffer_full
:
1826 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1828 case trace_disconnected
:
1829 printf_filtered (_("Trace stopped because of disconnection.\n"));
1831 case tracepoint_passcount
:
1832 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1833 ts
->stopping_tracepoint
);
1835 case tracepoint_error
:
1836 if (ts
->stopping_tracepoint
)
1837 printf_filtered (_("Trace stopped by an "
1838 "error (%s, tracepoint %d).\n"),
1839 ts
->stop_desc
, ts
->stopping_tracepoint
);
1841 printf_filtered (_("Trace stopped by an error (%s).\n"),
1844 case trace_stop_reason_unknown
:
1845 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1848 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1854 if (ts
->traceframes_created
>= 0
1855 && ts
->traceframe_count
!= ts
->traceframes_created
)
1857 printf_filtered (_("Buffer contains %d trace "
1858 "frames (of %d created total).\n"),
1859 ts
->traceframe_count
, ts
->traceframes_created
);
1861 else if (ts
->traceframe_count
>= 0)
1863 printf_filtered (_("Collected %d trace frames.\n"),
1864 ts
->traceframe_count
);
1867 if (ts
->buffer_free
>= 0)
1869 if (ts
->buffer_size
>= 0)
1871 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1872 ts
->buffer_free
, ts
->buffer_size
);
1873 if (ts
->buffer_size
> 0)
1874 printf_filtered (_(" (%d%% full)"),
1875 ((int) ((((long long) (ts
->buffer_size
1876 - ts
->buffer_free
)) * 100)
1877 / ts
->buffer_size
)));
1878 printf_filtered (_(".\n"));
1881 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1885 if (ts
->disconnected_tracing
)
1886 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1888 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1890 if (ts
->circular_buffer
)
1891 printf_filtered (_("Trace buffer is circular.\n"));
1893 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1894 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1896 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1897 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1899 /* Now report on what we're doing with tfind. */
1900 if (traceframe_number
>= 0)
1901 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1902 traceframe_number
, tracepoint_number
);
1904 printf_filtered (_("Not looking at any trace frame.\n"));
1906 /* Report start/stop times if supplied. */
1911 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1913 /* Reporting a run time is more readable than two long numbers. */
1914 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1915 (long int) (ts
->start_time
/ 1000000),
1916 (long int) (ts
->start_time
% 1000000),
1917 (long int) (run_time
/ 1000000),
1918 (long int) (run_time
% 1000000));
1921 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1922 (long int) (ts
->start_time
/ 1000000),
1923 (long int) (ts
->start_time
% 1000000));
1925 else if (ts
->stop_time
)
1926 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1927 (long int) (ts
->stop_time
/ 1000000),
1928 (long int) (ts
->stop_time
% 1000000));
1930 /* Now report any per-tracepoint status available. */
1931 for (breakpoint
*t
: all_tracepoints ())
1932 target_get_tracepoint_status (t
, NULL
);
1935 /* Report the trace status to uiout, in a way suitable for MI, and not
1936 suitable for CLI. If ON_STOP is true, suppress a few fields that
1937 are not meaningful in the -trace-stop response.
1939 The implementation is essentially parallel to trace_status_command, but
1940 merging them will result in unreadable code. */
1942 trace_status_mi (int on_stop
)
1944 struct ui_out
*uiout
= current_uiout
;
1945 struct trace_status
*ts
= current_trace_status ();
1948 status
= target_get_trace_status (ts
);
1950 if (status
== -1 && ts
->filename
== NULL
)
1952 uiout
->field_string ("supported", "0");
1956 if (ts
->filename
!= NULL
)
1957 uiout
->field_string ("supported", "file");
1959 uiout
->field_string ("supported", "1");
1961 if (ts
->filename
!= NULL
)
1962 uiout
->field_string ("trace-file", ts
->filename
);
1964 gdb_assert (ts
->running_known
);
1968 uiout
->field_string ("running", "1");
1970 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1971 Given that the frontend gets the status either on -trace-stop, or from
1972 -trace-status after re-connection, it does not seem like this
1973 information is necessary for anything. It is not necessary for either
1974 figuring the vital state of the target nor for navigation of trace
1975 frames. If the frontend wants to show the current state is some
1976 configure dialog, it can request the value when such dialog is
1977 invoked by the user. */
1981 const char *stop_reason
= NULL
;
1982 int stopping_tracepoint
= -1;
1985 uiout
->field_string ("running", "0");
1987 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1989 switch (ts
->stop_reason
)
1991 case trace_stop_command
:
1992 stop_reason
= "request";
1994 case trace_buffer_full
:
1995 stop_reason
= "overflow";
1997 case trace_disconnected
:
1998 stop_reason
= "disconnection";
2000 case tracepoint_passcount
:
2001 stop_reason
= "passcount";
2002 stopping_tracepoint
= ts
->stopping_tracepoint
;
2004 case tracepoint_error
:
2005 stop_reason
= "error";
2006 stopping_tracepoint
= ts
->stopping_tracepoint
;
2012 uiout
->field_string ("stop-reason", stop_reason
);
2013 if (stopping_tracepoint
!= -1)
2014 uiout
->field_signed ("stopping-tracepoint",
2015 stopping_tracepoint
);
2016 if (ts
->stop_reason
== tracepoint_error
)
2017 uiout
->field_string ("error-description",
2023 if (ts
->traceframe_count
!= -1)
2024 uiout
->field_signed ("frames", ts
->traceframe_count
);
2025 if (ts
->traceframes_created
!= -1)
2026 uiout
->field_signed ("frames-created", ts
->traceframes_created
);
2027 if (ts
->buffer_size
!= -1)
2028 uiout
->field_signed ("buffer-size", ts
->buffer_size
);
2029 if (ts
->buffer_free
!= -1)
2030 uiout
->field_signed ("buffer-free", ts
->buffer_free
);
2032 uiout
->field_signed ("disconnected", ts
->disconnected_tracing
);
2033 uiout
->field_signed ("circular", ts
->circular_buffer
);
2035 uiout
->field_string ("user-name", ts
->user_name
);
2036 uiout
->field_string ("notes", ts
->notes
);
2041 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2042 (long int) (ts
->start_time
/ 1000000),
2043 (long int) (ts
->start_time
% 1000000));
2044 uiout
->field_string ("start-time", buf
);
2045 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2046 (long int) (ts
->stop_time
/ 1000000),
2047 (long int) (ts
->stop_time
% 1000000));
2048 uiout
->field_string ("stop-time", buf
);
2052 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2053 user if she really wants to detach. */
2056 query_if_trace_running (int from_tty
)
2061 /* It can happen that the target that was tracing went away on its
2062 own, and we didn't notice. Get a status update, and if the
2063 current target doesn't even do tracing, then assume it's not
2065 if (target_get_trace_status (current_trace_status ()) < 0)
2066 current_trace_status ()->running
= 0;
2068 /* If running interactively, give the user the option to cancel and
2069 then decide what to do differently with the run. Scripts are
2070 just going to disconnect and let the target deal with it,
2071 according to how it's been instructed previously via
2072 disconnected-tracing. */
2073 if (current_trace_status ()->running
)
2075 process_tracepoint_on_disconnect ();
2077 if (current_trace_status ()->disconnected_tracing
)
2079 if (!query (_("Trace is running and will "
2080 "continue after detach; detach anyway? ")))
2081 error (_("Not confirmed."));
2085 if (!query (_("Trace is running but will "
2086 "stop on detach; detach anyway? ")))
2087 error (_("Not confirmed."));
2092 /* This function handles the details of what to do about an ongoing
2093 tracing run if the user has asked to detach or otherwise disconnect
2097 disconnect_tracing (void)
2099 /* Also we want to be out of tfind mode, otherwise things can get
2100 confusing upon reconnection. Just use these calls instead of
2101 full tfind_1 behavior because we're in the middle of detaching,
2102 and there's no point to updating current stack frame etc. */
2103 trace_reset_local_state ();
2106 /* Worker function for the various flavors of the tfind command. */
2108 tfind_1 (enum trace_find_type type
, int num
,
2109 CORE_ADDR addr1
, CORE_ADDR addr2
,
2112 int target_frameno
= -1, target_tracept
= -1;
2113 struct frame_id old_frame_id
= null_frame_id
;
2114 struct tracepoint
*tp
;
2115 struct ui_out
*uiout
= current_uiout
;
2117 /* Only try to get the current stack frame if we have a chance of
2118 succeeding. In particular, if we're trying to get a first trace
2119 frame while all threads are running, it's not going to succeed,
2120 so leave it with a default value and let the frame comparison
2121 below (correctly) decide to print out the source location of the
2123 if (!(type
== tfind_number
&& num
== -1)
2124 && (has_stack_frames () || traceframe_number
>= 0))
2125 old_frame_id
= get_frame_id (get_current_frame ());
2127 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2130 if (type
== tfind_number
2132 && target_frameno
== -1)
2134 /* We told the target to get out of tfind mode, and it did. */
2136 else if (target_frameno
== -1)
2138 /* A request for a non-existent trace frame has failed.
2139 Our response will be different, depending on FROM_TTY:
2141 If FROM_TTY is true, meaning that this command was
2142 typed interactively by the user, then give an error
2143 and DO NOT change the state of traceframe_number etc.
2145 However if FROM_TTY is false, meaning that we're either
2146 in a script, a loop, or a user-defined command, then
2147 DON'T give an error, but DO change the state of
2148 traceframe_number etc. to invalid.
2150 The rationale is that if you typed the command, you
2151 might just have committed a typo or something, and you'd
2152 like to NOT lose your current debugging state. However
2153 if you're in a user-defined command or especially in a
2154 loop, then you need a way to detect that the command
2155 failed WITHOUT aborting. This allows you to write
2156 scripts that search thru the trace buffer until the end,
2157 and then continue on to do something else. */
2160 error (_("Target failed to find requested trace frame."));
2164 printf_filtered ("End of trace buffer.\n");
2165 #if 0 /* dubious now? */
2166 /* The following will not recurse, since it's
2168 tfind_command ("-1", from_tty
);
2173 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2175 reinit_frame_cache ();
2176 target_dcache_invalidate ();
2178 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2180 if (target_frameno
!= get_traceframe_number ())
2181 gdb::observers::traceframe_changed
.notify (target_frameno
, tracepoint_number
);
2183 set_current_traceframe (target_frameno
);
2185 if (target_frameno
== -1)
2186 set_traceframe_context (NULL
);
2188 set_traceframe_context (get_current_frame ());
2190 if (traceframe_number
>= 0)
2192 /* Use different branches for MI and CLI to make CLI messages
2194 if (uiout
->is_mi_like_p ())
2196 uiout
->field_string ("found", "1");
2197 uiout
->field_signed ("tracepoint", tracepoint_number
);
2198 uiout
->field_signed ("traceframe", traceframe_number
);
2202 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2203 traceframe_number
, tracepoint_number
);
2208 if (uiout
->is_mi_like_p ())
2209 uiout
->field_string ("found", "0");
2210 else if (type
== tfind_number
&& num
== -1)
2211 printf_unfiltered (_("No longer looking at any trace frame\n"));
2212 else /* This case may never occur, check. */
2213 printf_unfiltered (_("No trace frame found\n"));
2216 /* If we're in nonstop mode and getting out of looking at trace
2217 frames, there won't be any current frame to go back to and
2220 && (has_stack_frames () || traceframe_number
>= 0))
2222 enum print_what print_what
;
2224 /* NOTE: in imitation of the step command, try to determine
2225 whether we have made a transition from one function to
2226 another. If so, we'll print the "stack frame" (ie. the new
2227 function and it's arguments) -- otherwise we'll just show the
2230 if (frame_id_eq (old_frame_id
,
2231 get_frame_id (get_current_frame ())))
2232 print_what
= SRC_LINE
;
2234 print_what
= SRC_AND_LOC
;
2236 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2241 /* Error on looking at traceframes while trace is running. */
2244 check_trace_running (struct trace_status
*status
)
2246 if (status
->running
&& status
->filename
== NULL
)
2247 error (_("May not look at trace frames while trace is running."));
2250 /* trace_find_command takes a trace frame number n,
2251 sends "QTFrame:<n>" to the target,
2252 and accepts a reply that may contain several optional pieces
2253 of information: a frame number, a tracepoint number, and an
2254 indication of whether this is a trap frame or a stepping frame.
2256 The minimal response is just "OK" (which indicates that the
2257 target does not give us a frame number or a tracepoint number).
2258 Instead of that, the target may send us a string containing
2260 F<hexnum> (gives the selected frame number)
2261 T<hexnum> (gives the selected tracepoint number)
2266 tfind_command_1 (const char *args
, int from_tty
)
2267 { /* This should only be called with a numeric argument. */
2270 check_trace_running (current_trace_status ());
2272 if (args
== 0 || *args
== 0)
2273 { /* TFIND with no args means find NEXT trace frame. */
2274 if (traceframe_number
== -1)
2275 frameno
= 0; /* "next" is first one. */
2277 frameno
= traceframe_number
+ 1;
2279 else if (0 == strcmp (args
, "-"))
2281 if (traceframe_number
== -1)
2282 error (_("not debugging trace buffer"));
2283 else if (from_tty
&& traceframe_number
== 0)
2284 error (_("already at start of trace buffer"));
2286 frameno
= traceframe_number
- 1;
2288 /* A hack to work around eval's need for fp to have been collected. */
2289 else if (0 == strcmp (args
, "-1"))
2292 frameno
= parse_and_eval_long (args
);
2295 error (_("invalid input (%d is less than zero)"), frameno
);
2297 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2301 tfind_command (const char *args
, int from_tty
)
2303 tfind_command_1 (args
, from_tty
);
2308 tfind_end_command (const char *args
, int from_tty
)
2310 tfind_command_1 ("-1", from_tty
);
2315 tfind_start_command (const char *args
, int from_tty
)
2317 tfind_command_1 ("0", from_tty
);
2320 /* tfind pc command */
2322 tfind_pc_command (const char *args
, int from_tty
)
2326 check_trace_running (current_trace_status ());
2328 if (args
== 0 || *args
== 0)
2329 pc
= regcache_read_pc (get_current_regcache ());
2331 pc
= parse_and_eval_address (args
);
2333 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2336 /* tfind tracepoint command */
2338 tfind_tracepoint_command (const char *args
, int from_tty
)
2341 struct tracepoint
*tp
;
2343 check_trace_running (current_trace_status ());
2345 if (args
== 0 || *args
== 0)
2347 if (tracepoint_number
== -1)
2348 error (_("No current tracepoint -- please supply an argument."));
2350 tdp
= tracepoint_number
; /* Default is current TDP. */
2353 tdp
= parse_and_eval_long (args
);
2355 /* If we have the tracepoint on hand, use the number that the
2356 target knows about (which may be different if we disconnected
2357 and reconnected). */
2358 tp
= get_tracepoint (tdp
);
2360 tdp
= tp
->number_on_target
;
2362 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2365 /* TFIND LINE command:
2367 This command will take a sourceline for argument, just like BREAK
2368 or TRACE (ie. anything that "decode_line_1" can handle).
2370 With no argument, this command will find the next trace frame
2371 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2374 tfind_line_command (const char *args
, int from_tty
)
2376 check_trace_running (current_trace_status ());
2378 symtab_and_line sal
;
2379 if (args
== 0 || *args
== 0)
2381 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2385 std::vector
<symtab_and_line
> sals
2386 = decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2390 if (sal
.symtab
== 0)
2391 error (_("No line number information available."));
2393 CORE_ADDR start_pc
, end_pc
;
2394 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2396 if (start_pc
== end_pc
)
2398 printf_filtered ("Line %d of \"%s\"",
2400 symtab_to_filename_for_display (sal
.symtab
));
2402 printf_filtered (" is at address ");
2403 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2405 printf_filtered (" but contains no code.\n");
2406 sal
= find_pc_line (start_pc
, 0);
2408 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2409 && start_pc
!= end_pc
)
2410 printf_filtered ("Attempting to find line %d instead.\n",
2413 error (_("Cannot find a good line."));
2417 /* Is there any case in which we get here, and have an address
2418 which the user would want to see? If we have debugging
2419 symbols and no line numbers? */
2420 error (_("Line number %d is out of range for \"%s\"."),
2421 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2423 /* Find within range of stated line. */
2425 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2427 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2430 /* tfind range command */
2432 tfind_range_command (const char *args
, int from_tty
)
2434 static CORE_ADDR start
, stop
;
2437 check_trace_running (current_trace_status ());
2439 if (args
== 0 || *args
== 0)
2440 { /* XXX FIXME: what should default behavior be? */
2441 printf_filtered ("Usage: tfind range STARTADDR, ENDADDR\n");
2445 if (0 != (tmp
= strchr (args
, ',')))
2447 std::string
start_addr (args
, tmp
);
2449 tmp
= skip_spaces (tmp
);
2450 start
= parse_and_eval_address (start_addr
.c_str ());
2451 stop
= parse_and_eval_address (tmp
);
2454 { /* No explicit end address? */
2455 start
= parse_and_eval_address (args
);
2456 stop
= start
+ 1; /* ??? */
2459 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2462 /* tfind outside command */
2464 tfind_outside_command (const char *args
, int from_tty
)
2466 CORE_ADDR start
, stop
;
2469 if (current_trace_status ()->running
2470 && current_trace_status ()->filename
== NULL
)
2471 error (_("May not look at trace frames while trace is running."));
2473 if (args
== 0 || *args
== 0)
2474 { /* XXX FIXME: what should default behavior be? */
2475 printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n");
2479 if (0 != (tmp
= strchr (args
, ',')))
2481 std::string
start_addr (args
, tmp
);
2483 tmp
= skip_spaces (tmp
);
2484 start
= parse_and_eval_address (start_addr
.c_str ());
2485 stop
= parse_and_eval_address (tmp
);
2488 { /* No explicit end address? */
2489 start
= parse_and_eval_address (args
);
2490 stop
= start
+ 1; /* ??? */
2493 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2496 /* info scope command: list the locals for a scope. */
2498 info_scope_command (const char *args_in
, int from_tty
)
2501 struct bound_minimal_symbol msym
;
2502 const struct block
*block
;
2503 const char *symname
;
2504 const char *save_args
= args_in
;
2505 struct block_iterator iter
;
2507 struct gdbarch
*gdbarch
;
2509 const char *args
= args_in
;
2511 if (args
== 0 || *args
== 0)
2512 error (_("requires an argument (function, "
2513 "line or *addr) to define a scope"));
2515 event_location_up location
= string_to_event_location (&args
,
2517 std::vector
<symtab_and_line
> sals
2518 = decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
2522 /* Presumably decode_line_1 has already warned. */
2526 /* Resolve line numbers to PC. */
2527 resolve_sal_pc (&sals
[0]);
2528 block
= block_for_pc (sals
[0].pc
);
2532 QUIT
; /* Allow user to bail out with ^C. */
2533 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2535 QUIT
; /* Allow user to bail out with ^C. */
2537 printf_filtered ("Scope for %s:\n", save_args
);
2540 symname
= sym
->print_name ();
2541 if (symname
== NULL
|| *symname
== '\0')
2542 continue; /* Probably botched, certainly useless. */
2544 gdbarch
= symbol_arch (sym
);
2546 printf_filtered ("Symbol %s is ", symname
);
2548 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2549 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2550 BLOCK_ENTRY_PC (block
),
2554 switch (SYMBOL_CLASS (sym
))
2557 case LOC_UNDEF
: /* Messed up symbol? */
2558 printf_filtered ("a bogus symbol, class %d.\n",
2559 SYMBOL_CLASS (sym
));
2560 count
--; /* Don't count this one. */
2563 printf_filtered ("a constant with value %s (%s)",
2564 plongest (SYMBOL_VALUE (sym
)),
2565 hex_string (SYMBOL_VALUE (sym
)));
2567 case LOC_CONST_BYTES
:
2568 printf_filtered ("constant bytes: ");
2569 if (SYMBOL_TYPE (sym
))
2570 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2571 fprintf_filtered (gdb_stdout
, " %02x",
2572 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2575 printf_filtered ("in static storage at address ");
2576 printf_filtered ("%s", paddress (gdbarch
,
2577 SYMBOL_VALUE_ADDRESS (sym
)));
2580 /* GDBARCH is the architecture associated with the objfile
2581 the symbol is defined in; the target architecture may be
2582 different, and may provide additional registers. However,
2583 we do not know the target architecture at this point.
2584 We assume the objfile architecture will contain all the
2585 standard registers that occur in debug info in that
2587 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2590 if (SYMBOL_IS_ARGUMENT (sym
))
2591 printf_filtered ("an argument in register $%s",
2592 gdbarch_register_name (gdbarch
, regno
));
2594 printf_filtered ("a local variable in register $%s",
2595 gdbarch_register_name (gdbarch
, regno
));
2598 printf_filtered ("an argument at stack/frame offset %s",
2599 plongest (SYMBOL_VALUE (sym
)));
2602 printf_filtered ("a local variable at frame offset %s",
2603 plongest (SYMBOL_VALUE (sym
)));
2606 printf_filtered ("a reference argument at offset %s",
2607 plongest (SYMBOL_VALUE (sym
)));
2609 case LOC_REGPARM_ADDR
:
2610 /* Note comment at LOC_REGISTER. */
2611 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2613 printf_filtered ("the address of an argument, in register $%s",
2614 gdbarch_register_name (gdbarch
, regno
));
2617 printf_filtered ("a typedef.\n");
2620 printf_filtered ("a label at address ");
2621 printf_filtered ("%s", paddress (gdbarch
,
2622 SYMBOL_VALUE_ADDRESS (sym
)));
2625 printf_filtered ("a function at address ");
2626 printf_filtered ("%s",
2627 paddress (gdbarch
, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
))));
2629 case LOC_UNRESOLVED
:
2630 msym
= lookup_minimal_symbol (sym
->linkage_name (),
2632 if (msym
.minsym
== NULL
)
2633 printf_filtered ("Unresolved Static");
2636 printf_filtered ("static storage at address ");
2637 printf_filtered ("%s",
2639 BMSYMBOL_VALUE_ADDRESS (msym
)));
2642 case LOC_OPTIMIZED_OUT
:
2643 printf_filtered ("optimized out.\n");
2646 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2649 if (SYMBOL_TYPE (sym
))
2651 struct type
*t
= check_typedef (SYMBOL_TYPE (sym
));
2653 printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t
)));
2656 if (BLOCK_FUNCTION (block
))
2659 block
= BLOCK_SUPERBLOCK (block
);
2662 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2666 /* Helper for trace_dump_command. Dump the action list starting at
2667 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2668 actions of the body of a while-stepping action. STEPPING_FRAME is
2669 set if the current traceframe was determined to be a while-stepping
2673 trace_dump_actions (struct command_line
*action
,
2674 int stepping_actions
, int stepping_frame
,
2677 const char *action_exp
, *next_comma
;
2679 for (; action
!= NULL
; action
= action
->next
)
2681 struct cmd_list_element
*cmd
;
2683 QUIT
; /* Allow user to bail out with ^C. */
2684 action_exp
= action
->line
;
2685 action_exp
= skip_spaces (action_exp
);
2687 /* The collection actions to be done while stepping are
2688 bracketed by the commands "while-stepping" and "end". */
2690 if (*action_exp
== '#') /* comment line */
2693 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", NULL
, -1, 1);
2695 error (_("Bad action list item: %s"), action_exp
);
2697 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2699 gdb_assert (action
->body_list_1
== nullptr);
2700 trace_dump_actions (action
->body_list_0
.get (),
2701 1, stepping_frame
, from_tty
);
2703 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2705 /* Display the collected data.
2706 For the trap frame, display only what was collected at
2707 the trap. Likewise for stepping frames, display only
2708 what was collected while stepping. This means that the
2709 two boolean variables, STEPPING_FRAME and
2710 STEPPING_ACTIONS should be equal. */
2711 if (stepping_frame
== stepping_actions
)
2713 int trace_string
= 0;
2715 if (*action_exp
== '/')
2716 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2719 { /* Repeat over a comma-separated list. */
2720 QUIT
; /* Allow user to bail out with ^C. */
2721 if (*action_exp
== ',')
2723 action_exp
= skip_spaces (action_exp
);
2725 next_comma
= strchr (action_exp
, ',');
2727 if (0 == strncasecmp (action_exp
, "$reg", 4))
2728 registers_info (NULL
, from_tty
);
2729 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2731 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2732 info_locals_command (NULL
, from_tty
);
2733 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2734 info_args_command (NULL
, from_tty
);
2737 std::string contents
;
2738 const char *exp
= action_exp
;
2739 if (next_comma
!= NULL
)
2741 size_t len
= next_comma
- action_exp
;
2742 contents
= std::string (action_exp
, len
);
2743 exp
= contents
.c_str ();
2746 printf_filtered ("%s = ", exp
);
2747 output_command (exp
, from_tty
);
2748 printf_filtered ("\n");
2750 action_exp
= next_comma
;
2752 while (action_exp
&& *action_exp
== ',');
2758 /* Return bp_location of the tracepoint associated with the current
2759 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2760 is a stepping traceframe. */
2762 struct bp_location
*
2763 get_traceframe_location (int *stepping_frame_p
)
2765 struct tracepoint
*t
;
2766 struct bp_location
*tloc
;
2767 struct regcache
*regcache
;
2769 if (tracepoint_number
== -1)
2770 error (_("No current trace frame."));
2772 t
= get_tracepoint (tracepoint_number
);
2775 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2778 /* The current frame is a trap frame if the frame PC is equal to the
2779 tracepoint PC. If not, then the current frame was collected
2780 during single-stepping. */
2781 regcache
= get_current_regcache ();
2783 /* If the traceframe's address matches any of the tracepoint's
2784 locations, assume it is a direct hit rather than a while-stepping
2785 frame. (FIXME this is not reliable, should record each frame's
2787 for (tloc
= t
->loc
; tloc
; tloc
= tloc
->next
)
2788 if (tloc
->address
== regcache_read_pc (regcache
))
2790 *stepping_frame_p
= 0;
2794 /* If this is a stepping frame, we don't know which location
2795 triggered. The first is as good (or bad) a guess as any... */
2796 *stepping_frame_p
= 1;
2800 /* Return the default collect actions of a tracepoint T. */
2802 static counted_command_line
2803 all_tracepoint_actions (struct breakpoint
*t
)
2805 counted_command_line
actions (nullptr, command_lines_deleter ());
2807 /* If there are default expressions to collect, make up a collect
2808 action and prepend to the action list to encode. Note that since
2809 validation is per-tracepoint (local var "xyz" might be valid for
2810 one tracepoint and not another, etc), we make up the action on
2811 the fly, and don't cache it. */
2812 if (*default_collect
)
2814 gdb::unique_xmalloc_ptr
<char> default_collect_line
2815 (xstrprintf ("collect %s", default_collect
));
2817 validate_actionline (default_collect_line
.get (), t
);
2818 actions
.reset (new struct command_line (simple_control
,
2819 default_collect_line
.release ()),
2820 command_lines_deleter ());
2826 /* The tdump command. */
2829 tdump_command (const char *args
, int from_tty
)
2831 int stepping_frame
= 0;
2832 struct bp_location
*loc
;
2834 /* This throws an error is not inspecting a trace frame. */
2835 loc
= get_traceframe_location (&stepping_frame
);
2837 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2838 tracepoint_number
, traceframe_number
);
2840 /* This command only makes sense for the current frame, not the
2842 scoped_restore_current_thread restore_thread
;
2844 select_frame (get_current_frame ());
2846 counted_command_line actions
= all_tracepoint_actions (loc
->owner
);
2848 trace_dump_actions (actions
.get (), 0, stepping_frame
, from_tty
);
2849 trace_dump_actions (breakpoint_commands (loc
->owner
), 0, stepping_frame
,
2853 /* Encode a piece of a tracepoint's source-level definition in a form
2854 that is suitable for both protocol and saving in files. */
2855 /* This version does not do multiple encodes for long strings; it should
2856 return an offset to the next piece to encode. FIXME */
2859 encode_source_string (int tpnum
, ULONGEST addr
,
2860 const char *srctype
, const char *src
,
2861 char *buf
, int buf_size
)
2863 if (80 + strlen (srctype
) > buf_size
)
2864 error (_("Buffer too small for source encoding"));
2865 sprintf (buf
, "%x:%s:%s:%x:%x:",
2866 tpnum
, phex_nz (addr
, sizeof (addr
)),
2867 srctype
, 0, (int) strlen (src
));
2868 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2869 error (_("Source string too long for buffer"));
2870 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
2874 /* Tell the target what to do with an ongoing tracing run if GDB
2875 disconnects for some reason. */
2878 set_disconnected_tracing (const char *args
, int from_tty
,
2879 struct cmd_list_element
*c
)
2881 target_set_disconnected_tracing (disconnected_tracing
);
2885 set_circular_trace_buffer (const char *args
, int from_tty
,
2886 struct cmd_list_element
*c
)
2888 target_set_circular_trace_buffer (circular_trace_buffer
);
2892 set_trace_buffer_size (const char *args
, int from_tty
,
2893 struct cmd_list_element
*c
)
2895 target_set_trace_buffer_size (trace_buffer_size
);
2899 set_trace_user (const char *args
, int from_tty
,
2900 struct cmd_list_element
*c
)
2904 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
2907 warning (_("Target does not support trace notes, user ignored"));
2911 set_trace_notes (const char *args
, int from_tty
,
2912 struct cmd_list_element
*c
)
2916 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
2919 warning (_("Target does not support trace notes, note ignored"));
2923 set_trace_stop_notes (const char *args
, int from_tty
,
2924 struct cmd_list_element
*c
)
2928 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
2931 warning (_("Target does not support trace notes, stop note ignored"));
2934 /* Convert the memory pointed to by mem into hex, placing result in buf.
2935 * Return a pointer to the last char put in buf (null)
2936 * "stolen" from sparc-stub.c
2939 static const char hexchars
[] = "0123456789abcdef";
2942 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2950 *buf
++ = hexchars
[ch
>> 4];
2951 *buf
++ = hexchars
[ch
& 0xf];
2960 get_traceframe_number (void)
2962 return traceframe_number
;
2966 get_tracepoint_number (void)
2968 return tracepoint_number
;
2971 /* Make the traceframe NUM be the current trace frame. Does nothing
2972 if NUM is already current. */
2975 set_current_traceframe (int num
)
2979 if (traceframe_number
== num
)
2981 /* Nothing to do. */
2985 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2988 warning (_("could not change traceframe"));
2990 set_traceframe_num (newnum
);
2992 /* Changing the traceframe changes our view of registers and of the
2994 registers_changed ();
2996 clear_traceframe_info ();
2999 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
3000 : m_traceframe_number (traceframe_number
)
3003 /* Given a number and address, return an uploaded tracepoint with that
3004 number, creating if necessary. */
3006 struct uploaded_tp
*
3007 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3009 struct uploaded_tp
*utp
;
3011 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3012 if (utp
->number
== num
&& utp
->addr
== addr
)
3015 utp
= new uploaded_tp
;
3025 free_uploaded_tps (struct uploaded_tp
**utpp
)
3027 struct uploaded_tp
*next_one
;
3031 next_one
= (*utpp
)->next
;
3037 /* Given a number and address, return an uploaded tracepoint with that
3038 number, creating if necessary. */
3040 struct uploaded_tsv
*
3041 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3043 struct uploaded_tsv
*utsv
;
3045 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3046 if (utsv
->number
== num
)
3049 utsv
= XCNEW (struct uploaded_tsv
);
3051 utsv
->next
= *utsvp
;
3058 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3060 struct uploaded_tsv
*next_one
;
3064 next_one
= (*utsvp
)->next
;
3070 /* FIXME this function is heuristic and will miss the cases where the
3071 conditional is semantically identical but differs in whitespace,
3072 such as "x == 0" vs "x==0". */
3075 cond_string_is_same (char *str1
, char *str2
)
3077 if (str1
== NULL
|| str2
== NULL
)
3078 return (str1
== str2
);
3080 return (strcmp (str1
, str2
) == 0);
3083 /* Look for an existing tracepoint that seems similar enough to the
3084 uploaded one. Enablement isn't compared, because the user can
3085 toggle that freely, and may have done so in anticipation of the
3086 next trace run. Return the location of matched tracepoint. */
3088 static struct bp_location
*
3089 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3091 struct bp_location
*loc
;
3093 for (breakpoint
*b
: all_tracepoints ())
3095 struct tracepoint
*t
= (struct tracepoint
*) b
;
3097 if (b
->type
== utp
->type
3098 && t
->step_count
== utp
->step
3099 && t
->pass_count
== utp
->pass
3100 && cond_string_is_same (t
->cond_string
,
3101 utp
->cond_string
.get ())
3102 /* FIXME also test actions. */
3105 /* Scan the locations for an address match. */
3106 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3108 if (loc
->address
== utp
->addr
)
3116 /* Given a list of tracepoints uploaded from a target, attempt to
3117 match them up with existing tracepoints, and create new ones if not
3121 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3123 struct uploaded_tp
*utp
;
3124 /* A set of tracepoints which are modified. */
3125 std::vector
<breakpoint
*> modified_tp
;
3127 /* Look for GDB tracepoints that match up with our uploaded versions. */
3128 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3130 struct bp_location
*loc
;
3131 struct tracepoint
*t
;
3133 loc
= find_matching_tracepoint_location (utp
);
3138 /* Mark this location as already inserted. */
3140 t
= (struct tracepoint
*) loc
->owner
;
3141 printf_filtered (_("Assuming tracepoint %d is same "
3142 "as target's tracepoint %d at %s.\n"),
3143 loc
->owner
->number
, utp
->number
,
3144 paddress (loc
->gdbarch
, utp
->addr
));
3146 /* The tracepoint LOC->owner was modified (the location LOC
3147 was marked as inserted in the target). Save it in
3148 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3149 observers will be notified later once for each tracepoint
3150 saved in MODIFIED_TP. */
3151 for (breakpoint
*b
: modified_tp
)
3152 if (b
== loc
->owner
)
3158 modified_tp
.push_back (loc
->owner
);
3162 t
= create_tracepoint_from_upload (utp
);
3164 printf_filtered (_("Created tracepoint %d for "
3165 "target's tracepoint %d at %s.\n"),
3166 t
->number
, utp
->number
,
3167 paddress (get_current_arch (), utp
->addr
));
3169 printf_filtered (_("Failed to create tracepoint for target's "
3170 "tracepoint %d at %s, skipping it.\n"),
3172 paddress (get_current_arch (), utp
->addr
));
3174 /* Whether found or created, record the number used by the
3175 target, to help with mapping target tracepoints back to their
3176 counterparts here. */
3178 t
->number_on_target
= utp
->number
;
3181 /* Notify 'breakpoint-modified' observer that at least one of B's
3182 locations was changed. */
3183 for (breakpoint
*b
: modified_tp
)
3184 gdb::observers::breakpoint_modified
.notify (b
);
3186 free_uploaded_tps (uploaded_tps
);
3189 /* Trace state variables don't have much to identify them beyond their
3190 name, so just use that to detect matches. */
3192 static struct trace_state_variable
*
3193 find_matching_tsv (struct uploaded_tsv
*utsv
)
3198 return find_trace_state_variable (utsv
->name
);
3201 static struct trace_state_variable
*
3202 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3204 const char *namebase
;
3207 struct trace_state_variable
*tsv
;
3211 namebase
= utsv
->name
;
3217 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3220 /* Fish for a name that is not in use. */
3221 /* (should check against all internal vars?) */
3222 while (find_trace_state_variable (buf
.c_str ()))
3223 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3225 /* We have an available name, create the variable. */
3226 tsv
= create_trace_state_variable (buf
.c_str ());
3227 tsv
->initial_value
= utsv
->initial_value
;
3228 tsv
->builtin
= utsv
->builtin
;
3230 gdb::observers::tsv_created
.notify (tsv
);
3235 /* Given a list of uploaded trace state variables, try to match them
3236 up with existing variables, or create additional ones. */
3239 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3241 struct uploaded_tsv
*utsv
;
3244 /* Most likely some numbers will have to be reassigned as part of
3245 the merge, so clear them all in anticipation. */
3246 for (trace_state_variable
&tsv
: tvariables
)
3249 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3251 struct trace_state_variable
*tsv
= find_matching_tsv (utsv
);
3255 printf_filtered (_("Assuming trace state variable $%s "
3256 "is same as target's variable %d.\n"),
3257 tsv
->name
.c_str (), utsv
->number
);
3261 tsv
= create_tsv_from_upload (utsv
);
3263 printf_filtered (_("Created trace state variable "
3264 "$%s for target's variable %d.\n"),
3265 tsv
->name
.c_str (), utsv
->number
);
3267 /* Give precedence to numberings that come from the target. */
3269 tsv
->number
= utsv
->number
;
3272 /* Renumber everything that didn't get a target-assigned number. */
3274 for (const trace_state_variable
&tsv
: tvariables
)
3275 highest
= std::max (tsv
.number
, highest
);
3278 for (trace_state_variable
&tsv
: tvariables
)
3279 if (tsv
.number
== 0)
3280 tsv
.number
= highest
++;
3282 free_uploaded_tsvs (uploaded_tsvs
);
3285 /* Parse the part of trace status syntax that is shared between
3286 the remote protocol and the trace file reader. */
3289 parse_trace_status (const char *line
, struct trace_status
*ts
)
3291 const char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3295 ts
->running_known
= 1;
3296 ts
->running
= (*p
++ == '1');
3297 ts
->stop_reason
= trace_stop_reason_unknown
;
3298 xfree (ts
->stop_desc
);
3299 ts
->stop_desc
= NULL
;
3300 ts
->traceframe_count
= -1;
3301 ts
->traceframes_created
= -1;
3302 ts
->buffer_free
= -1;
3303 ts
->buffer_size
= -1;
3304 ts
->disconnected_tracing
= 0;
3305 ts
->circular_buffer
= 0;
3306 xfree (ts
->user_name
);
3307 ts
->user_name
= NULL
;
3310 ts
->start_time
= ts
->stop_time
= 0;
3314 p1
= strchr (p
, ':');
3316 error (_("Malformed trace status, at %s\n\
3317 Status line: '%s'\n"), p
, line
);
3318 p3
= strchr (p
, ';');
3320 p3
= p
+ strlen (p
);
3321 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3323 p
= unpack_varlen_hex (++p1
, &val
);
3324 ts
->stop_reason
= trace_buffer_full
;
3326 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3328 p
= unpack_varlen_hex (++p1
, &val
);
3329 ts
->stop_reason
= trace_never_run
;
3331 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3334 p
= unpack_varlen_hex (++p1
, &val
);
3335 ts
->stop_reason
= tracepoint_passcount
;
3336 ts
->stopping_tracepoint
= val
;
3338 else if (strncmp (p
, stop_reason_names
[trace_stop_command
], p1
- p
) == 0)
3340 p2
= strchr (++p1
, ':');
3348 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3349 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3350 ts
->stop_desc
[end
] = '\0';
3353 ts
->stop_desc
= xstrdup ("");
3355 p
= unpack_varlen_hex (++p2
, &val
);
3356 ts
->stop_reason
= trace_stop_command
;
3358 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3360 p
= unpack_varlen_hex (++p1
, &val
);
3361 ts
->stop_reason
= trace_disconnected
;
3363 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3365 p2
= strchr (++p1
, ':');
3368 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3369 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3370 ts
->stop_desc
[end
] = '\0';
3373 ts
->stop_desc
= xstrdup ("");
3375 p
= unpack_varlen_hex (++p2
, &val
);
3376 ts
->stopping_tracepoint
= val
;
3377 ts
->stop_reason
= tracepoint_error
;
3379 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3381 p
= unpack_varlen_hex (++p1
, &val
);
3382 ts
->traceframe_count
= val
;
3384 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3386 p
= unpack_varlen_hex (++p1
, &val
);
3387 ts
->traceframes_created
= val
;
3389 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3391 p
= unpack_varlen_hex (++p1
, &val
);
3392 ts
->buffer_free
= val
;
3394 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3396 p
= unpack_varlen_hex (++p1
, &val
);
3397 ts
->buffer_size
= val
;
3399 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3401 p
= unpack_varlen_hex (++p1
, &val
);
3402 ts
->disconnected_tracing
= val
;
3404 else if (strncmp (p
, "circular", p1
- p
) == 0)
3406 p
= unpack_varlen_hex (++p1
, &val
);
3407 ts
->circular_buffer
= val
;
3409 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3411 p
= unpack_varlen_hex (++p1
, &val
);
3412 ts
->start_time
= val
;
3414 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3416 p
= unpack_varlen_hex (++p1
, &val
);
3417 ts
->stop_time
= val
;
3419 else if (strncmp (p
, "username", p1
- p
) == 0)
3422 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3423 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3424 ts
->user_name
[end
] = '\0';
3427 else if (strncmp (p
, "notes", p1
- p
) == 0)
3430 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3431 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3432 ts
->notes
[end
] = '\0';
3437 /* Silently skip unknown optional info. */
3438 p_temp
= strchr (p1
+ 1, ';');
3442 /* Must be at the end. */
3449 parse_tracepoint_status (const char *p
, struct breakpoint
*bp
,
3450 struct uploaded_tp
*utp
)
3453 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3455 p
= unpack_varlen_hex (p
, &uval
);
3457 tp
->hit_count
+= uval
;
3459 utp
->hit_count
+= uval
;
3460 p
= unpack_varlen_hex (p
+ 1, &uval
);
3462 tp
->traceframe_usage
+= uval
;
3464 utp
->traceframe_usage
+= uval
;
3465 /* Ignore any extra, allowing for future extensions. */
3468 /* Given a line of text defining a part of a tracepoint, parse it into
3469 an "uploaded tracepoint". */
3472 parse_tracepoint_definition (const char *line
, struct uploaded_tp
**utpp
)
3476 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3479 const char *srctype
;
3481 struct uploaded_tp
*utp
= NULL
;
3484 /* Both tracepoint and action definitions start with the same number
3485 and address sequence. */
3487 p
= unpack_varlen_hex (p
, &num
);
3488 p
++; /* skip a colon */
3489 p
= unpack_varlen_hex (p
, &addr
);
3490 p
++; /* skip a colon */
3493 gdb::unique_xmalloc_ptr
<char[]> cond
;
3495 enabled
= (*p
++ == 'E');
3496 p
++; /* skip a colon */
3497 p
= unpack_varlen_hex (p
, &step
);
3498 p
++; /* skip a colon */
3499 p
= unpack_varlen_hex (p
, &pass
);
3500 type
= bp_tracepoint
;
3501 /* Thumb through optional fields. */
3504 p
++; /* skip a colon */
3507 type
= bp_fast_tracepoint
;
3509 p
= unpack_varlen_hex (p
, &orig_size
);
3513 type
= bp_static_tracepoint
;
3519 p
= unpack_varlen_hex (p
, &xlen
);
3520 p
++; /* skip a comma */
3521 cond
.reset ((char *) xmalloc (2 * xlen
+ 1));
3522 strncpy (&cond
[0], p
, 2 * xlen
);
3523 cond
[2 * xlen
] = '\0';
3527 warning (_("Unrecognized char '%c' in tracepoint "
3528 "definition, skipping rest"), *p
);
3530 utp
= get_uploaded_tp (num
, addr
, utpp
);
3532 utp
->enabled
= enabled
;
3535 utp
->cond
= std::move (cond
);
3537 else if (piece
== 'A')
3539 utp
= get_uploaded_tp (num
, addr
, utpp
);
3540 utp
->actions
.emplace_back (xstrdup (p
));
3542 else if (piece
== 'S')
3544 utp
= get_uploaded_tp (num
, addr
, utpp
);
3545 utp
->step_actions
.emplace_back (xstrdup (p
));
3547 else if (piece
== 'Z')
3549 /* Parse a chunk of source form definition. */
3550 utp
= get_uploaded_tp (num
, addr
, utpp
);
3552 p
= strchr (p
, ':');
3553 p
++; /* skip a colon */
3554 p
= unpack_varlen_hex (p
, &start
);
3555 p
++; /* skip a colon */
3556 p
= unpack_varlen_hex (p
, &xlen
);
3557 p
++; /* skip a colon */
3559 buf
= (char *) alloca (strlen (line
));
3561 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3564 if (startswith (srctype
, "at:"))
3565 utp
->at_string
.reset (xstrdup (buf
));
3566 else if (startswith (srctype
, "cond:"))
3567 utp
->cond_string
.reset (xstrdup (buf
));
3568 else if (startswith (srctype
, "cmd:"))
3569 utp
->cmd_strings
.emplace_back (xstrdup (buf
));
3571 else if (piece
== 'V')
3573 utp
= get_uploaded_tp (num
, addr
, utpp
);
3575 parse_tracepoint_status (p
, NULL
, utp
);
3579 /* Don't error out, the target might be sending us optional
3580 info that we don't care about. */
3581 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3585 /* Convert a textual description of a trace state variable into an
3589 parse_tsv_definition (const char *line
, struct uploaded_tsv
**utsvp
)
3593 ULONGEST num
, initval
, builtin
;
3595 struct uploaded_tsv
*utsv
= NULL
;
3597 buf
= (char *) alloca (strlen (line
));
3600 p
= unpack_varlen_hex (p
, &num
);
3601 p
++; /* skip a colon */
3602 p
= unpack_varlen_hex (p
, &initval
);
3603 p
++; /* skip a colon */
3604 p
= unpack_varlen_hex (p
, &builtin
);
3605 p
++; /* skip a colon */
3606 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3609 utsv
= get_uploaded_tsv (num
, utsvp
);
3610 utsv
->initial_value
= initval
;
3611 utsv
->builtin
= builtin
;
3612 utsv
->name
= xstrdup (buf
);
3615 /* Given a line of text defining a static tracepoint marker, parse it
3616 into a "static tracepoint marker" object. Throws an error is
3617 parsing fails. If PP is non-null, it points to one past the end of
3618 the parsed marker definition. */
3621 parse_static_tracepoint_marker_definition (const char *line
, const char **pp
,
3622 static_tracepoint_marker
*marker
)
3624 const char *p
, *endp
;
3628 p
= unpack_varlen_hex (p
, &addr
);
3629 p
++; /* skip a colon */
3631 marker
->gdbarch
= target_gdbarch ();
3632 marker
->address
= (CORE_ADDR
) addr
;
3634 endp
= strchr (p
, ':');
3636 error (_("bad marker definition: %s"), line
);
3638 marker
->str_id
= hex2str (p
, (endp
- p
) / 2);
3641 p
++; /* skip a colon */
3643 /* This definition may be followed by another one, separated by a comma. */
3645 endp
= strchr (p
, ',');
3646 if (endp
!= nullptr)
3649 hex_len
= strlen (p
);
3651 marker
->extra
= hex2str (p
, hex_len
/ 2);
3657 /* Print MARKER to gdb_stdout. */
3660 print_one_static_tracepoint_marker (int count
,
3661 const static_tracepoint_marker
&marker
)
3665 char wrap_indent
[80];
3666 char extra_field_indent
[80];
3667 struct ui_out
*uiout
= current_uiout
;
3669 symtab_and_line sal
;
3670 sal
.pc
= marker
.address
;
3672 std::vector
<breakpoint
*> tracepoints
3673 = static_tracepoints_here (marker
.address
);
3675 ui_out_emit_tuple
tuple_emitter (uiout
, "marker");
3677 /* A counter field to help readability. This is not a stable
3679 uiout
->field_signed ("count", count
);
3681 uiout
->field_string ("marker-id", marker
.str_id
);
3683 uiout
->field_fmt ("enabled", "%c",
3684 !tracepoints
.empty () ? 'y' : 'n');
3687 strcpy (wrap_indent
, " ");
3689 if (gdbarch_addr_bit (marker
.gdbarch
) <= 32)
3690 strcat (wrap_indent
, " ");
3692 strcat (wrap_indent
, " ");
3694 strcpy (extra_field_indent
, " ");
3696 uiout
->field_core_addr ("addr", marker
.gdbarch
, marker
.address
);
3698 sal
= find_pc_line (marker
.address
, 0);
3699 sym
= find_pc_sect_function (marker
.address
, NULL
);
3702 uiout
->text ("in ");
3703 uiout
->field_string ("func", sym
->print_name (),
3704 function_name_style
.style ());
3705 uiout
->wrap_hint (wrap_indent
);
3706 uiout
->text (" at ");
3709 uiout
->field_skip ("func");
3711 if (sal
.symtab
!= NULL
)
3713 uiout
->field_string ("file",
3714 symtab_to_filename_for_display (sal
.symtab
),
3715 file_name_style
.style ());
3718 if (uiout
->is_mi_like_p ())
3720 const char *fullname
= symtab_to_fullname (sal
.symtab
);
3722 uiout
->field_string ("fullname", fullname
);
3725 uiout
->field_skip ("fullname");
3727 uiout
->field_signed ("line", sal
.line
);
3731 uiout
->field_skip ("fullname");
3732 uiout
->field_skip ("line");
3736 uiout
->text (extra_field_indent
);
3737 uiout
->text (_("Data: \""));
3738 uiout
->field_string ("extra-data", marker
.extra
);
3739 uiout
->text ("\"\n");
3741 if (!tracepoints
.empty ())
3746 ui_out_emit_tuple
inner_tuple_emitter (uiout
, "tracepoints-at");
3748 uiout
->text (extra_field_indent
);
3749 uiout
->text (_("Probed by static tracepoints: "));
3750 for (ix
= 0; ix
< tracepoints
.size (); ix
++)
3755 uiout
->field_signed ("tracepoint-id", tracepoints
[ix
]->number
);
3759 if (uiout
->is_mi_like_p ())
3760 uiout
->field_signed ("number-of-tracepoints", tracepoints
.size ());
3767 info_static_tracepoint_markers_command (const char *arg
, int from_tty
)
3769 struct ui_out
*uiout
= current_uiout
;
3770 std::vector
<static_tracepoint_marker
> markers
3771 = target_static_tracepoint_markers_by_strid (NULL
);
3773 /* We don't have to check target_can_use_agent and agent's capability on
3774 static tracepoint here, in order to be compatible with older GDBserver.
3775 We don't check USE_AGENT is true or not, because static tracepoints
3776 don't work without in-process agent, so we don't bother users to type
3777 `set agent on' when to use static tracepoint. */
3779 ui_out_emit_table
table_emitter (uiout
, 5, -1,
3780 "StaticTracepointMarkersTable");
3782 uiout
->table_header (7, ui_left
, "counter", "Cnt");
3784 uiout
->table_header (40, ui_left
, "marker-id", "ID");
3786 uiout
->table_header (3, ui_left
, "enabled", "Enb");
3787 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3788 uiout
->table_header (10, ui_left
, "addr", "Address");
3790 uiout
->table_header (18, ui_left
, "addr", "Address");
3791 uiout
->table_header (40, ui_noalign
, "what", "What");
3793 uiout
->table_body ();
3795 for (int i
= 0; i
< markers
.size (); i
++)
3796 print_one_static_tracepoint_marker (i
+ 1, markers
[i
]);
3799 /* The $_sdata convenience variable is a bit special. We don't know
3800 for sure type of the value until we actually have a chance to fetch
3801 the data --- the size of the object depends on what has been
3802 collected. We solve this by making $_sdata be an internalvar that
3803 creates a new value on access. */
3805 /* Return a new value with the correct type for the sdata object of
3806 the current trace frame. Return a void value if there's no object
3809 static struct value
*
3810 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
3813 /* We need to read the whole object before we know its size. */
3814 gdb::optional
<gdb::byte_vector
> buf
3815 = target_read_alloc (current_inferior ()->top_target (),
3816 TARGET_OBJECT_STATIC_TRACE_DATA
,
3823 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
3825 v
= allocate_value (type
);
3826 memcpy (value_contents_raw (v
), buf
->data (), buf
->size ());
3830 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
3833 #if !defined(HAVE_LIBEXPAT)
3835 struct std::unique_ptr
<traceframe_info
>
3836 parse_traceframe_info (const char *tframe_info
)
3838 static int have_warned
;
3843 warning (_("Can not parse XML trace frame info; XML support "
3844 "was disabled at compile time"));
3850 #else /* HAVE_LIBEXPAT */
3852 #include "xml-support.h"
3854 /* Handle the start of a <memory> element. */
3857 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
3858 const struct gdb_xml_element
*element
,
3860 std::vector
<gdb_xml_value
> &attributes
)
3862 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3863 ULONGEST
*start_p
, *length_p
;
3866 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
.get ();
3868 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
.get ();
3870 info
->memory
.emplace_back (*start_p
, *length_p
);
3873 /* Handle the start of a <tvar> element. */
3876 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
3877 const struct gdb_xml_element
*element
,
3879 std::vector
<gdb_xml_value
> &attributes
)
3881 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3882 const char *id_attrib
3883 = (const char *) xml_find_attribute (attributes
, "id")->value
.get ();
3884 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
3886 info
->tvars
.push_back (id
);
3889 /* The allowed elements and attributes for an XML memory map. */
3891 static const struct gdb_xml_attribute memory_attributes
[] = {
3892 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3893 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3894 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3897 static const struct gdb_xml_attribute tvar_attributes
[] = {
3898 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3899 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3902 static const struct gdb_xml_element traceframe_info_children
[] = {
3903 { "memory", memory_attributes
, NULL
,
3904 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3905 traceframe_info_start_memory
, NULL
},
3906 { "tvar", tvar_attributes
, NULL
,
3907 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3908 traceframe_info_start_tvar
, NULL
},
3909 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3912 static const struct gdb_xml_element traceframe_info_elements
[] = {
3913 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
3915 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3918 /* Parse a traceframe-info XML document. */
3921 parse_traceframe_info (const char *tframe_info
)
3923 traceframe_info_up
result (new traceframe_info
);
3925 if (gdb_xml_parse_quick (_("trace frame info"),
3926 "traceframe-info.dtd", traceframe_info_elements
,
3927 tframe_info
, result
.get ()) == 0)
3933 #endif /* HAVE_LIBEXPAT */
3935 /* Returns the traceframe_info object for the current traceframe.
3936 This is where we avoid re-fetching the object from the target if we
3937 already have it cached. */
3939 struct traceframe_info
*
3940 get_traceframe_info (void)
3942 if (current_traceframe_info
== NULL
)
3943 current_traceframe_info
= target_traceframe_info ();
3945 return current_traceframe_info
.get ();
3948 /* If the target supports the query, return in RESULT the set of
3949 collected memory in the current traceframe, found within the LEN
3950 bytes range starting at MEMADDR. Returns true if the target
3951 supports the query, otherwise returns false, and RESULT is left
3955 traceframe_available_memory (std::vector
<mem_range
> *result
,
3956 CORE_ADDR memaddr
, ULONGEST len
)
3958 struct traceframe_info
*info
= get_traceframe_info ();
3964 for (mem_range
&r
: info
->memory
)
3965 if (mem_ranges_overlap (r
.start
, r
.length
, memaddr
, len
))
3967 ULONGEST lo1
, hi1
, lo2
, hi2
;
3970 hi1
= memaddr
+ len
;
3973 hi2
= r
.start
+ r
.length
;
3975 CORE_ADDR start
= std::max (lo1
, lo2
);
3976 int length
= std::min (hi1
, hi2
) - start
;
3978 result
->emplace_back (start
, length
);
3981 normalize_mem_ranges (result
);
3988 /* Implementation of `sdata' variable. */
3990 static const struct internalvar_funcs sdata_funcs
=
3997 /* See tracepoint.h. */
3998 cmd_list_element
*while_stepping_cmd_element
= nullptr;
4000 /* module initialization */
4001 void _initialize_tracepoint ();
4003 _initialize_tracepoint ()
4005 struct cmd_list_element
*c
;
4007 /* Explicitly create without lookup, since that tries to create a
4008 value with a void typed value, and when we get here, gdbarch
4009 isn't initialized yet. At this point, we're quite sure there
4010 isn't another convenience variable of the same name. */
4011 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4013 traceframe_number
= -1;
4014 tracepoint_number
= -1;
4016 add_info ("scope", info_scope_command
,
4017 _("List the variables local to a scope."));
4019 add_cmd ("tracepoints", class_trace
,
4020 _("Tracing of program execution without stopping the program."),
4023 add_com ("tdump", class_trace
, tdump_command
,
4024 _("Print everything collected at the current tracepoint."));
4026 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4027 Define a trace state variable.\n\
4028 Argument is a $-prefixed name, optionally followed\n\
4029 by '=' and an expression that sets the initial value\n\
4030 at the start of tracing."));
4031 set_cmd_completer (c
, expression_completer
);
4033 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4034 Delete one or more trace state variables.\n\
4035 Arguments are the names of the variables to delete.\n\
4036 If no arguments are supplied, delete all variables."), &deletelist
);
4037 /* FIXME add a trace variable completer. */
4039 add_info ("tvariables", info_tvariables_command
, _("\
4040 Status of trace state variables and their values."));
4042 add_info ("static-tracepoint-markers",
4043 info_static_tracepoint_markers_command
, _("\
4044 List target static tracepoints markers."));
4046 add_prefix_cmd ("tfind", class_trace
, tfind_command
, _("\
4047 Select a trace frame.\n\
4048 No argument means forward by one frame; '-' means backward by one frame."),
4049 &tfindlist
, 1, &cmdlist
);
4051 add_cmd ("outside", class_trace
, tfind_outside_command
, _("\
4052 Select a trace frame whose PC is outside the given range (exclusive).\n\
4053 Usage: tfind outside ADDR1, ADDR2"),
4056 add_cmd ("range", class_trace
, tfind_range_command
, _("\
4057 Select a trace frame whose PC is in the given range (inclusive).\n\
4058 Usage: tfind range ADDR1, ADDR2"),
4061 add_cmd ("line", class_trace
, tfind_line_command
, _("\
4062 Select a trace frame by source line.\n\
4063 Argument can be a line number (with optional source file),\n\
4064 a function name, or '*' followed by an address.\n\
4065 Default argument is 'the next source line that was traced'."),
4068 add_cmd ("tracepoint", class_trace
, tfind_tracepoint_command
, _("\
4069 Select a trace frame by tracepoint number.\n\
4070 Default is the tracepoint for the current trace frame."),
4073 add_cmd ("pc", class_trace
, tfind_pc_command
, _("\
4074 Select a trace frame by PC.\n\
4075 Default is the current PC, or the PC of the current trace frame."),
4078 add_cmd ("end", class_trace
, tfind_end_command
, _("\
4079 De-select any trace frame and resume 'live' debugging."),
4082 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4084 add_cmd ("start", class_trace
, tfind_start_command
,
4085 _("Select the first trace frame in the trace buffer."),
4088 add_com ("tstatus", class_trace
, tstatus_command
,
4089 _("Display the status of the current trace data collection."));
4091 add_com ("tstop", class_trace
, tstop_command
, _("\
4092 Stop trace data collection.\n\
4093 Usage: tstop [NOTES]...\n\
4094 Any arguments supplied are recorded with the trace as a stop reason and\n\
4095 reported by tstatus (if the target supports trace notes)."));
4097 add_com ("tstart", class_trace
, tstart_command
, _("\
4098 Start trace data collection.\n\
4099 Usage: tstart [NOTES]...\n\
4100 Any arguments supplied are recorded with the trace as a note and\n\
4101 reported by tstatus (if the target supports trace notes)."));
4103 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4104 Ends a list of commands or actions.\n\
4105 Several GDB commands allow you to enter a list of commands or actions.\n\
4106 Entering \"end\" on a line by itself is the normal way to terminate\n\
4108 Note: the \"end\" command cannot be used at the gdb prompt."));
4110 while_stepping_cmd_element
= add_com ("while-stepping", class_trace
,
4111 while_stepping_pseudocommand
, _("\
4112 Specify single-stepping behavior at a tracepoint.\n\
4113 Argument is number of instructions to trace in single-step mode\n\
4114 following the tracepoint. This command is normally followed by\n\
4115 one or more \"collect\" commands, to specify what to collect\n\
4116 while single-stepping.\n\n\
4117 Note: this command can only be used in a tracepoint \"actions\" list."));
4119 add_com_alias ("ws", "while-stepping", class_trace
, 0);
4120 add_com_alias ("stepping", "while-stepping", class_trace
, 0);
4122 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4123 Specify one or more data items to be collected at a tracepoint.\n\
4124 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4125 collect all data (variables, registers) referenced by that expression.\n\
4126 Also accepts the following special arguments:\n\
4127 $regs -- all registers.\n\
4128 $args -- all function arguments.\n\
4129 $locals -- all variables local to the block/function scope.\n\
4130 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4131 Note: this command can only be used in a tracepoint \"actions\" list."));
4133 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4134 Specify one or more expressions to be evaluated at a tracepoint.\n\
4135 Accepts a comma-separated list of (one or more) expressions.\n\
4136 The result of each evaluation will be discarded.\n\
4137 Note: this command can only be used in a tracepoint \"actions\" list."));
4139 add_com ("actions", class_trace
, actions_command
, _("\
4140 Specify the actions to be taken at a tracepoint.\n\
4141 Tracepoint actions may include collecting of specified data,\n\
4142 single-stepping, or enabling/disabling other tracepoints,\n\
4143 depending on target's capabilities."));
4145 default_collect
= xstrdup ("");
4146 add_setshow_string_cmd ("default-collect", class_trace
,
4147 &default_collect
, _("\
4148 Set the list of expressions to collect by default."), _("\
4149 Show the list of expressions to collect by default."), NULL
,
4151 &setlist
, &showlist
);
4153 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4154 &disconnected_tracing
, _("\
4155 Set whether tracing continues after GDB disconnects."), _("\
4156 Show whether tracing continues after GDB disconnects."), _("\
4157 Use this to continue a tracing run even if GDB disconnects\n\
4158 or detaches from the target. You can reconnect later and look at\n\
4159 trace data collected in the meantime."),
4160 set_disconnected_tracing
,
4165 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4166 &circular_trace_buffer
, _("\
4167 Set target's use of circular trace buffer."), _("\
4168 Show target's use of circular trace buffer."), _("\
4169 Use this to make the trace buffer into a circular buffer,\n\
4170 which will discard traceframes (oldest first) instead of filling\n\
4171 up and stopping the trace run."),
4172 set_circular_trace_buffer
,
4177 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4178 &trace_buffer_size
, _("\
4179 Set requested size of trace buffer."), _("\
4180 Show requested size of trace buffer."), _("\
4181 Use this to choose a size for the trace buffer. Some targets\n\
4182 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4183 disables any attempt to set the buffer size and lets the target choose."),
4184 set_trace_buffer_size
, NULL
,
4185 &setlist
, &showlist
);
4187 add_setshow_string_cmd ("trace-user", class_trace
,
4189 Set the user name to use for current and future trace runs."), _("\
4190 Show the user name to use for current and future trace runs."), NULL
,
4191 set_trace_user
, NULL
,
4192 &setlist
, &showlist
);
4194 add_setshow_string_cmd ("trace-notes", class_trace
,
4196 Set notes string to use for current and future trace runs."), _("\
4197 Show the notes string to use for current and future trace runs."), NULL
,
4198 set_trace_notes
, NULL
,
4199 &setlist
, &showlist
);
4201 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4202 &trace_stop_notes
, _("\
4203 Set notes string to use for future tstop commands."), _("\
4204 Show the notes string to use for future tstop commands."), NULL
,
4205 set_trace_stop_notes
, NULL
,
4206 &setlist
, &showlist
);