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 counted_command_line
all_tracepoint_actions (struct breakpoint
*);
172 static struct trace_status trace_status
;
174 const char *stop_reason_names
[] = {
184 struct trace_status
*
185 current_trace_status (void)
187 return &trace_status
;
190 /* Free and clear the traceframe info cache of the current
194 clear_traceframe_info (void)
196 current_traceframe_info
= NULL
;
199 /* Set traceframe number to NUM. */
201 set_traceframe_num (int num
)
203 traceframe_number
= num
;
204 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
207 /* Set tracepoint number to NUM. */
209 set_tracepoint_num (int num
)
211 tracepoint_number
= num
;
212 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
215 /* Set externally visible debug variables for querying/printing
216 the traceframe context (line, function, file). */
219 set_traceframe_context (struct frame_info
*trace_frame
)
222 struct symbol
*traceframe_fun
;
223 symtab_and_line traceframe_sal
;
225 /* Save as globals for internal use. */
226 if (trace_frame
!= NULL
227 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
229 traceframe_sal
= find_pc_line (trace_pc
, 0);
230 traceframe_fun
= find_pc_function (trace_pc
);
232 /* Save linenumber as "$trace_line", a debugger variable visible to
234 set_internalvar_integer (lookup_internalvar ("trace_line"),
235 traceframe_sal
.line
);
239 traceframe_fun
= NULL
;
240 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
243 /* Save func name as "$trace_func", a debugger variable visible to
245 if (traceframe_fun
== NULL
246 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
247 clear_internalvar (lookup_internalvar ("trace_func"));
249 set_internalvar_string (lookup_internalvar ("trace_func"),
250 SYMBOL_LINKAGE_NAME (traceframe_fun
));
252 /* Save file name as "$trace_file", a debugger variable visible to
254 if (traceframe_sal
.symtab
== NULL
)
255 clear_internalvar (lookup_internalvar ("trace_file"));
257 set_internalvar_string (lookup_internalvar ("trace_file"),
258 symtab_to_filename_for_display (traceframe_sal
.symtab
));
261 /* Create a new trace state variable with the given name. */
263 struct trace_state_variable
*
264 create_trace_state_variable (const char *name
)
266 tvariables
.emplace_back (name
, next_tsv_number
++);
267 return &tvariables
.back ();
270 /* Look for a trace state variable of the given name. */
272 struct trace_state_variable
*
273 find_trace_state_variable (const char *name
)
275 for (trace_state_variable
&tsv
: tvariables
)
276 if (tsv
.name
== name
)
282 /* Look for a trace state variable of the given number. Return NULL if
285 struct trace_state_variable
*
286 find_trace_state_variable_by_number (int number
)
288 for (trace_state_variable
&tsv
: tvariables
)
289 if (tsv
.number
== number
)
296 delete_trace_state_variable (const char *name
)
298 for (auto it
= tvariables
.begin (); it
!= tvariables
.end (); it
++)
299 if (it
->name
== name
)
301 gdb::observers::tsv_deleted
.notify (&*it
);
302 tvariables
.erase (it
);
306 warning (_("No trace variable named \"$%s\", not deleting"), name
);
309 /* Throws an error if NAME is not valid syntax for a trace state
313 validate_trace_state_variable_name (const char *name
)
318 error (_("Must supply a non-empty variable name"));
320 /* All digits in the name is reserved for value history
322 for (p
= name
; isdigit (*p
); p
++)
325 error (_("$%s is not a valid trace state variable name"), name
);
327 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
330 error (_("$%s is not a valid trace state variable name"), name
);
333 /* The 'tvariable' command collects a name and optional expression to
334 evaluate into an initial value. */
337 trace_variable_command (const char *args
, int from_tty
)
340 struct trace_state_variable
*tsv
;
341 const char *name_start
, *p
;
344 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
346 /* Only allow two syntaxes; "$name" and "$name=value". */
347 p
= skip_spaces (args
);
350 error (_("Name of trace variable should start with '$'"));
353 while (isalnum (*p
) || *p
== '_')
355 std::string
name (name_start
, p
- name_start
);
358 if (*p
!= '=' && *p
!= '\0')
359 error (_("Syntax must be $NAME [ = EXPR ]"));
361 validate_trace_state_variable_name (name
.c_str ());
364 initval
= value_as_long (parse_and_eval (++p
));
366 /* If the variable already exists, just change its initial value. */
367 tsv
= find_trace_state_variable (name
.c_str ());
370 if (tsv
->initial_value
!= initval
)
372 tsv
->initial_value
= initval
;
373 gdb::observers::tsv_modified
.notify (tsv
);
375 printf_filtered (_("Trace state variable $%s "
376 "now has initial value %s.\n"),
377 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
381 /* Create a new variable. */
382 tsv
= create_trace_state_variable (name
.c_str ());
383 tsv
->initial_value
= initval
;
385 gdb::observers::tsv_created
.notify (tsv
);
387 printf_filtered (_("Trace state variable $%s "
388 "created, with initial value %s.\n"),
389 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
393 delete_trace_variable_command (const char *args
, int from_tty
)
397 if (query (_("Delete all trace state variables? ")))
400 gdb::observers::tsv_deleted
.notify (NULL
);
404 gdb_argv
argv (args
);
406 for (char *arg
: argv
)
409 delete_trace_state_variable (arg
+ 1);
411 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg
);
418 tvariables_info_1 (void)
420 struct ui_out
*uiout
= current_uiout
;
422 /* Try to acquire values from the target. */
423 for (trace_state_variable
&tsv
: tvariables
)
425 = target_get_trace_state_variable_value (tsv
.number
, &tsv
.value
);
428 ui_out_emit_table
table_emitter (uiout
, 3, tvariables
.size (),
430 uiout
->table_header (15, ui_left
, "name", "Name");
431 uiout
->table_header (11, ui_left
, "initial", "Initial");
432 uiout
->table_header (11, ui_left
, "current", "Current");
434 uiout
->table_body ();
436 for (const trace_state_variable
&tsv
: tvariables
)
440 ui_out_emit_tuple
tuple_emitter (uiout
, "variable");
442 uiout
->field_string ("name", std::string ("$") + tsv
.name
);
443 uiout
->field_string ("initial", plongest (tsv
.initial_value
));
446 c
= plongest (tsv
.value
);
447 else if (uiout
->is_mi_like_p ())
448 /* For MI, we prefer not to use magic string constants, but rather
449 omit the field completely. The difference between unknown and
450 undefined does not seem important enough to represent. */
452 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
453 /* The value is/was defined, but we don't have it. */
456 /* It is not meaningful to ask about the value. */
459 uiout
->field_string ("current", c
);
464 if (tvariables
.empty ())
465 uiout
->text (_("No trace state variables.\n"));
468 /* List all the trace state variables. */
471 info_tvariables_command (const char *args
, int from_tty
)
473 tvariables_info_1 ();
476 /* Stash definitions of tsvs into the given file. */
479 save_trace_state_variables (struct ui_file
*fp
)
481 for (const trace_state_variable
&tsv
: tvariables
)
483 fprintf_unfiltered (fp
, "tvariable $%s", tsv
.name
.c_str ());
484 if (tsv
.initial_value
)
485 fprintf_unfiltered (fp
, " = %s", plongest (tsv
.initial_value
));
486 fprintf_unfiltered (fp
, "\n");
490 /* ACTIONS functions: */
492 /* The three functions:
493 collect_pseudocommand,
494 while_stepping_pseudocommand, and
495 end_actions_pseudocommand
496 are placeholders for "commands" that are actually ONLY to be used
497 within a tracepoint action list. If the actual function is ever called,
498 it means that somebody issued the "command" at the top level,
499 which is always an error. */
502 end_actions_pseudocommand (const char *args
, int from_tty
)
504 error (_("This command cannot be used at the top level."));
508 while_stepping_pseudocommand (const char *args
, int from_tty
)
510 error (_("This command can only be used in a tracepoint actions list."));
514 collect_pseudocommand (const char *args
, int from_tty
)
516 error (_("This command can only be used in a tracepoint actions list."));
520 teval_pseudocommand (const char *args
, int from_tty
)
522 error (_("This command can only be used in a tracepoint actions list."));
525 /* Parse any collection options, such as /s for strings. */
528 decode_agent_options (const char *exp
, int *trace_string
)
530 struct value_print_options opts
;
537 /* Call this to borrow the print elements default for collection
539 get_user_print_options (&opts
);
544 if (target_supports_string_tracing ())
546 /* Allow an optional decimal number giving an explicit maximum
547 string length, defaulting it to the "print elements" value;
548 so "collect/s80 mystr" gets at most 80 bytes of string. */
549 *trace_string
= opts
.print_max
;
551 if (*exp
>= '0' && *exp
<= '9')
552 *trace_string
= atoi (exp
);
553 while (*exp
>= '0' && *exp
<= '9')
557 error (_("Target does not support \"/s\" option for string tracing."));
560 error (_("Undefined collection format \"%c\"."), *exp
);
562 exp
= skip_spaces (exp
);
567 /* Enter a list of actions for a tracepoint. */
569 actions_command (const char *args
, int from_tty
)
571 struct tracepoint
*t
;
573 t
= get_tracepoint_by_number (&args
, NULL
);
577 string_printf ("Enter actions for tracepoint %d, one per line.",
580 counted_command_line l
= read_command_lines (tmpbuf
.c_str (),
582 [=] (const char *line
)
584 validate_actionline (line
, t
);
586 breakpoint_set_commands (t
, std::move (l
));
588 /* else just return */
591 /* Report the results of checking the agent expression, as errors or
595 report_agent_reqs_errors (struct agent_expr
*aexpr
)
597 /* All of the "flaws" are serious bytecode generation issues that
598 should never occur. */
599 if (aexpr
->flaw
!= agent_flaw_none
)
600 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
602 /* If analysis shows a stack underflow, GDB must have done something
603 badly wrong in its bytecode generation. */
604 if (aexpr
->min_height
< 0)
605 internal_error (__FILE__
, __LINE__
,
606 _("expression has min height < 0"));
608 /* Issue this error if the stack is predicted to get too deep. The
609 limit is rather arbitrary; a better scheme might be for the
610 target to report how much stack it will have available. The
611 depth roughly corresponds to parenthesization, so a limit of 20
612 amounts to 20 levels of expression nesting, which is actually
613 a pretty big hairy expression. */
614 if (aexpr
->max_height
> 20)
615 error (_("Expression is too complicated."));
618 /* worker function */
620 validate_actionline (const char *line
, struct breakpoint
*b
)
622 struct cmd_list_element
*c
;
625 struct bp_location
*loc
;
626 struct tracepoint
*t
= (struct tracepoint
*) b
;
628 /* If EOF is typed, *line is NULL. */
632 p
= skip_spaces (line
);
634 /* Symbol lookup etc. */
635 if (*p
== '\0') /* empty line: just prompt for another line. */
638 if (*p
== '#') /* comment line */
641 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
643 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
645 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
647 int trace_string
= 0;
650 p
= decode_agent_options (p
, &trace_string
);
653 { /* Repeat over a comma-separated list. */
654 QUIT
; /* Allow user to bail out with ^C. */
657 if (*p
== '$') /* Look for special pseudo-symbols. */
659 if (0 == strncasecmp ("reg", p
+ 1, 3)
660 || 0 == strncasecmp ("arg", p
+ 1, 3)
661 || 0 == strncasecmp ("loc", p
+ 1, 3)
662 || 0 == strncasecmp ("_ret", p
+ 1, 4)
663 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
668 /* else fall thru, treat p as an expression and parse it! */
671 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
674 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
675 block_for_pc (loc
->address
), 1);
677 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
679 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
681 error (_("constant `%s' (value %s) "
682 "will not be collected."),
683 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
684 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
686 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
687 == LOC_OPTIMIZED_OUT
)
689 error (_("`%s' is optimized away "
690 "and cannot be collected."),
691 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
695 /* We have something to collect, make sure that the expr to
696 bytecode translator can handle it and that it's not too
698 agent_expr_up aexpr
= gen_trace_for_expr (loc
->address
,
702 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
703 error (_("Expression is too complicated."));
705 ax_reqs (aexpr
.get ());
707 report_agent_reqs_errors (aexpr
.get ());
710 while (p
&& *p
++ == ',');
713 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
716 { /* Repeat over a comma-separated list. */
717 QUIT
; /* Allow user to bail out with ^C. */
721 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
725 /* Only expressions are allowed for this action. */
726 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
727 block_for_pc (loc
->address
), 1);
729 /* We have something to evaluate, make sure that the expr to
730 bytecode translator can handle it and that it's not too
732 agent_expr_up aexpr
= gen_eval_for_expr (loc
->address
, exp
.get ());
734 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
735 error (_("Expression is too complicated."));
737 ax_reqs (aexpr
.get ());
738 report_agent_reqs_errors (aexpr
.get ());
741 while (p
&& *p
++ == ',');
744 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
749 t
->step_count
= strtol (p
, &endp
, 0);
750 if (endp
== p
|| t
->step_count
== 0)
751 error (_("while-stepping step count `%s' is malformed."), line
);
755 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
759 error (_("`%s' is not a supported tracepoint action."), line
);
763 memrange_absolute
= -1
766 /* MEMRANGE functions: */
768 /* Compare memranges for std::sort. */
771 memrange_comp (const memrange
&a
, const memrange
&b
)
773 if (a
.type
== b
.type
)
775 if (a
.type
== memrange_absolute
)
776 return (bfd_vma
) a
.start
< (bfd_vma
) b
.start
;
778 return a
.start
< b
.start
;
781 return a
.type
< b
.type
;
784 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
787 memrange_sortmerge (std::vector
<memrange
> &memranges
)
789 if (!memranges
.empty ())
793 std::sort (memranges
.begin (), memranges
.end (), memrange_comp
);
795 for (a
= 0, b
= 1; b
< memranges
.size (); b
++)
797 /* If memrange b overlaps or is adjacent to memrange a,
799 if (memranges
[a
].type
== memranges
[b
].type
800 && memranges
[b
].start
<= memranges
[a
].end
)
802 if (memranges
[b
].end
> memranges
[a
].end
)
803 memranges
[a
].end
= memranges
[b
].end
;
804 continue; /* next b, same a */
808 memranges
[a
] = memranges
[b
];
810 memranges
.resize (a
+ 1);
814 /* Add a register to a collection list. */
817 collection_list::add_register (unsigned int regno
)
820 printf_filtered ("collect register %d\n", regno
);
821 if (regno
>= (8 * sizeof (m_regs_mask
)))
822 error (_("Internal: register number %d too large for tracepoint"),
824 m_regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
827 /* Add a memrange to a collection list. */
830 collection_list::add_memrange (struct gdbarch
*gdbarch
,
831 int type
, bfd_signed_vma base
,
835 printf_filtered ("(%d,%s,%ld)\n", type
, paddress (gdbarch
, base
), len
);
837 /* type: memrange_absolute == memory, other n == basereg */
838 /* base: addr if memory, offset if reg relative. */
839 /* len: we actually save end (base + len) for convenience */
840 m_memranges
.emplace_back (type
, base
, base
+ len
);
842 if (type
!= memrange_absolute
) /* Better collect the base register! */
846 /* Add a symbol to a collection list. */
849 collection_list::collect_symbol (struct symbol
*sym
,
850 struct gdbarch
*gdbarch
,
851 long frame_regno
, long frame_offset
,
857 bfd_signed_vma offset
;
858 int treat_as_expr
= 0;
860 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
861 switch (SYMBOL_CLASS (sym
))
864 printf_filtered ("%s: don't know symbol class %d\n",
865 SYMBOL_PRINT_NAME (sym
),
869 printf_filtered ("constant %s (value %s) will not be collected.\n",
870 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
873 offset
= SYMBOL_VALUE_ADDRESS (sym
);
876 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
877 SYMBOL_PRINT_NAME (sym
), len
,
878 paddress (gdbarch
, offset
));
880 /* A struct may be a C++ class with static fields, go to general
881 expression handling. */
882 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
885 add_memrange (gdbarch
, memrange_absolute
, offset
, len
);
888 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
890 printf_filtered ("LOC_REG[parm] %s: ",
891 SYMBOL_PRINT_NAME (sym
));
893 /* Check for doubles stored in two registers. */
894 /* FIXME: how about larger types stored in 3 or more regs? */
895 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
896 len
> register_size (gdbarch
, reg
))
897 add_register (reg
+ 1);
900 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
901 printf_filtered (" (will not collect %s)\n",
902 SYMBOL_PRINT_NAME (sym
));
906 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
909 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
910 " from frame ptr reg %d\n",
911 SYMBOL_PRINT_NAME (sym
), len
,
912 paddress (gdbarch
, offset
), reg
);
914 add_memrange (gdbarch
, reg
, offset
, len
);
916 case LOC_REGPARM_ADDR
:
917 reg
= SYMBOL_VALUE (sym
);
921 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
923 SYMBOL_PRINT_NAME (sym
), len
,
924 paddress (gdbarch
, offset
), reg
);
926 add_memrange (gdbarch
, reg
, offset
, len
);
930 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
933 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
934 " from frame ptr reg %d\n",
935 SYMBOL_PRINT_NAME (sym
), len
,
936 paddress (gdbarch
, offset
), reg
);
938 add_memrange (gdbarch
, reg
, offset
, len
);
945 case LOC_OPTIMIZED_OUT
:
946 printf_filtered ("%s has been optimized out of existence.\n",
947 SYMBOL_PRINT_NAME (sym
));
955 /* Expressions are the most general case. */
958 agent_expr_up aexpr
= gen_trace_for_var (scope
, gdbarch
,
961 /* It can happen that the symbol is recorded as a computed
962 location, but it's been optimized away and doesn't actually
963 have a location expression. */
966 printf_filtered ("%s has been optimized out of existence.\n",
967 SYMBOL_PRINT_NAME (sym
));
971 ax_reqs (aexpr
.get ());
973 report_agent_reqs_errors (aexpr
.get ());
975 /* Take care of the registers. */
976 if (aexpr
->reg_mask_len
> 0)
978 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
980 QUIT
; /* Allow user to bail out with ^C. */
981 if (aexpr
->reg_mask
[ndx1
] != 0)
983 /* Assume chars have 8 bits. */
984 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
985 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
986 /* It's used -- record it. */
987 add_register (ndx1
* 8 + ndx2
);
992 add_aexpr (std::move (aexpr
));
996 /* Data to be passed around in the calls to the locals and args
999 struct add_local_symbols_data
1001 struct collection_list
*collect
;
1002 struct gdbarch
*gdbarch
;
1010 /* The callback for the locals and args iterators. */
1013 do_collect_symbol (const char *print_name
,
1017 struct add_local_symbols_data
*p
= (struct add_local_symbols_data
*) cb_data
;
1019 p
->collect
->collect_symbol (sym
, p
->gdbarch
, p
->frame_regno
,
1020 p
->frame_offset
, p
->pc
, p
->trace_string
);
1023 p
->collect
->add_wholly_collected (print_name
);
1027 collection_list::add_wholly_collected (const char *print_name
)
1029 m_wholly_collected
.push_back (print_name
);
1032 /* Add all locals (or args) symbols to collection list. */
1035 collection_list::add_local_symbols (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1036 long frame_regno
, long frame_offset
, int type
,
1039 const struct block
*block
;
1040 struct add_local_symbols_data cb_data
;
1042 cb_data
.collect
= this;
1043 cb_data
.gdbarch
= gdbarch
;
1045 cb_data
.frame_regno
= frame_regno
;
1046 cb_data
.frame_offset
= frame_offset
;
1048 cb_data
.trace_string
= trace_string
;
1052 block
= block_for_pc (pc
);
1055 warning (_("Can't collect locals; "
1056 "no symbol table info available.\n"));
1060 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1061 if (cb_data
.count
== 0)
1062 warning (_("No locals found in scope."));
1066 pc
= get_pc_function_start (pc
);
1067 block
= block_for_pc (pc
);
1070 warning (_("Can't collect args; no symbol table info available."));
1074 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1075 if (cb_data
.count
== 0)
1076 warning (_("No args found in scope."));
1081 collection_list::add_static_trace_data ()
1084 printf_filtered ("collect static trace data\n");
1085 m_strace_data
= true;
1088 collection_list::collection_list ()
1090 m_strace_data (false)
1092 m_memranges
.reserve (128);
1093 m_aexprs
.reserve (128);
1096 /* Reduce a collection list to string form (for gdb protocol). */
1098 std::vector
<std::string
>
1099 collection_list::stringify ()
1101 char temp_buf
[2048];
1105 std::vector
<std::string
> str_list
;
1110 printf_filtered ("\nCollecting static trace data\n");
1113 str_list
.emplace_back (temp_buf
, end
- temp_buf
);
1116 for (i
= sizeof (m_regs_mask
) - 1; i
> 0; i
--)
1117 if (m_regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1119 if (m_regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1122 printf_filtered ("\nCollecting registers (mask): 0x");
1127 QUIT
; /* Allow user to bail out with ^C. */
1129 printf_filtered ("%02X", m_regs_mask
[i
]);
1130 sprintf (end
, "%02X", m_regs_mask
[i
]);
1133 str_list
.emplace_back (temp_buf
);
1136 printf_filtered ("\n");
1137 if (!m_memranges
.empty () && info_verbose
)
1138 printf_filtered ("Collecting memranges: \n");
1139 for (i
= 0, count
= 0, end
= temp_buf
; i
< m_memranges
.size (); i
++)
1141 QUIT
; /* Allow user to bail out with ^C. */
1144 printf_filtered ("(%d, %s, %ld)\n",
1145 m_memranges
[i
].type
,
1146 paddress (target_gdbarch (),
1147 m_memranges
[i
].start
),
1148 (long) (m_memranges
[i
].end
1149 - m_memranges
[i
].start
));
1151 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1153 str_list
.emplace_back (temp_buf
, count
);
1159 bfd_signed_vma length
1160 = m_memranges
[i
].end
- m_memranges
[i
].start
;
1162 /* The "%X" conversion specifier expects an unsigned argument,
1163 so passing -1 (memrange_absolute) to it directly gives you
1164 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1166 if (m_memranges
[i
].type
== memrange_absolute
)
1167 sprintf (end
, "M-1,%s,%lX", phex_nz (m_memranges
[i
].start
, 0),
1170 sprintf (end
, "M%X,%s,%lX", m_memranges
[i
].type
,
1171 phex_nz (m_memranges
[i
].start
, 0), (long) length
);
1174 count
+= strlen (end
);
1175 end
= temp_buf
+ count
;
1178 for (i
= 0; i
< m_aexprs
.size (); i
++)
1180 QUIT
; /* Allow user to bail out with ^C. */
1181 if ((count
+ 10 + 2 * m_aexprs
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1183 str_list
.emplace_back (temp_buf
, count
);
1187 sprintf (end
, "X%08X,", m_aexprs
[i
]->len
);
1188 end
+= 10; /* 'X' + 8 hex digits + ',' */
1191 end
= mem2hex (m_aexprs
[i
]->buf
, end
, m_aexprs
[i
]->len
);
1192 count
+= 2 * m_aexprs
[i
]->len
;
1197 str_list
.emplace_back (temp_buf
, count
);
1205 /* Add the printed expression EXP to *LIST. */
1208 collection_list::append_exp (struct expression
*exp
)
1210 string_file tmp_stream
;
1212 print_expression (exp
, &tmp_stream
);
1214 m_computed
.push_back (std::move (tmp_stream
.string ()));
1218 collection_list::finish ()
1220 memrange_sortmerge (m_memranges
);
1224 encode_actions_1 (struct command_line
*action
,
1225 struct bp_location
*tloc
,
1227 LONGEST frame_offset
,
1228 struct collection_list
*collect
,
1229 struct collection_list
*stepping_list
)
1231 const char *action_exp
;
1233 struct value
*tempval
;
1234 struct cmd_list_element
*cmd
;
1236 for (; action
; action
= action
->next
)
1238 QUIT
; /* Allow user to bail out with ^C. */
1239 action_exp
= action
->line
;
1240 action_exp
= skip_spaces (action_exp
);
1242 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1244 error (_("Bad action list item: %s"), action_exp
);
1246 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1248 int trace_string
= 0;
1250 if (*action_exp
== '/')
1251 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1254 { /* Repeat over a comma-separated list. */
1255 QUIT
; /* Allow user to bail out with ^C. */
1256 action_exp
= skip_spaces (action_exp
);
1258 if (0 == strncasecmp ("$reg", action_exp
, 4))
1260 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
1261 collect
->add_register (i
);
1262 action_exp
= strchr (action_exp
, ','); /* more? */
1264 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1266 collect
->add_local_symbols (target_gdbarch (),
1272 action_exp
= strchr (action_exp
, ','); /* more? */
1274 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1276 collect
->add_local_symbols (target_gdbarch (),
1282 action_exp
= strchr (action_exp
, ','); /* more? */
1284 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1287 = gen_trace_for_return_address (tloc
->address
,
1291 ax_reqs (aexpr
.get ());
1292 report_agent_reqs_errors (aexpr
.get ());
1294 /* take care of the registers */
1295 if (aexpr
->reg_mask_len
> 0)
1297 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1299 QUIT
; /* allow user to bail out with ^C */
1300 if (aexpr
->reg_mask
[ndx1
] != 0)
1302 /* assume chars have 8 bits */
1303 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1304 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1306 /* It's used -- record it. */
1307 collect
->add_register (ndx1
* 8 + ndx2
);
1313 collect
->add_aexpr (std::move (aexpr
));
1314 action_exp
= strchr (action_exp
, ','); /* more? */
1316 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1318 collect
->add_static_trace_data ();
1319 action_exp
= strchr (action_exp
, ','); /* more? */
1325 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1326 block_for_pc (tloc
->address
),
1329 switch (exp
->elts
[0].opcode
)
1333 const char *name
= &exp
->elts
[2].string
;
1335 i
= user_reg_map_name_to_regnum (target_gdbarch (),
1336 name
, strlen (name
));
1338 internal_error (__FILE__
, __LINE__
,
1339 _("Register $%s not available"),
1342 printf_filtered ("OP_REGISTER: ");
1343 collect
->add_register (i
);
1348 /* Safe because we know it's a simple expression. */
1349 tempval
= evaluate_expression (exp
.get ());
1350 addr
= value_address (tempval
);
1351 /* Initialize the TYPE_LENGTH if it is a typedef. */
1352 check_typedef (exp
->elts
[1].type
);
1353 collect
->add_memrange (target_gdbarch (),
1354 memrange_absolute
, addr
,
1355 TYPE_LENGTH (exp
->elts
[1].type
));
1356 collect
->append_exp (exp
.get ());
1361 struct symbol
*sym
= exp
->elts
[2].symbol
;
1362 const char *name
= SYMBOL_NATURAL_NAME (sym
);
1364 collect
->collect_symbol (exp
->elts
[2].symbol
,
1370 collect
->add_wholly_collected (name
);
1374 default: /* Full-fledged expression. */
1375 agent_expr_up aexpr
= gen_trace_for_expr (tloc
->address
,
1379 ax_reqs (aexpr
.get ());
1381 report_agent_reqs_errors (aexpr
.get ());
1383 /* Take care of the registers. */
1384 if (aexpr
->reg_mask_len
> 0)
1386 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1388 QUIT
; /* Allow user to bail out with ^C. */
1389 if (aexpr
->reg_mask
[ndx1
] != 0)
1391 /* Assume chars have 8 bits. */
1392 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
1393 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1395 /* It's used -- record it. */
1396 collect
->add_register (ndx1
* 8 + ndx2
);
1402 collect
->add_aexpr (std::move (aexpr
));
1403 collect
->append_exp (exp
.get ());
1408 while (action_exp
&& *action_exp
++ == ',');
1410 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1413 { /* Repeat over a comma-separated list. */
1414 QUIT
; /* Allow user to bail out with ^C. */
1415 action_exp
= skip_spaces (action_exp
);
1418 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1419 block_for_pc (tloc
->address
),
1422 agent_expr_up aexpr
= gen_eval_for_expr (tloc
->address
,
1425 ax_reqs (aexpr
.get ());
1426 report_agent_reqs_errors (aexpr
.get ());
1428 /* Even though we're not officially collecting, add
1429 to the collect list anyway. */
1430 collect
->add_aexpr (std::move (aexpr
));
1433 while (action_exp
&& *action_exp
++ == ',');
1435 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1437 /* We check against nested while-stepping when setting
1438 breakpoint action, so no way to run into nested
1440 gdb_assert (stepping_list
);
1442 encode_actions_1 (action
->body_list_0
.get (), tloc
, frame_reg
,
1443 frame_offset
, stepping_list
, NULL
);
1446 error (_("Invalid tracepoint command '%s'"), action
->line
);
1450 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1451 and STEPPING_LIST. */
1454 encode_actions (struct bp_location
*tloc
,
1455 struct collection_list
*tracepoint_list
,
1456 struct collection_list
*stepping_list
)
1459 LONGEST frame_offset
;
1461 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1462 tloc
->address
, &frame_reg
, &frame_offset
);
1464 counted_command_line actions
= all_tracepoint_actions (tloc
->owner
);
1465 encode_actions_1 (actions
.get (), tloc
, frame_reg
, frame_offset
,
1466 tracepoint_list
, stepping_list
);
1467 encode_actions_1 (breakpoint_commands (tloc
->owner
), tloc
,
1468 frame_reg
, frame_offset
, tracepoint_list
, stepping_list
);
1470 tracepoint_list
->finish ();
1471 stepping_list
->finish ();
1474 /* Render all actions into gdb protocol. */
1477 encode_actions_rsp (struct bp_location
*tloc
,
1478 std::vector
<std::string
> *tdp_actions
,
1479 std::vector
<std::string
> *stepping_actions
)
1481 struct collection_list tracepoint_list
, stepping_list
;
1483 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
1485 *tdp_actions
= tracepoint_list
.stringify ();
1486 *stepping_actions
= stepping_list
.stringify ();
1490 collection_list::add_aexpr (agent_expr_up aexpr
)
1492 m_aexprs
.push_back (std::move (aexpr
));
1496 process_tracepoint_on_disconnect (void)
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 for (breakpoint
*b
: all_tracepoints ())
1511 struct bp_location
*loc1
;
1513 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1515 if (loc1
->shlib_disabled
)
1528 warning (_("Pending tracepoints will not be resolved while"
1529 " GDB is disconnected\n"));
1532 /* Reset local state of tracing. */
1535 trace_reset_local_state (void)
1537 set_traceframe_num (-1);
1538 set_tracepoint_num (-1);
1539 set_traceframe_context (NULL
);
1540 clear_traceframe_info ();
1544 start_tracing (const char *notes
)
1546 int any_enabled
= 0, num_to_download
= 0;
1549 std::vector
<breakpoint
*> tp_vec
= all_tracepoints ();
1551 /* No point in tracing without any tracepoints... */
1552 if (tp_vec
.empty ())
1553 error (_("No tracepoints defined, not starting trace"));
1555 for (breakpoint
*b
: tp_vec
)
1557 if (b
->enable_state
== bp_enabled
)
1560 if ((b
->type
== bp_fast_tracepoint
1561 ? may_insert_fast_tracepoints
1562 : may_insert_tracepoints
))
1565 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1566 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1571 if (target_supports_enable_disable_tracepoint ())
1572 warning (_("No tracepoints enabled"));
1575 /* No point in tracing with only disabled tracepoints that
1576 cannot be re-enabled. */
1577 error (_("No tracepoints enabled, not starting trace"));
1581 if (num_to_download
<= 0)
1582 error (_("No tracepoints that may be downloaded, not starting trace"));
1584 target_trace_init ();
1586 for (breakpoint
*b
: tp_vec
)
1588 struct tracepoint
*t
= (struct tracepoint
*) b
;
1589 struct bp_location
*loc
;
1590 int bp_location_downloaded
= 0;
1592 /* Clear `inserted' flag. */
1593 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1596 if ((b
->type
== bp_fast_tracepoint
1597 ? !may_insert_fast_tracepoints
1598 : !may_insert_tracepoints
))
1601 t
->number_on_target
= 0;
1603 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1605 /* Since tracepoint locations are never duplicated, `inserted'
1606 flag should be zero. */
1607 gdb_assert (!loc
->inserted
);
1609 target_download_tracepoint (loc
);
1612 bp_location_downloaded
= 1;
1615 t
->number_on_target
= b
->number
;
1617 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1618 if (loc
->probe
.prob
!= NULL
)
1619 loc
->probe
.prob
->set_semaphore (loc
->probe
.objfile
,
1622 if (bp_location_downloaded
)
1623 gdb::observers::breakpoint_modified
.notify (b
);
1626 /* Send down all the trace state variables too. */
1627 for (const trace_state_variable
&tsv
: tvariables
)
1628 target_download_trace_state_variable (tsv
);
1630 /* Tell target to treat text-like sections as transparent. */
1631 target_trace_set_readonly_regions ();
1632 /* Set some mode flags. */
1633 target_set_disconnected_tracing (disconnected_tracing
);
1634 target_set_circular_trace_buffer (circular_trace_buffer
);
1635 target_set_trace_buffer_size (trace_buffer_size
);
1638 notes
= trace_notes
;
1639 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1641 if (!ret
&& (trace_user
|| notes
))
1642 warning (_("Target does not support trace user/notes, info ignored"));
1644 /* Now insert traps and begin collecting data. */
1645 target_trace_start ();
1647 /* Reset our local state. */
1648 trace_reset_local_state ();
1649 current_trace_status()->running
= 1;
1652 /* The tstart command requests the target to start a new trace run.
1653 The command passes any arguments it has to the target verbatim, as
1654 an optional "trace note". This is useful as for instance a warning
1655 to other users if the trace runs disconnected, and you don't want
1656 anybody else messing with the target. */
1659 tstart_command (const char *args
, int from_tty
)
1661 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1663 if (current_trace_status ()->running
)
1666 && !query (_("A trace is running already. Start a new run? ")))
1667 error (_("New trace run not started."));
1670 start_tracing (args
);
1673 /* The tstop command stops the tracing run. The command passes any
1674 supplied arguments to the target verbatim as a "stop note"; if the
1675 target supports trace notes, then it will be reported back as part
1676 of the trace run's status. */
1679 tstop_command (const char *args
, int from_tty
)
1681 if (!current_trace_status ()->running
)
1682 error (_("Trace is not running."));
1684 stop_tracing (args
);
1688 stop_tracing (const char *note
)
1692 target_trace_stop ();
1694 for (breakpoint
*t
: all_tracepoints ())
1696 struct bp_location
*loc
;
1698 if ((t
->type
== bp_fast_tracepoint
1699 ? !may_insert_fast_tracepoints
1700 : !may_insert_tracepoints
))
1703 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1705 /* GDB can be totally absent in some disconnected trace scenarios,
1706 but we don't really care if this semaphore goes out of sync.
1707 That's why we are decrementing it here, but not taking care
1709 if (loc
->probe
.prob
!= NULL
)
1710 loc
->probe
.prob
->clear_semaphore (loc
->probe
.objfile
,
1716 note
= trace_stop_notes
;
1717 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1720 warning (_("Target does not support trace notes, note ignored"));
1722 /* Should change in response to reply? */
1723 current_trace_status ()->running
= 0;
1726 /* tstatus command */
1728 tstatus_command (const char *args
, int from_tty
)
1730 struct trace_status
*ts
= current_trace_status ();
1733 status
= target_get_trace_status (ts
);
1737 if (ts
->filename
!= NULL
)
1738 printf_filtered (_("Using a trace file.\n"));
1741 printf_filtered (_("Trace can not be run on this target.\n"));
1746 if (!ts
->running_known
)
1748 printf_filtered (_("Run/stop status is unknown.\n"));
1750 else if (ts
->running
)
1752 printf_filtered (_("Trace is running on the target.\n"));
1756 switch (ts
->stop_reason
)
1758 case trace_never_run
:
1759 printf_filtered (_("No trace has been run on the target.\n"));
1761 case trace_stop_command
:
1763 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1766 printf_filtered (_("Trace stopped by a tstop command.\n"));
1768 case trace_buffer_full
:
1769 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1771 case trace_disconnected
:
1772 printf_filtered (_("Trace stopped because of disconnection.\n"));
1774 case tracepoint_passcount
:
1775 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1776 ts
->stopping_tracepoint
);
1778 case tracepoint_error
:
1779 if (ts
->stopping_tracepoint
)
1780 printf_filtered (_("Trace stopped by an "
1781 "error (%s, tracepoint %d).\n"),
1782 ts
->stop_desc
, ts
->stopping_tracepoint
);
1784 printf_filtered (_("Trace stopped by an error (%s).\n"),
1787 case trace_stop_reason_unknown
:
1788 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1791 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1797 if (ts
->traceframes_created
>= 0
1798 && ts
->traceframe_count
!= ts
->traceframes_created
)
1800 printf_filtered (_("Buffer contains %d trace "
1801 "frames (of %d created total).\n"),
1802 ts
->traceframe_count
, ts
->traceframes_created
);
1804 else if (ts
->traceframe_count
>= 0)
1806 printf_filtered (_("Collected %d trace frames.\n"),
1807 ts
->traceframe_count
);
1810 if (ts
->buffer_free
>= 0)
1812 if (ts
->buffer_size
>= 0)
1814 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1815 ts
->buffer_free
, ts
->buffer_size
);
1816 if (ts
->buffer_size
> 0)
1817 printf_filtered (_(" (%d%% full)"),
1818 ((int) ((((long long) (ts
->buffer_size
1819 - ts
->buffer_free
)) * 100)
1820 / ts
->buffer_size
)));
1821 printf_filtered (_(".\n"));
1824 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1828 if (ts
->disconnected_tracing
)
1829 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1831 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1833 if (ts
->circular_buffer
)
1834 printf_filtered (_("Trace buffer is circular.\n"));
1836 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1837 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1839 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1840 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1842 /* Now report on what we're doing with tfind. */
1843 if (traceframe_number
>= 0)
1844 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1845 traceframe_number
, tracepoint_number
);
1847 printf_filtered (_("Not looking at any trace frame.\n"));
1849 /* Report start/stop times if supplied. */
1854 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1856 /* Reporting a run time is more readable than two long numbers. */
1857 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1858 (long int) (ts
->start_time
/ 1000000),
1859 (long int) (ts
->start_time
% 1000000),
1860 (long int) (run_time
/ 1000000),
1861 (long int) (run_time
% 1000000));
1864 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1865 (long int) (ts
->start_time
/ 1000000),
1866 (long int) (ts
->start_time
% 1000000));
1868 else if (ts
->stop_time
)
1869 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1870 (long int) (ts
->stop_time
/ 1000000),
1871 (long int) (ts
->stop_time
% 1000000));
1873 /* Now report any per-tracepoint status available. */
1874 for (breakpoint
*t
: all_tracepoints ())
1875 target_get_tracepoint_status (t
, NULL
);
1878 /* Report the trace status to uiout, in a way suitable for MI, and not
1879 suitable for CLI. If ON_STOP is true, suppress a few fields that
1880 are not meaningful in the -trace-stop response.
1882 The implementation is essentially parallel to trace_status_command, but
1883 merging them will result in unreadable code. */
1885 trace_status_mi (int on_stop
)
1887 struct ui_out
*uiout
= current_uiout
;
1888 struct trace_status
*ts
= current_trace_status ();
1891 status
= target_get_trace_status (ts
);
1893 if (status
== -1 && ts
->filename
== NULL
)
1895 uiout
->field_string ("supported", "0");
1899 if (ts
->filename
!= NULL
)
1900 uiout
->field_string ("supported", "file");
1902 uiout
->field_string ("supported", "1");
1904 if (ts
->filename
!= NULL
)
1905 uiout
->field_string ("trace-file", ts
->filename
);
1907 gdb_assert (ts
->running_known
);
1911 uiout
->field_string ("running", "1");
1913 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1914 Given that the frontend gets the status either on -trace-stop, or from
1915 -trace-status after re-connection, it does not seem like this
1916 information is necessary for anything. It is not necessary for either
1917 figuring the vital state of the target nor for navigation of trace
1918 frames. If the frontend wants to show the current state is some
1919 configure dialog, it can request the value when such dialog is
1920 invoked by the user. */
1924 const char *stop_reason
= NULL
;
1925 int stopping_tracepoint
= -1;
1928 uiout
->field_string ("running", "0");
1930 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1932 switch (ts
->stop_reason
)
1934 case trace_stop_command
:
1935 stop_reason
= "request";
1937 case trace_buffer_full
:
1938 stop_reason
= "overflow";
1940 case trace_disconnected
:
1941 stop_reason
= "disconnection";
1943 case tracepoint_passcount
:
1944 stop_reason
= "passcount";
1945 stopping_tracepoint
= ts
->stopping_tracepoint
;
1947 case tracepoint_error
:
1948 stop_reason
= "error";
1949 stopping_tracepoint
= ts
->stopping_tracepoint
;
1955 uiout
->field_string ("stop-reason", stop_reason
);
1956 if (stopping_tracepoint
!= -1)
1957 uiout
->field_int ("stopping-tracepoint",
1958 stopping_tracepoint
);
1959 if (ts
->stop_reason
== tracepoint_error
)
1960 uiout
->field_string ("error-description",
1966 if (ts
->traceframe_count
!= -1)
1967 uiout
->field_int ("frames", ts
->traceframe_count
);
1968 if (ts
->traceframes_created
!= -1)
1969 uiout
->field_int ("frames-created", ts
->traceframes_created
);
1970 if (ts
->buffer_size
!= -1)
1971 uiout
->field_int ("buffer-size", ts
->buffer_size
);
1972 if (ts
->buffer_free
!= -1)
1973 uiout
->field_int ("buffer-free", ts
->buffer_free
);
1975 uiout
->field_int ("disconnected", ts
->disconnected_tracing
);
1976 uiout
->field_int ("circular", ts
->circular_buffer
);
1978 uiout
->field_string ("user-name", ts
->user_name
);
1979 uiout
->field_string ("notes", ts
->notes
);
1984 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
1985 (long int) (ts
->start_time
/ 1000000),
1986 (long int) (ts
->start_time
% 1000000));
1987 uiout
->field_string ("start-time", buf
);
1988 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
1989 (long int) (ts
->stop_time
/ 1000000),
1990 (long int) (ts
->stop_time
% 1000000));
1991 uiout
->field_string ("stop-time", buf
);
1995 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
1996 user if she really wants to detach. */
1999 query_if_trace_running (int from_tty
)
2004 /* It can happen that the target that was tracing went away on its
2005 own, and we didn't notice. Get a status update, and if the
2006 current target doesn't even do tracing, then assume it's not
2008 if (target_get_trace_status (current_trace_status ()) < 0)
2009 current_trace_status ()->running
= 0;
2011 /* If running interactively, give the user the option to cancel and
2012 then decide what to do differently with the run. Scripts are
2013 just going to disconnect and let the target deal with it,
2014 according to how it's been instructed previously via
2015 disconnected-tracing. */
2016 if (current_trace_status ()->running
)
2018 process_tracepoint_on_disconnect ();
2020 if (current_trace_status ()->disconnected_tracing
)
2022 if (!query (_("Trace is running and will "
2023 "continue after detach; detach anyway? ")))
2024 error (_("Not confirmed."));
2028 if (!query (_("Trace is running but will "
2029 "stop on detach; detach anyway? ")))
2030 error (_("Not confirmed."));
2035 /* This function handles the details of what to do about an ongoing
2036 tracing run if the user has asked to detach or otherwise disconnect
2040 disconnect_tracing (void)
2042 /* Also we want to be out of tfind mode, otherwise things can get
2043 confusing upon reconnection. Just use these calls instead of
2044 full tfind_1 behavior because we're in the middle of detaching,
2045 and there's no point to updating current stack frame etc. */
2046 trace_reset_local_state ();
2049 /* Worker function for the various flavors of the tfind command. */
2051 tfind_1 (enum trace_find_type type
, int num
,
2052 CORE_ADDR addr1
, CORE_ADDR addr2
,
2055 int target_frameno
= -1, target_tracept
= -1;
2056 struct frame_id old_frame_id
= null_frame_id
;
2057 struct tracepoint
*tp
;
2058 struct ui_out
*uiout
= current_uiout
;
2060 /* Only try to get the current stack frame if we have a chance of
2061 succeeding. In particular, if we're trying to get a first trace
2062 frame while all threads are running, it's not going to succeed,
2063 so leave it with a default value and let the frame comparison
2064 below (correctly) decide to print out the source location of the
2066 if (!(type
== tfind_number
&& num
== -1)
2067 && (has_stack_frames () || traceframe_number
>= 0))
2068 old_frame_id
= get_frame_id (get_current_frame ());
2070 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2073 if (type
== tfind_number
2075 && target_frameno
== -1)
2077 /* We told the target to get out of tfind mode, and it did. */
2079 else if (target_frameno
== -1)
2081 /* A request for a non-existent trace frame has failed.
2082 Our response will be different, depending on FROM_TTY:
2084 If FROM_TTY is true, meaning that this command was
2085 typed interactively by the user, then give an error
2086 and DO NOT change the state of traceframe_number etc.
2088 However if FROM_TTY is false, meaning that we're either
2089 in a script, a loop, or a user-defined command, then
2090 DON'T give an error, but DO change the state of
2091 traceframe_number etc. to invalid.
2093 The rationalle is that if you typed the command, you
2094 might just have committed a typo or something, and you'd
2095 like to NOT lose your current debugging state. However
2096 if you're in a user-defined command or especially in a
2097 loop, then you need a way to detect that the command
2098 failed WITHOUT aborting. This allows you to write
2099 scripts that search thru the trace buffer until the end,
2100 and then continue on to do something else. */
2103 error (_("Target failed to find requested trace frame."));
2107 printf_filtered ("End of trace buffer.\n");
2108 #if 0 /* dubious now? */
2109 /* The following will not recurse, since it's
2111 tfind_command ("-1", from_tty
);
2116 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2118 reinit_frame_cache ();
2119 target_dcache_invalidate ();
2121 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2123 if (target_frameno
!= get_traceframe_number ())
2124 gdb::observers::traceframe_changed
.notify (target_frameno
, tracepoint_number
);
2126 set_current_traceframe (target_frameno
);
2128 if (target_frameno
== -1)
2129 set_traceframe_context (NULL
);
2131 set_traceframe_context (get_current_frame ());
2133 if (traceframe_number
>= 0)
2135 /* Use different branches for MI and CLI to make CLI messages
2137 if (uiout
->is_mi_like_p ())
2139 uiout
->field_string ("found", "1");
2140 uiout
->field_int ("tracepoint", tracepoint_number
);
2141 uiout
->field_int ("traceframe", traceframe_number
);
2145 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2146 traceframe_number
, tracepoint_number
);
2151 if (uiout
->is_mi_like_p ())
2152 uiout
->field_string ("found", "0");
2153 else if (type
== tfind_number
&& num
== -1)
2154 printf_unfiltered (_("No longer looking at any trace frame\n"));
2155 else /* This case may never occur, check. */
2156 printf_unfiltered (_("No trace frame found\n"));
2159 /* If we're in nonstop mode and getting out of looking at trace
2160 frames, there won't be any current frame to go back to and
2163 && (has_stack_frames () || traceframe_number
>= 0))
2165 enum print_what print_what
;
2167 /* NOTE: in imitation of the step command, try to determine
2168 whether we have made a transition from one function to
2169 another. If so, we'll print the "stack frame" (ie. the new
2170 function and it's arguments) -- otherwise we'll just show the
2173 if (frame_id_eq (old_frame_id
,
2174 get_frame_id (get_current_frame ())))
2175 print_what
= SRC_LINE
;
2177 print_what
= SRC_AND_LOC
;
2179 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2184 /* Error on looking at traceframes while trace is running. */
2187 check_trace_running (struct trace_status
*status
)
2189 if (status
->running
&& status
->filename
== NULL
)
2190 error (_("May not look at trace frames while trace is running."));
2193 /* trace_find_command takes a trace frame number n,
2194 sends "QTFrame:<n>" to the target,
2195 and accepts a reply that may contain several optional pieces
2196 of information: a frame number, a tracepoint number, and an
2197 indication of whether this is a trap frame or a stepping frame.
2199 The minimal response is just "OK" (which indicates that the
2200 target does not give us a frame number or a tracepoint number).
2201 Instead of that, the target may send us a string containing
2203 F<hexnum> (gives the selected frame number)
2204 T<hexnum> (gives the selected tracepoint number)
2209 tfind_command_1 (const char *args
, int from_tty
)
2210 { /* This should only be called with a numeric argument. */
2213 check_trace_running (current_trace_status ());
2215 if (args
== 0 || *args
== 0)
2216 { /* TFIND with no args means find NEXT trace frame. */
2217 if (traceframe_number
== -1)
2218 frameno
= 0; /* "next" is first one. */
2220 frameno
= traceframe_number
+ 1;
2222 else if (0 == strcmp (args
, "-"))
2224 if (traceframe_number
== -1)
2225 error (_("not debugging trace buffer"));
2226 else if (from_tty
&& traceframe_number
== 0)
2227 error (_("already at start of trace buffer"));
2229 frameno
= traceframe_number
- 1;
2231 /* A hack to work around eval's need for fp to have been collected. */
2232 else if (0 == strcmp (args
, "-1"))
2235 frameno
= parse_and_eval_long (args
);
2238 error (_("invalid input (%d is less than zero)"), frameno
);
2240 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2244 tfind_command (const char *args
, int from_tty
)
2246 tfind_command_1 (args
, from_tty
);
2251 tfind_end_command (const char *args
, int from_tty
)
2253 tfind_command_1 ("-1", from_tty
);
2258 tfind_start_command (const char *args
, int from_tty
)
2260 tfind_command_1 ("0", from_tty
);
2263 /* tfind pc command */
2265 tfind_pc_command (const char *args
, int from_tty
)
2269 check_trace_running (current_trace_status ());
2271 if (args
== 0 || *args
== 0)
2272 pc
= regcache_read_pc (get_current_regcache ());
2274 pc
= parse_and_eval_address (args
);
2276 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2279 /* tfind tracepoint command */
2281 tfind_tracepoint_command (const char *args
, int from_tty
)
2284 struct tracepoint
*tp
;
2286 check_trace_running (current_trace_status ());
2288 if (args
== 0 || *args
== 0)
2290 if (tracepoint_number
== -1)
2291 error (_("No current tracepoint -- please supply an argument."));
2293 tdp
= tracepoint_number
; /* Default is current TDP. */
2296 tdp
= parse_and_eval_long (args
);
2298 /* If we have the tracepoint on hand, use the number that the
2299 target knows about (which may be different if we disconnected
2300 and reconnected). */
2301 tp
= get_tracepoint (tdp
);
2303 tdp
= tp
->number_on_target
;
2305 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2308 /* TFIND LINE command:
2310 This command will take a sourceline for argument, just like BREAK
2311 or TRACE (ie. anything that "decode_line_1" can handle).
2313 With no argument, this command will find the next trace frame
2314 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2317 tfind_line_command (const char *args
, int from_tty
)
2319 check_trace_running (current_trace_status ());
2321 symtab_and_line sal
;
2322 if (args
== 0 || *args
== 0)
2324 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2328 std::vector
<symtab_and_line
> sals
2329 = decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2333 if (sal
.symtab
== 0)
2334 error (_("No line number information available."));
2336 CORE_ADDR start_pc
, end_pc
;
2337 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2339 if (start_pc
== end_pc
)
2341 printf_filtered ("Line %d of \"%s\"",
2343 symtab_to_filename_for_display (sal
.symtab
));
2345 printf_filtered (" is at address ");
2346 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2348 printf_filtered (" but contains no code.\n");
2349 sal
= find_pc_line (start_pc
, 0);
2351 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2352 && start_pc
!= end_pc
)
2353 printf_filtered ("Attempting to find line %d instead.\n",
2356 error (_("Cannot find a good line."));
2360 /* Is there any case in which we get here, and have an address
2361 which the user would want to see? If we have debugging
2362 symbols and no line numbers? */
2363 error (_("Line number %d is out of range for \"%s\"."),
2364 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2366 /* Find within range of stated line. */
2368 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2370 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2373 /* tfind range command */
2375 tfind_range_command (const char *args
, int from_tty
)
2377 static CORE_ADDR start
, stop
;
2380 check_trace_running (current_trace_status ());
2382 if (args
== 0 || *args
== 0)
2383 { /* XXX FIXME: what should default behavior be? */
2384 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2388 if (0 != (tmp
= strchr (args
, ',')))
2390 std::string
start_addr (args
, tmp
);
2392 tmp
= skip_spaces (tmp
);
2393 start
= parse_and_eval_address (start_addr
.c_str ());
2394 stop
= parse_and_eval_address (tmp
);
2397 { /* No explicit end address? */
2398 start
= parse_and_eval_address (args
);
2399 stop
= start
+ 1; /* ??? */
2402 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2405 /* tfind outside command */
2407 tfind_outside_command (const char *args
, int from_tty
)
2409 CORE_ADDR start
, stop
;
2412 if (current_trace_status ()->running
2413 && current_trace_status ()->filename
== NULL
)
2414 error (_("May not look at trace frames while trace is running."));
2416 if (args
== 0 || *args
== 0)
2417 { /* XXX FIXME: what should default behavior be? */
2418 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2422 if (0 != (tmp
= strchr (args
, ',')))
2424 std::string
start_addr (args
, tmp
);
2426 tmp
= skip_spaces (tmp
);
2427 start
= parse_and_eval_address (start_addr
.c_str ());
2428 stop
= parse_and_eval_address (tmp
);
2431 { /* No explicit end address? */
2432 start
= parse_and_eval_address (args
);
2433 stop
= start
+ 1; /* ??? */
2436 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2439 /* info scope command: list the locals for a scope. */
2441 info_scope_command (const char *args_in
, int from_tty
)
2444 struct bound_minimal_symbol msym
;
2445 const struct block
*block
;
2446 const char *symname
;
2447 const char *save_args
= args_in
;
2448 struct block_iterator iter
;
2450 struct gdbarch
*gdbarch
;
2452 const char *args
= args_in
;
2454 if (args
== 0 || *args
== 0)
2455 error (_("requires an argument (function, "
2456 "line or *addr) to define a scope"));
2458 event_location_up location
= string_to_event_location (&args
,
2460 std::vector
<symtab_and_line
> sals
2461 = decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
2465 /* Presumably decode_line_1 has already warned. */
2469 /* Resolve line numbers to PC. */
2470 resolve_sal_pc (&sals
[0]);
2471 block
= block_for_pc (sals
[0].pc
);
2475 QUIT
; /* Allow user to bail out with ^C. */
2476 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2478 QUIT
; /* Allow user to bail out with ^C. */
2480 printf_filtered ("Scope for %s:\n", save_args
);
2483 symname
= SYMBOL_PRINT_NAME (sym
);
2484 if (symname
== NULL
|| *symname
== '\0')
2485 continue; /* Probably botched, certainly useless. */
2487 gdbarch
= symbol_arch (sym
);
2489 printf_filtered ("Symbol %s is ", symname
);
2491 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2492 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2493 BLOCK_START (block
),
2497 switch (SYMBOL_CLASS (sym
))
2500 case LOC_UNDEF
: /* Messed up symbol? */
2501 printf_filtered ("a bogus symbol, class %d.\n",
2502 SYMBOL_CLASS (sym
));
2503 count
--; /* Don't count this one. */
2506 printf_filtered ("a constant with value %s (%s)",
2507 plongest (SYMBOL_VALUE (sym
)),
2508 hex_string (SYMBOL_VALUE (sym
)));
2510 case LOC_CONST_BYTES
:
2511 printf_filtered ("constant bytes: ");
2512 if (SYMBOL_TYPE (sym
))
2513 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2514 fprintf_filtered (gdb_stdout
, " %02x",
2515 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2518 printf_filtered ("in static storage at address ");
2519 printf_filtered ("%s", paddress (gdbarch
,
2520 SYMBOL_VALUE_ADDRESS (sym
)));
2523 /* GDBARCH is the architecture associated with the objfile
2524 the symbol is defined in; the target architecture may be
2525 different, and may provide additional registers. However,
2526 we do not know the target architecture at this point.
2527 We assume the objfile architecture will contain all the
2528 standard registers that occur in debug info in that
2530 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2533 if (SYMBOL_IS_ARGUMENT (sym
))
2534 printf_filtered ("an argument in register $%s",
2535 gdbarch_register_name (gdbarch
, regno
));
2537 printf_filtered ("a local variable in register $%s",
2538 gdbarch_register_name (gdbarch
, regno
));
2541 printf_filtered ("an argument at stack/frame offset %s",
2542 plongest (SYMBOL_VALUE (sym
)));
2545 printf_filtered ("a local variable at frame offset %s",
2546 plongest (SYMBOL_VALUE (sym
)));
2549 printf_filtered ("a reference argument at offset %s",
2550 plongest (SYMBOL_VALUE (sym
)));
2552 case LOC_REGPARM_ADDR
:
2553 /* Note comment at LOC_REGISTER. */
2554 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2556 printf_filtered ("the address of an argument, in register $%s",
2557 gdbarch_register_name (gdbarch
, regno
));
2560 printf_filtered ("a typedef.\n");
2563 printf_filtered ("a label at address ");
2564 printf_filtered ("%s", paddress (gdbarch
,
2565 SYMBOL_VALUE_ADDRESS (sym
)));
2568 printf_filtered ("a function at address ");
2569 printf_filtered ("%s",
2570 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2572 case LOC_UNRESOLVED
:
2573 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2575 if (msym
.minsym
== NULL
)
2576 printf_filtered ("Unresolved Static");
2579 printf_filtered ("static storage at address ");
2580 printf_filtered ("%s",
2582 BMSYMBOL_VALUE_ADDRESS (msym
)));
2585 case LOC_OPTIMIZED_OUT
:
2586 printf_filtered ("optimized out.\n");
2589 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2592 if (SYMBOL_TYPE (sym
))
2593 printf_filtered (", length %d.\n",
2594 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2596 if (BLOCK_FUNCTION (block
))
2599 block
= BLOCK_SUPERBLOCK (block
);
2602 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2606 /* Helper for trace_dump_command. Dump the action list starting at
2607 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2608 actions of the body of a while-stepping action. STEPPING_FRAME is
2609 set if the current traceframe was determined to be a while-stepping
2613 trace_dump_actions (struct command_line
*action
,
2614 int stepping_actions
, int stepping_frame
,
2617 const char *action_exp
, *next_comma
;
2619 for (; action
!= NULL
; action
= action
->next
)
2621 struct cmd_list_element
*cmd
;
2623 QUIT
; /* Allow user to bail out with ^C. */
2624 action_exp
= action
->line
;
2625 action_exp
= skip_spaces (action_exp
);
2627 /* The collection actions to be done while stepping are
2628 bracketed by the commands "while-stepping" and "end". */
2630 if (*action_exp
== '#') /* comment line */
2633 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2635 error (_("Bad action list item: %s"), action_exp
);
2637 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2639 gdb_assert (action
->body_list_1
== nullptr);
2640 trace_dump_actions (action
->body_list_0
.get (),
2641 1, stepping_frame
, from_tty
);
2643 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2645 /* Display the collected data.
2646 For the trap frame, display only what was collected at
2647 the trap. Likewise for stepping frames, display only
2648 what was collected while stepping. This means that the
2649 two boolean variables, STEPPING_FRAME and
2650 STEPPING_ACTIONS should be equal. */
2651 if (stepping_frame
== stepping_actions
)
2653 int trace_string
= 0;
2655 if (*action_exp
== '/')
2656 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2659 { /* Repeat over a comma-separated list. */
2660 QUIT
; /* Allow user to bail out with ^C. */
2661 if (*action_exp
== ',')
2663 action_exp
= skip_spaces (action_exp
);
2665 next_comma
= strchr (action_exp
, ',');
2667 if (0 == strncasecmp (action_exp
, "$reg", 4))
2668 registers_info (NULL
, from_tty
);
2669 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2671 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2672 info_locals_command (NULL
, from_tty
);
2673 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2674 info_args_command (NULL
, from_tty
);
2677 std::string contents
;
2678 const char *exp
= action_exp
;
2679 if (next_comma
!= NULL
)
2681 size_t len
= next_comma
- action_exp
;
2682 contents
= std::string (action_exp
, len
);
2683 exp
= contents
.c_str ();
2686 printf_filtered ("%s = ", exp
);
2687 output_command (exp
, from_tty
);
2688 printf_filtered ("\n");
2690 action_exp
= next_comma
;
2692 while (action_exp
&& *action_exp
== ',');
2698 /* Return bp_location of the tracepoint associated with the current
2699 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2700 is a stepping traceframe. */
2702 struct bp_location
*
2703 get_traceframe_location (int *stepping_frame_p
)
2705 struct tracepoint
*t
;
2706 struct bp_location
*tloc
;
2707 struct regcache
*regcache
;
2709 if (tracepoint_number
== -1)
2710 error (_("No current trace frame."));
2712 t
= get_tracepoint (tracepoint_number
);
2715 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2718 /* The current frame is a trap frame if the frame PC is equal to the
2719 tracepoint PC. If not, then the current frame was collected
2720 during single-stepping. */
2721 regcache
= get_current_regcache ();
2723 /* If the traceframe's address matches any of the tracepoint's
2724 locations, assume it is a direct hit rather than a while-stepping
2725 frame. (FIXME this is not reliable, should record each frame's
2727 for (tloc
= t
->loc
; tloc
; tloc
= tloc
->next
)
2728 if (tloc
->address
== regcache_read_pc (regcache
))
2730 *stepping_frame_p
= 0;
2734 /* If this is a stepping frame, we don't know which location
2735 triggered. The first is as good (or bad) a guess as any... */
2736 *stepping_frame_p
= 1;
2740 /* Return the default collect actions of a tracepoint T. */
2742 static counted_command_line
2743 all_tracepoint_actions (struct breakpoint
*t
)
2745 counted_command_line
actions (nullptr, command_lines_deleter ());
2747 /* If there are default expressions to collect, make up a collect
2748 action and prepend to the action list to encode. Note that since
2749 validation is per-tracepoint (local var "xyz" might be valid for
2750 one tracepoint and not another, etc), we make up the action on
2751 the fly, and don't cache it. */
2752 if (*default_collect
)
2754 gdb::unique_xmalloc_ptr
<char> default_collect_line
2755 (xstrprintf ("collect %s", default_collect
));
2757 validate_actionline (default_collect_line
.get (), t
);
2758 actions
.reset (new struct command_line (simple_control
,
2759 default_collect_line
.release ()),
2760 command_lines_deleter ());
2766 /* The tdump command. */
2769 tdump_command (const char *args
, int from_tty
)
2771 int stepping_frame
= 0;
2772 struct bp_location
*loc
;
2774 /* This throws an error is not inspecting a trace frame. */
2775 loc
= get_traceframe_location (&stepping_frame
);
2777 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2778 tracepoint_number
, traceframe_number
);
2780 /* This command only makes sense for the current frame, not the
2782 scoped_restore_current_thread restore_thread
;
2784 select_frame (get_current_frame ());
2786 counted_command_line actions
= all_tracepoint_actions (loc
->owner
);
2788 trace_dump_actions (actions
.get (), 0, stepping_frame
, from_tty
);
2789 trace_dump_actions (breakpoint_commands (loc
->owner
), 0, stepping_frame
,
2793 /* Encode a piece of a tracepoint's source-level definition in a form
2794 that is suitable for both protocol and saving in files. */
2795 /* This version does not do multiple encodes for long strings; it should
2796 return an offset to the next piece to encode. FIXME */
2799 encode_source_string (int tpnum
, ULONGEST addr
,
2800 const char *srctype
, const char *src
,
2801 char *buf
, int buf_size
)
2803 if (80 + strlen (srctype
) > buf_size
)
2804 error (_("Buffer too small for source encoding"));
2805 sprintf (buf
, "%x:%s:%s:%x:%x:",
2806 tpnum
, phex_nz (addr
, sizeof (addr
)),
2807 srctype
, 0, (int) strlen (src
));
2808 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2809 error (_("Source string too long for buffer"));
2810 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
2814 /* Tell the target what to do with an ongoing tracing run if GDB
2815 disconnects for some reason. */
2818 set_disconnected_tracing (const char *args
, int from_tty
,
2819 struct cmd_list_element
*c
)
2821 target_set_disconnected_tracing (disconnected_tracing
);
2825 set_circular_trace_buffer (const char *args
, int from_tty
,
2826 struct cmd_list_element
*c
)
2828 target_set_circular_trace_buffer (circular_trace_buffer
);
2832 set_trace_buffer_size (const char *args
, int from_tty
,
2833 struct cmd_list_element
*c
)
2835 target_set_trace_buffer_size (trace_buffer_size
);
2839 set_trace_user (const char *args
, int from_tty
,
2840 struct cmd_list_element
*c
)
2844 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
2847 warning (_("Target does not support trace notes, user ignored"));
2851 set_trace_notes (const char *args
, int from_tty
,
2852 struct cmd_list_element
*c
)
2856 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
2859 warning (_("Target does not support trace notes, note ignored"));
2863 set_trace_stop_notes (const char *args
, int from_tty
,
2864 struct cmd_list_element
*c
)
2868 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
2871 warning (_("Target does not support trace notes, stop note ignored"));
2874 /* Convert the memory pointed to by mem into hex, placing result in buf.
2875 * Return a pointer to the last char put in buf (null)
2876 * "stolen" from sparc-stub.c
2879 static const char hexchars
[] = "0123456789abcdef";
2882 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2890 *buf
++ = hexchars
[ch
>> 4];
2891 *buf
++ = hexchars
[ch
& 0xf];
2900 get_traceframe_number (void)
2902 return traceframe_number
;
2906 get_tracepoint_number (void)
2908 return tracepoint_number
;
2911 /* Make the traceframe NUM be the current trace frame. Does nothing
2912 if NUM is already current. */
2915 set_current_traceframe (int num
)
2919 if (traceframe_number
== num
)
2921 /* Nothing to do. */
2925 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2928 warning (_("could not change traceframe"));
2930 set_traceframe_num (newnum
);
2932 /* Changing the traceframe changes our view of registers and of the
2934 registers_changed ();
2936 clear_traceframe_info ();
2939 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2940 : m_traceframe_number (traceframe_number
)
2943 /* Given a number and address, return an uploaded tracepoint with that
2944 number, creating if necessary. */
2946 struct uploaded_tp
*
2947 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2949 struct uploaded_tp
*utp
;
2951 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2952 if (utp
->number
== num
&& utp
->addr
== addr
)
2955 utp
= new uploaded_tp
;
2965 free_uploaded_tps (struct uploaded_tp
**utpp
)
2967 struct uploaded_tp
*next_one
;
2971 next_one
= (*utpp
)->next
;
2977 /* Given a number and address, return an uploaded tracepoint with that
2978 number, creating if necessary. */
2980 struct uploaded_tsv
*
2981 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2983 struct uploaded_tsv
*utsv
;
2985 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2986 if (utsv
->number
== num
)
2989 utsv
= XCNEW (struct uploaded_tsv
);
2991 utsv
->next
= *utsvp
;
2998 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3000 struct uploaded_tsv
*next_one
;
3004 next_one
= (*utsvp
)->next
;
3010 /* FIXME this function is heuristic and will miss the cases where the
3011 conditional is semantically identical but differs in whitespace,
3012 such as "x == 0" vs "x==0". */
3015 cond_string_is_same (char *str1
, char *str2
)
3017 if (str1
== NULL
|| str2
== NULL
)
3018 return (str1
== str2
);
3020 return (strcmp (str1
, str2
) == 0);
3023 /* Look for an existing tracepoint that seems similar enough to the
3024 uploaded one. Enablement isn't compared, because the user can
3025 toggle that freely, and may have done so in anticipation of the
3026 next trace run. Return the location of matched tracepoint. */
3028 static struct bp_location
*
3029 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3031 struct bp_location
*loc
;
3033 for (breakpoint
*b
: all_tracepoints ())
3035 struct tracepoint
*t
= (struct tracepoint
*) b
;
3037 if (b
->type
== utp
->type
3038 && t
->step_count
== utp
->step
3039 && t
->pass_count
== utp
->pass
3040 && cond_string_is_same (t
->cond_string
, utp
->cond_string
)
3041 /* FIXME also test actions. */
3044 /* Scan the locations for an address match. */
3045 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3047 if (loc
->address
== utp
->addr
)
3055 /* Given a list of tracepoints uploaded from a target, attempt to
3056 match them up with existing tracepoints, and create new ones if not
3060 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3062 struct uploaded_tp
*utp
;
3063 /* A set of tracepoints which are modified. */
3064 std::vector
<breakpoint
*> modified_tp
;
3066 /* Look for GDB tracepoints that match up with our uploaded versions. */
3067 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3069 struct bp_location
*loc
;
3070 struct tracepoint
*t
;
3072 loc
= find_matching_tracepoint_location (utp
);
3077 /* Mark this location as already inserted. */
3079 t
= (struct tracepoint
*) loc
->owner
;
3080 printf_filtered (_("Assuming tracepoint %d is same "
3081 "as target's tracepoint %d at %s.\n"),
3082 loc
->owner
->number
, utp
->number
,
3083 paddress (loc
->gdbarch
, utp
->addr
));
3085 /* The tracepoint LOC->owner was modified (the location LOC
3086 was marked as inserted in the target). Save it in
3087 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3088 observers will be notified later once for each tracepoint
3089 saved in MODIFIED_TP. */
3090 for (breakpoint
*b
: modified_tp
)
3091 if (b
== loc
->owner
)
3097 modified_tp
.push_back (loc
->owner
);
3101 t
= create_tracepoint_from_upload (utp
);
3103 printf_filtered (_("Created tracepoint %d for "
3104 "target's tracepoint %d at %s.\n"),
3105 t
->number
, utp
->number
,
3106 paddress (get_current_arch (), utp
->addr
));
3108 printf_filtered (_("Failed to create tracepoint for target's "
3109 "tracepoint %d at %s, skipping it.\n"),
3111 paddress (get_current_arch (), utp
->addr
));
3113 /* Whether found or created, record the number used by the
3114 target, to help with mapping target tracepoints back to their
3115 counterparts here. */
3117 t
->number_on_target
= utp
->number
;
3120 /* Notify 'breakpoint-modified' observer that at least one of B's
3121 locations was changed. */
3122 for (breakpoint
*b
: modified_tp
)
3123 gdb::observers::breakpoint_modified
.notify (b
);
3125 free_uploaded_tps (uploaded_tps
);
3128 /* Trace state variables don't have much to identify them beyond their
3129 name, so just use that to detect matches. */
3131 static struct trace_state_variable
*
3132 find_matching_tsv (struct uploaded_tsv
*utsv
)
3137 return find_trace_state_variable (utsv
->name
);
3140 static struct trace_state_variable
*
3141 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3143 const char *namebase
;
3146 struct trace_state_variable
*tsv
;
3150 namebase
= utsv
->name
;
3156 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3159 /* Fish for a name that is not in use. */
3160 /* (should check against all internal vars?) */
3161 while (find_trace_state_variable (buf
.c_str ()))
3162 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3164 /* We have an available name, create the variable. */
3165 tsv
= create_trace_state_variable (buf
.c_str ());
3166 tsv
->initial_value
= utsv
->initial_value
;
3167 tsv
->builtin
= utsv
->builtin
;
3169 gdb::observers::tsv_created
.notify (tsv
);
3174 /* Given a list of uploaded trace state variables, try to match them
3175 up with existing variables, or create additional ones. */
3178 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3180 struct uploaded_tsv
*utsv
;
3181 struct trace_state_variable
*tsv
;
3184 /* Most likely some numbers will have to be reassigned as part of
3185 the merge, so clear them all in anticipation. */
3186 for (trace_state_variable
&tsv
: tvariables
)
3189 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3191 tsv
= find_matching_tsv (utsv
);
3195 printf_filtered (_("Assuming trace state variable $%s "
3196 "is same as target's variable %d.\n"),
3197 tsv
->name
.c_str (), utsv
->number
);
3201 tsv
= create_tsv_from_upload (utsv
);
3203 printf_filtered (_("Created trace state variable "
3204 "$%s for target's variable %d.\n"),
3205 tsv
->name
.c_str (), utsv
->number
);
3207 /* Give precedence to numberings that come from the target. */
3209 tsv
->number
= utsv
->number
;
3212 /* Renumber everything that didn't get a target-assigned number. */
3214 for (const trace_state_variable
&tsv
: tvariables
)
3215 highest
= std::max (tsv
.number
, highest
);
3218 for (trace_state_variable
&tsv
: tvariables
)
3219 if (tsv
.number
== 0)
3220 tsv
.number
= highest
++;
3222 free_uploaded_tsvs (uploaded_tsvs
);
3225 /* Parse the part of trace status syntax that is shared between
3226 the remote protocol and the trace file reader. */
3229 parse_trace_status (const char *line
, struct trace_status
*ts
)
3231 const char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3235 ts
->running_known
= 1;
3236 ts
->running
= (*p
++ == '1');
3237 ts
->stop_reason
= trace_stop_reason_unknown
;
3238 xfree (ts
->stop_desc
);
3239 ts
->stop_desc
= NULL
;
3240 ts
->traceframe_count
= -1;
3241 ts
->traceframes_created
= -1;
3242 ts
->buffer_free
= -1;
3243 ts
->buffer_size
= -1;
3244 ts
->disconnected_tracing
= 0;
3245 ts
->circular_buffer
= 0;
3246 xfree (ts
->user_name
);
3247 ts
->user_name
= NULL
;
3250 ts
->start_time
= ts
->stop_time
= 0;
3254 p1
= strchr (p
, ':');
3256 error (_("Malformed trace status, at %s\n\
3257 Status line: '%s'\n"), p
, line
);
3258 p3
= strchr (p
, ';');
3260 p3
= p
+ strlen (p
);
3261 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3263 p
= unpack_varlen_hex (++p1
, &val
);
3264 ts
->stop_reason
= trace_buffer_full
;
3266 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3268 p
= unpack_varlen_hex (++p1
, &val
);
3269 ts
->stop_reason
= trace_never_run
;
3271 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3274 p
= unpack_varlen_hex (++p1
, &val
);
3275 ts
->stop_reason
= tracepoint_passcount
;
3276 ts
->stopping_tracepoint
= val
;
3278 else if (strncmp (p
, stop_reason_names
[trace_stop_command
], p1
- p
) == 0)
3280 p2
= strchr (++p1
, ':');
3288 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3289 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3290 ts
->stop_desc
[end
] = '\0';
3293 ts
->stop_desc
= xstrdup ("");
3295 p
= unpack_varlen_hex (++p2
, &val
);
3296 ts
->stop_reason
= trace_stop_command
;
3298 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3300 p
= unpack_varlen_hex (++p1
, &val
);
3301 ts
->stop_reason
= trace_disconnected
;
3303 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3305 p2
= strchr (++p1
, ':');
3308 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3309 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3310 ts
->stop_desc
[end
] = '\0';
3313 ts
->stop_desc
= xstrdup ("");
3315 p
= unpack_varlen_hex (++p2
, &val
);
3316 ts
->stopping_tracepoint
= val
;
3317 ts
->stop_reason
= tracepoint_error
;
3319 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3321 p
= unpack_varlen_hex (++p1
, &val
);
3322 ts
->traceframe_count
= val
;
3324 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3326 p
= unpack_varlen_hex (++p1
, &val
);
3327 ts
->traceframes_created
= val
;
3329 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3331 p
= unpack_varlen_hex (++p1
, &val
);
3332 ts
->buffer_free
= val
;
3334 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3336 p
= unpack_varlen_hex (++p1
, &val
);
3337 ts
->buffer_size
= val
;
3339 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3341 p
= unpack_varlen_hex (++p1
, &val
);
3342 ts
->disconnected_tracing
= val
;
3344 else if (strncmp (p
, "circular", p1
- p
) == 0)
3346 p
= unpack_varlen_hex (++p1
, &val
);
3347 ts
->circular_buffer
= val
;
3349 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3351 p
= unpack_varlen_hex (++p1
, &val
);
3352 ts
->start_time
= val
;
3354 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3356 p
= unpack_varlen_hex (++p1
, &val
);
3357 ts
->stop_time
= val
;
3359 else if (strncmp (p
, "username", p1
- p
) == 0)
3362 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3363 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3364 ts
->user_name
[end
] = '\0';
3367 else if (strncmp (p
, "notes", p1
- p
) == 0)
3370 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3371 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3372 ts
->notes
[end
] = '\0';
3377 /* Silently skip unknown optional info. */
3378 p_temp
= strchr (p1
+ 1, ';');
3382 /* Must be at the end. */
3389 parse_tracepoint_status (const char *p
, struct breakpoint
*bp
,
3390 struct uploaded_tp
*utp
)
3393 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3395 p
= unpack_varlen_hex (p
, &uval
);
3397 tp
->hit_count
+= uval
;
3399 utp
->hit_count
+= uval
;
3400 p
= unpack_varlen_hex (p
+ 1, &uval
);
3402 tp
->traceframe_usage
+= uval
;
3404 utp
->traceframe_usage
+= uval
;
3405 /* Ignore any extra, allowing for future extensions. */
3408 /* Given a line of text defining a part of a tracepoint, parse it into
3409 an "uploaded tracepoint". */
3412 parse_tracepoint_definition (const char *line
, struct uploaded_tp
**utpp
)
3416 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3419 const char *srctype
;
3421 struct uploaded_tp
*utp
= NULL
;
3424 /* Both tracepoint and action definitions start with the same number
3425 and address sequence. */
3427 p
= unpack_varlen_hex (p
, &num
);
3428 p
++; /* skip a colon */
3429 p
= unpack_varlen_hex (p
, &addr
);
3430 p
++; /* skip a colon */
3433 enabled
= (*p
++ == 'E');
3434 p
++; /* skip a colon */
3435 p
= unpack_varlen_hex (p
, &step
);
3436 p
++; /* skip a colon */
3437 p
= unpack_varlen_hex (p
, &pass
);
3438 type
= bp_tracepoint
;
3440 /* Thumb through optional fields. */
3443 p
++; /* skip a colon */
3446 type
= bp_fast_tracepoint
;
3448 p
= unpack_varlen_hex (p
, &orig_size
);
3452 type
= bp_static_tracepoint
;
3458 p
= unpack_varlen_hex (p
, &xlen
);
3459 p
++; /* skip a comma */
3460 cond
= (char *) xmalloc (2 * xlen
+ 1);
3461 strncpy (cond
, p
, 2 * xlen
);
3462 cond
[2 * xlen
] = '\0';
3466 warning (_("Unrecognized char '%c' in tracepoint "
3467 "definition, skipping rest"), *p
);
3469 utp
= get_uploaded_tp (num
, addr
, utpp
);
3471 utp
->enabled
= enabled
;
3476 else if (piece
== 'A')
3478 utp
= get_uploaded_tp (num
, addr
, utpp
);
3479 utp
->actions
.push_back (xstrdup (p
));
3481 else if (piece
== 'S')
3483 utp
= get_uploaded_tp (num
, addr
, utpp
);
3484 utp
->step_actions
.push_back (xstrdup (p
));
3486 else if (piece
== 'Z')
3488 /* Parse a chunk of source form definition. */
3489 utp
= get_uploaded_tp (num
, addr
, utpp
);
3491 p
= strchr (p
, ':');
3492 p
++; /* skip a colon */
3493 p
= unpack_varlen_hex (p
, &start
);
3494 p
++; /* skip a colon */
3495 p
= unpack_varlen_hex (p
, &xlen
);
3496 p
++; /* skip a colon */
3498 buf
= (char *) alloca (strlen (line
));
3500 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3503 if (startswith (srctype
, "at:"))
3504 utp
->at_string
= xstrdup (buf
);
3505 else if (startswith (srctype
, "cond:"))
3506 utp
->cond_string
= xstrdup (buf
);
3507 else if (startswith (srctype
, "cmd:"))
3508 utp
->cmd_strings
.push_back (xstrdup (buf
));
3510 else if (piece
== 'V')
3512 utp
= get_uploaded_tp (num
, addr
, utpp
);
3514 parse_tracepoint_status (p
, NULL
, utp
);
3518 /* Don't error out, the target might be sending us optional
3519 info that we don't care about. */
3520 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3524 /* Convert a textual description of a trace state variable into an
3528 parse_tsv_definition (const char *line
, struct uploaded_tsv
**utsvp
)
3532 ULONGEST num
, initval
, builtin
;
3534 struct uploaded_tsv
*utsv
= NULL
;
3536 buf
= (char *) alloca (strlen (line
));
3539 p
= unpack_varlen_hex (p
, &num
);
3540 p
++; /* skip a colon */
3541 p
= unpack_varlen_hex (p
, &initval
);
3542 p
++; /* skip a colon */
3543 p
= unpack_varlen_hex (p
, &builtin
);
3544 p
++; /* skip a colon */
3545 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3548 utsv
= get_uploaded_tsv (num
, utsvp
);
3549 utsv
->initial_value
= initval
;
3550 utsv
->builtin
= builtin
;
3551 utsv
->name
= xstrdup (buf
);
3554 /* Given a line of text defining a static tracepoint marker, parse it
3555 into a "static tracepoint marker" object. Throws an error is
3556 parsing fails. If PP is non-null, it points to one past the end of
3557 the parsed marker definition. */
3560 parse_static_tracepoint_marker_definition (const char *line
, const char **pp
,
3561 static_tracepoint_marker
*marker
)
3563 const char *p
, *endp
;
3567 p
= unpack_varlen_hex (p
, &addr
);
3568 p
++; /* skip a colon */
3570 marker
->gdbarch
= target_gdbarch ();
3571 marker
->address
= (CORE_ADDR
) addr
;
3573 endp
= strchr (p
, ':');
3575 error (_("bad marker definition: %s"), line
);
3577 marker
->str_id
= hex2str (p
, (endp
- p
) / 2);
3580 p
++; /* skip a colon */
3582 /* This definition may be followed by another one, separated by a comma. */
3584 endp
= strchr (p
, ',');
3585 if (endp
!= nullptr)
3588 hex_len
= strlen (p
);
3590 marker
->extra
= hex2str (p
, hex_len
/ 2);
3596 /* Print MARKER to gdb_stdout. */
3599 print_one_static_tracepoint_marker (int count
,
3600 const static_tracepoint_marker
&marker
)
3604 char wrap_indent
[80];
3605 char extra_field_indent
[80];
3606 struct ui_out
*uiout
= current_uiout
;
3608 symtab_and_line sal
;
3609 sal
.pc
= marker
.address
;
3611 std::vector
<breakpoint
*> tracepoints
3612 = static_tracepoints_here (marker
.address
);
3614 ui_out_emit_tuple
tuple_emitter (uiout
, "marker");
3616 /* A counter field to help readability. This is not a stable
3618 uiout
->field_int ("count", count
);
3620 uiout
->field_string ("marker-id", marker
.str_id
.c_str ());
3622 uiout
->field_fmt ("enabled", "%c",
3623 !tracepoints
.empty () ? 'y' : 'n');
3626 strcpy (wrap_indent
, " ");
3628 if (gdbarch_addr_bit (marker
.gdbarch
) <= 32)
3629 strcat (wrap_indent
, " ");
3631 strcat (wrap_indent
, " ");
3633 strcpy (extra_field_indent
, " ");
3635 uiout
->field_core_addr ("addr", marker
.gdbarch
, marker
.address
);
3637 sal
= find_pc_line (marker
.address
, 0);
3638 sym
= find_pc_sect_function (marker
.address
, NULL
);
3641 uiout
->text ("in ");
3642 uiout
->field_string ("func",
3643 SYMBOL_PRINT_NAME (sym
));
3644 uiout
->wrap_hint (wrap_indent
);
3645 uiout
->text (" at ");
3648 uiout
->field_skip ("func");
3650 if (sal
.symtab
!= NULL
)
3652 uiout
->field_string ("file",
3653 symtab_to_filename_for_display (sal
.symtab
));
3656 if (uiout
->is_mi_like_p ())
3658 const char *fullname
= symtab_to_fullname (sal
.symtab
);
3660 uiout
->field_string ("fullname", fullname
);
3663 uiout
->field_skip ("fullname");
3665 uiout
->field_int ("line", sal
.line
);
3669 uiout
->field_skip ("fullname");
3670 uiout
->field_skip ("line");
3674 uiout
->text (extra_field_indent
);
3675 uiout
->text (_("Data: \""));
3676 uiout
->field_string ("extra-data", marker
.extra
.c_str ());
3677 uiout
->text ("\"\n");
3679 if (!tracepoints
.empty ())
3684 ui_out_emit_tuple
tuple_emitter (uiout
, "tracepoints-at");
3686 uiout
->text (extra_field_indent
);
3687 uiout
->text (_("Probed by static tracepoints: "));
3688 for (ix
= 0; ix
< tracepoints
.size (); ix
++)
3693 uiout
->field_int ("tracepoint-id", tracepoints
[ix
]->number
);
3697 if (uiout
->is_mi_like_p ())
3698 uiout
->field_int ("number-of-tracepoints", tracepoints
.size ());
3705 info_static_tracepoint_markers_command (const char *arg
, int from_tty
)
3707 struct ui_out
*uiout
= current_uiout
;
3708 std::vector
<static_tracepoint_marker
> markers
3709 = target_static_tracepoint_markers_by_strid (NULL
);
3711 /* We don't have to check target_can_use_agent and agent's capability on
3712 static tracepoint here, in order to be compatible with older GDBserver.
3713 We don't check USE_AGENT is true or not, because static tracepoints
3714 don't work without in-process agent, so we don't bother users to type
3715 `set agent on' when to use static tracepoint. */
3717 ui_out_emit_table
table_emitter (uiout
, 5, -1,
3718 "StaticTracepointMarkersTable");
3720 uiout
->table_header (7, ui_left
, "counter", "Cnt");
3722 uiout
->table_header (40, ui_left
, "marker-id", "ID");
3724 uiout
->table_header (3, ui_left
, "enabled", "Enb");
3725 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3726 uiout
->table_header (10, ui_left
, "addr", "Address");
3728 uiout
->table_header (18, ui_left
, "addr", "Address");
3729 uiout
->table_header (40, ui_noalign
, "what", "What");
3731 uiout
->table_body ();
3733 for (int i
= 0; i
< markers
.size (); i
++)
3734 print_one_static_tracepoint_marker (i
+ 1, markers
[i
]);
3737 /* The $_sdata convenience variable is a bit special. We don't know
3738 for sure type of the value until we actually have a chance to fetch
3739 the data --- the size of the object depends on what has been
3740 collected. We solve this by making $_sdata be an internalvar that
3741 creates a new value on access. */
3743 /* Return a new value with the correct type for the sdata object of
3744 the current trace frame. Return a void value if there's no object
3747 static struct value
*
3748 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
3751 /* We need to read the whole object before we know its size. */
3752 gdb::optional
<gdb::byte_vector
> buf
3753 = target_read_alloc (current_top_target (), TARGET_OBJECT_STATIC_TRACE_DATA
,
3760 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
3762 v
= allocate_value (type
);
3763 memcpy (value_contents_raw (v
), buf
->data (), buf
->size ());
3767 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
3770 #if !defined(HAVE_LIBEXPAT)
3772 struct std::unique_ptr
<traceframe_info
>
3773 parse_traceframe_info (const char *tframe_info
)
3775 static int have_warned
;
3780 warning (_("Can not parse XML trace frame info; XML support "
3781 "was disabled at compile time"));
3787 #else /* HAVE_LIBEXPAT */
3789 #include "xml-support.h"
3791 /* Handle the start of a <memory> element. */
3794 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
3795 const struct gdb_xml_element
*element
,
3797 std::vector
<gdb_xml_value
> &attributes
)
3799 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3800 ULONGEST
*start_p
, *length_p
;
3803 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
.get ();
3805 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
.get ();
3807 info
->memory
.emplace_back (*start_p
, *length_p
);
3810 /* Handle the start of a <tvar> element. */
3813 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
3814 const struct gdb_xml_element
*element
,
3816 std::vector
<gdb_xml_value
> &attributes
)
3818 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3819 const char *id_attrib
3820 = (const char *) xml_find_attribute (attributes
, "id")->value
.get ();
3821 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
3823 info
->tvars
.push_back (id
);
3826 /* The allowed elements and attributes for an XML memory map. */
3828 static const struct gdb_xml_attribute memory_attributes
[] = {
3829 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3830 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3831 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3834 static const struct gdb_xml_attribute tvar_attributes
[] = {
3835 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3836 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3839 static const struct gdb_xml_element traceframe_info_children
[] = {
3840 { "memory", memory_attributes
, NULL
,
3841 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3842 traceframe_info_start_memory
, NULL
},
3843 { "tvar", tvar_attributes
, NULL
,
3844 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3845 traceframe_info_start_tvar
, NULL
},
3846 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3849 static const struct gdb_xml_element traceframe_info_elements
[] = {
3850 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
3852 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3855 /* Parse a traceframe-info XML document. */
3858 parse_traceframe_info (const char *tframe_info
)
3860 traceframe_info_up
result (new traceframe_info
);
3862 if (gdb_xml_parse_quick (_("trace frame info"),
3863 "traceframe-info.dtd", traceframe_info_elements
,
3864 tframe_info
, result
.get ()) == 0)
3870 #endif /* HAVE_LIBEXPAT */
3872 /* Returns the traceframe_info object for the current traceframe.
3873 This is where we avoid re-fetching the object from the target if we
3874 already have it cached. */
3876 struct traceframe_info
*
3877 get_traceframe_info (void)
3879 if (current_traceframe_info
== NULL
)
3880 current_traceframe_info
= target_traceframe_info ();
3882 return current_traceframe_info
.get ();
3885 /* If the target supports the query, return in RESULT the set of
3886 collected memory in the current traceframe, found within the LEN
3887 bytes range starting at MEMADDR. Returns true if the target
3888 supports the query, otherwise returns false, and RESULT is left
3892 traceframe_available_memory (std::vector
<mem_range
> *result
,
3893 CORE_ADDR memaddr
, ULONGEST len
)
3895 struct traceframe_info
*info
= get_traceframe_info ();
3901 for (mem_range
&r
: info
->memory
)
3902 if (mem_ranges_overlap (r
.start
, r
.length
, memaddr
, len
))
3904 ULONGEST lo1
, hi1
, lo2
, hi2
;
3907 hi1
= memaddr
+ len
;
3910 hi2
= r
.start
+ r
.length
;
3912 CORE_ADDR start
= std::max (lo1
, lo2
);
3913 int length
= std::min (hi1
, hi2
) - start
;
3915 result
->emplace_back (start
, length
);
3918 normalize_mem_ranges (result
);
3925 /* Implementation of `sdata' variable. */
3927 static const struct internalvar_funcs sdata_funcs
=
3934 /* module initialization */
3936 _initialize_tracepoint (void)
3938 struct cmd_list_element
*c
;
3940 /* Explicitly create without lookup, since that tries to create a
3941 value with a void typed value, and when we get here, gdbarch
3942 isn't initialized yet. At this point, we're quite sure there
3943 isn't another convenience variable of the same name. */
3944 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
3946 traceframe_number
= -1;
3947 tracepoint_number
= -1;
3949 add_info ("scope", info_scope_command
,
3950 _("List the variables local to a scope"));
3952 add_cmd ("tracepoints", class_trace
,
3953 _("Tracing of program execution without stopping the program."),
3956 add_com ("tdump", class_trace
, tdump_command
,
3957 _("Print everything collected at the current tracepoint."));
3959 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3960 Define a trace state variable.\n\
3961 Argument is a $-prefixed name, optionally followed\n\
3962 by '=' and an expression that sets the initial value\n\
3963 at the start of tracing."));
3964 set_cmd_completer (c
, expression_completer
);
3966 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3967 Delete one or more trace state variables.\n\
3968 Arguments are the names of the variables to delete.\n\
3969 If no arguments are supplied, delete all variables."), &deletelist
);
3970 /* FIXME add a trace variable completer. */
3972 add_info ("tvariables", info_tvariables_command
, _("\
3973 Status of trace state variables and their values.\n\
3976 add_info ("static-tracepoint-markers",
3977 info_static_tracepoint_markers_command
, _("\
3978 List target static tracepoints markers.\n\
3981 add_prefix_cmd ("tfind", class_trace
, tfind_command
, _("\
3982 Select a trace frame;\n\
3983 No argument means forward by one frame; '-' means backward by one frame."),
3984 &tfindlist
, "tfind ", 1, &cmdlist
);
3986 add_cmd ("outside", class_trace
, tfind_outside_command
, _("\
3987 Select a trace frame whose PC is outside the given range (exclusive).\n\
3988 Usage: tfind outside addr1, addr2"),
3991 add_cmd ("range", class_trace
, tfind_range_command
, _("\
3992 Select a trace frame whose PC is in the given range (inclusive).\n\
3993 Usage: tfind range addr1,addr2"),
3996 add_cmd ("line", class_trace
, tfind_line_command
, _("\
3997 Select a trace frame by source line.\n\
3998 Argument can be a line number (with optional source file),\n\
3999 a function name, or '*' followed by an address.\n\
4000 Default argument is 'the next source line that was traced'."),
4003 add_cmd ("tracepoint", class_trace
, tfind_tracepoint_command
, _("\
4004 Select a trace frame by tracepoint number.\n\
4005 Default is the tracepoint for the current trace frame."),
4008 add_cmd ("pc", class_trace
, tfind_pc_command
, _("\
4009 Select a trace frame by PC.\n\
4010 Default is the current PC, or the PC of the current trace frame."),
4013 add_cmd ("end", class_trace
, tfind_end_command
, _("\
4014 De-select any trace frame and resume 'live' debugging."),
4017 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4019 add_cmd ("start", class_trace
, tfind_start_command
,
4020 _("Select the first trace frame in the trace buffer."),
4023 add_com ("tstatus", class_trace
, tstatus_command
,
4024 _("Display the status of the current trace data collection."));
4026 add_com ("tstop", class_trace
, tstop_command
, _("\
4027 Stop trace data collection.\n\
4028 Usage: tstop [NOTES]...\n\
4029 Any arguments supplied are recorded with the trace as a stop reason and\n\
4030 reported by tstatus (if the target supports trace notes)."));
4032 add_com ("tstart", class_trace
, tstart_command
, _("\
4033 Start trace data collection.\n\
4034 Usage: tstart [NOTES]...\n\
4035 Any arguments supplied are recorded with the trace as a note and\n\
4036 reported by tstatus (if the target supports trace notes)."));
4038 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4039 Ends a list of commands or actions.\n\
4040 Several GDB commands allow you to enter a list of commands or actions.\n\
4041 Entering \"end\" on a line by itself is the normal way to terminate\n\
4043 Note: the \"end\" command cannot be used at the gdb prompt."));
4045 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4046 Specify single-stepping behavior at a tracepoint.\n\
4047 Argument is number of instructions to trace in single-step mode\n\
4048 following the tracepoint. This command is normally followed by\n\
4049 one or more \"collect\" commands, to specify what to collect\n\
4050 while single-stepping.\n\n\
4051 Note: this command can only be used in a tracepoint \"actions\" list."));
4053 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4054 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4056 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4057 Specify one or more data items to be collected at a tracepoint.\n\
4058 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4059 collect all data (variables, registers) referenced by that expression.\n\
4060 Also accepts the following special arguments:\n\
4061 $regs -- all registers.\n\
4062 $args -- all function arguments.\n\
4063 $locals -- all variables local to the block/function scope.\n\
4064 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4065 Note: this command can only be used in a tracepoint \"actions\" list."));
4067 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4068 Specify one or more expressions to be evaluated at a tracepoint.\n\
4069 Accepts a comma-separated list of (one or more) expressions.\n\
4070 The result of each evaluation will be discarded.\n\
4071 Note: this command can only be used in a tracepoint \"actions\" list."));
4073 add_com ("actions", class_trace
, actions_command
, _("\
4074 Specify the actions to be taken at a tracepoint.\n\
4075 Tracepoint actions may include collecting of specified data,\n\
4076 single-stepping, or enabling/disabling other tracepoints,\n\
4077 depending on target's capabilities."));
4079 default_collect
= xstrdup ("");
4080 add_setshow_string_cmd ("default-collect", class_trace
,
4081 &default_collect
, _("\
4082 Set the list of expressions to collect by default"), _("\
4083 Show the list of expressions to collect by default"), NULL
,
4085 &setlist
, &showlist
);
4087 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4088 &disconnected_tracing
, _("\
4089 Set whether tracing continues after GDB disconnects."), _("\
4090 Show whether tracing continues after GDB disconnects."), _("\
4091 Use this to continue a tracing run even if GDB disconnects\n\
4092 or detaches from the target. You can reconnect later and look at\n\
4093 trace data collected in the meantime."),
4094 set_disconnected_tracing
,
4099 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4100 &circular_trace_buffer
, _("\
4101 Set target's use of circular trace buffer."), _("\
4102 Show target's use of circular trace buffer."), _("\
4103 Use this to make the trace buffer into a circular buffer,\n\
4104 which will discard traceframes (oldest first) instead of filling\n\
4105 up and stopping the trace run."),
4106 set_circular_trace_buffer
,
4111 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4112 &trace_buffer_size
, _("\
4113 Set requested size of trace buffer."), _("\
4114 Show requested size of trace buffer."), _("\
4115 Use this to choose a size for the trace buffer. Some targets\n\
4116 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4117 disables any attempt to set the buffer size and lets the target choose."),
4118 set_trace_buffer_size
, NULL
,
4119 &setlist
, &showlist
);
4121 add_setshow_string_cmd ("trace-user", class_trace
,
4123 Set the user name to use for current and future trace runs"), _("\
4124 Show the user name to use for current and future trace runs"), NULL
,
4125 set_trace_user
, NULL
,
4126 &setlist
, &showlist
);
4128 add_setshow_string_cmd ("trace-notes", class_trace
,
4130 Set notes string to use for current and future trace runs"), _("\
4131 Show the notes string to use for current and future trace runs"), NULL
,
4132 set_trace_notes
, NULL
,
4133 &setlist
, &showlist
);
4135 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4136 &trace_stop_notes
, _("\
4137 Set notes string to use for future tstop commands"), _("\
4138 Show the notes string to use for future tstop commands"), NULL
,
4139 set_trace_stop_notes
, NULL
,
4140 &setlist
, &showlist
);