1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2018 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"
55 #include "filestuff.h"
57 #include "tracefile.h"
61 /* readline include files */
62 #include "readline/readline.h"
63 #include "readline/history.h"
65 /* readline defines this. */
70 /* Maximum length of an agent aexpression.
71 This accounts for the fact that packets are limited to 400 bytes
72 (which includes everything -- including the checksum), and assumes
73 the worst case of maximum length for each of the pieces of a
76 NOTE: expressions get mem2hex'ed otherwise this would be twice as
77 large. (400 - 31)/2 == 184 */
78 #define MAX_AGENT_EXPR_LEN 184
80 /* A hook used to notify the UI of tracepoint operations. */
82 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
83 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
88 This module defines the following debugger commands:
89 trace : set a tracepoint on a function, line, or address.
90 info trace : list all debugger-defined tracepoints.
91 delete trace : delete one or more tracepoints.
92 enable trace : enable one or more tracepoints.
93 disable trace : disable one or more tracepoints.
94 actions : specify actions to be taken at a tracepoint.
95 passcount : specify a pass count for a tracepoint.
96 tstart : start a trace experiment.
97 tstop : stop a trace experiment.
98 tstatus : query the status of a trace experiment.
99 tfind : find a trace frame in the trace buffer.
100 tdump : print everything collected at the current tracepoint.
101 save-tracepoints : write tracepoint setup into a file.
103 This module defines the following user-visible debugger variables:
104 $trace_frame : sequence number of trace frame currently being debugged.
105 $trace_line : source line of trace frame currently being debugged.
106 $trace_file : source file of trace frame currently being debugged.
107 $tracepoint : tracepoint number of trace frame currently being debugged.
111 /* ======= Important global variables: ======= */
113 /* The list of all trace state variables. We don't retain pointers to
114 any of these for any reason - API is by name or number only - so it
115 works to have a vector of objects. */
117 static std::vector
<trace_state_variable
> tvariables
;
119 /* The next integer to assign to a variable. */
121 static int next_tsv_number
= 1;
123 /* Number of last traceframe collected. */
124 static int traceframe_number
;
126 /* Tracepoint for last traceframe collected. */
127 static int tracepoint_number
;
129 /* The traceframe info of the current traceframe. NULL if we haven't
130 yet attempted to fetch it, or if the target does not support
131 fetching this object, or if we're not inspecting a traceframe
133 static traceframe_info_up current_traceframe_info
;
135 /* Tracing command lists. */
136 static struct cmd_list_element
*tfindlist
;
138 /* List of expressions to collect by default at each tracepoint hit. */
139 char *default_collect
;
141 static int disconnected_tracing
;
143 /* This variable controls whether we ask the target for a linear or
144 circular trace buffer. */
146 static int circular_trace_buffer
;
148 /* This variable is the requested trace buffer size, or -1 to indicate
149 that we don't care and leave it up to the target to set a size. */
151 static int trace_buffer_size
= -1;
153 /* Textual notes applying to the current and/or future trace runs. */
155 char *trace_user
= NULL
;
157 /* Textual notes applying to the current and/or future trace runs. */
159 char *trace_notes
= NULL
;
161 /* Textual notes applying to the stopping of a trace. */
163 char *trace_stop_notes
= NULL
;
165 /* support routines */
167 struct collection_list
;
168 static char *mem2hex (gdb_byte
*, char *, int);
170 static struct command_line
*
171 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
173 static struct trace_status trace_status
;
175 const char *stop_reason_names
[] = {
185 struct trace_status
*
186 current_trace_status (void)
188 return &trace_status
;
191 /* Free and clear the traceframe info cache of the current
195 clear_traceframe_info (void)
197 current_traceframe_info
= NULL
;
200 /* Set traceframe number to NUM. */
202 set_traceframe_num (int num
)
204 traceframe_number
= num
;
205 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
208 /* Set tracepoint number to NUM. */
210 set_tracepoint_num (int num
)
212 tracepoint_number
= num
;
213 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
216 /* Set externally visible debug variables for querying/printing
217 the traceframe context (line, function, file). */
220 set_traceframe_context (struct frame_info
*trace_frame
)
223 struct symbol
*traceframe_fun
;
224 symtab_and_line traceframe_sal
;
226 /* Save as globals for internal use. */
227 if (trace_frame
!= NULL
228 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
230 traceframe_sal
= find_pc_line (trace_pc
, 0);
231 traceframe_fun
= find_pc_function (trace_pc
);
233 /* Save linenumber as "$trace_line", a debugger variable visible to
235 set_internalvar_integer (lookup_internalvar ("trace_line"),
236 traceframe_sal
.line
);
240 traceframe_fun
= NULL
;
241 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
244 /* Save func name as "$trace_func", a debugger variable visible to
246 if (traceframe_fun
== NULL
247 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
248 clear_internalvar (lookup_internalvar ("trace_func"));
250 set_internalvar_string (lookup_internalvar ("trace_func"),
251 SYMBOL_LINKAGE_NAME (traceframe_fun
));
253 /* Save file name as "$trace_file", a debugger variable visible to
255 if (traceframe_sal
.symtab
== NULL
)
256 clear_internalvar (lookup_internalvar ("trace_file"));
258 set_internalvar_string (lookup_internalvar ("trace_file"),
259 symtab_to_filename_for_display (traceframe_sal
.symtab
));
262 /* Create a new trace state variable with the given name. */
264 struct trace_state_variable
*
265 create_trace_state_variable (const char *name
)
267 tvariables
.emplace_back (name
, next_tsv_number
++);
268 return &tvariables
.back ();
271 /* Look for a trace state variable of the given name. */
273 struct trace_state_variable
*
274 find_trace_state_variable (const char *name
)
276 for (trace_state_variable
&tsv
: tvariables
)
277 if (tsv
.name
== name
)
283 /* Look for a trace state variable of the given number. Return NULL if
286 struct trace_state_variable
*
287 find_trace_state_variable_by_number (int number
)
289 for (trace_state_variable
&tsv
: tvariables
)
290 if (tsv
.number
== number
)
297 delete_trace_state_variable (const char *name
)
299 for (auto it
= tvariables
.begin (); it
!= tvariables
.end (); it
++)
300 if (it
->name
== name
)
302 gdb::observers::tsv_deleted
.notify (&*it
);
303 tvariables
.erase (it
);
307 warning (_("No trace variable named \"$%s\", not deleting"), name
);
310 /* Throws an error if NAME is not valid syntax for a trace state
314 validate_trace_state_variable_name (const char *name
)
319 error (_("Must supply a non-empty variable name"));
321 /* All digits in the name is reserved for value history
323 for (p
= name
; isdigit (*p
); p
++)
326 error (_("$%s is not a valid trace state variable name"), name
);
328 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
331 error (_("$%s is not a valid trace state variable name"), name
);
334 /* The 'tvariable' command collects a name and optional expression to
335 evaluate into an initial value. */
338 trace_variable_command (const char *args
, int from_tty
)
341 struct trace_state_variable
*tsv
;
342 const char *name_start
, *p
;
345 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
347 /* Only allow two syntaxes; "$name" and "$name=value". */
348 p
= skip_spaces (args
);
351 error (_("Name of trace variable should start with '$'"));
354 while (isalnum (*p
) || *p
== '_')
356 std::string
name (name_start
, p
- name_start
);
359 if (*p
!= '=' && *p
!= '\0')
360 error (_("Syntax must be $NAME [ = EXPR ]"));
362 validate_trace_state_variable_name (name
.c_str ());
365 initval
= value_as_long (parse_and_eval (++p
));
367 /* If the variable already exists, just change its initial value. */
368 tsv
= find_trace_state_variable (name
.c_str ());
371 if (tsv
->initial_value
!= initval
)
373 tsv
->initial_value
= initval
;
374 gdb::observers::tsv_modified
.notify (tsv
);
376 printf_filtered (_("Trace state variable $%s "
377 "now has initial value %s.\n"),
378 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
382 /* Create a new variable. */
383 tsv
= create_trace_state_variable (name
.c_str ());
384 tsv
->initial_value
= initval
;
386 gdb::observers::tsv_created
.notify (tsv
);
388 printf_filtered (_("Trace state variable $%s "
389 "created, with initial value %s.\n"),
390 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
394 delete_trace_variable_command (const char *args
, int from_tty
)
398 if (query (_("Delete all trace state variables? ")))
401 gdb::observers::tsv_deleted
.notify (NULL
);
405 gdb_argv
argv (args
);
407 for (char *arg
: argv
)
410 delete_trace_state_variable (arg
+ 1);
412 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg
);
419 tvariables_info_1 (void)
421 struct ui_out
*uiout
= current_uiout
;
423 /* Try to acquire values from the target. */
424 for (trace_state_variable
&tsv
: tvariables
)
426 = target_get_trace_state_variable_value (tsv
.number
, &tsv
.value
);
429 ui_out_emit_table
table_emitter (uiout
, 3, tvariables
.size (),
431 uiout
->table_header (15, ui_left
, "name", "Name");
432 uiout
->table_header (11, ui_left
, "initial", "Initial");
433 uiout
->table_header (11, ui_left
, "current", "Current");
435 uiout
->table_body ();
437 for (const trace_state_variable
&tsv
: tvariables
)
441 ui_out_emit_tuple
tuple_emitter (uiout
, "variable");
443 uiout
->field_string ("name", std::string ("$") + tsv
.name
);
444 uiout
->field_string ("initial", plongest (tsv
.initial_value
));
447 c
= plongest (tsv
.value
);
448 else if (uiout
->is_mi_like_p ())
449 /* For MI, we prefer not to use magic string constants, but rather
450 omit the field completely. The difference between unknown and
451 undefined does not seem important enough to represent. */
453 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
454 /* The value is/was defined, but we don't have it. */
457 /* It is not meaningful to ask about the value. */
460 uiout
->field_string ("current", c
);
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 command_line_up l
= read_command_lines (&tmpbuf
[0], from_tty
, 1,
582 check_tracepoint_command
, t
);
583 breakpoint_set_commands (t
, std::move (l
));
585 /* else just return */
588 /* Report the results of checking the agent expression, as errors or
592 report_agent_reqs_errors (struct agent_expr
*aexpr
)
594 /* All of the "flaws" are serious bytecode generation issues that
595 should never occur. */
596 if (aexpr
->flaw
!= agent_flaw_none
)
597 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
599 /* If analysis shows a stack underflow, GDB must have done something
600 badly wrong in its bytecode generation. */
601 if (aexpr
->min_height
< 0)
602 internal_error (__FILE__
, __LINE__
,
603 _("expression has min height < 0"));
605 /* Issue this error if the stack is predicted to get too deep. The
606 limit is rather arbitrary; a better scheme might be for the
607 target to report how much stack it will have available. The
608 depth roughly corresponds to parenthesization, so a limit of 20
609 amounts to 20 levels of expression nesting, which is actually
610 a pretty big hairy expression. */
611 if (aexpr
->max_height
> 20)
612 error (_("Expression is too complicated."));
615 /* worker function */
617 validate_actionline (const char *line
, struct breakpoint
*b
)
619 struct cmd_list_element
*c
;
622 struct bp_location
*loc
;
623 struct tracepoint
*t
= (struct tracepoint
*) b
;
625 /* If EOF is typed, *line is NULL. */
629 p
= skip_spaces (line
);
631 /* Symbol lookup etc. */
632 if (*p
== '\0') /* empty line: just prompt for another line. */
635 if (*p
== '#') /* comment line */
638 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
640 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
642 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
644 int trace_string
= 0;
647 p
= decode_agent_options (p
, &trace_string
);
650 { /* Repeat over a comma-separated list. */
651 QUIT
; /* Allow user to bail out with ^C. */
654 if (*p
== '$') /* Look for special pseudo-symbols. */
656 if (0 == strncasecmp ("reg", p
+ 1, 3)
657 || 0 == strncasecmp ("arg", p
+ 1, 3)
658 || 0 == strncasecmp ("loc", p
+ 1, 3)
659 || 0 == strncasecmp ("_ret", p
+ 1, 4)
660 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
665 /* else fall thru, treat p as an expression and parse it! */
668 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
671 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
672 block_for_pc (loc
->address
), 1);
674 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
676 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
678 error (_("constant `%s' (value %s) "
679 "will not be collected."),
680 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
681 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
683 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
684 == LOC_OPTIMIZED_OUT
)
686 error (_("`%s' is optimized away "
687 "and cannot be collected."),
688 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
692 /* We have something to collect, make sure that the expr to
693 bytecode translator can handle it and that it's not too
695 agent_expr_up aexpr
= gen_trace_for_expr (loc
->address
,
699 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
700 error (_("Expression is too complicated."));
702 ax_reqs (aexpr
.get ());
704 report_agent_reqs_errors (aexpr
.get ());
707 while (p
&& *p
++ == ',');
710 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
713 { /* Repeat over a comma-separated list. */
714 QUIT
; /* Allow user to bail out with ^C. */
718 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
722 /* Only expressions are allowed for this action. */
723 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
724 block_for_pc (loc
->address
), 1);
726 /* We have something to evaluate, make sure that the expr to
727 bytecode translator can handle it and that it's not too
729 agent_expr_up aexpr
= gen_eval_for_expr (loc
->address
, exp
.get ());
731 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
732 error (_("Expression is too complicated."));
734 ax_reqs (aexpr
.get ());
735 report_agent_reqs_errors (aexpr
.get ());
738 while (p
&& *p
++ == ',');
741 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
746 t
->step_count
= strtol (p
, &endp
, 0);
747 if (endp
== p
|| t
->step_count
== 0)
748 error (_("while-stepping step count `%s' is malformed."), line
);
752 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
756 error (_("`%s' is not a supported tracepoint action."), line
);
760 memrange_absolute
= -1
763 /* MEMRANGE functions: */
765 /* Compare memranges for std::sort. */
768 memrange_comp (const memrange
&a
, const memrange
&b
)
770 if (a
.type
== b
.type
)
772 if (a
.type
== memrange_absolute
)
773 return (bfd_vma
) a
.start
< (bfd_vma
) b
.start
;
775 return a
.start
< b
.start
;
778 return a
.type
< b
.type
;
781 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
784 memrange_sortmerge (std::vector
<memrange
> &memranges
)
786 if (!memranges
.empty ())
790 std::sort (memranges
.begin (), memranges
.end (), memrange_comp
);
792 for (a
= 0, b
= 1; b
< memranges
.size (); b
++)
794 /* If memrange b overlaps or is adjacent to memrange a,
796 if (memranges
[a
].type
== memranges
[b
].type
797 && memranges
[b
].start
<= memranges
[a
].end
)
799 if (memranges
[b
].end
> memranges
[a
].end
)
800 memranges
[a
].end
= memranges
[b
].end
;
801 continue; /* next b, same a */
805 memranges
[a
] = memranges
[b
];
807 memranges
.resize (a
+ 1);
811 /* Add a register to a collection list. */
814 collection_list::add_register (unsigned int regno
)
817 printf_filtered ("collect register %d\n", regno
);
818 if (regno
>= (8 * sizeof (m_regs_mask
)))
819 error (_("Internal: register number %d too large for tracepoint"),
821 m_regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
824 /* Add a memrange to a collection list. */
827 collection_list::add_memrange (struct gdbarch
*gdbarch
,
828 int type
, bfd_signed_vma base
,
832 printf_filtered ("(%d,%s,%ld)\n", type
, paddress (gdbarch
, base
), len
);
834 /* type: memrange_absolute == memory, other n == basereg */
835 /* base: addr if memory, offset if reg relative. */
836 /* len: we actually save end (base + len) for convenience */
837 m_memranges
.emplace_back (type
, base
, base
+ len
);
839 if (type
!= memrange_absolute
) /* Better collect the base register! */
843 /* Add a symbol to a collection list. */
846 collection_list::collect_symbol (struct symbol
*sym
,
847 struct gdbarch
*gdbarch
,
848 long frame_regno
, long frame_offset
,
854 bfd_signed_vma offset
;
855 int treat_as_expr
= 0;
857 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
858 switch (SYMBOL_CLASS (sym
))
861 printf_filtered ("%s: don't know symbol class %d\n",
862 SYMBOL_PRINT_NAME (sym
),
866 printf_filtered ("constant %s (value %s) will not be collected.\n",
867 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
870 offset
= SYMBOL_VALUE_ADDRESS (sym
);
873 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
874 SYMBOL_PRINT_NAME (sym
), len
,
875 paddress (gdbarch
, offset
));
877 /* A struct may be a C++ class with static fields, go to general
878 expression handling. */
879 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
882 add_memrange (gdbarch
, memrange_absolute
, offset
, len
);
885 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
887 printf_filtered ("LOC_REG[parm] %s: ",
888 SYMBOL_PRINT_NAME (sym
));
890 /* Check for doubles stored in two registers. */
891 /* FIXME: how about larger types stored in 3 or more regs? */
892 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
893 len
> register_size (gdbarch
, reg
))
894 add_register (reg
+ 1);
897 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
898 printf_filtered (" (will not collect %s)\n",
899 SYMBOL_PRINT_NAME (sym
));
903 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
906 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
907 " from frame ptr reg %d\n",
908 SYMBOL_PRINT_NAME (sym
), len
,
909 paddress (gdbarch
, offset
), reg
);
911 add_memrange (gdbarch
, reg
, offset
, len
);
913 case LOC_REGPARM_ADDR
:
914 reg
= SYMBOL_VALUE (sym
);
918 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
920 SYMBOL_PRINT_NAME (sym
), len
,
921 paddress (gdbarch
, offset
), reg
);
923 add_memrange (gdbarch
, reg
, offset
, len
);
927 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
930 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
931 " from frame ptr reg %d\n",
932 SYMBOL_PRINT_NAME (sym
), len
,
933 paddress (gdbarch
, offset
), reg
);
935 add_memrange (gdbarch
, reg
, offset
, len
);
942 case LOC_OPTIMIZED_OUT
:
943 printf_filtered ("%s has been optimized out of existence.\n",
944 SYMBOL_PRINT_NAME (sym
));
952 /* Expressions are the most general case. */
955 agent_expr_up aexpr
= gen_trace_for_var (scope
, gdbarch
,
958 /* It can happen that the symbol is recorded as a computed
959 location, but it's been optimized away and doesn't actually
960 have a location expression. */
963 printf_filtered ("%s has been optimized out of existence.\n",
964 SYMBOL_PRINT_NAME (sym
));
968 ax_reqs (aexpr
.get ());
970 report_agent_reqs_errors (aexpr
.get ());
972 /* Take care of the registers. */
973 if (aexpr
->reg_mask_len
> 0)
975 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
977 QUIT
; /* Allow user to bail out with ^C. */
978 if (aexpr
->reg_mask
[ndx1
] != 0)
980 /* Assume chars have 8 bits. */
981 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
982 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
983 /* It's used -- record it. */
984 add_register (ndx1
* 8 + ndx2
);
989 add_aexpr (std::move (aexpr
));
993 /* Data to be passed around in the calls to the locals and args
996 struct add_local_symbols_data
998 struct collection_list
*collect
;
999 struct gdbarch
*gdbarch
;
1007 /* The callback for the locals and args iterators. */
1010 do_collect_symbol (const char *print_name
,
1014 struct add_local_symbols_data
*p
= (struct add_local_symbols_data
*) cb_data
;
1016 p
->collect
->collect_symbol (sym
, p
->gdbarch
, p
->frame_regno
,
1017 p
->frame_offset
, p
->pc
, p
->trace_string
);
1020 p
->collect
->add_wholly_collected (print_name
);
1024 collection_list::add_wholly_collected (const char *print_name
)
1026 m_wholly_collected
.push_back (print_name
);
1029 /* Add all locals (or args) symbols to collection list. */
1032 collection_list::add_local_symbols (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1033 long frame_regno
, long frame_offset
, int type
,
1036 const struct block
*block
;
1037 struct add_local_symbols_data cb_data
;
1039 cb_data
.collect
= this;
1040 cb_data
.gdbarch
= gdbarch
;
1042 cb_data
.frame_regno
= frame_regno
;
1043 cb_data
.frame_offset
= frame_offset
;
1045 cb_data
.trace_string
= trace_string
;
1049 block
= block_for_pc (pc
);
1052 warning (_("Can't collect locals; "
1053 "no symbol table info available.\n"));
1057 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1058 if (cb_data
.count
== 0)
1059 warning (_("No locals found in scope."));
1063 pc
= get_pc_function_start (pc
);
1064 block
= block_for_pc (pc
);
1067 warning (_("Can't collect args; no symbol table info available."));
1071 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1072 if (cb_data
.count
== 0)
1073 warning (_("No args found in scope."));
1078 collection_list::add_static_trace_data ()
1081 printf_filtered ("collect static trace data\n");
1082 m_strace_data
= true;
1085 collection_list::collection_list ()
1087 m_strace_data (false)
1089 m_memranges
.reserve (128);
1090 m_aexprs
.reserve (128);
1093 /* Reduce a collection list to string form (for gdb protocol). */
1095 std::vector
<std::string
>
1096 collection_list::stringify ()
1098 char temp_buf
[2048];
1102 std::vector
<std::string
> str_list
;
1107 printf_filtered ("\nCollecting static trace data\n");
1110 str_list
.emplace_back (temp_buf
, end
- temp_buf
);
1113 for (i
= sizeof (m_regs_mask
) - 1; i
> 0; i
--)
1114 if (m_regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1116 if (m_regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1119 printf_filtered ("\nCollecting registers (mask): 0x");
1124 QUIT
; /* Allow user to bail out with ^C. */
1126 printf_filtered ("%02X", m_regs_mask
[i
]);
1127 sprintf (end
, "%02X", m_regs_mask
[i
]);
1130 str_list
.emplace_back (temp_buf
);
1133 printf_filtered ("\n");
1134 if (!m_memranges
.empty () && info_verbose
)
1135 printf_filtered ("Collecting memranges: \n");
1136 for (i
= 0, count
= 0, end
= temp_buf
; i
< m_memranges
.size (); i
++)
1138 QUIT
; /* Allow user to bail out with ^C. */
1141 printf_filtered ("(%d, %s, %ld)\n",
1142 m_memranges
[i
].type
,
1143 paddress (target_gdbarch (),
1144 m_memranges
[i
].start
),
1145 (long) (m_memranges
[i
].end
1146 - m_memranges
[i
].start
));
1148 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1150 str_list
.emplace_back (temp_buf
, count
);
1156 bfd_signed_vma length
1157 = m_memranges
[i
].end
- m_memranges
[i
].start
;
1159 /* The "%X" conversion specifier expects an unsigned argument,
1160 so passing -1 (memrange_absolute) to it directly gives you
1161 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1163 if (m_memranges
[i
].type
== memrange_absolute
)
1164 sprintf (end
, "M-1,%s,%lX", phex_nz (m_memranges
[i
].start
, 0),
1167 sprintf (end
, "M%X,%s,%lX", m_memranges
[i
].type
,
1168 phex_nz (m_memranges
[i
].start
, 0), (long) length
);
1171 count
+= strlen (end
);
1172 end
= temp_buf
+ count
;
1175 for (i
= 0; i
< m_aexprs
.size (); i
++)
1177 QUIT
; /* Allow user to bail out with ^C. */
1178 if ((count
+ 10 + 2 * m_aexprs
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1180 str_list
.emplace_back (temp_buf
, count
);
1184 sprintf (end
, "X%08X,", m_aexprs
[i
]->len
);
1185 end
+= 10; /* 'X' + 8 hex digits + ',' */
1188 end
= mem2hex (m_aexprs
[i
]->buf
, end
, m_aexprs
[i
]->len
);
1189 count
+= 2 * m_aexprs
[i
]->len
;
1194 str_list
.emplace_back (temp_buf
, count
);
1202 /* Add the printed expression EXP to *LIST. */
1205 collection_list::append_exp (struct expression
*exp
)
1207 string_file tmp_stream
;
1209 print_expression (exp
, &tmp_stream
);
1211 m_computed
.push_back (std::move (tmp_stream
.string ()));
1215 collection_list::finish ()
1217 memrange_sortmerge (m_memranges
);
1221 encode_actions_1 (struct command_line
*action
,
1222 struct bp_location
*tloc
,
1224 LONGEST frame_offset
,
1225 struct collection_list
*collect
,
1226 struct collection_list
*stepping_list
)
1228 const char *action_exp
;
1230 struct value
*tempval
;
1231 struct cmd_list_element
*cmd
;
1233 for (; action
; action
= action
->next
)
1235 QUIT
; /* Allow user to bail out with ^C. */
1236 action_exp
= action
->line
;
1237 action_exp
= skip_spaces (action_exp
);
1239 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1241 error (_("Bad action list item: %s"), action_exp
);
1243 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1245 int trace_string
= 0;
1247 if (*action_exp
== '/')
1248 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1251 { /* Repeat over a comma-separated list. */
1252 QUIT
; /* Allow user to bail out with ^C. */
1253 action_exp
= skip_spaces (action_exp
);
1255 if (0 == strncasecmp ("$reg", action_exp
, 4))
1257 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
1258 collect
->add_register (i
);
1259 action_exp
= strchr (action_exp
, ','); /* more? */
1261 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1263 collect
->add_local_symbols (target_gdbarch (),
1269 action_exp
= strchr (action_exp
, ','); /* more? */
1271 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1273 collect
->add_local_symbols (target_gdbarch (),
1279 action_exp
= strchr (action_exp
, ','); /* more? */
1281 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1284 = gen_trace_for_return_address (tloc
->address
,
1288 ax_reqs (aexpr
.get ());
1289 report_agent_reqs_errors (aexpr
.get ());
1291 /* take care of the registers */
1292 if (aexpr
->reg_mask_len
> 0)
1294 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1296 QUIT
; /* allow user to bail out with ^C */
1297 if (aexpr
->reg_mask
[ndx1
] != 0)
1299 /* assume chars have 8 bits */
1300 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1301 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1303 /* It's used -- record it. */
1304 collect
->add_register (ndx1
* 8 + ndx2
);
1310 collect
->add_aexpr (std::move (aexpr
));
1311 action_exp
= strchr (action_exp
, ','); /* more? */
1313 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1315 collect
->add_static_trace_data ();
1316 action_exp
= strchr (action_exp
, ','); /* more? */
1322 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1323 block_for_pc (tloc
->address
),
1326 switch (exp
->elts
[0].opcode
)
1330 const char *name
= &exp
->elts
[2].string
;
1332 i
= user_reg_map_name_to_regnum (target_gdbarch (),
1333 name
, strlen (name
));
1335 internal_error (__FILE__
, __LINE__
,
1336 _("Register $%s not available"),
1339 printf_filtered ("OP_REGISTER: ");
1340 collect
->add_register (i
);
1345 /* Safe because we know it's a simple expression. */
1346 tempval
= evaluate_expression (exp
.get ());
1347 addr
= value_address (tempval
);
1348 /* Initialize the TYPE_LENGTH if it is a typedef. */
1349 check_typedef (exp
->elts
[1].type
);
1350 collect
->add_memrange (target_gdbarch (),
1351 memrange_absolute
, addr
,
1352 TYPE_LENGTH (exp
->elts
[1].type
));
1353 collect
->append_exp (exp
.get ());
1358 struct symbol
*sym
= exp
->elts
[2].symbol
;
1359 const char *name
= SYMBOL_NATURAL_NAME (sym
);
1361 collect
->collect_symbol (exp
->elts
[2].symbol
,
1367 collect
->add_wholly_collected (name
);
1371 default: /* Full-fledged expression. */
1372 agent_expr_up aexpr
= gen_trace_for_expr (tloc
->address
,
1376 ax_reqs (aexpr
.get ());
1378 report_agent_reqs_errors (aexpr
.get ());
1380 /* Take care of the registers. */
1381 if (aexpr
->reg_mask_len
> 0)
1383 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1385 QUIT
; /* Allow user to bail out with ^C. */
1386 if (aexpr
->reg_mask
[ndx1
] != 0)
1388 /* Assume chars have 8 bits. */
1389 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1390 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1392 /* It's used -- record it. */
1393 collect
->add_register (ndx1
* 8 + ndx2
);
1399 collect
->add_aexpr (std::move (aexpr
));
1400 collect
->append_exp (exp
.get ());
1405 while (action_exp
&& *action_exp
++ == ',');
1407 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1410 { /* Repeat over a comma-separated list. */
1411 QUIT
; /* Allow user to bail out with ^C. */
1412 action_exp
= skip_spaces (action_exp
);
1415 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1416 block_for_pc (tloc
->address
),
1419 agent_expr_up aexpr
= gen_eval_for_expr (tloc
->address
,
1422 ax_reqs (aexpr
.get ());
1423 report_agent_reqs_errors (aexpr
.get ());
1425 /* Even though we're not officially collecting, add
1426 to the collect list anyway. */
1427 collect
->add_aexpr (std::move (aexpr
));
1430 while (action_exp
&& *action_exp
++ == ',');
1432 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1434 /* We check against nested while-stepping when setting
1435 breakpoint action, so no way to run into nested
1437 gdb_assert (stepping_list
);
1439 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1440 frame_offset
, stepping_list
, NULL
);
1443 error (_("Invalid tracepoint command '%s'"), action
->line
);
1447 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1448 and STEPPING_LIST. */
1451 encode_actions (struct bp_location
*tloc
,
1452 struct collection_list
*tracepoint_list
,
1453 struct collection_list
*stepping_list
)
1455 struct command_line
*actions
;
1457 LONGEST frame_offset
;
1459 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1460 tloc
->address
, &frame_reg
, &frame_offset
);
1462 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1464 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1465 tracepoint_list
, stepping_list
);
1467 tracepoint_list
->finish ();
1468 stepping_list
->finish ();
1471 /* Render all actions into gdb protocol. */
1474 encode_actions_rsp (struct bp_location
*tloc
,
1475 std::vector
<std::string
> *tdp_actions
,
1476 std::vector
<std::string
> *stepping_actions
)
1478 struct collection_list tracepoint_list
, stepping_list
;
1480 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
1482 *tdp_actions
= tracepoint_list
.stringify ();
1483 *stepping_actions
= stepping_list
.stringify ();
1487 collection_list::add_aexpr (agent_expr_up aexpr
)
1489 m_aexprs
.push_back (std::move (aexpr
));
1493 process_tracepoint_on_disconnect (void)
1495 VEC(breakpoint_p
) *tp_vec
= NULL
;
1497 struct breakpoint
*b
;
1498 int has_pending_p
= 0;
1500 /* Check whether we still have pending tracepoint. If we have, warn the
1501 user that pending tracepoint will no longer work. */
1502 tp_vec
= all_tracepoints ();
1503 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1512 struct bp_location
*loc1
;
1514 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1516 if (loc1
->shlib_disabled
)
1527 VEC_free (breakpoint_p
, tp_vec
);
1530 warning (_("Pending tracepoints will not be resolved while"
1531 " GDB is disconnected\n"));
1534 /* Reset local state of tracing. */
1537 trace_reset_local_state (void)
1539 set_traceframe_num (-1);
1540 set_tracepoint_num (-1);
1541 set_traceframe_context (NULL
);
1542 clear_traceframe_info ();
1546 start_tracing (const char *notes
)
1548 VEC(breakpoint_p
) *tp_vec
= NULL
;
1550 struct breakpoint
*b
;
1551 struct trace_state_variable
*tsv
;
1552 int any_enabled
= 0, num_to_download
= 0;
1555 tp_vec
= all_tracepoints ();
1557 /* No point in tracing without any tracepoints... */
1558 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1560 VEC_free (breakpoint_p
, tp_vec
);
1561 error (_("No tracepoints defined, not starting trace"));
1564 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1566 if (b
->enable_state
== bp_enabled
)
1569 if ((b
->type
== bp_fast_tracepoint
1570 ? may_insert_fast_tracepoints
1571 : may_insert_tracepoints
))
1574 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1575 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1580 if (target_supports_enable_disable_tracepoint ())
1581 warning (_("No tracepoints enabled"));
1584 /* No point in tracing with only disabled tracepoints that
1585 cannot be re-enabled. */
1586 VEC_free (breakpoint_p
, tp_vec
);
1587 error (_("No tracepoints enabled, not starting trace"));
1591 if (num_to_download
<= 0)
1593 VEC_free (breakpoint_p
, tp_vec
);
1594 error (_("No tracepoints that may be downloaded, not starting trace"));
1597 target_trace_init ();
1599 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1601 struct tracepoint
*t
= (struct tracepoint
*) b
;
1602 struct bp_location
*loc
;
1603 int bp_location_downloaded
= 0;
1605 /* Clear `inserted' flag. */
1606 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1609 if ((b
->type
== bp_fast_tracepoint
1610 ? !may_insert_fast_tracepoints
1611 : !may_insert_tracepoints
))
1614 t
->number_on_target
= 0;
1616 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1618 /* Since tracepoint locations are never duplicated, `inserted'
1619 flag should be zero. */
1620 gdb_assert (!loc
->inserted
);
1622 target_download_tracepoint (loc
);
1625 bp_location_downloaded
= 1;
1628 t
->number_on_target
= b
->number
;
1630 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1631 if (loc
->probe
.prob
!= NULL
)
1632 loc
->probe
.prob
->set_semaphore (loc
->probe
.objfile
,
1635 if (bp_location_downloaded
)
1636 gdb::observers::breakpoint_modified
.notify (b
);
1638 VEC_free (breakpoint_p
, tp_vec
);
1640 /* Send down all the trace state variables too. */
1641 for (const trace_state_variable
&tsv
: tvariables
)
1642 target_download_trace_state_variable (tsv
);
1644 /* Tell target to treat text-like sections as transparent. */
1645 target_trace_set_readonly_regions ();
1646 /* Set some mode flags. */
1647 target_set_disconnected_tracing (disconnected_tracing
);
1648 target_set_circular_trace_buffer (circular_trace_buffer
);
1649 target_set_trace_buffer_size (trace_buffer_size
);
1652 notes
= trace_notes
;
1653 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1655 if (!ret
&& (trace_user
|| notes
))
1656 warning (_("Target does not support trace user/notes, info ignored"));
1658 /* Now insert traps and begin collecting data. */
1659 target_trace_start ();
1661 /* Reset our local state. */
1662 trace_reset_local_state ();
1663 current_trace_status()->running
= 1;
1666 /* The tstart command requests the target to start a new trace run.
1667 The command passes any arguments it has to the target verbatim, as
1668 an optional "trace note". This is useful as for instance a warning
1669 to other users if the trace runs disconnected, and you don't want
1670 anybody else messing with the target. */
1673 tstart_command (const char *args
, int from_tty
)
1675 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1677 if (current_trace_status ()->running
)
1680 && !query (_("A trace is running already. Start a new run? ")))
1681 error (_("New trace run not started."));
1684 start_tracing (args
);
1687 /* The tstop command stops the tracing run. The command passes any
1688 supplied arguments to the target verbatim as a "stop note"; if the
1689 target supports trace notes, then it will be reported back as part
1690 of the trace run's status. */
1693 tstop_command (const char *args
, int from_tty
)
1695 if (!current_trace_status ()->running
)
1696 error (_("Trace is not running."));
1698 stop_tracing (args
);
1702 stop_tracing (const char *note
)
1705 VEC(breakpoint_p
) *tp_vec
= NULL
;
1707 struct breakpoint
*t
;
1709 target_trace_stop ();
1711 tp_vec
= all_tracepoints ();
1712 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1714 struct bp_location
*loc
;
1716 if ((t
->type
== bp_fast_tracepoint
1717 ? !may_insert_fast_tracepoints
1718 : !may_insert_tracepoints
))
1721 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1723 /* GDB can be totally absent in some disconnected trace scenarios,
1724 but we don't really care if this semaphore goes out of sync.
1725 That's why we are decrementing it here, but not taking care
1727 if (loc
->probe
.prob
!= NULL
)
1728 loc
->probe
.prob
->clear_semaphore (loc
->probe
.objfile
,
1733 VEC_free (breakpoint_p
, tp_vec
);
1736 note
= trace_stop_notes
;
1737 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1740 warning (_("Target does not support trace notes, note ignored"));
1742 /* Should change in response to reply? */
1743 current_trace_status ()->running
= 0;
1746 /* tstatus command */
1748 tstatus_command (const char *args
, int from_tty
)
1750 struct trace_status
*ts
= current_trace_status ();
1752 VEC(breakpoint_p
) *tp_vec
= NULL
;
1753 struct breakpoint
*t
;
1755 status
= target_get_trace_status (ts
);
1759 if (ts
->filename
!= NULL
)
1760 printf_filtered (_("Using a trace file.\n"));
1763 printf_filtered (_("Trace can not be run on this target.\n"));
1768 if (!ts
->running_known
)
1770 printf_filtered (_("Run/stop status is unknown.\n"));
1772 else if (ts
->running
)
1774 printf_filtered (_("Trace is running on the target.\n"));
1778 switch (ts
->stop_reason
)
1780 case trace_never_run
:
1781 printf_filtered (_("No trace has been run on the target.\n"));
1783 case trace_stop_command
:
1785 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1788 printf_filtered (_("Trace stopped by a tstop command.\n"));
1790 case trace_buffer_full
:
1791 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1793 case trace_disconnected
:
1794 printf_filtered (_("Trace stopped because of disconnection.\n"));
1796 case tracepoint_passcount
:
1797 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1798 ts
->stopping_tracepoint
);
1800 case tracepoint_error
:
1801 if (ts
->stopping_tracepoint
)
1802 printf_filtered (_("Trace stopped by an "
1803 "error (%s, tracepoint %d).\n"),
1804 ts
->stop_desc
, ts
->stopping_tracepoint
);
1806 printf_filtered (_("Trace stopped by an error (%s).\n"),
1809 case trace_stop_reason_unknown
:
1810 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1813 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1819 if (ts
->traceframes_created
>= 0
1820 && ts
->traceframe_count
!= ts
->traceframes_created
)
1822 printf_filtered (_("Buffer contains %d trace "
1823 "frames (of %d created total).\n"),
1824 ts
->traceframe_count
, ts
->traceframes_created
);
1826 else if (ts
->traceframe_count
>= 0)
1828 printf_filtered (_("Collected %d trace frames.\n"),
1829 ts
->traceframe_count
);
1832 if (ts
->buffer_free
>= 0)
1834 if (ts
->buffer_size
>= 0)
1836 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1837 ts
->buffer_free
, ts
->buffer_size
);
1838 if (ts
->buffer_size
> 0)
1839 printf_filtered (_(" (%d%% full)"),
1840 ((int) ((((long long) (ts
->buffer_size
1841 - ts
->buffer_free
)) * 100)
1842 / ts
->buffer_size
)));
1843 printf_filtered (_(".\n"));
1846 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1850 if (ts
->disconnected_tracing
)
1851 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1853 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1855 if (ts
->circular_buffer
)
1856 printf_filtered (_("Trace buffer is circular.\n"));
1858 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1859 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1861 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1862 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1864 /* Now report on what we're doing with tfind. */
1865 if (traceframe_number
>= 0)
1866 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1867 traceframe_number
, tracepoint_number
);
1869 printf_filtered (_("Not looking at any trace frame.\n"));
1871 /* Report start/stop times if supplied. */
1876 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1878 /* Reporting a run time is more readable than two long numbers. */
1879 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1880 (long int) (ts
->start_time
/ 1000000),
1881 (long int) (ts
->start_time
% 1000000),
1882 (long int) (run_time
/ 1000000),
1883 (long int) (run_time
% 1000000));
1886 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1887 (long int) (ts
->start_time
/ 1000000),
1888 (long int) (ts
->start_time
% 1000000));
1890 else if (ts
->stop_time
)
1891 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1892 (long int) (ts
->stop_time
/ 1000000),
1893 (long int) (ts
->stop_time
% 1000000));
1895 /* Now report any per-tracepoint status available. */
1896 tp_vec
= all_tracepoints ();
1898 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1899 target_get_tracepoint_status (t
, NULL
);
1901 VEC_free (breakpoint_p
, tp_vec
);
1904 /* Report the trace status to uiout, in a way suitable for MI, and not
1905 suitable for CLI. If ON_STOP is true, suppress a few fields that
1906 are not meaningful in the -trace-stop response.
1908 The implementation is essentially parallel to trace_status_command, but
1909 merging them will result in unreadable code. */
1911 trace_status_mi (int on_stop
)
1913 struct ui_out
*uiout
= current_uiout
;
1914 struct trace_status
*ts
= current_trace_status ();
1917 status
= target_get_trace_status (ts
);
1919 if (status
== -1 && ts
->filename
== NULL
)
1921 uiout
->field_string ("supported", "0");
1925 if (ts
->filename
!= NULL
)
1926 uiout
->field_string ("supported", "file");
1928 uiout
->field_string ("supported", "1");
1930 if (ts
->filename
!= NULL
)
1931 uiout
->field_string ("trace-file", ts
->filename
);
1933 gdb_assert (ts
->running_known
);
1937 uiout
->field_string ("running", "1");
1939 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1940 Given that the frontend gets the status either on -trace-stop, or from
1941 -trace-status after re-connection, it does not seem like this
1942 information is necessary for anything. It is not necessary for either
1943 figuring the vital state of the target nor for navigation of trace
1944 frames. If the frontend wants to show the current state is some
1945 configure dialog, it can request the value when such dialog is
1946 invoked by the user. */
1950 const char *stop_reason
= NULL
;
1951 int stopping_tracepoint
= -1;
1954 uiout
->field_string ("running", "0");
1956 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1958 switch (ts
->stop_reason
)
1960 case trace_stop_command
:
1961 stop_reason
= "request";
1963 case trace_buffer_full
:
1964 stop_reason
= "overflow";
1966 case trace_disconnected
:
1967 stop_reason
= "disconnection";
1969 case tracepoint_passcount
:
1970 stop_reason
= "passcount";
1971 stopping_tracepoint
= ts
->stopping_tracepoint
;
1973 case tracepoint_error
:
1974 stop_reason
= "error";
1975 stopping_tracepoint
= ts
->stopping_tracepoint
;
1981 uiout
->field_string ("stop-reason", stop_reason
);
1982 if (stopping_tracepoint
!= -1)
1983 uiout
->field_int ("stopping-tracepoint",
1984 stopping_tracepoint
);
1985 if (ts
->stop_reason
== tracepoint_error
)
1986 uiout
->field_string ("error-description",
1992 if (ts
->traceframe_count
!= -1)
1993 uiout
->field_int ("frames", ts
->traceframe_count
);
1994 if (ts
->traceframes_created
!= -1)
1995 uiout
->field_int ("frames-created", ts
->traceframes_created
);
1996 if (ts
->buffer_size
!= -1)
1997 uiout
->field_int ("buffer-size", ts
->buffer_size
);
1998 if (ts
->buffer_free
!= -1)
1999 uiout
->field_int ("buffer-free", ts
->buffer_free
);
2001 uiout
->field_int ("disconnected", ts
->disconnected_tracing
);
2002 uiout
->field_int ("circular", ts
->circular_buffer
);
2004 uiout
->field_string ("user-name", ts
->user_name
);
2005 uiout
->field_string ("notes", ts
->notes
);
2010 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2011 (long int) (ts
->start_time
/ 1000000),
2012 (long int) (ts
->start_time
% 1000000));
2013 uiout
->field_string ("start-time", buf
);
2014 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2015 (long int) (ts
->stop_time
/ 1000000),
2016 (long int) (ts
->stop_time
% 1000000));
2017 uiout
->field_string ("stop-time", buf
);
2021 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2022 user if she really wants to detach. */
2025 query_if_trace_running (int from_tty
)
2030 /* It can happen that the target that was tracing went away on its
2031 own, and we didn't notice. Get a status update, and if the
2032 current target doesn't even do tracing, then assume it's not
2034 if (target_get_trace_status (current_trace_status ()) < 0)
2035 current_trace_status ()->running
= 0;
2037 /* If running interactively, give the user the option to cancel and
2038 then decide what to do differently with the run. Scripts are
2039 just going to disconnect and let the target deal with it,
2040 according to how it's been instructed previously via
2041 disconnected-tracing. */
2042 if (current_trace_status ()->running
)
2044 process_tracepoint_on_disconnect ();
2046 if (current_trace_status ()->disconnected_tracing
)
2048 if (!query (_("Trace is running and will "
2049 "continue after detach; detach anyway? ")))
2050 error (_("Not confirmed."));
2054 if (!query (_("Trace is running but will "
2055 "stop on detach; detach anyway? ")))
2056 error (_("Not confirmed."));
2061 /* This function handles the details of what to do about an ongoing
2062 tracing run if the user has asked to detach or otherwise disconnect
2066 disconnect_tracing (void)
2068 /* Also we want to be out of tfind mode, otherwise things can get
2069 confusing upon reconnection. Just use these calls instead of
2070 full tfind_1 behavior because we're in the middle of detaching,
2071 and there's no point to updating current stack frame etc. */
2072 trace_reset_local_state ();
2075 /* Worker function for the various flavors of the tfind command. */
2077 tfind_1 (enum trace_find_type type
, int num
,
2078 CORE_ADDR addr1
, CORE_ADDR addr2
,
2081 int target_frameno
= -1, target_tracept
= -1;
2082 struct frame_id old_frame_id
= null_frame_id
;
2083 struct tracepoint
*tp
;
2084 struct ui_out
*uiout
= current_uiout
;
2086 /* Only try to get the current stack frame if we have a chance of
2087 succeeding. In particular, if we're trying to get a first trace
2088 frame while all threads are running, it's not going to succeed,
2089 so leave it with a default value and let the frame comparison
2090 below (correctly) decide to print out the source location of the
2092 if (!(type
== tfind_number
&& num
== -1)
2093 && (has_stack_frames () || traceframe_number
>= 0))
2094 old_frame_id
= get_frame_id (get_current_frame ());
2096 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2099 if (type
== tfind_number
2101 && target_frameno
== -1)
2103 /* We told the target to get out of tfind mode, and it did. */
2105 else if (target_frameno
== -1)
2107 /* A request for a non-existent trace frame has failed.
2108 Our response will be different, depending on FROM_TTY:
2110 If FROM_TTY is true, meaning that this command was
2111 typed interactively by the user, then give an error
2112 and DO NOT change the state of traceframe_number etc.
2114 However if FROM_TTY is false, meaning that we're either
2115 in a script, a loop, or a user-defined command, then
2116 DON'T give an error, but DO change the state of
2117 traceframe_number etc. to invalid.
2119 The rationalle is that if you typed the command, you
2120 might just have committed a typo or something, and you'd
2121 like to NOT lose your current debugging state. However
2122 if you're in a user-defined command or especially in a
2123 loop, then you need a way to detect that the command
2124 failed WITHOUT aborting. This allows you to write
2125 scripts that search thru the trace buffer until the end,
2126 and then continue on to do something else. */
2129 error (_("Target failed to find requested trace frame."));
2133 printf_filtered ("End of trace buffer.\n");
2134 #if 0 /* dubious now? */
2135 /* The following will not recurse, since it's
2137 tfind_command ("-1", from_tty
);
2142 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2144 reinit_frame_cache ();
2145 target_dcache_invalidate ();
2147 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2149 if (target_frameno
!= get_traceframe_number ())
2150 gdb::observers::traceframe_changed
.notify (target_frameno
, tracepoint_number
);
2152 set_current_traceframe (target_frameno
);
2154 if (target_frameno
== -1)
2155 set_traceframe_context (NULL
);
2157 set_traceframe_context (get_current_frame ());
2159 if (traceframe_number
>= 0)
2161 /* Use different branches for MI and CLI to make CLI messages
2163 if (uiout
->is_mi_like_p ())
2165 uiout
->field_string ("found", "1");
2166 uiout
->field_int ("tracepoint", tracepoint_number
);
2167 uiout
->field_int ("traceframe", traceframe_number
);
2171 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2172 traceframe_number
, tracepoint_number
);
2177 if (uiout
->is_mi_like_p ())
2178 uiout
->field_string ("found", "0");
2179 else if (type
== tfind_number
&& num
== -1)
2180 printf_unfiltered (_("No longer looking at any trace frame\n"));
2181 else /* This case may never occur, check. */
2182 printf_unfiltered (_("No trace frame found\n"));
2185 /* If we're in nonstop mode and getting out of looking at trace
2186 frames, there won't be any current frame to go back to and
2189 && (has_stack_frames () || traceframe_number
>= 0))
2191 enum print_what print_what
;
2193 /* NOTE: in imitation of the step command, try to determine
2194 whether we have made a transition from one function to
2195 another. If so, we'll print the "stack frame" (ie. the new
2196 function and it's arguments) -- otherwise we'll just show the
2199 if (frame_id_eq (old_frame_id
,
2200 get_frame_id (get_current_frame ())))
2201 print_what
= SRC_LINE
;
2203 print_what
= SRC_AND_LOC
;
2205 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2210 /* Error on looking at traceframes while trace is running. */
2213 check_trace_running (struct trace_status
*status
)
2215 if (status
->running
&& status
->filename
== NULL
)
2216 error (_("May not look at trace frames while trace is running."));
2219 /* trace_find_command takes a trace frame number n,
2220 sends "QTFrame:<n>" to the target,
2221 and accepts a reply that may contain several optional pieces
2222 of information: a frame number, a tracepoint number, and an
2223 indication of whether this is a trap frame or a stepping frame.
2225 The minimal response is just "OK" (which indicates that the
2226 target does not give us a frame number or a tracepoint number).
2227 Instead of that, the target may send us a string containing
2229 F<hexnum> (gives the selected frame number)
2230 T<hexnum> (gives the selected tracepoint number)
2235 tfind_command_1 (const char *args
, int from_tty
)
2236 { /* This should only be called with a numeric argument. */
2239 check_trace_running (current_trace_status ());
2241 if (args
== 0 || *args
== 0)
2242 { /* TFIND with no args means find NEXT trace frame. */
2243 if (traceframe_number
== -1)
2244 frameno
= 0; /* "next" is first one. */
2246 frameno
= traceframe_number
+ 1;
2248 else if (0 == strcmp (args
, "-"))
2250 if (traceframe_number
== -1)
2251 error (_("not debugging trace buffer"));
2252 else if (from_tty
&& traceframe_number
== 0)
2253 error (_("already at start of trace buffer"));
2255 frameno
= traceframe_number
- 1;
2257 /* A hack to work around eval's need for fp to have been collected. */
2258 else if (0 == strcmp (args
, "-1"))
2261 frameno
= parse_and_eval_long (args
);
2264 error (_("invalid input (%d is less than zero)"), frameno
);
2266 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2270 tfind_command (const char *args
, int from_tty
)
2272 tfind_command_1 (args
, from_tty
);
2277 tfind_end_command (const char *args
, int from_tty
)
2279 tfind_command_1 ("-1", from_tty
);
2284 tfind_start_command (const char *args
, int from_tty
)
2286 tfind_command_1 ("0", from_tty
);
2289 /* tfind pc command */
2291 tfind_pc_command (const char *args
, int from_tty
)
2295 check_trace_running (current_trace_status ());
2297 if (args
== 0 || *args
== 0)
2298 pc
= regcache_read_pc (get_current_regcache ());
2300 pc
= parse_and_eval_address (args
);
2302 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2305 /* tfind tracepoint command */
2307 tfind_tracepoint_command (const char *args
, int from_tty
)
2310 struct tracepoint
*tp
;
2312 check_trace_running (current_trace_status ());
2314 if (args
== 0 || *args
== 0)
2316 if (tracepoint_number
== -1)
2317 error (_("No current tracepoint -- please supply an argument."));
2319 tdp
= tracepoint_number
; /* Default is current TDP. */
2322 tdp
= parse_and_eval_long (args
);
2324 /* If we have the tracepoint on hand, use the number that the
2325 target knows about (which may be different if we disconnected
2326 and reconnected). */
2327 tp
= get_tracepoint (tdp
);
2329 tdp
= tp
->number_on_target
;
2331 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2334 /* TFIND LINE command:
2336 This command will take a sourceline for argument, just like BREAK
2337 or TRACE (ie. anything that "decode_line_1" can handle).
2339 With no argument, this command will find the next trace frame
2340 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2343 tfind_line_command (const char *args
, int from_tty
)
2345 check_trace_running (current_trace_status ());
2347 symtab_and_line sal
;
2348 if (args
== 0 || *args
== 0)
2350 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2354 std::vector
<symtab_and_line
> sals
2355 = decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2359 if (sal
.symtab
== 0)
2360 error (_("No line number information available."));
2362 CORE_ADDR start_pc
, end_pc
;
2363 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2365 if (start_pc
== end_pc
)
2367 printf_filtered ("Line %d of \"%s\"",
2369 symtab_to_filename_for_display (sal
.symtab
));
2371 printf_filtered (" is at address ");
2372 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2374 printf_filtered (" but contains no code.\n");
2375 sal
= find_pc_line (start_pc
, 0);
2377 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2378 && start_pc
!= end_pc
)
2379 printf_filtered ("Attempting to find line %d instead.\n",
2382 error (_("Cannot find a good line."));
2386 /* Is there any case in which we get here, and have an address
2387 which the user would want to see? If we have debugging
2388 symbols and no line numbers? */
2389 error (_("Line number %d is out of range for \"%s\"."),
2390 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2392 /* Find within range of stated line. */
2394 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2396 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2399 /* tfind range command */
2401 tfind_range_command (const char *args
, int from_tty
)
2403 static CORE_ADDR start
, stop
;
2406 check_trace_running (current_trace_status ());
2408 if (args
== 0 || *args
== 0)
2409 { /* XXX FIXME: what should default behavior be? */
2410 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2414 if (0 != (tmp
= strchr (args
, ',')))
2416 std::string
start_addr (args
, tmp
);
2418 tmp
= skip_spaces (tmp
);
2419 start
= parse_and_eval_address (start_addr
.c_str ());
2420 stop
= parse_and_eval_address (tmp
);
2423 { /* No explicit end address? */
2424 start
= parse_and_eval_address (args
);
2425 stop
= start
+ 1; /* ??? */
2428 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2431 /* tfind outside command */
2433 tfind_outside_command (const char *args
, int from_tty
)
2435 CORE_ADDR start
, stop
;
2438 if (current_trace_status ()->running
2439 && current_trace_status ()->filename
== NULL
)
2440 error (_("May not look at trace frames while trace is running."));
2442 if (args
== 0 || *args
== 0)
2443 { /* XXX FIXME: what should default behavior be? */
2444 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2448 if (0 != (tmp
= strchr (args
, ',')))
2450 std::string
start_addr (args
, tmp
);
2452 tmp
= skip_spaces (tmp
);
2453 start
= parse_and_eval_address (start_addr
.c_str ());
2454 stop
= parse_and_eval_address (tmp
);
2457 { /* No explicit end address? */
2458 start
= parse_and_eval_address (args
);
2459 stop
= start
+ 1; /* ??? */
2462 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2465 /* info scope command: list the locals for a scope. */
2467 info_scope_command (const char *args_in
, int from_tty
)
2470 struct bound_minimal_symbol msym
;
2471 const struct block
*block
;
2472 const char *symname
;
2473 const char *save_args
= args_in
;
2474 struct block_iterator iter
;
2476 struct gdbarch
*gdbarch
;
2478 const char *args
= args_in
;
2480 if (args
== 0 || *args
== 0)
2481 error (_("requires an argument (function, "
2482 "line or *addr) to define a scope"));
2484 event_location_up location
= string_to_event_location (&args
,
2486 std::vector
<symtab_and_line
> sals
2487 = decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
2491 /* Presumably decode_line_1 has already warned. */
2495 /* Resolve line numbers to PC. */
2496 resolve_sal_pc (&sals
[0]);
2497 block
= block_for_pc (sals
[0].pc
);
2501 QUIT
; /* Allow user to bail out with ^C. */
2502 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2504 QUIT
; /* Allow user to bail out with ^C. */
2506 printf_filtered ("Scope for %s:\n", save_args
);
2509 symname
= SYMBOL_PRINT_NAME (sym
);
2510 if (symname
== NULL
|| *symname
== '\0')
2511 continue; /* Probably botched, certainly useless. */
2513 gdbarch
= symbol_arch (sym
);
2515 printf_filtered ("Symbol %s is ", symname
);
2517 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2518 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2519 BLOCK_START (block
),
2523 switch (SYMBOL_CLASS (sym
))
2526 case LOC_UNDEF
: /* Messed up symbol? */
2527 printf_filtered ("a bogus symbol, class %d.\n",
2528 SYMBOL_CLASS (sym
));
2529 count
--; /* Don't count this one. */
2532 printf_filtered ("a constant with value %s (%s)",
2533 plongest (SYMBOL_VALUE (sym
)),
2534 hex_string (SYMBOL_VALUE (sym
)));
2536 case LOC_CONST_BYTES
:
2537 printf_filtered ("constant bytes: ");
2538 if (SYMBOL_TYPE (sym
))
2539 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2540 fprintf_filtered (gdb_stdout
, " %02x",
2541 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2544 printf_filtered ("in static storage at address ");
2545 printf_filtered ("%s", paddress (gdbarch
,
2546 SYMBOL_VALUE_ADDRESS (sym
)));
2549 /* GDBARCH is the architecture associated with the objfile
2550 the symbol is defined in; the target architecture may be
2551 different, and may provide additional registers. However,
2552 we do not know the target architecture at this point.
2553 We assume the objfile architecture will contain all the
2554 standard registers that occur in debug info in that
2556 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2559 if (SYMBOL_IS_ARGUMENT (sym
))
2560 printf_filtered ("an argument in register $%s",
2561 gdbarch_register_name (gdbarch
, regno
));
2563 printf_filtered ("a local variable in register $%s",
2564 gdbarch_register_name (gdbarch
, regno
));
2567 printf_filtered ("an argument at stack/frame offset %s",
2568 plongest (SYMBOL_VALUE (sym
)));
2571 printf_filtered ("a local variable at frame offset %s",
2572 plongest (SYMBOL_VALUE (sym
)));
2575 printf_filtered ("a reference argument at offset %s",
2576 plongest (SYMBOL_VALUE (sym
)));
2578 case LOC_REGPARM_ADDR
:
2579 /* Note comment at LOC_REGISTER. */
2580 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2582 printf_filtered ("the address of an argument, in register $%s",
2583 gdbarch_register_name (gdbarch
, regno
));
2586 printf_filtered ("a typedef.\n");
2589 printf_filtered ("a label at address ");
2590 printf_filtered ("%s", paddress (gdbarch
,
2591 SYMBOL_VALUE_ADDRESS (sym
)));
2594 printf_filtered ("a function at address ");
2595 printf_filtered ("%s",
2596 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2598 case LOC_UNRESOLVED
:
2599 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2601 if (msym
.minsym
== NULL
)
2602 printf_filtered ("Unresolved Static");
2605 printf_filtered ("static storage at address ");
2606 printf_filtered ("%s",
2608 BMSYMBOL_VALUE_ADDRESS (msym
)));
2611 case LOC_OPTIMIZED_OUT
:
2612 printf_filtered ("optimized out.\n");
2615 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2618 if (SYMBOL_TYPE (sym
))
2619 printf_filtered (", length %d.\n",
2620 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2622 if (BLOCK_FUNCTION (block
))
2625 block
= BLOCK_SUPERBLOCK (block
);
2628 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2632 /* Helper for trace_dump_command. Dump the action list starting at
2633 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2634 actions of the body of a while-stepping action. STEPPING_FRAME is
2635 set if the current traceframe was determined to be a while-stepping
2639 trace_dump_actions (struct command_line
*action
,
2640 int stepping_actions
, int stepping_frame
,
2643 const char *action_exp
, *next_comma
;
2645 for (; action
!= NULL
; action
= action
->next
)
2647 struct cmd_list_element
*cmd
;
2649 QUIT
; /* Allow user to bail out with ^C. */
2650 action_exp
= action
->line
;
2651 action_exp
= skip_spaces (action_exp
);
2653 /* The collection actions to be done while stepping are
2654 bracketed by the commands "while-stepping" and "end". */
2656 if (*action_exp
== '#') /* comment line */
2659 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2661 error (_("Bad action list item: %s"), action_exp
);
2663 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2667 for (i
= 0; i
< action
->body_count
; ++i
)
2668 trace_dump_actions (action
->body_list
[i
],
2669 1, stepping_frame
, from_tty
);
2671 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2673 /* Display the collected data.
2674 For the trap frame, display only what was collected at
2675 the trap. Likewise for stepping frames, display only
2676 what was collected while stepping. This means that the
2677 two boolean variables, STEPPING_FRAME and
2678 STEPPING_ACTIONS should be equal. */
2679 if (stepping_frame
== stepping_actions
)
2682 struct cleanup
*old_chain
2683 = make_cleanup (free_current_contents
, &cmd
);
2684 int trace_string
= 0;
2686 if (*action_exp
== '/')
2687 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2690 { /* Repeat over a comma-separated list. */
2691 QUIT
; /* Allow user to bail out with ^C. */
2692 if (*action_exp
== ',')
2694 action_exp
= skip_spaces (action_exp
);
2696 next_comma
= strchr (action_exp
, ',');
2698 if (0 == strncasecmp (action_exp
, "$reg", 4))
2699 registers_info (NULL
, from_tty
);
2700 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2702 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2703 info_locals_command (NULL
, from_tty
);
2704 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2705 info_args_command (NULL
, from_tty
);
2708 if (next_comma
!= NULL
)
2710 size_t len
= next_comma
- action_exp
;
2712 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2713 memcpy (cmd
, action_exp
, len
);
2718 size_t len
= strlen (action_exp
);
2720 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2721 memcpy (cmd
, action_exp
, len
+ 1);
2724 printf_filtered ("%s = ", cmd
);
2725 output_command_const (cmd
, from_tty
);
2726 printf_filtered ("\n");
2728 action_exp
= next_comma
;
2730 while (action_exp
&& *action_exp
== ',');
2732 do_cleanups (old_chain
);
2738 /* Return bp_location of the tracepoint associated with the current
2739 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2740 is a stepping traceframe. */
2742 struct bp_location
*
2743 get_traceframe_location (int *stepping_frame_p
)
2745 struct tracepoint
*t
;
2746 struct bp_location
*tloc
;
2747 struct regcache
*regcache
;
2749 if (tracepoint_number
== -1)
2750 error (_("No current trace frame."));
2752 t
= get_tracepoint (tracepoint_number
);
2755 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2758 /* The current frame is a trap frame if the frame PC is equal to the
2759 tracepoint PC. If not, then the current frame was collected
2760 during single-stepping. */
2761 regcache
= get_current_regcache ();
2763 /* If the traceframe's address matches any of the tracepoint's
2764 locations, assume it is a direct hit rather than a while-stepping
2765 frame. (FIXME this is not reliable, should record each frame's
2767 for (tloc
= t
->loc
; tloc
; tloc
= tloc
->next
)
2768 if (tloc
->address
== regcache_read_pc (regcache
))
2770 *stepping_frame_p
= 0;
2774 /* If this is a stepping frame, we don't know which location
2775 triggered. The first is as good (or bad) a guess as any... */
2776 *stepping_frame_p
= 1;
2780 /* Return all the actions, including default collect, of a tracepoint
2781 T. It constructs cleanups into the chain, and leaves the caller to
2782 handle them (call do_cleanups). */
2784 static struct command_line
*
2785 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
2787 struct command_line
*actions
;
2789 actions
= breakpoint_commands (t
);
2791 /* If there are default expressions to collect, make up a collect
2792 action and prepend to the action list to encode. Note that since
2793 validation is per-tracepoint (local var "xyz" might be valid for
2794 one tracepoint and not another, etc), we make up the action on
2795 the fly, and don't cache it. */
2796 if (*default_collect
)
2798 struct command_line
*default_collect_action
;
2799 char *default_collect_line
;
2801 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2802 make_cleanup (xfree
, default_collect_line
);
2804 validate_actionline (default_collect_line
, t
);
2805 default_collect_action
= XNEW (struct command_line
);
2806 make_cleanup (xfree
, default_collect_action
);
2807 default_collect_action
->next
= actions
;
2808 default_collect_action
->line
= default_collect_line
;
2809 actions
= default_collect_action
;
2815 /* The tdump command. */
2818 tdump_command (const char *args
, int from_tty
)
2820 int stepping_frame
= 0;
2821 struct bp_location
*loc
;
2822 struct command_line
*actions
;
2824 /* This throws an error is not inspecting a trace frame. */
2825 loc
= get_traceframe_location (&stepping_frame
);
2827 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2828 tracepoint_number
, traceframe_number
);
2830 /* This command only makes sense for the current frame, not the
2832 scoped_restore_current_thread restore_thread
;
2834 select_frame (get_current_frame ());
2836 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
2838 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2841 /* Encode a piece of a tracepoint's source-level definition in a form
2842 that is suitable for both protocol and saving in files. */
2843 /* This version does not do multiple encodes for long strings; it should
2844 return an offset to the next piece to encode. FIXME */
2847 encode_source_string (int tpnum
, ULONGEST addr
,
2848 const char *srctype
, const char *src
,
2849 char *buf
, int buf_size
)
2851 if (80 + strlen (srctype
) > buf_size
)
2852 error (_("Buffer too small for source encoding"));
2853 sprintf (buf
, "%x:%s:%s:%x:%x:",
2854 tpnum
, phex_nz (addr
, sizeof (addr
)),
2855 srctype
, 0, (int) strlen (src
));
2856 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2857 error (_("Source string too long for buffer"));
2858 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
2862 /* Tell the target what to do with an ongoing tracing run if GDB
2863 disconnects for some reason. */
2866 set_disconnected_tracing (const char *args
, int from_tty
,
2867 struct cmd_list_element
*c
)
2869 target_set_disconnected_tracing (disconnected_tracing
);
2873 set_circular_trace_buffer (const char *args
, int from_tty
,
2874 struct cmd_list_element
*c
)
2876 target_set_circular_trace_buffer (circular_trace_buffer
);
2880 set_trace_buffer_size (const char *args
, int from_tty
,
2881 struct cmd_list_element
*c
)
2883 target_set_trace_buffer_size (trace_buffer_size
);
2887 set_trace_user (const char *args
, int from_tty
,
2888 struct cmd_list_element
*c
)
2892 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
2895 warning (_("Target does not support trace notes, user ignored"));
2899 set_trace_notes (const char *args
, int from_tty
,
2900 struct cmd_list_element
*c
)
2904 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
2907 warning (_("Target does not support trace notes, note ignored"));
2911 set_trace_stop_notes (const char *args
, int from_tty
,
2912 struct cmd_list_element
*c
)
2916 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
2919 warning (_("Target does not support trace notes, stop note ignored"));
2922 /* Convert the memory pointed to by mem into hex, placing result in buf.
2923 * Return a pointer to the last char put in buf (null)
2924 * "stolen" from sparc-stub.c
2927 static const char hexchars
[] = "0123456789abcdef";
2930 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2938 *buf
++ = hexchars
[ch
>> 4];
2939 *buf
++ = hexchars
[ch
& 0xf];
2948 get_traceframe_number (void)
2950 return traceframe_number
;
2954 get_tracepoint_number (void)
2956 return tracepoint_number
;
2959 /* Make the traceframe NUM be the current trace frame. Does nothing
2960 if NUM is already current. */
2963 set_current_traceframe (int num
)
2967 if (traceframe_number
== num
)
2969 /* Nothing to do. */
2973 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2976 warning (_("could not change traceframe"));
2978 set_traceframe_num (newnum
);
2980 /* Changing the traceframe changes our view of registers and of the
2982 registers_changed ();
2984 clear_traceframe_info ();
2987 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2988 : m_traceframe_number (traceframe_number
)
2991 /* Given a number and address, return an uploaded tracepoint with that
2992 number, creating if necessary. */
2994 struct uploaded_tp
*
2995 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2997 struct uploaded_tp
*utp
;
2999 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3000 if (utp
->number
== num
&& utp
->addr
== addr
)
3003 utp
= new uploaded_tp
;
3013 free_uploaded_tps (struct uploaded_tp
**utpp
)
3015 struct uploaded_tp
*next_one
;
3019 next_one
= (*utpp
)->next
;
3025 /* Given a number and address, return an uploaded tracepoint with that
3026 number, creating if necessary. */
3028 struct uploaded_tsv
*
3029 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3031 struct uploaded_tsv
*utsv
;
3033 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3034 if (utsv
->number
== num
)
3037 utsv
= XCNEW (struct uploaded_tsv
);
3039 utsv
->next
= *utsvp
;
3046 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3048 struct uploaded_tsv
*next_one
;
3052 next_one
= (*utsvp
)->next
;
3058 /* FIXME this function is heuristic and will miss the cases where the
3059 conditional is semantically identical but differs in whitespace,
3060 such as "x == 0" vs "x==0". */
3063 cond_string_is_same (char *str1
, char *str2
)
3065 if (str1
== NULL
|| str2
== NULL
)
3066 return (str1
== str2
);
3068 return (strcmp (str1
, str2
) == 0);
3071 /* Look for an existing tracepoint that seems similar enough to the
3072 uploaded one. Enablement isn't compared, because the user can
3073 toggle that freely, and may have done so in anticipation of the
3074 next trace run. Return the location of matched tracepoint. */
3076 static struct bp_location
*
3077 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3079 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3081 struct breakpoint
*b
;
3082 struct bp_location
*loc
;
3084 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3086 struct tracepoint
*t
= (struct tracepoint
*) b
;
3088 if (b
->type
== utp
->type
3089 && t
->step_count
== utp
->step
3090 && t
->pass_count
== utp
->pass
3091 && cond_string_is_same (t
->cond_string
, utp
->cond_string
)
3092 /* FIXME also test actions. */
3095 /* Scan the locations for an address match. */
3096 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3098 if (loc
->address
== utp
->addr
)
3106 /* Given a list of tracepoints uploaded from a target, attempt to
3107 match them up with existing tracepoints, and create new ones if not
3111 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3113 struct uploaded_tp
*utp
;
3114 /* A set of tracepoints which are modified. */
3115 VEC(breakpoint_p
) *modified_tp
= NULL
;
3117 struct breakpoint
*b
;
3119 /* Look for GDB tracepoints that match up with our uploaded versions. */
3120 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3122 struct bp_location
*loc
;
3123 struct tracepoint
*t
;
3125 loc
= find_matching_tracepoint_location (utp
);
3130 /* Mark this location as already inserted. */
3132 t
= (struct tracepoint
*) loc
->owner
;
3133 printf_filtered (_("Assuming tracepoint %d is same "
3134 "as target's tracepoint %d at %s.\n"),
3135 loc
->owner
->number
, utp
->number
,
3136 paddress (loc
->gdbarch
, utp
->addr
));
3138 /* The tracepoint LOC->owner was modified (the location LOC
3139 was marked as inserted in the target). Save it in
3140 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3141 observers will be notified later once for each tracepoint
3142 saved in MODIFIED_TP. */
3144 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3146 if (b
== loc
->owner
)
3152 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3156 t
= create_tracepoint_from_upload (utp
);
3158 printf_filtered (_("Created tracepoint %d for "
3159 "target's tracepoint %d at %s.\n"),
3160 t
->number
, utp
->number
,
3161 paddress (get_current_arch (), utp
->addr
));
3163 printf_filtered (_("Failed to create tracepoint for target's "
3164 "tracepoint %d at %s, skipping it.\n"),
3166 paddress (get_current_arch (), utp
->addr
));
3168 /* Whether found or created, record the number used by the
3169 target, to help with mapping target tracepoints back to their
3170 counterparts here. */
3172 t
->number_on_target
= utp
->number
;
3175 /* Notify 'breakpoint-modified' observer that at least one of B's
3176 locations was changed. */
3177 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3178 gdb::observers::breakpoint_modified
.notify (b
);
3180 VEC_free (breakpoint_p
, modified_tp
);
3181 free_uploaded_tps (uploaded_tps
);
3184 /* Trace state variables don't have much to identify them beyond their
3185 name, so just use that to detect matches. */
3187 static struct trace_state_variable
*
3188 find_matching_tsv (struct uploaded_tsv
*utsv
)
3193 return find_trace_state_variable (utsv
->name
);
3196 static struct trace_state_variable
*
3197 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3199 const char *namebase
;
3202 struct trace_state_variable
*tsv
;
3206 namebase
= utsv
->name
;
3212 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3215 /* Fish for a name that is not in use. */
3216 /* (should check against all internal vars?) */
3217 while (find_trace_state_variable (buf
.c_str ()))
3218 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3220 /* We have an available name, create the variable. */
3221 tsv
= create_trace_state_variable (buf
.c_str ());
3222 tsv
->initial_value
= utsv
->initial_value
;
3223 tsv
->builtin
= utsv
->builtin
;
3225 gdb::observers::tsv_created
.notify (tsv
);
3230 /* Given a list of uploaded trace state variables, try to match them
3231 up with existing variables, or create additional ones. */
3234 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3237 struct uploaded_tsv
*utsv
;
3238 struct trace_state_variable
*tsv
;
3241 /* Most likely some numbers will have to be reassigned as part of
3242 the merge, so clear them all in anticipation. */
3243 for (trace_state_variable
&tsv
: tvariables
)
3246 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3248 tsv
= find_matching_tsv (utsv
);
3252 printf_filtered (_("Assuming trace state variable $%s "
3253 "is same as target's variable %d.\n"),
3254 tsv
->name
.c_str (), utsv
->number
);
3258 tsv
= create_tsv_from_upload (utsv
);
3260 printf_filtered (_("Created trace state variable "
3261 "$%s for target's variable %d.\n"),
3262 tsv
->name
.c_str (), utsv
->number
);
3264 /* Give precedence to numberings that come from the target. */
3266 tsv
->number
= utsv
->number
;
3269 /* Renumber everything that didn't get a target-assigned number. */
3271 for (const trace_state_variable
&tsv
: tvariables
)
3272 highest
= std::max (tsv
.number
, highest
);
3275 for (trace_state_variable
&tsv
: tvariables
)
3276 if (tsv
.number
== 0)
3277 tsv
.number
= highest
++;
3279 free_uploaded_tsvs (uploaded_tsvs
);
3282 /* Parse the part of trace status syntax that is shared between
3283 the remote protocol and the trace file reader. */
3286 parse_trace_status (const char *line
, struct trace_status
*ts
)
3288 const char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3292 ts
->running_known
= 1;
3293 ts
->running
= (*p
++ == '1');
3294 ts
->stop_reason
= trace_stop_reason_unknown
;
3295 xfree (ts
->stop_desc
);
3296 ts
->stop_desc
= NULL
;
3297 ts
->traceframe_count
= -1;
3298 ts
->traceframes_created
= -1;
3299 ts
->buffer_free
= -1;
3300 ts
->buffer_size
= -1;
3301 ts
->disconnected_tracing
= 0;
3302 ts
->circular_buffer
= 0;
3303 xfree (ts
->user_name
);
3304 ts
->user_name
= NULL
;
3307 ts
->start_time
= ts
->stop_time
= 0;
3311 p1
= strchr (p
, ':');
3313 error (_("Malformed trace status, at %s\n\
3314 Status line: '%s'\n"), p
, line
);
3315 p3
= strchr (p
, ';');
3317 p3
= p
+ strlen (p
);
3318 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3320 p
= unpack_varlen_hex (++p1
, &val
);
3321 ts
->stop_reason
= trace_buffer_full
;
3323 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3325 p
= unpack_varlen_hex (++p1
, &val
);
3326 ts
->stop_reason
= trace_never_run
;
3328 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3331 p
= unpack_varlen_hex (++p1
, &val
);
3332 ts
->stop_reason
= tracepoint_passcount
;
3333 ts
->stopping_tracepoint
= val
;
3335 else if (strncmp (p
, stop_reason_names
[trace_stop_command
], p1
- p
) == 0)
3337 p2
= strchr (++p1
, ':');
3345 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3346 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3347 ts
->stop_desc
[end
] = '\0';
3350 ts
->stop_desc
= xstrdup ("");
3352 p
= unpack_varlen_hex (++p2
, &val
);
3353 ts
->stop_reason
= trace_stop_command
;
3355 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3357 p
= unpack_varlen_hex (++p1
, &val
);
3358 ts
->stop_reason
= trace_disconnected
;
3360 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3362 p2
= strchr (++p1
, ':');
3365 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3366 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3367 ts
->stop_desc
[end
] = '\0';
3370 ts
->stop_desc
= xstrdup ("");
3372 p
= unpack_varlen_hex (++p2
, &val
);
3373 ts
->stopping_tracepoint
= val
;
3374 ts
->stop_reason
= tracepoint_error
;
3376 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3378 p
= unpack_varlen_hex (++p1
, &val
);
3379 ts
->traceframe_count
= val
;
3381 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3383 p
= unpack_varlen_hex (++p1
, &val
);
3384 ts
->traceframes_created
= val
;
3386 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3388 p
= unpack_varlen_hex (++p1
, &val
);
3389 ts
->buffer_free
= val
;
3391 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3393 p
= unpack_varlen_hex (++p1
, &val
);
3394 ts
->buffer_size
= val
;
3396 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3398 p
= unpack_varlen_hex (++p1
, &val
);
3399 ts
->disconnected_tracing
= val
;
3401 else if (strncmp (p
, "circular", p1
- p
) == 0)
3403 p
= unpack_varlen_hex (++p1
, &val
);
3404 ts
->circular_buffer
= val
;
3406 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3408 p
= unpack_varlen_hex (++p1
, &val
);
3409 ts
->start_time
= val
;
3411 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3413 p
= unpack_varlen_hex (++p1
, &val
);
3414 ts
->stop_time
= val
;
3416 else if (strncmp (p
, "username", p1
- p
) == 0)
3419 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3420 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3421 ts
->user_name
[end
] = '\0';
3424 else if (strncmp (p
, "notes", p1
- p
) == 0)
3427 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3428 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3429 ts
->notes
[end
] = '\0';
3434 /* Silently skip unknown optional info. */
3435 p_temp
= strchr (p1
+ 1, ';');
3439 /* Must be at the end. */
3446 parse_tracepoint_status (const char *p
, struct breakpoint
*bp
,
3447 struct uploaded_tp
*utp
)
3450 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3452 p
= unpack_varlen_hex (p
, &uval
);
3454 tp
->hit_count
+= uval
;
3456 utp
->hit_count
+= uval
;
3457 p
= unpack_varlen_hex (p
+ 1, &uval
);
3459 tp
->traceframe_usage
+= uval
;
3461 utp
->traceframe_usage
+= uval
;
3462 /* Ignore any extra, allowing for future extensions. */
3465 /* Given a line of text defining a part of a tracepoint, parse it into
3466 an "uploaded tracepoint". */
3469 parse_tracepoint_definition (const char *line
, struct uploaded_tp
**utpp
)
3473 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3476 const char *srctype
;
3478 struct uploaded_tp
*utp
= NULL
;
3481 /* Both tracepoint and action definitions start with the same number
3482 and address sequence. */
3484 p
= unpack_varlen_hex (p
, &num
);
3485 p
++; /* skip a colon */
3486 p
= unpack_varlen_hex (p
, &addr
);
3487 p
++; /* skip a colon */
3490 enabled
= (*p
++ == 'E');
3491 p
++; /* skip a colon */
3492 p
= unpack_varlen_hex (p
, &step
);
3493 p
++; /* skip a colon */
3494 p
= unpack_varlen_hex (p
, &pass
);
3495 type
= bp_tracepoint
;
3497 /* Thumb through optional fields. */
3500 p
++; /* skip a colon */
3503 type
= bp_fast_tracepoint
;
3505 p
= unpack_varlen_hex (p
, &orig_size
);
3509 type
= bp_static_tracepoint
;
3515 p
= unpack_varlen_hex (p
, &xlen
);
3516 p
++; /* skip a comma */
3517 cond
= (char *) xmalloc (2 * xlen
+ 1);
3518 strncpy (cond
, p
, 2 * xlen
);
3519 cond
[2 * xlen
] = '\0';
3523 warning (_("Unrecognized char '%c' in tracepoint "
3524 "definition, skipping rest"), *p
);
3526 utp
= get_uploaded_tp (num
, addr
, utpp
);
3528 utp
->enabled
= enabled
;
3533 else if (piece
== 'A')
3535 utp
= get_uploaded_tp (num
, addr
, utpp
);
3536 utp
->actions
.push_back (xstrdup (p
));
3538 else if (piece
== 'S')
3540 utp
= get_uploaded_tp (num
, addr
, utpp
);
3541 utp
->step_actions
.push_back (xstrdup (p
));
3543 else if (piece
== 'Z')
3545 /* Parse a chunk of source form definition. */
3546 utp
= get_uploaded_tp (num
, addr
, utpp
);
3548 p
= strchr (p
, ':');
3549 p
++; /* skip a colon */
3550 p
= unpack_varlen_hex (p
, &start
);
3551 p
++; /* skip a colon */
3552 p
= unpack_varlen_hex (p
, &xlen
);
3553 p
++; /* skip a colon */
3555 buf
= (char *) alloca (strlen (line
));
3557 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3560 if (startswith (srctype
, "at:"))
3561 utp
->at_string
= xstrdup (buf
);
3562 else if (startswith (srctype
, "cond:"))
3563 utp
->cond_string
= xstrdup (buf
);
3564 else if (startswith (srctype
, "cmd:"))
3565 utp
->cmd_strings
.push_back (xstrdup (buf
));
3567 else if (piece
== 'V')
3569 utp
= get_uploaded_tp (num
, addr
, utpp
);
3571 parse_tracepoint_status (p
, NULL
, utp
);
3575 /* Don't error out, the target might be sending us optional
3576 info that we don't care about. */
3577 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3581 /* Convert a textual description of a trace state variable into an
3585 parse_tsv_definition (const char *line
, struct uploaded_tsv
**utsvp
)
3589 ULONGEST num
, initval
, builtin
;
3591 struct uploaded_tsv
*utsv
= NULL
;
3593 buf
= (char *) alloca (strlen (line
));
3596 p
= unpack_varlen_hex (p
, &num
);
3597 p
++; /* skip a colon */
3598 p
= unpack_varlen_hex (p
, &initval
);
3599 p
++; /* skip a colon */
3600 p
= unpack_varlen_hex (p
, &builtin
);
3601 p
++; /* skip a colon */
3602 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3605 utsv
= get_uploaded_tsv (num
, utsvp
);
3606 utsv
->initial_value
= initval
;
3607 utsv
->builtin
= builtin
;
3608 utsv
->name
= xstrdup (buf
);
3611 /* Given a line of text defining a static tracepoint marker, parse it
3612 into a "static tracepoint marker" object. Throws an error is
3613 parsing fails. If PP is non-null, it points to one past the end of
3614 the parsed marker definition. */
3617 parse_static_tracepoint_marker_definition (const char *line
, const char **pp
,
3618 static_tracepoint_marker
*marker
)
3620 const char *p
, *endp
;
3624 p
= unpack_varlen_hex (p
, &addr
);
3625 p
++; /* skip a colon */
3627 marker
->gdbarch
= target_gdbarch ();
3628 marker
->address
= (CORE_ADDR
) addr
;
3630 endp
= strchr (p
, ':');
3632 error (_("bad marker definition: %s"), line
);
3634 marker
->str_id
= hex2str (p
, (endp
- p
) / 2);
3637 p
++; /* skip a colon */
3639 /* This definition may be followed by another one, separated by a comma. */
3641 endp
= strchr (p
, ',');
3642 if (endp
!= nullptr)
3645 hex_len
= strlen (p
);
3647 marker
->extra
= hex2str (p
, hex_len
/ 2);
3653 /* Print MARKER to gdb_stdout. */
3656 print_one_static_tracepoint_marker (int count
,
3657 const static_tracepoint_marker
&marker
)
3661 char wrap_indent
[80];
3662 char extra_field_indent
[80];
3663 struct ui_out
*uiout
= current_uiout
;
3664 VEC(breakpoint_p
) *tracepoints
;
3666 symtab_and_line sal
;
3667 sal
.pc
= marker
.address
;
3669 tracepoints
= static_tracepoints_here (marker
.address
);
3671 ui_out_emit_tuple
tuple_emitter (uiout
, "marker");
3673 /* A counter field to help readability. This is not a stable
3675 uiout
->field_int ("count", count
);
3677 uiout
->field_string ("marker-id", marker
.str_id
.c_str ());
3679 uiout
->field_fmt ("enabled", "%c",
3680 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
3683 strcpy (wrap_indent
, " ");
3685 if (gdbarch_addr_bit (marker
.gdbarch
) <= 32)
3686 strcat (wrap_indent
, " ");
3688 strcat (wrap_indent
, " ");
3690 strcpy (extra_field_indent
, " ");
3692 uiout
->field_core_addr ("addr", marker
.gdbarch
, marker
.address
);
3694 sal
= find_pc_line (marker
.address
, 0);
3695 sym
= find_pc_sect_function (marker
.address
, NULL
);
3698 uiout
->text ("in ");
3699 uiout
->field_string ("func",
3700 SYMBOL_PRINT_NAME (sym
));
3701 uiout
->wrap_hint (wrap_indent
);
3702 uiout
->text (" at ");
3705 uiout
->field_skip ("func");
3707 if (sal
.symtab
!= NULL
)
3709 uiout
->field_string ("file",
3710 symtab_to_filename_for_display (sal
.symtab
));
3713 if (uiout
->is_mi_like_p ())
3715 const char *fullname
= symtab_to_fullname (sal
.symtab
);
3717 uiout
->field_string ("fullname", fullname
);
3720 uiout
->field_skip ("fullname");
3722 uiout
->field_int ("line", sal
.line
);
3726 uiout
->field_skip ("fullname");
3727 uiout
->field_skip ("line");
3731 uiout
->text (extra_field_indent
);
3732 uiout
->text (_("Data: \""));
3733 uiout
->field_string ("extra-data", marker
.extra
.c_str ());
3734 uiout
->text ("\"\n");
3736 if (!VEC_empty (breakpoint_p
, tracepoints
))
3739 struct breakpoint
*b
;
3742 ui_out_emit_tuple
tuple_emitter (uiout
, "tracepoints-at");
3744 uiout
->text (extra_field_indent
);
3745 uiout
->text (_("Probed by static tracepoints: "));
3746 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
3751 uiout
->field_int ("tracepoint-id", b
->number
);
3755 if (uiout
->is_mi_like_p ())
3756 uiout
->field_int ("number-of-tracepoints",
3757 VEC_length(breakpoint_p
, tracepoints
));
3761 VEC_free (breakpoint_p
, tracepoints
);
3765 info_static_tracepoint_markers_command (const char *arg
, int from_tty
)
3767 struct ui_out
*uiout
= current_uiout
;
3768 std::vector
<static_tracepoint_marker
> markers
3769 = target_static_tracepoint_markers_by_strid (NULL
);
3771 /* We don't have to check target_can_use_agent and agent's capability on
3772 static tracepoint here, in order to be compatible with older GDBserver.
3773 We don't check USE_AGENT is true or not, because static tracepoints
3774 don't work without in-process agent, so we don't bother users to type
3775 `set agent on' when to use static tracepoint. */
3777 ui_out_emit_table
table_emitter (uiout
, 5, -1,
3778 "StaticTracepointMarkersTable");
3780 uiout
->table_header (7, ui_left
, "counter", "Cnt");
3782 uiout
->table_header (40, ui_left
, "marker-id", "ID");
3784 uiout
->table_header (3, ui_left
, "enabled", "Enb");
3785 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3786 uiout
->table_header (10, ui_left
, "addr", "Address");
3788 uiout
->table_header (18, ui_left
, "addr", "Address");
3789 uiout
->table_header (40, ui_noalign
, "what", "What");
3791 uiout
->table_body ();
3793 for (int i
= 0; i
< markers
.size (); i
++)
3794 print_one_static_tracepoint_marker (i
+ 1, markers
[i
]);
3797 /* The $_sdata convenience variable is a bit special. We don't know
3798 for sure type of the value until we actually have a chance to fetch
3799 the data --- the size of the object depends on what has been
3800 collected. We solve this by making $_sdata be an internalvar that
3801 creates a new value on access. */
3803 /* Return a new value with the correct type for the sdata object of
3804 the current trace frame. Return a void value if there's no object
3807 static struct value
*
3808 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
3811 /* We need to read the whole object before we know its size. */
3812 gdb::optional
<gdb::byte_vector
> buf
3813 = target_read_alloc (¤t_target
, TARGET_OBJECT_STATIC_TRACE_DATA
,
3820 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
3822 v
= allocate_value (type
);
3823 memcpy (value_contents_raw (v
), buf
->data (), buf
->size ());
3827 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
3830 #if !defined(HAVE_LIBEXPAT)
3832 struct std::unique_ptr
<traceframe_info
>
3833 parse_traceframe_info (const char *tframe_info
)
3835 static int have_warned
;
3840 warning (_("Can not parse XML trace frame info; XML support "
3841 "was disabled at compile time"));
3847 #else /* HAVE_LIBEXPAT */
3849 #include "xml-support.h"
3851 /* Handle the start of a <memory> element. */
3854 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
3855 const struct gdb_xml_element
*element
,
3857 std::vector
<gdb_xml_value
> &attributes
)
3859 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3860 ULONGEST
*start_p
, *length_p
;
3863 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
.get ();
3865 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
.get ();
3867 info
->memory
.emplace_back (*start_p
, *length_p
);
3870 /* Handle the start of a <tvar> element. */
3873 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
3874 const struct gdb_xml_element
*element
,
3876 std::vector
<gdb_xml_value
> &attributes
)
3878 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3879 const char *id_attrib
3880 = (const char *) xml_find_attribute (attributes
, "id")->value
.get ();
3881 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
3883 info
->tvars
.push_back (id
);
3886 /* The allowed elements and attributes for an XML memory map. */
3888 static const struct gdb_xml_attribute memory_attributes
[] = {
3889 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3890 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3891 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3894 static const struct gdb_xml_attribute tvar_attributes
[] = {
3895 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3896 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3899 static const struct gdb_xml_element traceframe_info_children
[] = {
3900 { "memory", memory_attributes
, NULL
,
3901 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3902 traceframe_info_start_memory
, NULL
},
3903 { "tvar", tvar_attributes
, NULL
,
3904 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3905 traceframe_info_start_tvar
, NULL
},
3906 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3909 static const struct gdb_xml_element traceframe_info_elements
[] = {
3910 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
3912 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3915 /* Parse a traceframe-info XML document. */
3918 parse_traceframe_info (const char *tframe_info
)
3920 traceframe_info_up
result (new traceframe_info
);
3922 if (gdb_xml_parse_quick (_("trace frame info"),
3923 "traceframe-info.dtd", traceframe_info_elements
,
3924 tframe_info
, result
.get ()) == 0)
3930 #endif /* HAVE_LIBEXPAT */
3932 /* Returns the traceframe_info object for the current traceframe.
3933 This is where we avoid re-fetching the object from the target if we
3934 already have it cached. */
3936 struct traceframe_info
*
3937 get_traceframe_info (void)
3939 if (current_traceframe_info
== NULL
)
3940 current_traceframe_info
= target_traceframe_info ();
3942 return current_traceframe_info
.get ();
3945 /* If the target supports the query, return in RESULT the set of
3946 collected memory in the current traceframe, found within the LEN
3947 bytes range starting at MEMADDR. Returns true if the target
3948 supports the query, otherwise returns false, and RESULT is left
3952 traceframe_available_memory (std::vector
<mem_range
> *result
,
3953 CORE_ADDR memaddr
, ULONGEST len
)
3955 struct traceframe_info
*info
= get_traceframe_info ();
3961 for (mem_range
&r
: info
->memory
)
3962 if (mem_ranges_overlap (r
.start
, r
.length
, memaddr
, len
))
3964 ULONGEST lo1
, hi1
, lo2
, hi2
;
3967 hi1
= memaddr
+ len
;
3970 hi2
= r
.start
+ r
.length
;
3972 CORE_ADDR start
= std::max (lo1
, lo2
);
3973 int length
= std::min (hi1
, hi2
) - start
;
3975 result
->emplace_back (start
, length
);
3978 normalize_mem_ranges (result
);
3985 /* Implementation of `sdata' variable. */
3987 static const struct internalvar_funcs sdata_funcs
=
3994 /* module initialization */
3996 _initialize_tracepoint (void)
3998 struct cmd_list_element
*c
;
4000 /* Explicitly create without lookup, since that tries to create a
4001 value with a void typed value, and when we get here, gdbarch
4002 isn't initialized yet. At this point, we're quite sure there
4003 isn't another convenience variable of the same name. */
4004 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4006 traceframe_number
= -1;
4007 tracepoint_number
= -1;
4009 add_info ("scope", info_scope_command
,
4010 _("List the variables local to a scope"));
4012 add_cmd ("tracepoints", class_trace
,
4013 _("Tracing of program execution without stopping the program."),
4016 add_com ("tdump", class_trace
, tdump_command
,
4017 _("Print everything collected at the current tracepoint."));
4019 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4020 Define a trace state variable.\n\
4021 Argument is a $-prefixed name, optionally followed\n\
4022 by '=' and an expression that sets the initial value\n\
4023 at the start of tracing."));
4024 set_cmd_completer (c
, expression_completer
);
4026 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4027 Delete one or more trace state variables.\n\
4028 Arguments are the names of the variables to delete.\n\
4029 If no arguments are supplied, delete all variables."), &deletelist
);
4030 /* FIXME add a trace variable completer. */
4032 add_info ("tvariables", info_tvariables_command
, _("\
4033 Status of trace state variables and their values.\n\
4036 add_info ("static-tracepoint-markers",
4037 info_static_tracepoint_markers_command
, _("\
4038 List target static tracepoints markers.\n\
4041 add_prefix_cmd ("tfind", class_trace
, tfind_command
, _("\
4042 Select a trace frame;\n\
4043 No argument means forward by one frame; '-' means backward by one frame."),
4044 &tfindlist
, "tfind ", 1, &cmdlist
);
4046 add_cmd ("outside", class_trace
, tfind_outside_command
, _("\
4047 Select a trace frame whose PC is outside the given range (exclusive).\n\
4048 Usage: tfind outside addr1, addr2"),
4051 add_cmd ("range", class_trace
, tfind_range_command
, _("\
4052 Select a trace frame whose PC is in the given range (inclusive).\n\
4053 Usage: tfind range addr1,addr2"),
4056 add_cmd ("line", class_trace
, tfind_line_command
, _("\
4057 Select a trace frame by source line.\n\
4058 Argument can be a line number (with optional source file),\n\
4059 a function name, or '*' followed by an address.\n\
4060 Default argument is 'the next source line that was traced'."),
4063 add_cmd ("tracepoint", class_trace
, tfind_tracepoint_command
, _("\
4064 Select a trace frame by tracepoint number.\n\
4065 Default is the tracepoint for the current trace frame."),
4068 add_cmd ("pc", class_trace
, tfind_pc_command
, _("\
4069 Select a trace frame by PC.\n\
4070 Default is the current PC, or the PC of the current trace frame."),
4073 add_cmd ("end", class_trace
, tfind_end_command
, _("\
4074 De-select any trace frame and resume 'live' debugging."),
4077 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4079 add_cmd ("start", class_trace
, tfind_start_command
,
4080 _("Select the first trace frame in the trace buffer."),
4083 add_com ("tstatus", class_trace
, tstatus_command
,
4084 _("Display the status of the current trace data collection."));
4086 add_com ("tstop", class_trace
, tstop_command
, _("\
4087 Stop trace data collection.\n\
4088 Usage: tstop [ <notes> ... ]\n\
4089 Any arguments supplied are recorded with the trace as a stop reason and\n\
4090 reported by tstatus (if the target supports trace notes)."));
4092 add_com ("tstart", class_trace
, tstart_command
, _("\
4093 Start trace data collection.\n\
4094 Usage: tstart [ <notes> ... ]\n\
4095 Any arguments supplied are recorded with the trace as a note and\n\
4096 reported by tstatus (if the target supports trace notes)."));
4098 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4099 Ends a list of commands or actions.\n\
4100 Several GDB commands allow you to enter a list of commands or actions.\n\
4101 Entering \"end\" on a line by itself is the normal way to terminate\n\
4103 Note: the \"end\" command cannot be used at the gdb prompt."));
4105 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4106 Specify single-stepping behavior at a tracepoint.\n\
4107 Argument is number of instructions to trace in single-step mode\n\
4108 following the tracepoint. This command is normally followed by\n\
4109 one or more \"collect\" commands, to specify what to collect\n\
4110 while single-stepping.\n\n\
4111 Note: this command can only be used in a tracepoint \"actions\" list."));
4113 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4114 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4116 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4117 Specify one or more data items to be collected at a tracepoint.\n\
4118 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4119 collect all data (variables, registers) referenced by that expression.\n\
4120 Also accepts the following special arguments:\n\
4121 $regs -- all registers.\n\
4122 $args -- all function arguments.\n\
4123 $locals -- all variables local to the block/function scope.\n\
4124 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4125 Note: this command can only be used in a tracepoint \"actions\" list."));
4127 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4128 Specify one or more expressions to be evaluated at a tracepoint.\n\
4129 Accepts a comma-separated list of (one or more) expressions.\n\
4130 The result of each evaluation will be discarded.\n\
4131 Note: this command can only be used in a tracepoint \"actions\" list."));
4133 add_com ("actions", class_trace
, actions_command
, _("\
4134 Specify the actions to be taken at a tracepoint.\n\
4135 Tracepoint actions may include collecting of specified data,\n\
4136 single-stepping, or enabling/disabling other tracepoints,\n\
4137 depending on target's capabilities."));
4139 default_collect
= xstrdup ("");
4140 add_setshow_string_cmd ("default-collect", class_trace
,
4141 &default_collect
, _("\
4142 Set the list of expressions to collect by default"), _("\
4143 Show the list of expressions to collect by default"), NULL
,
4145 &setlist
, &showlist
);
4147 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4148 &disconnected_tracing
, _("\
4149 Set whether tracing continues after GDB disconnects."), _("\
4150 Show whether tracing continues after GDB disconnects."), _("\
4151 Use this to continue a tracing run even if GDB disconnects\n\
4152 or detaches from the target. You can reconnect later and look at\n\
4153 trace data collected in the meantime."),
4154 set_disconnected_tracing
,
4159 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4160 &circular_trace_buffer
, _("\
4161 Set target's use of circular trace buffer."), _("\
4162 Show target's use of circular trace buffer."), _("\
4163 Use this to make the trace buffer into a circular buffer,\n\
4164 which will discard traceframes (oldest first) instead of filling\n\
4165 up and stopping the trace run."),
4166 set_circular_trace_buffer
,
4171 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4172 &trace_buffer_size
, _("\
4173 Set requested size of trace buffer."), _("\
4174 Show requested size of trace buffer."), _("\
4175 Use this to choose a size for the trace buffer. Some targets\n\
4176 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4177 disables any attempt to set the buffer size and lets the target choose."),
4178 set_trace_buffer_size
, NULL
,
4179 &setlist
, &showlist
);
4181 add_setshow_string_cmd ("trace-user", class_trace
,
4183 Set the user name to use for current and future trace runs"), _("\
4184 Show the user name to use for current and future trace runs"), NULL
,
4185 set_trace_user
, NULL
,
4186 &setlist
, &showlist
);
4188 add_setshow_string_cmd ("trace-notes", class_trace
,
4190 Set notes string to use for current and future trace runs"), _("\
4191 Show the notes string to use for current and future trace runs"), NULL
,
4192 set_trace_notes
, NULL
,
4193 &setlist
, &showlist
);
4195 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4196 &trace_stop_notes
, _("\
4197 Set notes string to use for future tstop commands"), _("\
4198 Show the notes string to use for future tstop commands"), NULL
,
4199 set_trace_stop_notes
, NULL
,
4200 &setlist
, &showlist
);