1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2019 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 "gdbsupport/filestuff.h"
56 #include "gdbsupport/rsp-low.h"
57 #include "tracefile.h"
63 /* Maximum length of an agent aexpression.
64 This accounts for the fact that packets are limited to 400 bytes
65 (which includes everything -- including the checksum), and assumes
66 the worst case of maximum length for each of the pieces of a
69 NOTE: expressions get mem2hex'ed otherwise this would be twice as
70 large. (400 - 31)/2 == 184 */
71 #define MAX_AGENT_EXPR_LEN 184
73 /* A hook used to notify the UI of tracepoint operations. */
75 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
76 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
81 This module defines the following debugger commands:
82 trace : set a tracepoint on a function, line, or address.
83 info trace : list all debugger-defined tracepoints.
84 delete trace : delete one or more tracepoints.
85 enable trace : enable one or more tracepoints.
86 disable trace : disable one or more tracepoints.
87 actions : specify actions to be taken at a tracepoint.
88 passcount : specify a pass count for a tracepoint.
89 tstart : start a trace experiment.
90 tstop : stop a trace experiment.
91 tstatus : query the status of a trace experiment.
92 tfind : find a trace frame in the trace buffer.
93 tdump : print everything collected at the current tracepoint.
94 save-tracepoints : write tracepoint setup into a file.
96 This module defines the following user-visible debugger variables:
97 $trace_frame : sequence number of trace frame currently being debugged.
98 $trace_line : source line of trace frame currently being debugged.
99 $trace_file : source file of trace frame currently being debugged.
100 $tracepoint : tracepoint number of trace frame currently being debugged.
104 /* ======= Important global variables: ======= */
106 /* The list of all trace state variables. We don't retain pointers to
107 any of these for any reason - API is by name or number only - so it
108 works to have a vector of objects. */
110 static std::vector
<trace_state_variable
> tvariables
;
112 /* The next integer to assign to a variable. */
114 static int next_tsv_number
= 1;
116 /* Number of last traceframe collected. */
117 static int traceframe_number
;
119 /* Tracepoint for last traceframe collected. */
120 static int tracepoint_number
;
122 /* The traceframe info of the current traceframe. NULL if we haven't
123 yet attempted to fetch it, or if the target does not support
124 fetching this object, or if we're not inspecting a traceframe
126 static traceframe_info_up current_traceframe_info
;
128 /* Tracing command lists. */
129 static struct cmd_list_element
*tfindlist
;
131 /* List of expressions to collect by default at each tracepoint hit. */
132 char *default_collect
;
134 static int disconnected_tracing
;
136 /* This variable controls whether we ask the target for a linear or
137 circular trace buffer. */
139 static int circular_trace_buffer
;
141 /* This variable is the requested trace buffer size, or -1 to indicate
142 that we don't care and leave it up to the target to set a size. */
144 static int trace_buffer_size
= -1;
146 /* Textual notes applying to the current and/or future trace runs. */
148 char *trace_user
= NULL
;
150 /* Textual notes applying to the current and/or future trace runs. */
152 char *trace_notes
= NULL
;
154 /* Textual notes applying to the stopping of a trace. */
156 char *trace_stop_notes
= NULL
;
158 /* support routines */
160 struct collection_list
;
161 static char *mem2hex (gdb_byte
*, char *, int);
163 static counted_command_line
all_tracepoint_actions (struct breakpoint
*);
165 static struct trace_status trace_status
;
167 const char *stop_reason_names
[] = {
177 struct trace_status
*
178 current_trace_status (void)
180 return &trace_status
;
183 /* Free and clear the traceframe info cache of the current
187 clear_traceframe_info (void)
189 current_traceframe_info
= NULL
;
192 /* Set traceframe number to NUM. */
194 set_traceframe_num (int num
)
196 traceframe_number
= num
;
197 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
200 /* Set tracepoint number to NUM. */
202 set_tracepoint_num (int num
)
204 tracepoint_number
= num
;
205 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
208 /* Set externally visible debug variables for querying/printing
209 the traceframe context (line, function, file). */
212 set_traceframe_context (struct frame_info
*trace_frame
)
215 struct symbol
*traceframe_fun
;
216 symtab_and_line traceframe_sal
;
218 /* Save as globals for internal use. */
219 if (trace_frame
!= NULL
220 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
222 traceframe_sal
= find_pc_line (trace_pc
, 0);
223 traceframe_fun
= find_pc_function (trace_pc
);
225 /* Save linenumber as "$trace_line", a debugger variable visible to
227 set_internalvar_integer (lookup_internalvar ("trace_line"),
228 traceframe_sal
.line
);
232 traceframe_fun
= NULL
;
233 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
236 /* Save func name as "$trace_func", a debugger variable visible to
238 if (traceframe_fun
== NULL
239 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
240 clear_internalvar (lookup_internalvar ("trace_func"));
242 set_internalvar_string (lookup_internalvar ("trace_func"),
243 SYMBOL_LINKAGE_NAME (traceframe_fun
));
245 /* Save file name as "$trace_file", a debugger variable visible to
247 if (traceframe_sal
.symtab
== NULL
)
248 clear_internalvar (lookup_internalvar ("trace_file"));
250 set_internalvar_string (lookup_internalvar ("trace_file"),
251 symtab_to_filename_for_display (traceframe_sal
.symtab
));
254 /* Create a new trace state variable with the given name. */
256 struct trace_state_variable
*
257 create_trace_state_variable (const char *name
)
259 tvariables
.emplace_back (name
, next_tsv_number
++);
260 return &tvariables
.back ();
263 /* Look for a trace state variable of the given name. */
265 struct trace_state_variable
*
266 find_trace_state_variable (const char *name
)
268 for (trace_state_variable
&tsv
: tvariables
)
269 if (tsv
.name
== name
)
275 /* Look for a trace state variable of the given number. Return NULL if
278 struct trace_state_variable
*
279 find_trace_state_variable_by_number (int number
)
281 for (trace_state_variable
&tsv
: tvariables
)
282 if (tsv
.number
== number
)
289 delete_trace_state_variable (const char *name
)
291 for (auto it
= tvariables
.begin (); it
!= tvariables
.end (); it
++)
292 if (it
->name
== name
)
294 gdb::observers::tsv_deleted
.notify (&*it
);
295 tvariables
.erase (it
);
299 warning (_("No trace variable named \"$%s\", not deleting"), name
);
302 /* Throws an error if NAME is not valid syntax for a trace state
306 validate_trace_state_variable_name (const char *name
)
311 error (_("Must supply a non-empty variable name"));
313 /* All digits in the name is reserved for value history
315 for (p
= name
; isdigit (*p
); p
++)
318 error (_("$%s is not a valid trace state variable name"), name
);
320 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
323 error (_("$%s is not a valid trace state variable name"), name
);
326 /* The 'tvariable' command collects a name and optional expression to
327 evaluate into an initial value. */
330 trace_variable_command (const char *args
, int from_tty
)
333 struct trace_state_variable
*tsv
;
334 const char *name_start
, *p
;
337 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
339 /* Only allow two syntaxes; "$name" and "$name=value". */
340 p
= skip_spaces (args
);
343 error (_("Name of trace variable should start with '$'"));
346 while (isalnum (*p
) || *p
== '_')
348 std::string
name (name_start
, p
- name_start
);
351 if (*p
!= '=' && *p
!= '\0')
352 error (_("Syntax must be $NAME [ = EXPR ]"));
354 validate_trace_state_variable_name (name
.c_str ());
357 initval
= value_as_long (parse_and_eval (++p
));
359 /* If the variable already exists, just change its initial value. */
360 tsv
= find_trace_state_variable (name
.c_str ());
363 if (tsv
->initial_value
!= initval
)
365 tsv
->initial_value
= initval
;
366 gdb::observers::tsv_modified
.notify (tsv
);
368 printf_filtered (_("Trace state variable $%s "
369 "now has initial value %s.\n"),
370 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
374 /* Create a new variable. */
375 tsv
= create_trace_state_variable (name
.c_str ());
376 tsv
->initial_value
= initval
;
378 gdb::observers::tsv_created
.notify (tsv
);
380 printf_filtered (_("Trace state variable $%s "
381 "created, with initial value %s.\n"),
382 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
386 delete_trace_variable_command (const char *args
, int from_tty
)
390 if (query (_("Delete all trace state variables? ")))
393 gdb::observers::tsv_deleted
.notify (NULL
);
397 gdb_argv
argv (args
);
399 for (char *arg
: argv
)
402 delete_trace_state_variable (arg
+ 1);
404 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg
);
411 tvariables_info_1 (void)
413 struct ui_out
*uiout
= current_uiout
;
415 /* Try to acquire values from the target. */
416 for (trace_state_variable
&tsv
: tvariables
)
418 = target_get_trace_state_variable_value (tsv
.number
, &tsv
.value
);
421 ui_out_emit_table
table_emitter (uiout
, 3, tvariables
.size (),
423 uiout
->table_header (15, ui_left
, "name", "Name");
424 uiout
->table_header (11, ui_left
, "initial", "Initial");
425 uiout
->table_header (11, ui_left
, "current", "Current");
427 uiout
->table_body ();
429 for (const trace_state_variable
&tsv
: tvariables
)
433 ui_out_emit_tuple
tuple_emitter (uiout
, "variable");
435 uiout
->field_string ("name", std::string ("$") + tsv
.name
);
436 uiout
->field_string ("initial", plongest (tsv
.initial_value
));
439 c
= plongest (tsv
.value
);
440 else if (uiout
->is_mi_like_p ())
441 /* For MI, we prefer not to use magic string constants, but rather
442 omit the field completely. The difference between unknown and
443 undefined does not seem important enough to represent. */
445 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
446 /* The value is/was defined, but we don't have it. */
449 /* It is not meaningful to ask about the value. */
452 uiout
->field_string ("current", c
);
457 if (tvariables
.empty ())
458 uiout
->text (_("No trace state variables.\n"));
461 /* List all the trace state variables. */
464 info_tvariables_command (const char *args
, int from_tty
)
466 tvariables_info_1 ();
469 /* Stash definitions of tsvs into the given file. */
472 save_trace_state_variables (struct ui_file
*fp
)
474 for (const trace_state_variable
&tsv
: tvariables
)
476 fprintf_unfiltered (fp
, "tvariable $%s", tsv
.name
.c_str ());
477 if (tsv
.initial_value
)
478 fprintf_unfiltered (fp
, " = %s", plongest (tsv
.initial_value
));
479 fprintf_unfiltered (fp
, "\n");
483 /* ACTIONS functions: */
485 /* The three functions:
486 collect_pseudocommand,
487 while_stepping_pseudocommand, and
488 end_actions_pseudocommand
489 are placeholders for "commands" that are actually ONLY to be used
490 within a tracepoint action list. If the actual function is ever called,
491 it means that somebody issued the "command" at the top level,
492 which is always an error. */
495 end_actions_pseudocommand (const char *args
, int from_tty
)
497 error (_("This command cannot be used at the top level."));
501 while_stepping_pseudocommand (const char *args
, int from_tty
)
503 error (_("This command can only be used in a tracepoint actions list."));
507 collect_pseudocommand (const char *args
, int from_tty
)
509 error (_("This command can only be used in a tracepoint actions list."));
513 teval_pseudocommand (const char *args
, int from_tty
)
515 error (_("This command can only be used in a tracepoint actions list."));
518 /* Parse any collection options, such as /s for strings. */
521 decode_agent_options (const char *exp
, int *trace_string
)
523 struct value_print_options opts
;
530 /* Call this to borrow the print elements default for collection
532 get_user_print_options (&opts
);
537 if (target_supports_string_tracing ())
539 /* Allow an optional decimal number giving an explicit maximum
540 string length, defaulting it to the "print elements" value;
541 so "collect/s80 mystr" gets at most 80 bytes of string. */
542 *trace_string
= opts
.print_max
;
544 if (*exp
>= '0' && *exp
<= '9')
545 *trace_string
= atoi (exp
);
546 while (*exp
>= '0' && *exp
<= '9')
550 error (_("Target does not support \"/s\" option for string tracing."));
553 error (_("Undefined collection format \"%c\"."), *exp
);
555 exp
= skip_spaces (exp
);
560 /* Enter a list of actions for a tracepoint. */
562 actions_command (const char *args
, int from_tty
)
564 struct tracepoint
*t
;
566 t
= get_tracepoint_by_number (&args
, NULL
);
570 string_printf ("Enter actions for tracepoint %d, one per line.",
573 counted_command_line l
= read_command_lines (tmpbuf
.c_str (),
575 [=] (const char *line
)
577 validate_actionline (line
, t
);
579 breakpoint_set_commands (t
, std::move (l
));
581 /* else just return */
584 /* Report the results of checking the agent expression, as errors or
588 report_agent_reqs_errors (struct agent_expr
*aexpr
)
590 /* All of the "flaws" are serious bytecode generation issues that
591 should never occur. */
592 if (aexpr
->flaw
!= agent_flaw_none
)
593 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
595 /* If analysis shows a stack underflow, GDB must have done something
596 badly wrong in its bytecode generation. */
597 if (aexpr
->min_height
< 0)
598 internal_error (__FILE__
, __LINE__
,
599 _("expression has min height < 0"));
601 /* Issue this error if the stack is predicted to get too deep. The
602 limit is rather arbitrary; a better scheme might be for the
603 target to report how much stack it will have available. The
604 depth roughly corresponds to parenthesization, so a limit of 20
605 amounts to 20 levels of expression nesting, which is actually
606 a pretty big hairy expression. */
607 if (aexpr
->max_height
> 20)
608 error (_("Expression is too complicated."));
611 /* Call ax_reqs on AEXPR and raise an error if something is wrong. */
614 finalize_tracepoint_aexpr (struct agent_expr
*aexpr
)
618 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
619 error (_("Expression is too complicated."));
621 report_agent_reqs_errors (aexpr
);
624 /* worker function */
626 validate_actionline (const char *line
, struct breakpoint
*b
)
628 struct cmd_list_element
*c
;
631 struct bp_location
*loc
;
632 struct tracepoint
*t
= (struct tracepoint
*) b
;
634 /* If EOF is typed, *line is NULL. */
638 p
= skip_spaces (line
);
640 /* Symbol lookup etc. */
641 if (*p
== '\0') /* empty line: just prompt for another line. */
644 if (*p
== '#') /* comment line */
647 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
649 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
651 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
653 int trace_string
= 0;
656 p
= decode_agent_options (p
, &trace_string
);
659 { /* Repeat over a comma-separated list. */
660 QUIT
; /* Allow user to bail out with ^C. */
663 if (*p
== '$') /* Look for special pseudo-symbols. */
665 if (0 == strncasecmp ("reg", p
+ 1, 3)
666 || 0 == strncasecmp ("arg", p
+ 1, 3)
667 || 0 == strncasecmp ("loc", p
+ 1, 3)
668 || 0 == strncasecmp ("_ret", p
+ 1, 4)
669 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
674 /* else fall thru, treat p as an expression and parse it! */
677 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
680 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
681 block_for_pc (loc
->address
), 1);
683 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
685 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
687 error (_("constant `%s' (value %s) "
688 "will not be collected."),
689 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
690 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
692 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
693 == LOC_OPTIMIZED_OUT
)
695 error (_("`%s' is optimized away "
696 "and cannot be collected."),
697 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
701 /* We have something to collect, make sure that the expr to
702 bytecode translator can handle it and that it's not too
704 agent_expr_up aexpr
= gen_trace_for_expr (loc
->address
,
708 finalize_tracepoint_aexpr (aexpr
.get ());
711 while (p
&& *p
++ == ',');
714 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
717 { /* Repeat over a comma-separated list. */
718 QUIT
; /* Allow user to bail out with ^C. */
722 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
726 /* Only expressions are allowed for this action. */
727 expression_up exp
= parse_exp_1 (&p
, loc
->address
,
728 block_for_pc (loc
->address
), 1);
730 /* We have something to evaluate, make sure that the expr to
731 bytecode translator can handle it and that it's not too
733 agent_expr_up aexpr
= gen_eval_for_expr (loc
->address
, exp
.get ());
735 finalize_tracepoint_aexpr (aexpr
.get ());
738 while (p
&& *p
++ == ',');
741 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
746 t
->step_count
= strtol (p
, &endp
, 0);
747 if (endp
== p
|| t
->step_count
== 0)
748 error (_("while-stepping step count `%s' is malformed."), line
);
752 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
756 error (_("`%s' is not a supported tracepoint action."), line
);
760 memrange_absolute
= -1
763 /* MEMRANGE functions: */
765 /* Compare memranges for std::sort. */
768 memrange_comp (const memrange
&a
, const memrange
&b
)
770 if (a
.type
== b
.type
)
772 if (a
.type
== memrange_absolute
)
773 return (bfd_vma
) a
.start
< (bfd_vma
) b
.start
;
775 return a
.start
< b
.start
;
778 return a
.type
< b
.type
;
781 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
784 memrange_sortmerge (std::vector
<memrange
> &memranges
)
786 if (!memranges
.empty ())
790 std::sort (memranges
.begin (), memranges
.end (), memrange_comp
);
792 for (a
= 0, b
= 1; b
< memranges
.size (); b
++)
794 /* If memrange b overlaps or is adjacent to memrange a,
796 if (memranges
[a
].type
== memranges
[b
].type
797 && memranges
[b
].start
<= memranges
[a
].end
)
799 if (memranges
[b
].end
> memranges
[a
].end
)
800 memranges
[a
].end
= memranges
[b
].end
;
801 continue; /* next b, same a */
805 memranges
[a
] = memranges
[b
];
807 memranges
.resize (a
+ 1);
811 /* Add remote register number REGNO to the collection list mask. */
814 collection_list::add_remote_register (unsigned int regno
)
817 printf_filtered ("collect register %d\n", regno
);
819 m_regs_mask
.at (regno
/ 8) |= 1 << (regno
% 8);
822 /* Add all the registers from the mask in AEXPR to the mask in the
823 collection list. Registers in the AEXPR mask are already remote
827 collection_list::add_ax_registers (struct agent_expr
*aexpr
)
829 if (aexpr
->reg_mask_len
> 0)
831 for (int ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
833 QUIT
; /* Allow user to bail out with ^C. */
834 if (aexpr
->reg_mask
[ndx1
] != 0)
836 /* Assume chars have 8 bits. */
837 for (int ndx2
= 0; ndx2
< 8; ndx2
++)
838 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
839 /* It's used -- record it. */
840 add_remote_register (ndx1
* 8 + ndx2
);
846 /* If REGNO is raw, add its corresponding remote register number to
847 the mask. If REGNO is a pseudo-register, figure out the necessary
848 registers using a temporary agent expression, and add it to the
849 list if it needs more than just a mask. */
852 collection_list::add_local_register (struct gdbarch
*gdbarch
,
856 if (regno
< gdbarch_num_regs (gdbarch
))
858 int remote_regno
= gdbarch_remote_register_number (gdbarch
, regno
);
860 if (remote_regno
< 0)
861 error (_("Can't collect register %d"), regno
);
863 add_remote_register (remote_regno
);
867 agent_expr_up
aexpr (new agent_expr (gdbarch
, scope
));
869 ax_reg_mask (aexpr
.get (), regno
);
871 finalize_tracepoint_aexpr (aexpr
.get ());
873 add_ax_registers (aexpr
.get ());
875 /* Usually ax_reg_mask for a pseudo-regiser only sets the
876 corresponding raw registers in the ax mask, but if this isn't
877 the case add the expression that is generated to the
880 add_aexpr (std::move (aexpr
));
884 /* Add a memrange to a collection list. */
887 collection_list::add_memrange (struct gdbarch
*gdbarch
,
888 int type
, bfd_signed_vma base
,
889 unsigned long len
, CORE_ADDR scope
)
892 printf_filtered ("(%d,%s,%ld)\n", type
, paddress (gdbarch
, base
), len
);
894 /* type: memrange_absolute == memory, other n == basereg */
895 /* base: addr if memory, offset if reg relative. */
896 /* len: we actually save end (base + len) for convenience */
897 m_memranges
.emplace_back (type
, base
, base
+ len
);
899 if (type
!= memrange_absolute
) /* Better collect the base register! */
900 add_local_register (gdbarch
, type
, scope
);
903 /* Add a symbol to a collection list. */
906 collection_list::collect_symbol (struct symbol
*sym
,
907 struct gdbarch
*gdbarch
,
908 long frame_regno
, long frame_offset
,
914 bfd_signed_vma offset
;
915 int treat_as_expr
= 0;
917 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
918 switch (SYMBOL_CLASS (sym
))
921 printf_filtered ("%s: don't know symbol class %d\n",
922 SYMBOL_PRINT_NAME (sym
),
926 printf_filtered ("constant %s (value %s) will not be collected.\n",
927 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
930 offset
= SYMBOL_VALUE_ADDRESS (sym
);
933 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
934 SYMBOL_PRINT_NAME (sym
), len
,
935 paddress (gdbarch
, offset
));
937 /* A struct may be a C++ class with static fields, go to general
938 expression handling. */
939 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
942 add_memrange (gdbarch
, memrange_absolute
, offset
, len
, scope
);
945 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
947 printf_filtered ("LOC_REG[parm] %s: ",
948 SYMBOL_PRINT_NAME (sym
));
949 add_local_register (gdbarch
, reg
, scope
);
950 /* Check for doubles stored in two registers. */
951 /* FIXME: how about larger types stored in 3 or more regs? */
952 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
953 len
> register_size (gdbarch
, reg
))
954 add_local_register (gdbarch
, reg
+ 1, scope
);
957 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
958 printf_filtered (" (will not collect %s)\n",
959 SYMBOL_PRINT_NAME (sym
));
963 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
966 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
967 " from frame ptr reg %d\n",
968 SYMBOL_PRINT_NAME (sym
), len
,
969 paddress (gdbarch
, offset
), reg
);
971 add_memrange (gdbarch
, reg
, offset
, len
, scope
);
973 case LOC_REGPARM_ADDR
:
974 reg
= SYMBOL_VALUE (sym
);
978 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
980 SYMBOL_PRINT_NAME (sym
), len
,
981 paddress (gdbarch
, offset
), reg
);
983 add_memrange (gdbarch
, reg
, offset
, len
, scope
);
987 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
990 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
991 " from frame ptr reg %d\n",
992 SYMBOL_PRINT_NAME (sym
), len
,
993 paddress (gdbarch
, offset
), reg
);
995 add_memrange (gdbarch
, reg
, offset
, len
, scope
);
1002 case LOC_OPTIMIZED_OUT
:
1003 printf_filtered ("%s has been optimized out of existence.\n",
1004 SYMBOL_PRINT_NAME (sym
));
1012 /* Expressions are the most general case. */
1015 agent_expr_up aexpr
= gen_trace_for_var (scope
, gdbarch
,
1018 /* It can happen that the symbol is recorded as a computed
1019 location, but it's been optimized away and doesn't actually
1020 have a location expression. */
1023 printf_filtered ("%s has been optimized out of existence.\n",
1024 SYMBOL_PRINT_NAME (sym
));
1028 finalize_tracepoint_aexpr (aexpr
.get ());
1030 /* Take care of the registers. */
1031 add_ax_registers (aexpr
.get ());
1033 add_aexpr (std::move (aexpr
));
1037 /* Data to be passed around in the calls to the locals and args
1040 struct add_local_symbols_data
1042 struct collection_list
*collect
;
1043 struct gdbarch
*gdbarch
;
1051 /* The callback for the locals and args iterators. */
1054 do_collect_symbol (const char *print_name
,
1058 struct add_local_symbols_data
*p
= (struct add_local_symbols_data
*) cb_data
;
1060 p
->collect
->collect_symbol (sym
, p
->gdbarch
, p
->frame_regno
,
1061 p
->frame_offset
, p
->pc
, p
->trace_string
);
1064 p
->collect
->add_wholly_collected (print_name
);
1068 collection_list::add_wholly_collected (const char *print_name
)
1070 m_wholly_collected
.push_back (print_name
);
1073 /* Add all locals (or args) symbols to collection list. */
1076 collection_list::add_local_symbols (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1077 long frame_regno
, long frame_offset
, int type
,
1080 const struct block
*block
;
1081 struct add_local_symbols_data cb_data
;
1083 cb_data
.collect
= this;
1084 cb_data
.gdbarch
= gdbarch
;
1086 cb_data
.frame_regno
= frame_regno
;
1087 cb_data
.frame_offset
= frame_offset
;
1089 cb_data
.trace_string
= trace_string
;
1093 block
= block_for_pc (pc
);
1096 warning (_("Can't collect locals; "
1097 "no symbol table info available.\n"));
1101 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1102 if (cb_data
.count
== 0)
1103 warning (_("No locals found in scope."));
1107 pc
= get_pc_function_start (pc
);
1108 block
= block_for_pc (pc
);
1111 warning (_("Can't collect args; no symbol table info available."));
1115 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1116 if (cb_data
.count
== 0)
1117 warning (_("No args found in scope."));
1122 collection_list::add_static_trace_data ()
1125 printf_filtered ("collect static trace data\n");
1126 m_strace_data
= true;
1129 collection_list::collection_list ()
1130 : m_strace_data (false)
1132 int max_remote_regno
= 0;
1133 for (int i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
1135 int remote_regno
= (gdbarch_remote_register_number
1136 (target_gdbarch (), i
));
1138 if (remote_regno
>= 0 && remote_regno
> max_remote_regno
)
1139 max_remote_regno
= remote_regno
;
1142 m_regs_mask
.resize ((max_remote_regno
/ 8) + 1);
1144 m_memranges
.reserve (128);
1145 m_aexprs
.reserve (128);
1148 /* Reduce a collection list to string form (for gdb protocol). */
1150 std::vector
<std::string
>
1151 collection_list::stringify ()
1153 gdb::char_vector
temp_buf (2048);
1158 std::vector
<std::string
> str_list
;
1163 printf_filtered ("\nCollecting static trace data\n");
1164 end
= temp_buf
.data ();
1166 str_list
.emplace_back (temp_buf
.data (), end
- temp_buf
.data ());
1169 for (i
= m_regs_mask
.size () - 1; i
> 0; i
--)
1170 if (m_regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1172 if (m_regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1175 printf_filtered ("\nCollecting registers (mask): 0x");
1177 /* One char for 'R', one for the null terminator and two per
1179 std::size_t new_size
= (i
+ 1) * 2 + 2;
1180 if (new_size
> temp_buf
.size ())
1181 temp_buf
.resize (new_size
);
1183 end
= temp_buf
.data ();
1187 QUIT
; /* Allow user to bail out with ^C. */
1189 printf_filtered ("%02X", m_regs_mask
[i
]);
1191 end
= pack_hex_byte (end
, m_regs_mask
[i
]);
1195 str_list
.emplace_back (temp_buf
.data ());
1198 printf_filtered ("\n");
1199 if (!m_memranges
.empty () && info_verbose
)
1200 printf_filtered ("Collecting memranges: \n");
1201 for (i
= 0, count
= 0, end
= temp_buf
.data ();
1202 i
< m_memranges
.size (); i
++)
1204 QUIT
; /* Allow user to bail out with ^C. */
1207 printf_filtered ("(%d, %s, %ld)\n",
1208 m_memranges
[i
].type
,
1209 paddress (target_gdbarch (),
1210 m_memranges
[i
].start
),
1211 (long) (m_memranges
[i
].end
1212 - m_memranges
[i
].start
));
1214 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1216 str_list
.emplace_back (temp_buf
.data (), count
);
1218 end
= temp_buf
.data ();
1222 bfd_signed_vma length
1223 = m_memranges
[i
].end
- m_memranges
[i
].start
;
1225 /* The "%X" conversion specifier expects an unsigned argument,
1226 so passing -1 (memrange_absolute) to it directly gives you
1227 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1229 if (m_memranges
[i
].type
== memrange_absolute
)
1230 sprintf (end
, "M-1,%s,%lX", phex_nz (m_memranges
[i
].start
, 0),
1233 sprintf (end
, "M%X,%s,%lX", m_memranges
[i
].type
,
1234 phex_nz (m_memranges
[i
].start
, 0), (long) length
);
1237 count
+= strlen (end
);
1238 end
= temp_buf
.data () + count
;
1241 for (i
= 0; i
< m_aexprs
.size (); i
++)
1243 QUIT
; /* Allow user to bail out with ^C. */
1244 if ((count
+ 10 + 2 * m_aexprs
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1246 str_list
.emplace_back (temp_buf
.data (), count
);
1248 end
= temp_buf
.data ();
1250 sprintf (end
, "X%08X,", m_aexprs
[i
]->len
);
1251 end
+= 10; /* 'X' + 8 hex digits + ',' */
1254 end
= mem2hex (m_aexprs
[i
]->buf
, end
, m_aexprs
[i
]->len
);
1255 count
+= 2 * m_aexprs
[i
]->len
;
1260 str_list
.emplace_back (temp_buf
.data (), count
);
1262 end
= temp_buf
.data ();
1268 /* Add the printed expression EXP to *LIST. */
1271 collection_list::append_exp (struct expression
*exp
)
1273 string_file tmp_stream
;
1275 print_expression (exp
, &tmp_stream
);
1277 m_computed
.push_back (std::move (tmp_stream
.string ()));
1281 collection_list::finish ()
1283 memrange_sortmerge (m_memranges
);
1287 encode_actions_1 (struct command_line
*action
,
1288 struct bp_location
*tloc
,
1290 LONGEST frame_offset
,
1291 struct collection_list
*collect
,
1292 struct collection_list
*stepping_list
)
1294 const char *action_exp
;
1296 struct value
*tempval
;
1297 struct cmd_list_element
*cmd
;
1299 for (; action
; action
= action
->next
)
1301 QUIT
; /* Allow user to bail out with ^C. */
1302 action_exp
= action
->line
;
1303 action_exp
= skip_spaces (action_exp
);
1305 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1307 error (_("Bad action list item: %s"), action_exp
);
1309 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1311 int trace_string
= 0;
1313 if (*action_exp
== '/')
1314 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1317 { /* Repeat over a comma-separated list. */
1318 QUIT
; /* Allow user to bail out with ^C. */
1319 action_exp
= skip_spaces (action_exp
);
1321 if (0 == strncasecmp ("$reg", action_exp
, 4))
1323 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ());
1326 int remote_regno
= (gdbarch_remote_register_number
1327 (target_gdbarch (), i
));
1329 /* Ignore arch regnos without a corresponding
1330 remote regno. This can happen for regnos not
1332 if (remote_regno
>= 0)
1333 collect
->add_remote_register (remote_regno
);
1335 action_exp
= strchr (action_exp
, ','); /* more? */
1337 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1339 collect
->add_local_symbols (target_gdbarch (),
1345 action_exp
= strchr (action_exp
, ','); /* more? */
1347 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1349 collect
->add_local_symbols (target_gdbarch (),
1355 action_exp
= strchr (action_exp
, ','); /* more? */
1357 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1360 = gen_trace_for_return_address (tloc
->address
,
1364 finalize_tracepoint_aexpr (aexpr
.get ());
1366 /* take care of the registers */
1367 collect
->add_ax_registers (aexpr
.get ());
1369 collect
->add_aexpr (std::move (aexpr
));
1370 action_exp
= strchr (action_exp
, ','); /* more? */
1372 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1374 collect
->add_static_trace_data ();
1375 action_exp
= strchr (action_exp
, ','); /* more? */
1381 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1382 block_for_pc (tloc
->address
),
1385 switch (exp
->elts
[0].opcode
)
1389 const char *name
= &exp
->elts
[2].string
;
1391 i
= user_reg_map_name_to_regnum (target_gdbarch (),
1392 name
, strlen (name
));
1394 internal_error (__FILE__
, __LINE__
,
1395 _("Register $%s not available"),
1398 printf_filtered ("OP_REGISTER: ");
1399 collect
->add_local_register (target_gdbarch (),
1405 /* Safe because we know it's a simple expression. */
1406 tempval
= evaluate_expression (exp
.get ());
1407 addr
= value_address (tempval
);
1408 /* Initialize the TYPE_LENGTH if it is a typedef. */
1409 check_typedef (exp
->elts
[1].type
);
1410 collect
->add_memrange (target_gdbarch (),
1411 memrange_absolute
, addr
,
1412 TYPE_LENGTH (exp
->elts
[1].type
),
1414 collect
->append_exp (exp
.get ());
1419 struct symbol
*sym
= exp
->elts
[2].symbol
;
1420 const char *name
= SYMBOL_NATURAL_NAME (sym
);
1422 collect
->collect_symbol (exp
->elts
[2].symbol
,
1428 collect
->add_wholly_collected (name
);
1432 default: /* Full-fledged expression. */
1433 agent_expr_up aexpr
= gen_trace_for_expr (tloc
->address
,
1437 finalize_tracepoint_aexpr (aexpr
.get ());
1439 /* Take care of the registers. */
1440 collect
->add_ax_registers (aexpr
.get ());
1442 collect
->add_aexpr (std::move (aexpr
));
1443 collect
->append_exp (exp
.get ());
1448 while (action_exp
&& *action_exp
++ == ',');
1450 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1453 { /* Repeat over a comma-separated list. */
1454 QUIT
; /* Allow user to bail out with ^C. */
1455 action_exp
= skip_spaces (action_exp
);
1458 expression_up exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1459 block_for_pc (tloc
->address
),
1462 agent_expr_up aexpr
= gen_eval_for_expr (tloc
->address
,
1465 finalize_tracepoint_aexpr (aexpr
.get ());
1467 /* Even though we're not officially collecting, add
1468 to the collect list anyway. */
1469 collect
->add_aexpr (std::move (aexpr
));
1472 while (action_exp
&& *action_exp
++ == ',');
1474 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1476 /* We check against nested while-stepping when setting
1477 breakpoint action, so no way to run into nested
1479 gdb_assert (stepping_list
);
1481 encode_actions_1 (action
->body_list_0
.get (), tloc
, frame_reg
,
1482 frame_offset
, stepping_list
, NULL
);
1485 error (_("Invalid tracepoint command '%s'"), action
->line
);
1489 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1490 and STEPPING_LIST. */
1493 encode_actions (struct bp_location
*tloc
,
1494 struct collection_list
*tracepoint_list
,
1495 struct collection_list
*stepping_list
)
1498 LONGEST frame_offset
;
1500 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1501 tloc
->address
, &frame_reg
, &frame_offset
);
1503 counted_command_line actions
= all_tracepoint_actions (tloc
->owner
);
1504 encode_actions_1 (actions
.get (), tloc
, frame_reg
, frame_offset
,
1505 tracepoint_list
, stepping_list
);
1506 encode_actions_1 (breakpoint_commands (tloc
->owner
), tloc
,
1507 frame_reg
, frame_offset
, tracepoint_list
, stepping_list
);
1509 tracepoint_list
->finish ();
1510 stepping_list
->finish ();
1513 /* Render all actions into gdb protocol. */
1516 encode_actions_rsp (struct bp_location
*tloc
,
1517 std::vector
<std::string
> *tdp_actions
,
1518 std::vector
<std::string
> *stepping_actions
)
1520 struct collection_list tracepoint_list
, stepping_list
;
1522 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
1524 *tdp_actions
= tracepoint_list
.stringify ();
1525 *stepping_actions
= stepping_list
.stringify ();
1529 collection_list::add_aexpr (agent_expr_up aexpr
)
1531 m_aexprs
.push_back (std::move (aexpr
));
1535 process_tracepoint_on_disconnect (void)
1537 int has_pending_p
= 0;
1539 /* Check whether we still have pending tracepoint. If we have, warn the
1540 user that pending tracepoint will no longer work. */
1541 for (breakpoint
*b
: all_tracepoints ())
1550 struct bp_location
*loc1
;
1552 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1554 if (loc1
->shlib_disabled
)
1567 warning (_("Pending tracepoints will not be resolved while"
1568 " GDB is disconnected\n"));
1571 /* Reset local state of tracing. */
1574 trace_reset_local_state (void)
1576 set_traceframe_num (-1);
1577 set_tracepoint_num (-1);
1578 set_traceframe_context (NULL
);
1579 clear_traceframe_info ();
1583 start_tracing (const char *notes
)
1585 int any_enabled
= 0, num_to_download
= 0;
1588 std::vector
<breakpoint
*> tp_vec
= all_tracepoints ();
1590 /* No point in tracing without any tracepoints... */
1591 if (tp_vec
.empty ())
1592 error (_("No tracepoints defined, not starting trace"));
1594 for (breakpoint
*b
: tp_vec
)
1596 if (b
->enable_state
== bp_enabled
)
1599 if ((b
->type
== bp_fast_tracepoint
1600 ? may_insert_fast_tracepoints
1601 : may_insert_tracepoints
))
1604 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1605 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1610 if (target_supports_enable_disable_tracepoint ())
1611 warning (_("No tracepoints enabled"));
1614 /* No point in tracing with only disabled tracepoints that
1615 cannot be re-enabled. */
1616 error (_("No tracepoints enabled, not starting trace"));
1620 if (num_to_download
<= 0)
1621 error (_("No tracepoints that may be downloaded, not starting trace"));
1623 target_trace_init ();
1625 for (breakpoint
*b
: tp_vec
)
1627 struct tracepoint
*t
= (struct tracepoint
*) b
;
1628 struct bp_location
*loc
;
1629 int bp_location_downloaded
= 0;
1631 /* Clear `inserted' flag. */
1632 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1635 if ((b
->type
== bp_fast_tracepoint
1636 ? !may_insert_fast_tracepoints
1637 : !may_insert_tracepoints
))
1640 t
->number_on_target
= 0;
1642 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1644 /* Since tracepoint locations are never duplicated, `inserted'
1645 flag should be zero. */
1646 gdb_assert (!loc
->inserted
);
1648 target_download_tracepoint (loc
);
1651 bp_location_downloaded
= 1;
1654 t
->number_on_target
= b
->number
;
1656 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1657 if (loc
->probe
.prob
!= NULL
)
1658 loc
->probe
.prob
->set_semaphore (loc
->probe
.objfile
,
1661 if (bp_location_downloaded
)
1662 gdb::observers::breakpoint_modified
.notify (b
);
1665 /* Send down all the trace state variables too. */
1666 for (const trace_state_variable
&tsv
: tvariables
)
1667 target_download_trace_state_variable (tsv
);
1669 /* Tell target to treat text-like sections as transparent. */
1670 target_trace_set_readonly_regions ();
1671 /* Set some mode flags. */
1672 target_set_disconnected_tracing (disconnected_tracing
);
1673 target_set_circular_trace_buffer (circular_trace_buffer
);
1674 target_set_trace_buffer_size (trace_buffer_size
);
1677 notes
= trace_notes
;
1678 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1680 if (!ret
&& (trace_user
|| notes
))
1681 warning (_("Target does not support trace user/notes, info ignored"));
1683 /* Now insert traps and begin collecting data. */
1684 target_trace_start ();
1686 /* Reset our local state. */
1687 trace_reset_local_state ();
1688 current_trace_status()->running
= 1;
1691 /* The tstart command requests the target to start a new trace run.
1692 The command passes any arguments it has to the target verbatim, as
1693 an optional "trace note". This is useful as for instance a warning
1694 to other users if the trace runs disconnected, and you don't want
1695 anybody else messing with the target. */
1698 tstart_command (const char *args
, int from_tty
)
1700 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1702 if (current_trace_status ()->running
)
1705 && !query (_("A trace is running already. Start a new run? ")))
1706 error (_("New trace run not started."));
1709 start_tracing (args
);
1712 /* The tstop command stops the tracing run. The command passes any
1713 supplied arguments to the target verbatim as a "stop note"; if the
1714 target supports trace notes, then it will be reported back as part
1715 of the trace run's status. */
1718 tstop_command (const char *args
, int from_tty
)
1720 if (!current_trace_status ()->running
)
1721 error (_("Trace is not running."));
1723 stop_tracing (args
);
1727 stop_tracing (const char *note
)
1731 target_trace_stop ();
1733 for (breakpoint
*t
: all_tracepoints ())
1735 struct bp_location
*loc
;
1737 if ((t
->type
== bp_fast_tracepoint
1738 ? !may_insert_fast_tracepoints
1739 : !may_insert_tracepoints
))
1742 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1744 /* GDB can be totally absent in some disconnected trace scenarios,
1745 but we don't really care if this semaphore goes out of sync.
1746 That's why we are decrementing it here, but not taking care
1748 if (loc
->probe
.prob
!= NULL
)
1749 loc
->probe
.prob
->clear_semaphore (loc
->probe
.objfile
,
1755 note
= trace_stop_notes
;
1756 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1759 warning (_("Target does not support trace notes, note ignored"));
1761 /* Should change in response to reply? */
1762 current_trace_status ()->running
= 0;
1765 /* tstatus command */
1767 tstatus_command (const char *args
, int from_tty
)
1769 struct trace_status
*ts
= current_trace_status ();
1772 status
= target_get_trace_status (ts
);
1776 if (ts
->filename
!= NULL
)
1777 printf_filtered (_("Using a trace file.\n"));
1780 printf_filtered (_("Trace can not be run on this target.\n"));
1785 if (!ts
->running_known
)
1787 printf_filtered (_("Run/stop status is unknown.\n"));
1789 else if (ts
->running
)
1791 printf_filtered (_("Trace is running on the target.\n"));
1795 switch (ts
->stop_reason
)
1797 case trace_never_run
:
1798 printf_filtered (_("No trace has been run on the target.\n"));
1800 case trace_stop_command
:
1802 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1805 printf_filtered (_("Trace stopped by a tstop command.\n"));
1807 case trace_buffer_full
:
1808 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1810 case trace_disconnected
:
1811 printf_filtered (_("Trace stopped because of disconnection.\n"));
1813 case tracepoint_passcount
:
1814 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1815 ts
->stopping_tracepoint
);
1817 case tracepoint_error
:
1818 if (ts
->stopping_tracepoint
)
1819 printf_filtered (_("Trace stopped by an "
1820 "error (%s, tracepoint %d).\n"),
1821 ts
->stop_desc
, ts
->stopping_tracepoint
);
1823 printf_filtered (_("Trace stopped by an error (%s).\n"),
1826 case trace_stop_reason_unknown
:
1827 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1830 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1836 if (ts
->traceframes_created
>= 0
1837 && ts
->traceframe_count
!= ts
->traceframes_created
)
1839 printf_filtered (_("Buffer contains %d trace "
1840 "frames (of %d created total).\n"),
1841 ts
->traceframe_count
, ts
->traceframes_created
);
1843 else if (ts
->traceframe_count
>= 0)
1845 printf_filtered (_("Collected %d trace frames.\n"),
1846 ts
->traceframe_count
);
1849 if (ts
->buffer_free
>= 0)
1851 if (ts
->buffer_size
>= 0)
1853 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1854 ts
->buffer_free
, ts
->buffer_size
);
1855 if (ts
->buffer_size
> 0)
1856 printf_filtered (_(" (%d%% full)"),
1857 ((int) ((((long long) (ts
->buffer_size
1858 - ts
->buffer_free
)) * 100)
1859 / ts
->buffer_size
)));
1860 printf_filtered (_(".\n"));
1863 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1867 if (ts
->disconnected_tracing
)
1868 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1870 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1872 if (ts
->circular_buffer
)
1873 printf_filtered (_("Trace buffer is circular.\n"));
1875 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1876 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1878 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1879 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1881 /* Now report on what we're doing with tfind. */
1882 if (traceframe_number
>= 0)
1883 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1884 traceframe_number
, tracepoint_number
);
1886 printf_filtered (_("Not looking at any trace frame.\n"));
1888 /* Report start/stop times if supplied. */
1893 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1895 /* Reporting a run time is more readable than two long numbers. */
1896 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1897 (long int) (ts
->start_time
/ 1000000),
1898 (long int) (ts
->start_time
% 1000000),
1899 (long int) (run_time
/ 1000000),
1900 (long int) (run_time
% 1000000));
1903 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1904 (long int) (ts
->start_time
/ 1000000),
1905 (long int) (ts
->start_time
% 1000000));
1907 else if (ts
->stop_time
)
1908 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1909 (long int) (ts
->stop_time
/ 1000000),
1910 (long int) (ts
->stop_time
% 1000000));
1912 /* Now report any per-tracepoint status available. */
1913 for (breakpoint
*t
: all_tracepoints ())
1914 target_get_tracepoint_status (t
, NULL
);
1917 /* Report the trace status to uiout, in a way suitable for MI, and not
1918 suitable for CLI. If ON_STOP is true, suppress a few fields that
1919 are not meaningful in the -trace-stop response.
1921 The implementation is essentially parallel to trace_status_command, but
1922 merging them will result in unreadable code. */
1924 trace_status_mi (int on_stop
)
1926 struct ui_out
*uiout
= current_uiout
;
1927 struct trace_status
*ts
= current_trace_status ();
1930 status
= target_get_trace_status (ts
);
1932 if (status
== -1 && ts
->filename
== NULL
)
1934 uiout
->field_string ("supported", "0");
1938 if (ts
->filename
!= NULL
)
1939 uiout
->field_string ("supported", "file");
1941 uiout
->field_string ("supported", "1");
1943 if (ts
->filename
!= NULL
)
1944 uiout
->field_string ("trace-file", ts
->filename
);
1946 gdb_assert (ts
->running_known
);
1950 uiout
->field_string ("running", "1");
1952 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1953 Given that the frontend gets the status either on -trace-stop, or from
1954 -trace-status after re-connection, it does not seem like this
1955 information is necessary for anything. It is not necessary for either
1956 figuring the vital state of the target nor for navigation of trace
1957 frames. If the frontend wants to show the current state is some
1958 configure dialog, it can request the value when such dialog is
1959 invoked by the user. */
1963 const char *stop_reason
= NULL
;
1964 int stopping_tracepoint
= -1;
1967 uiout
->field_string ("running", "0");
1969 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1971 switch (ts
->stop_reason
)
1973 case trace_stop_command
:
1974 stop_reason
= "request";
1976 case trace_buffer_full
:
1977 stop_reason
= "overflow";
1979 case trace_disconnected
:
1980 stop_reason
= "disconnection";
1982 case tracepoint_passcount
:
1983 stop_reason
= "passcount";
1984 stopping_tracepoint
= ts
->stopping_tracepoint
;
1986 case tracepoint_error
:
1987 stop_reason
= "error";
1988 stopping_tracepoint
= ts
->stopping_tracepoint
;
1994 uiout
->field_string ("stop-reason", stop_reason
);
1995 if (stopping_tracepoint
!= -1)
1996 uiout
->field_signed ("stopping-tracepoint",
1997 stopping_tracepoint
);
1998 if (ts
->stop_reason
== tracepoint_error
)
1999 uiout
->field_string ("error-description",
2005 if (ts
->traceframe_count
!= -1)
2006 uiout
->field_signed ("frames", ts
->traceframe_count
);
2007 if (ts
->traceframes_created
!= -1)
2008 uiout
->field_signed ("frames-created", ts
->traceframes_created
);
2009 if (ts
->buffer_size
!= -1)
2010 uiout
->field_signed ("buffer-size", ts
->buffer_size
);
2011 if (ts
->buffer_free
!= -1)
2012 uiout
->field_signed ("buffer-free", ts
->buffer_free
);
2014 uiout
->field_signed ("disconnected", ts
->disconnected_tracing
);
2015 uiout
->field_signed ("circular", ts
->circular_buffer
);
2017 uiout
->field_string ("user-name", ts
->user_name
);
2018 uiout
->field_string ("notes", ts
->notes
);
2023 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2024 (long int) (ts
->start_time
/ 1000000),
2025 (long int) (ts
->start_time
% 1000000));
2026 uiout
->field_string ("start-time", buf
);
2027 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2028 (long int) (ts
->stop_time
/ 1000000),
2029 (long int) (ts
->stop_time
% 1000000));
2030 uiout
->field_string ("stop-time", buf
);
2034 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2035 user if she really wants to detach. */
2038 query_if_trace_running (int from_tty
)
2043 /* It can happen that the target that was tracing went away on its
2044 own, and we didn't notice. Get a status update, and if the
2045 current target doesn't even do tracing, then assume it's not
2047 if (target_get_trace_status (current_trace_status ()) < 0)
2048 current_trace_status ()->running
= 0;
2050 /* If running interactively, give the user the option to cancel and
2051 then decide what to do differently with the run. Scripts are
2052 just going to disconnect and let the target deal with it,
2053 according to how it's been instructed previously via
2054 disconnected-tracing. */
2055 if (current_trace_status ()->running
)
2057 process_tracepoint_on_disconnect ();
2059 if (current_trace_status ()->disconnected_tracing
)
2061 if (!query (_("Trace is running and will "
2062 "continue after detach; detach anyway? ")))
2063 error (_("Not confirmed."));
2067 if (!query (_("Trace is running but will "
2068 "stop on detach; detach anyway? ")))
2069 error (_("Not confirmed."));
2074 /* This function handles the details of what to do about an ongoing
2075 tracing run if the user has asked to detach or otherwise disconnect
2079 disconnect_tracing (void)
2081 /* Also we want to be out of tfind mode, otherwise things can get
2082 confusing upon reconnection. Just use these calls instead of
2083 full tfind_1 behavior because we're in the middle of detaching,
2084 and there's no point to updating current stack frame etc. */
2085 trace_reset_local_state ();
2088 /* Worker function for the various flavors of the tfind command. */
2090 tfind_1 (enum trace_find_type type
, int num
,
2091 CORE_ADDR addr1
, CORE_ADDR addr2
,
2094 int target_frameno
= -1, target_tracept
= -1;
2095 struct frame_id old_frame_id
= null_frame_id
;
2096 struct tracepoint
*tp
;
2097 struct ui_out
*uiout
= current_uiout
;
2099 /* Only try to get the current stack frame if we have a chance of
2100 succeeding. In particular, if we're trying to get a first trace
2101 frame while all threads are running, it's not going to succeed,
2102 so leave it with a default value and let the frame comparison
2103 below (correctly) decide to print out the source location of the
2105 if (!(type
== tfind_number
&& num
== -1)
2106 && (has_stack_frames () || traceframe_number
>= 0))
2107 old_frame_id
= get_frame_id (get_current_frame ());
2109 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2112 if (type
== tfind_number
2114 && target_frameno
== -1)
2116 /* We told the target to get out of tfind mode, and it did. */
2118 else if (target_frameno
== -1)
2120 /* A request for a non-existent trace frame has failed.
2121 Our response will be different, depending on FROM_TTY:
2123 If FROM_TTY is true, meaning that this command was
2124 typed interactively by the user, then give an error
2125 and DO NOT change the state of traceframe_number etc.
2127 However if FROM_TTY is false, meaning that we're either
2128 in a script, a loop, or a user-defined command, then
2129 DON'T give an error, but DO change the state of
2130 traceframe_number etc. to invalid.
2132 The rationalle is that if you typed the command, you
2133 might just have committed a typo or something, and you'd
2134 like to NOT lose your current debugging state. However
2135 if you're in a user-defined command or especially in a
2136 loop, then you need a way to detect that the command
2137 failed WITHOUT aborting. This allows you to write
2138 scripts that search thru the trace buffer until the end,
2139 and then continue on to do something else. */
2142 error (_("Target failed to find requested trace frame."));
2146 printf_filtered ("End of trace buffer.\n");
2147 #if 0 /* dubious now? */
2148 /* The following will not recurse, since it's
2150 tfind_command ("-1", from_tty
);
2155 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2157 reinit_frame_cache ();
2158 target_dcache_invalidate ();
2160 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2162 if (target_frameno
!= get_traceframe_number ())
2163 gdb::observers::traceframe_changed
.notify (target_frameno
, tracepoint_number
);
2165 set_current_traceframe (target_frameno
);
2167 if (target_frameno
== -1)
2168 set_traceframe_context (NULL
);
2170 set_traceframe_context (get_current_frame ());
2172 if (traceframe_number
>= 0)
2174 /* Use different branches for MI and CLI to make CLI messages
2176 if (uiout
->is_mi_like_p ())
2178 uiout
->field_string ("found", "1");
2179 uiout
->field_signed ("tracepoint", tracepoint_number
);
2180 uiout
->field_signed ("traceframe", traceframe_number
);
2184 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2185 traceframe_number
, tracepoint_number
);
2190 if (uiout
->is_mi_like_p ())
2191 uiout
->field_string ("found", "0");
2192 else if (type
== tfind_number
&& num
== -1)
2193 printf_unfiltered (_("No longer looking at any trace frame\n"));
2194 else /* This case may never occur, check. */
2195 printf_unfiltered (_("No trace frame found\n"));
2198 /* If we're in nonstop mode and getting out of looking at trace
2199 frames, there won't be any current frame to go back to and
2202 && (has_stack_frames () || traceframe_number
>= 0))
2204 enum print_what print_what
;
2206 /* NOTE: in imitation of the step command, try to determine
2207 whether we have made a transition from one function to
2208 another. If so, we'll print the "stack frame" (ie. the new
2209 function and it's arguments) -- otherwise we'll just show the
2212 if (frame_id_eq (old_frame_id
,
2213 get_frame_id (get_current_frame ())))
2214 print_what
= SRC_LINE
;
2216 print_what
= SRC_AND_LOC
;
2218 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2223 /* Error on looking at traceframes while trace is running. */
2226 check_trace_running (struct trace_status
*status
)
2228 if (status
->running
&& status
->filename
== NULL
)
2229 error (_("May not look at trace frames while trace is running."));
2232 /* trace_find_command takes a trace frame number n,
2233 sends "QTFrame:<n>" to the target,
2234 and accepts a reply that may contain several optional pieces
2235 of information: a frame number, a tracepoint number, and an
2236 indication of whether this is a trap frame or a stepping frame.
2238 The minimal response is just "OK" (which indicates that the
2239 target does not give us a frame number or a tracepoint number).
2240 Instead of that, the target may send us a string containing
2242 F<hexnum> (gives the selected frame number)
2243 T<hexnum> (gives the selected tracepoint number)
2248 tfind_command_1 (const char *args
, int from_tty
)
2249 { /* This should only be called with a numeric argument. */
2252 check_trace_running (current_trace_status ());
2254 if (args
== 0 || *args
== 0)
2255 { /* TFIND with no args means find NEXT trace frame. */
2256 if (traceframe_number
== -1)
2257 frameno
= 0; /* "next" is first one. */
2259 frameno
= traceframe_number
+ 1;
2261 else if (0 == strcmp (args
, "-"))
2263 if (traceframe_number
== -1)
2264 error (_("not debugging trace buffer"));
2265 else if (from_tty
&& traceframe_number
== 0)
2266 error (_("already at start of trace buffer"));
2268 frameno
= traceframe_number
- 1;
2270 /* A hack to work around eval's need for fp to have been collected. */
2271 else if (0 == strcmp (args
, "-1"))
2274 frameno
= parse_and_eval_long (args
);
2277 error (_("invalid input (%d is less than zero)"), frameno
);
2279 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2283 tfind_command (const char *args
, int from_tty
)
2285 tfind_command_1 (args
, from_tty
);
2290 tfind_end_command (const char *args
, int from_tty
)
2292 tfind_command_1 ("-1", from_tty
);
2297 tfind_start_command (const char *args
, int from_tty
)
2299 tfind_command_1 ("0", from_tty
);
2302 /* tfind pc command */
2304 tfind_pc_command (const char *args
, int from_tty
)
2308 check_trace_running (current_trace_status ());
2310 if (args
== 0 || *args
== 0)
2311 pc
= regcache_read_pc (get_current_regcache ());
2313 pc
= parse_and_eval_address (args
);
2315 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2318 /* tfind tracepoint command */
2320 tfind_tracepoint_command (const char *args
, int from_tty
)
2323 struct tracepoint
*tp
;
2325 check_trace_running (current_trace_status ());
2327 if (args
== 0 || *args
== 0)
2329 if (tracepoint_number
== -1)
2330 error (_("No current tracepoint -- please supply an argument."));
2332 tdp
= tracepoint_number
; /* Default is current TDP. */
2335 tdp
= parse_and_eval_long (args
);
2337 /* If we have the tracepoint on hand, use the number that the
2338 target knows about (which may be different if we disconnected
2339 and reconnected). */
2340 tp
= get_tracepoint (tdp
);
2342 tdp
= tp
->number_on_target
;
2344 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2347 /* TFIND LINE command:
2349 This command will take a sourceline for argument, just like BREAK
2350 or TRACE (ie. anything that "decode_line_1" can handle).
2352 With no argument, this command will find the next trace frame
2353 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2356 tfind_line_command (const char *args
, int from_tty
)
2358 check_trace_running (current_trace_status ());
2360 symtab_and_line sal
;
2361 if (args
== 0 || *args
== 0)
2363 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2367 std::vector
<symtab_and_line
> sals
2368 = decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2372 if (sal
.symtab
== 0)
2373 error (_("No line number information available."));
2375 CORE_ADDR start_pc
, end_pc
;
2376 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2378 if (start_pc
== end_pc
)
2380 printf_filtered ("Line %d of \"%s\"",
2382 symtab_to_filename_for_display (sal
.symtab
));
2384 printf_filtered (" is at address ");
2385 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2387 printf_filtered (" but contains no code.\n");
2388 sal
= find_pc_line (start_pc
, 0);
2390 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2391 && start_pc
!= end_pc
)
2392 printf_filtered ("Attempting to find line %d instead.\n",
2395 error (_("Cannot find a good line."));
2399 /* Is there any case in which we get here, and have an address
2400 which the user would want to see? If we have debugging
2401 symbols and no line numbers? */
2402 error (_("Line number %d is out of range for \"%s\"."),
2403 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2405 /* Find within range of stated line. */
2407 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2409 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2412 /* tfind range command */
2414 tfind_range_command (const char *args
, int from_tty
)
2416 static CORE_ADDR start
, stop
;
2419 check_trace_running (current_trace_status ());
2421 if (args
== 0 || *args
== 0)
2422 { /* XXX FIXME: what should default behavior be? */
2423 printf_filtered ("Usage: tfind range STARTADDR, ENDADDR\n");
2427 if (0 != (tmp
= strchr (args
, ',')))
2429 std::string
start_addr (args
, tmp
);
2431 tmp
= skip_spaces (tmp
);
2432 start
= parse_and_eval_address (start_addr
.c_str ());
2433 stop
= parse_and_eval_address (tmp
);
2436 { /* No explicit end address? */
2437 start
= parse_and_eval_address (args
);
2438 stop
= start
+ 1; /* ??? */
2441 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2444 /* tfind outside command */
2446 tfind_outside_command (const char *args
, int from_tty
)
2448 CORE_ADDR start
, stop
;
2451 if (current_trace_status ()->running
2452 && current_trace_status ()->filename
== NULL
)
2453 error (_("May not look at trace frames while trace is running."));
2455 if (args
== 0 || *args
== 0)
2456 { /* XXX FIXME: what should default behavior be? */
2457 printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n");
2461 if (0 != (tmp
= strchr (args
, ',')))
2463 std::string
start_addr (args
, tmp
);
2465 tmp
= skip_spaces (tmp
);
2466 start
= parse_and_eval_address (start_addr
.c_str ());
2467 stop
= parse_and_eval_address (tmp
);
2470 { /* No explicit end address? */
2471 start
= parse_and_eval_address (args
);
2472 stop
= start
+ 1; /* ??? */
2475 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2478 /* info scope command: list the locals for a scope. */
2480 info_scope_command (const char *args_in
, int from_tty
)
2483 struct bound_minimal_symbol msym
;
2484 const struct block
*block
;
2485 const char *symname
;
2486 const char *save_args
= args_in
;
2487 struct block_iterator iter
;
2489 struct gdbarch
*gdbarch
;
2491 const char *args
= args_in
;
2493 if (args
== 0 || *args
== 0)
2494 error (_("requires an argument (function, "
2495 "line or *addr) to define a scope"));
2497 event_location_up location
= string_to_event_location (&args
,
2499 std::vector
<symtab_and_line
> sals
2500 = decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
2504 /* Presumably decode_line_1 has already warned. */
2508 /* Resolve line numbers to PC. */
2509 resolve_sal_pc (&sals
[0]);
2510 block
= block_for_pc (sals
[0].pc
);
2514 QUIT
; /* Allow user to bail out with ^C. */
2515 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2517 QUIT
; /* Allow user to bail out with ^C. */
2519 printf_filtered ("Scope for %s:\n", save_args
);
2522 symname
= SYMBOL_PRINT_NAME (sym
);
2523 if (symname
== NULL
|| *symname
== '\0')
2524 continue; /* Probably botched, certainly useless. */
2526 gdbarch
= symbol_arch (sym
);
2528 printf_filtered ("Symbol %s is ", symname
);
2530 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2531 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2532 BLOCK_ENTRY_PC (block
),
2536 switch (SYMBOL_CLASS (sym
))
2539 case LOC_UNDEF
: /* Messed up symbol? */
2540 printf_filtered ("a bogus symbol, class %d.\n",
2541 SYMBOL_CLASS (sym
));
2542 count
--; /* Don't count this one. */
2545 printf_filtered ("a constant with value %s (%s)",
2546 plongest (SYMBOL_VALUE (sym
)),
2547 hex_string (SYMBOL_VALUE (sym
)));
2549 case LOC_CONST_BYTES
:
2550 printf_filtered ("constant bytes: ");
2551 if (SYMBOL_TYPE (sym
))
2552 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2553 fprintf_filtered (gdb_stdout
, " %02x",
2554 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2557 printf_filtered ("in static storage at address ");
2558 printf_filtered ("%s", paddress (gdbarch
,
2559 SYMBOL_VALUE_ADDRESS (sym
)));
2562 /* GDBARCH is the architecture associated with the objfile
2563 the symbol is defined in; the target architecture may be
2564 different, and may provide additional registers. However,
2565 we do not know the target architecture at this point.
2566 We assume the objfile architecture will contain all the
2567 standard registers that occur in debug info in that
2569 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2572 if (SYMBOL_IS_ARGUMENT (sym
))
2573 printf_filtered ("an argument in register $%s",
2574 gdbarch_register_name (gdbarch
, regno
));
2576 printf_filtered ("a local variable in register $%s",
2577 gdbarch_register_name (gdbarch
, regno
));
2580 printf_filtered ("an argument at stack/frame offset %s",
2581 plongest (SYMBOL_VALUE (sym
)));
2584 printf_filtered ("a local variable at frame offset %s",
2585 plongest (SYMBOL_VALUE (sym
)));
2588 printf_filtered ("a reference argument at offset %s",
2589 plongest (SYMBOL_VALUE (sym
)));
2591 case LOC_REGPARM_ADDR
:
2592 /* Note comment at LOC_REGISTER. */
2593 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2595 printf_filtered ("the address of an argument, in register $%s",
2596 gdbarch_register_name (gdbarch
, regno
));
2599 printf_filtered ("a typedef.\n");
2602 printf_filtered ("a label at address ");
2603 printf_filtered ("%s", paddress (gdbarch
,
2604 SYMBOL_VALUE_ADDRESS (sym
)));
2607 printf_filtered ("a function at address ");
2608 printf_filtered ("%s",
2609 paddress (gdbarch
, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
))));
2611 case LOC_UNRESOLVED
:
2612 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2614 if (msym
.minsym
== NULL
)
2615 printf_filtered ("Unresolved Static");
2618 printf_filtered ("static storage at address ");
2619 printf_filtered ("%s",
2621 BMSYMBOL_VALUE_ADDRESS (msym
)));
2624 case LOC_OPTIMIZED_OUT
:
2625 printf_filtered ("optimized out.\n");
2628 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2631 if (SYMBOL_TYPE (sym
))
2633 struct type
*t
= check_typedef (SYMBOL_TYPE (sym
));
2635 printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t
)));
2638 if (BLOCK_FUNCTION (block
))
2641 block
= BLOCK_SUPERBLOCK (block
);
2644 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2648 /* Helper for trace_dump_command. Dump the action list starting at
2649 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2650 actions of the body of a while-stepping action. STEPPING_FRAME is
2651 set if the current traceframe was determined to be a while-stepping
2655 trace_dump_actions (struct command_line
*action
,
2656 int stepping_actions
, int stepping_frame
,
2659 const char *action_exp
, *next_comma
;
2661 for (; action
!= NULL
; action
= action
->next
)
2663 struct cmd_list_element
*cmd
;
2665 QUIT
; /* Allow user to bail out with ^C. */
2666 action_exp
= action
->line
;
2667 action_exp
= skip_spaces (action_exp
);
2669 /* The collection actions to be done while stepping are
2670 bracketed by the commands "while-stepping" and "end". */
2672 if (*action_exp
== '#') /* comment line */
2675 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2677 error (_("Bad action list item: %s"), action_exp
);
2679 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2681 gdb_assert (action
->body_list_1
== nullptr);
2682 trace_dump_actions (action
->body_list_0
.get (),
2683 1, stepping_frame
, from_tty
);
2685 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2687 /* Display the collected data.
2688 For the trap frame, display only what was collected at
2689 the trap. Likewise for stepping frames, display only
2690 what was collected while stepping. This means that the
2691 two boolean variables, STEPPING_FRAME and
2692 STEPPING_ACTIONS should be equal. */
2693 if (stepping_frame
== stepping_actions
)
2695 int trace_string
= 0;
2697 if (*action_exp
== '/')
2698 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2701 { /* Repeat over a comma-separated list. */
2702 QUIT
; /* Allow user to bail out with ^C. */
2703 if (*action_exp
== ',')
2705 action_exp
= skip_spaces (action_exp
);
2707 next_comma
= strchr (action_exp
, ',');
2709 if (0 == strncasecmp (action_exp
, "$reg", 4))
2710 registers_info (NULL
, from_tty
);
2711 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2713 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2714 info_locals_command (NULL
, from_tty
);
2715 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2716 info_args_command (NULL
, from_tty
);
2719 std::string contents
;
2720 const char *exp
= action_exp
;
2721 if (next_comma
!= NULL
)
2723 size_t len
= next_comma
- action_exp
;
2724 contents
= std::string (action_exp
, len
);
2725 exp
= contents
.c_str ();
2728 printf_filtered ("%s = ", exp
);
2729 output_command (exp
, from_tty
);
2730 printf_filtered ("\n");
2732 action_exp
= next_comma
;
2734 while (action_exp
&& *action_exp
== ',');
2740 /* Return bp_location of the tracepoint associated with the current
2741 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2742 is a stepping traceframe. */
2744 struct bp_location
*
2745 get_traceframe_location (int *stepping_frame_p
)
2747 struct tracepoint
*t
;
2748 struct bp_location
*tloc
;
2749 struct regcache
*regcache
;
2751 if (tracepoint_number
== -1)
2752 error (_("No current trace frame."));
2754 t
= get_tracepoint (tracepoint_number
);
2757 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2760 /* The current frame is a trap frame if the frame PC is equal to the
2761 tracepoint PC. If not, then the current frame was collected
2762 during single-stepping. */
2763 regcache
= get_current_regcache ();
2765 /* If the traceframe's address matches any of the tracepoint's
2766 locations, assume it is a direct hit rather than a while-stepping
2767 frame. (FIXME this is not reliable, should record each frame's
2769 for (tloc
= t
->loc
; tloc
; tloc
= tloc
->next
)
2770 if (tloc
->address
== regcache_read_pc (regcache
))
2772 *stepping_frame_p
= 0;
2776 /* If this is a stepping frame, we don't know which location
2777 triggered. The first is as good (or bad) a guess as any... */
2778 *stepping_frame_p
= 1;
2782 /* Return the default collect actions of a tracepoint T. */
2784 static counted_command_line
2785 all_tracepoint_actions (struct breakpoint
*t
)
2787 counted_command_line
actions (nullptr, command_lines_deleter ());
2789 /* If there are default expressions to collect, make up a collect
2790 action and prepend to the action list to encode. Note that since
2791 validation is per-tracepoint (local var "xyz" might be valid for
2792 one tracepoint and not another, etc), we make up the action on
2793 the fly, and don't cache it. */
2794 if (*default_collect
)
2796 gdb::unique_xmalloc_ptr
<char> default_collect_line
2797 (xstrprintf ("collect %s", default_collect
));
2799 validate_actionline (default_collect_line
.get (), t
);
2800 actions
.reset (new struct command_line (simple_control
,
2801 default_collect_line
.release ()),
2802 command_lines_deleter ());
2808 /* The tdump command. */
2811 tdump_command (const char *args
, int from_tty
)
2813 int stepping_frame
= 0;
2814 struct bp_location
*loc
;
2816 /* This throws an error is not inspecting a trace frame. */
2817 loc
= get_traceframe_location (&stepping_frame
);
2819 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2820 tracepoint_number
, traceframe_number
);
2822 /* This command only makes sense for the current frame, not the
2824 scoped_restore_current_thread restore_thread
;
2826 select_frame (get_current_frame ());
2828 counted_command_line actions
= all_tracepoint_actions (loc
->owner
);
2830 trace_dump_actions (actions
.get (), 0, stepping_frame
, from_tty
);
2831 trace_dump_actions (breakpoint_commands (loc
->owner
), 0, stepping_frame
,
2835 /* Encode a piece of a tracepoint's source-level definition in a form
2836 that is suitable for both protocol and saving in files. */
2837 /* This version does not do multiple encodes for long strings; it should
2838 return an offset to the next piece to encode. FIXME */
2841 encode_source_string (int tpnum
, ULONGEST addr
,
2842 const char *srctype
, const char *src
,
2843 char *buf
, int buf_size
)
2845 if (80 + strlen (srctype
) > buf_size
)
2846 error (_("Buffer too small for source encoding"));
2847 sprintf (buf
, "%x:%s:%s:%x:%x:",
2848 tpnum
, phex_nz (addr
, sizeof (addr
)),
2849 srctype
, 0, (int) strlen (src
));
2850 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2851 error (_("Source string too long for buffer"));
2852 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
2856 /* Tell the target what to do with an ongoing tracing run if GDB
2857 disconnects for some reason. */
2860 set_disconnected_tracing (const char *args
, int from_tty
,
2861 struct cmd_list_element
*c
)
2863 target_set_disconnected_tracing (disconnected_tracing
);
2867 set_circular_trace_buffer (const char *args
, int from_tty
,
2868 struct cmd_list_element
*c
)
2870 target_set_circular_trace_buffer (circular_trace_buffer
);
2874 set_trace_buffer_size (const char *args
, int from_tty
,
2875 struct cmd_list_element
*c
)
2877 target_set_trace_buffer_size (trace_buffer_size
);
2881 set_trace_user (const char *args
, int from_tty
,
2882 struct cmd_list_element
*c
)
2886 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
2889 warning (_("Target does not support trace notes, user ignored"));
2893 set_trace_notes (const char *args
, int from_tty
,
2894 struct cmd_list_element
*c
)
2898 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
2901 warning (_("Target does not support trace notes, note ignored"));
2905 set_trace_stop_notes (const char *args
, int from_tty
,
2906 struct cmd_list_element
*c
)
2910 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
2913 warning (_("Target does not support trace notes, stop note ignored"));
2916 /* Convert the memory pointed to by mem into hex, placing result in buf.
2917 * Return a pointer to the last char put in buf (null)
2918 * "stolen" from sparc-stub.c
2921 static const char hexchars
[] = "0123456789abcdef";
2924 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2932 *buf
++ = hexchars
[ch
>> 4];
2933 *buf
++ = hexchars
[ch
& 0xf];
2942 get_traceframe_number (void)
2944 return traceframe_number
;
2948 get_tracepoint_number (void)
2950 return tracepoint_number
;
2953 /* Make the traceframe NUM be the current trace frame. Does nothing
2954 if NUM is already current. */
2957 set_current_traceframe (int num
)
2961 if (traceframe_number
== num
)
2963 /* Nothing to do. */
2967 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2970 warning (_("could not change traceframe"));
2972 set_traceframe_num (newnum
);
2974 /* Changing the traceframe changes our view of registers and of the
2976 registers_changed ();
2978 clear_traceframe_info ();
2981 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2982 : m_traceframe_number (traceframe_number
)
2985 /* Given a number and address, return an uploaded tracepoint with that
2986 number, creating if necessary. */
2988 struct uploaded_tp
*
2989 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2991 struct uploaded_tp
*utp
;
2993 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2994 if (utp
->number
== num
&& utp
->addr
== addr
)
2997 utp
= new uploaded_tp
;
3007 free_uploaded_tps (struct uploaded_tp
**utpp
)
3009 struct uploaded_tp
*next_one
;
3013 next_one
= (*utpp
)->next
;
3019 /* Given a number and address, return an uploaded tracepoint with that
3020 number, creating if necessary. */
3022 struct uploaded_tsv
*
3023 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3025 struct uploaded_tsv
*utsv
;
3027 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3028 if (utsv
->number
== num
)
3031 utsv
= XCNEW (struct uploaded_tsv
);
3033 utsv
->next
= *utsvp
;
3040 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3042 struct uploaded_tsv
*next_one
;
3046 next_one
= (*utsvp
)->next
;
3052 /* FIXME this function is heuristic and will miss the cases where the
3053 conditional is semantically identical but differs in whitespace,
3054 such as "x == 0" vs "x==0". */
3057 cond_string_is_same (char *str1
, char *str2
)
3059 if (str1
== NULL
|| str2
== NULL
)
3060 return (str1
== str2
);
3062 return (strcmp (str1
, str2
) == 0);
3065 /* Look for an existing tracepoint that seems similar enough to the
3066 uploaded one. Enablement isn't compared, because the user can
3067 toggle that freely, and may have done so in anticipation of the
3068 next trace run. Return the location of matched tracepoint. */
3070 static struct bp_location
*
3071 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3073 struct bp_location
*loc
;
3075 for (breakpoint
*b
: all_tracepoints ())
3077 struct tracepoint
*t
= (struct tracepoint
*) b
;
3079 if (b
->type
== utp
->type
3080 && t
->step_count
== utp
->step
3081 && t
->pass_count
== utp
->pass
3082 && cond_string_is_same (t
->cond_string
,
3083 utp
->cond_string
.get ())
3084 /* FIXME also test actions. */
3087 /* Scan the locations for an address match. */
3088 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3090 if (loc
->address
== utp
->addr
)
3098 /* Given a list of tracepoints uploaded from a target, attempt to
3099 match them up with existing tracepoints, and create new ones if not
3103 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3105 struct uploaded_tp
*utp
;
3106 /* A set of tracepoints which are modified. */
3107 std::vector
<breakpoint
*> modified_tp
;
3109 /* Look for GDB tracepoints that match up with our uploaded versions. */
3110 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3112 struct bp_location
*loc
;
3113 struct tracepoint
*t
;
3115 loc
= find_matching_tracepoint_location (utp
);
3120 /* Mark this location as already inserted. */
3122 t
= (struct tracepoint
*) loc
->owner
;
3123 printf_filtered (_("Assuming tracepoint %d is same "
3124 "as target's tracepoint %d at %s.\n"),
3125 loc
->owner
->number
, utp
->number
,
3126 paddress (loc
->gdbarch
, utp
->addr
));
3128 /* The tracepoint LOC->owner was modified (the location LOC
3129 was marked as inserted in the target). Save it in
3130 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3131 observers will be notified later once for each tracepoint
3132 saved in MODIFIED_TP. */
3133 for (breakpoint
*b
: modified_tp
)
3134 if (b
== loc
->owner
)
3140 modified_tp
.push_back (loc
->owner
);
3144 t
= create_tracepoint_from_upload (utp
);
3146 printf_filtered (_("Created tracepoint %d for "
3147 "target's tracepoint %d at %s.\n"),
3148 t
->number
, utp
->number
,
3149 paddress (get_current_arch (), utp
->addr
));
3151 printf_filtered (_("Failed to create tracepoint for target's "
3152 "tracepoint %d at %s, skipping it.\n"),
3154 paddress (get_current_arch (), utp
->addr
));
3156 /* Whether found or created, record the number used by the
3157 target, to help with mapping target tracepoints back to their
3158 counterparts here. */
3160 t
->number_on_target
= utp
->number
;
3163 /* Notify 'breakpoint-modified' observer that at least one of B's
3164 locations was changed. */
3165 for (breakpoint
*b
: modified_tp
)
3166 gdb::observers::breakpoint_modified
.notify (b
);
3168 free_uploaded_tps (uploaded_tps
);
3171 /* Trace state variables don't have much to identify them beyond their
3172 name, so just use that to detect matches. */
3174 static struct trace_state_variable
*
3175 find_matching_tsv (struct uploaded_tsv
*utsv
)
3180 return find_trace_state_variable (utsv
->name
);
3183 static struct trace_state_variable
*
3184 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3186 const char *namebase
;
3189 struct trace_state_variable
*tsv
;
3193 namebase
= utsv
->name
;
3199 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3202 /* Fish for a name that is not in use. */
3203 /* (should check against all internal vars?) */
3204 while (find_trace_state_variable (buf
.c_str ()))
3205 buf
= string_printf ("%s_%d", namebase
, try_num
++);
3207 /* We have an available name, create the variable. */
3208 tsv
= create_trace_state_variable (buf
.c_str ());
3209 tsv
->initial_value
= utsv
->initial_value
;
3210 tsv
->builtin
= utsv
->builtin
;
3212 gdb::observers::tsv_created
.notify (tsv
);
3217 /* Given a list of uploaded trace state variables, try to match them
3218 up with existing variables, or create additional ones. */
3221 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3223 struct uploaded_tsv
*utsv
;
3226 /* Most likely some numbers will have to be reassigned as part of
3227 the merge, so clear them all in anticipation. */
3228 for (trace_state_variable
&tsv
: tvariables
)
3231 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3233 struct trace_state_variable
*tsv
= find_matching_tsv (utsv
);
3237 printf_filtered (_("Assuming trace state variable $%s "
3238 "is same as target's variable %d.\n"),
3239 tsv
->name
.c_str (), utsv
->number
);
3243 tsv
= create_tsv_from_upload (utsv
);
3245 printf_filtered (_("Created trace state variable "
3246 "$%s for target's variable %d.\n"),
3247 tsv
->name
.c_str (), utsv
->number
);
3249 /* Give precedence to numberings that come from the target. */
3251 tsv
->number
= utsv
->number
;
3254 /* Renumber everything that didn't get a target-assigned number. */
3256 for (const trace_state_variable
&tsv
: tvariables
)
3257 highest
= std::max (tsv
.number
, highest
);
3260 for (trace_state_variable
&tsv
: tvariables
)
3261 if (tsv
.number
== 0)
3262 tsv
.number
= highest
++;
3264 free_uploaded_tsvs (uploaded_tsvs
);
3267 /* Parse the part of trace status syntax that is shared between
3268 the remote protocol and the trace file reader. */
3271 parse_trace_status (const char *line
, struct trace_status
*ts
)
3273 const char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3277 ts
->running_known
= 1;
3278 ts
->running
= (*p
++ == '1');
3279 ts
->stop_reason
= trace_stop_reason_unknown
;
3280 xfree (ts
->stop_desc
);
3281 ts
->stop_desc
= NULL
;
3282 ts
->traceframe_count
= -1;
3283 ts
->traceframes_created
= -1;
3284 ts
->buffer_free
= -1;
3285 ts
->buffer_size
= -1;
3286 ts
->disconnected_tracing
= 0;
3287 ts
->circular_buffer
= 0;
3288 xfree (ts
->user_name
);
3289 ts
->user_name
= NULL
;
3292 ts
->start_time
= ts
->stop_time
= 0;
3296 p1
= strchr (p
, ':');
3298 error (_("Malformed trace status, at %s\n\
3299 Status line: '%s'\n"), p
, line
);
3300 p3
= strchr (p
, ';');
3302 p3
= p
+ strlen (p
);
3303 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3305 p
= unpack_varlen_hex (++p1
, &val
);
3306 ts
->stop_reason
= trace_buffer_full
;
3308 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3310 p
= unpack_varlen_hex (++p1
, &val
);
3311 ts
->stop_reason
= trace_never_run
;
3313 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3316 p
= unpack_varlen_hex (++p1
, &val
);
3317 ts
->stop_reason
= tracepoint_passcount
;
3318 ts
->stopping_tracepoint
= val
;
3320 else if (strncmp (p
, stop_reason_names
[trace_stop_command
], p1
- p
) == 0)
3322 p2
= strchr (++p1
, ':');
3330 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3331 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3332 ts
->stop_desc
[end
] = '\0';
3335 ts
->stop_desc
= xstrdup ("");
3337 p
= unpack_varlen_hex (++p2
, &val
);
3338 ts
->stop_reason
= trace_stop_command
;
3340 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3342 p
= unpack_varlen_hex (++p1
, &val
);
3343 ts
->stop_reason
= trace_disconnected
;
3345 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3347 p2
= strchr (++p1
, ':');
3350 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3351 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3352 ts
->stop_desc
[end
] = '\0';
3355 ts
->stop_desc
= xstrdup ("");
3357 p
= unpack_varlen_hex (++p2
, &val
);
3358 ts
->stopping_tracepoint
= val
;
3359 ts
->stop_reason
= tracepoint_error
;
3361 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3363 p
= unpack_varlen_hex (++p1
, &val
);
3364 ts
->traceframe_count
= val
;
3366 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3368 p
= unpack_varlen_hex (++p1
, &val
);
3369 ts
->traceframes_created
= val
;
3371 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3373 p
= unpack_varlen_hex (++p1
, &val
);
3374 ts
->buffer_free
= val
;
3376 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3378 p
= unpack_varlen_hex (++p1
, &val
);
3379 ts
->buffer_size
= val
;
3381 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3383 p
= unpack_varlen_hex (++p1
, &val
);
3384 ts
->disconnected_tracing
= val
;
3386 else if (strncmp (p
, "circular", p1
- p
) == 0)
3388 p
= unpack_varlen_hex (++p1
, &val
);
3389 ts
->circular_buffer
= val
;
3391 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3393 p
= unpack_varlen_hex (++p1
, &val
);
3394 ts
->start_time
= val
;
3396 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3398 p
= unpack_varlen_hex (++p1
, &val
);
3399 ts
->stop_time
= val
;
3401 else if (strncmp (p
, "username", p1
- p
) == 0)
3404 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3405 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3406 ts
->user_name
[end
] = '\0';
3409 else if (strncmp (p
, "notes", p1
- p
) == 0)
3412 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3413 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3414 ts
->notes
[end
] = '\0';
3419 /* Silently skip unknown optional info. */
3420 p_temp
= strchr (p1
+ 1, ';');
3424 /* Must be at the end. */
3431 parse_tracepoint_status (const char *p
, struct breakpoint
*bp
,
3432 struct uploaded_tp
*utp
)
3435 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3437 p
= unpack_varlen_hex (p
, &uval
);
3439 tp
->hit_count
+= uval
;
3441 utp
->hit_count
+= uval
;
3442 p
= unpack_varlen_hex (p
+ 1, &uval
);
3444 tp
->traceframe_usage
+= uval
;
3446 utp
->traceframe_usage
+= uval
;
3447 /* Ignore any extra, allowing for future extensions. */
3450 /* Given a line of text defining a part of a tracepoint, parse it into
3451 an "uploaded tracepoint". */
3454 parse_tracepoint_definition (const char *line
, struct uploaded_tp
**utpp
)
3458 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3461 const char *srctype
;
3463 struct uploaded_tp
*utp
= NULL
;
3466 /* Both tracepoint and action definitions start with the same number
3467 and address sequence. */
3469 p
= unpack_varlen_hex (p
, &num
);
3470 p
++; /* skip a colon */
3471 p
= unpack_varlen_hex (p
, &addr
);
3472 p
++; /* skip a colon */
3475 gdb::unique_xmalloc_ptr
<char[]> cond
;
3477 enabled
= (*p
++ == 'E');
3478 p
++; /* skip a colon */
3479 p
= unpack_varlen_hex (p
, &step
);
3480 p
++; /* skip a colon */
3481 p
= unpack_varlen_hex (p
, &pass
);
3482 type
= bp_tracepoint
;
3483 /* Thumb through optional fields. */
3486 p
++; /* skip a colon */
3489 type
= bp_fast_tracepoint
;
3491 p
= unpack_varlen_hex (p
, &orig_size
);
3495 type
= bp_static_tracepoint
;
3501 p
= unpack_varlen_hex (p
, &xlen
);
3502 p
++; /* skip a comma */
3503 cond
.reset ((char *) xmalloc (2 * xlen
+ 1));
3504 strncpy (&cond
[0], p
, 2 * xlen
);
3505 cond
[2 * xlen
] = '\0';
3509 warning (_("Unrecognized char '%c' in tracepoint "
3510 "definition, skipping rest"), *p
);
3512 utp
= get_uploaded_tp (num
, addr
, utpp
);
3514 utp
->enabled
= enabled
;
3517 utp
->cond
= std::move (cond
);
3519 else if (piece
== 'A')
3521 utp
= get_uploaded_tp (num
, addr
, utpp
);
3522 utp
->actions
.emplace_back (xstrdup (p
));
3524 else if (piece
== 'S')
3526 utp
= get_uploaded_tp (num
, addr
, utpp
);
3527 utp
->step_actions
.emplace_back (xstrdup (p
));
3529 else if (piece
== 'Z')
3531 /* Parse a chunk of source form definition. */
3532 utp
= get_uploaded_tp (num
, addr
, utpp
);
3534 p
= strchr (p
, ':');
3535 p
++; /* skip a colon */
3536 p
= unpack_varlen_hex (p
, &start
);
3537 p
++; /* skip a colon */
3538 p
= unpack_varlen_hex (p
, &xlen
);
3539 p
++; /* skip a colon */
3541 buf
= (char *) alloca (strlen (line
));
3543 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3546 if (startswith (srctype
, "at:"))
3547 utp
->at_string
.reset (xstrdup (buf
));
3548 else if (startswith (srctype
, "cond:"))
3549 utp
->cond_string
.reset (xstrdup (buf
));
3550 else if (startswith (srctype
, "cmd:"))
3551 utp
->cmd_strings
.emplace_back (xstrdup (buf
));
3553 else if (piece
== 'V')
3555 utp
= get_uploaded_tp (num
, addr
, utpp
);
3557 parse_tracepoint_status (p
, NULL
, utp
);
3561 /* Don't error out, the target might be sending us optional
3562 info that we don't care about. */
3563 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3567 /* Convert a textual description of a trace state variable into an
3571 parse_tsv_definition (const char *line
, struct uploaded_tsv
**utsvp
)
3575 ULONGEST num
, initval
, builtin
;
3577 struct uploaded_tsv
*utsv
= NULL
;
3579 buf
= (char *) alloca (strlen (line
));
3582 p
= unpack_varlen_hex (p
, &num
);
3583 p
++; /* skip a colon */
3584 p
= unpack_varlen_hex (p
, &initval
);
3585 p
++; /* skip a colon */
3586 p
= unpack_varlen_hex (p
, &builtin
);
3587 p
++; /* skip a colon */
3588 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3591 utsv
= get_uploaded_tsv (num
, utsvp
);
3592 utsv
->initial_value
= initval
;
3593 utsv
->builtin
= builtin
;
3594 utsv
->name
= xstrdup (buf
);
3597 /* Given a line of text defining a static tracepoint marker, parse it
3598 into a "static tracepoint marker" object. Throws an error is
3599 parsing fails. If PP is non-null, it points to one past the end of
3600 the parsed marker definition. */
3603 parse_static_tracepoint_marker_definition (const char *line
, const char **pp
,
3604 static_tracepoint_marker
*marker
)
3606 const char *p
, *endp
;
3610 p
= unpack_varlen_hex (p
, &addr
);
3611 p
++; /* skip a colon */
3613 marker
->gdbarch
= target_gdbarch ();
3614 marker
->address
= (CORE_ADDR
) addr
;
3616 endp
= strchr (p
, ':');
3618 error (_("bad marker definition: %s"), line
);
3620 marker
->str_id
= hex2str (p
, (endp
- p
) / 2);
3623 p
++; /* skip a colon */
3625 /* This definition may be followed by another one, separated by a comma. */
3627 endp
= strchr (p
, ',');
3628 if (endp
!= nullptr)
3631 hex_len
= strlen (p
);
3633 marker
->extra
= hex2str (p
, hex_len
/ 2);
3639 /* Print MARKER to gdb_stdout. */
3642 print_one_static_tracepoint_marker (int count
,
3643 const static_tracepoint_marker
&marker
)
3647 char wrap_indent
[80];
3648 char extra_field_indent
[80];
3649 struct ui_out
*uiout
= current_uiout
;
3651 symtab_and_line sal
;
3652 sal
.pc
= marker
.address
;
3654 std::vector
<breakpoint
*> tracepoints
3655 = static_tracepoints_here (marker
.address
);
3657 ui_out_emit_tuple
tuple_emitter (uiout
, "marker");
3659 /* A counter field to help readability. This is not a stable
3661 uiout
->field_signed ("count", count
);
3663 uiout
->field_string ("marker-id", marker
.str_id
.c_str ());
3665 uiout
->field_fmt ("enabled", "%c",
3666 !tracepoints
.empty () ? 'y' : 'n');
3669 strcpy (wrap_indent
, " ");
3671 if (gdbarch_addr_bit (marker
.gdbarch
) <= 32)
3672 strcat (wrap_indent
, " ");
3674 strcat (wrap_indent
, " ");
3676 strcpy (extra_field_indent
, " ");
3678 uiout
->field_core_addr ("addr", marker
.gdbarch
, marker
.address
);
3680 sal
= find_pc_line (marker
.address
, 0);
3681 sym
= find_pc_sect_function (marker
.address
, NULL
);
3684 uiout
->text ("in ");
3685 uiout
->field_string ("func", SYMBOL_PRINT_NAME (sym
),
3686 ui_out_style_kind::FUNCTION
);
3687 uiout
->wrap_hint (wrap_indent
);
3688 uiout
->text (" at ");
3691 uiout
->field_skip ("func");
3693 if (sal
.symtab
!= NULL
)
3695 uiout
->field_string ("file",
3696 symtab_to_filename_for_display (sal
.symtab
),
3697 ui_out_style_kind::FILE);
3700 if (uiout
->is_mi_like_p ())
3702 const char *fullname
= symtab_to_fullname (sal
.symtab
);
3704 uiout
->field_string ("fullname", fullname
);
3707 uiout
->field_skip ("fullname");
3709 uiout
->field_signed ("line", sal
.line
);
3713 uiout
->field_skip ("fullname");
3714 uiout
->field_skip ("line");
3718 uiout
->text (extra_field_indent
);
3719 uiout
->text (_("Data: \""));
3720 uiout
->field_string ("extra-data", marker
.extra
.c_str ());
3721 uiout
->text ("\"\n");
3723 if (!tracepoints
.empty ())
3728 ui_out_emit_tuple
inner_tuple_emitter (uiout
, "tracepoints-at");
3730 uiout
->text (extra_field_indent
);
3731 uiout
->text (_("Probed by static tracepoints: "));
3732 for (ix
= 0; ix
< tracepoints
.size (); ix
++)
3737 uiout
->field_signed ("tracepoint-id", tracepoints
[ix
]->number
);
3741 if (uiout
->is_mi_like_p ())
3742 uiout
->field_signed ("number-of-tracepoints", tracepoints
.size ());
3749 info_static_tracepoint_markers_command (const char *arg
, int from_tty
)
3751 struct ui_out
*uiout
= current_uiout
;
3752 std::vector
<static_tracepoint_marker
> markers
3753 = target_static_tracepoint_markers_by_strid (NULL
);
3755 /* We don't have to check target_can_use_agent and agent's capability on
3756 static tracepoint here, in order to be compatible with older GDBserver.
3757 We don't check USE_AGENT is true or not, because static tracepoints
3758 don't work without in-process agent, so we don't bother users to type
3759 `set agent on' when to use static tracepoint. */
3761 ui_out_emit_table
table_emitter (uiout
, 5, -1,
3762 "StaticTracepointMarkersTable");
3764 uiout
->table_header (7, ui_left
, "counter", "Cnt");
3766 uiout
->table_header (40, ui_left
, "marker-id", "ID");
3768 uiout
->table_header (3, ui_left
, "enabled", "Enb");
3769 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3770 uiout
->table_header (10, ui_left
, "addr", "Address");
3772 uiout
->table_header (18, ui_left
, "addr", "Address");
3773 uiout
->table_header (40, ui_noalign
, "what", "What");
3775 uiout
->table_body ();
3777 for (int i
= 0; i
< markers
.size (); i
++)
3778 print_one_static_tracepoint_marker (i
+ 1, markers
[i
]);
3781 /* The $_sdata convenience variable is a bit special. We don't know
3782 for sure type of the value until we actually have a chance to fetch
3783 the data --- the size of the object depends on what has been
3784 collected. We solve this by making $_sdata be an internalvar that
3785 creates a new value on access. */
3787 /* Return a new value with the correct type for the sdata object of
3788 the current trace frame. Return a void value if there's no object
3791 static struct value
*
3792 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
3795 /* We need to read the whole object before we know its size. */
3796 gdb::optional
<gdb::byte_vector
> buf
3797 = target_read_alloc (current_top_target (), TARGET_OBJECT_STATIC_TRACE_DATA
,
3804 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
3806 v
= allocate_value (type
);
3807 memcpy (value_contents_raw (v
), buf
->data (), buf
->size ());
3811 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
3814 #if !defined(HAVE_LIBEXPAT)
3816 struct std::unique_ptr
<traceframe_info
>
3817 parse_traceframe_info (const char *tframe_info
)
3819 static int have_warned
;
3824 warning (_("Can not parse XML trace frame info; XML support "
3825 "was disabled at compile time"));
3831 #else /* HAVE_LIBEXPAT */
3833 #include "xml-support.h"
3835 /* Handle the start of a <memory> element. */
3838 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
3839 const struct gdb_xml_element
*element
,
3841 std::vector
<gdb_xml_value
> &attributes
)
3843 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3844 ULONGEST
*start_p
, *length_p
;
3847 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
.get ();
3849 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
.get ();
3851 info
->memory
.emplace_back (*start_p
, *length_p
);
3854 /* Handle the start of a <tvar> element. */
3857 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
3858 const struct gdb_xml_element
*element
,
3860 std::vector
<gdb_xml_value
> &attributes
)
3862 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
3863 const char *id_attrib
3864 = (const char *) xml_find_attribute (attributes
, "id")->value
.get ();
3865 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
3867 info
->tvars
.push_back (id
);
3870 /* The allowed elements and attributes for an XML memory map. */
3872 static const struct gdb_xml_attribute memory_attributes
[] = {
3873 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3874 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
3875 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3878 static const struct gdb_xml_attribute tvar_attributes
[] = {
3879 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3880 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3883 static const struct gdb_xml_element traceframe_info_children
[] = {
3884 { "memory", memory_attributes
, NULL
,
3885 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3886 traceframe_info_start_memory
, NULL
},
3887 { "tvar", tvar_attributes
, NULL
,
3888 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3889 traceframe_info_start_tvar
, NULL
},
3890 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3893 static const struct gdb_xml_element traceframe_info_elements
[] = {
3894 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
3896 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3899 /* Parse a traceframe-info XML document. */
3902 parse_traceframe_info (const char *tframe_info
)
3904 traceframe_info_up
result (new traceframe_info
);
3906 if (gdb_xml_parse_quick (_("trace frame info"),
3907 "traceframe-info.dtd", traceframe_info_elements
,
3908 tframe_info
, result
.get ()) == 0)
3914 #endif /* HAVE_LIBEXPAT */
3916 /* Returns the traceframe_info object for the current traceframe.
3917 This is where we avoid re-fetching the object from the target if we
3918 already have it cached. */
3920 struct traceframe_info
*
3921 get_traceframe_info (void)
3923 if (current_traceframe_info
== NULL
)
3924 current_traceframe_info
= target_traceframe_info ();
3926 return current_traceframe_info
.get ();
3929 /* If the target supports the query, return in RESULT the set of
3930 collected memory in the current traceframe, found within the LEN
3931 bytes range starting at MEMADDR. Returns true if the target
3932 supports the query, otherwise returns false, and RESULT is left
3936 traceframe_available_memory (std::vector
<mem_range
> *result
,
3937 CORE_ADDR memaddr
, ULONGEST len
)
3939 struct traceframe_info
*info
= get_traceframe_info ();
3945 for (mem_range
&r
: info
->memory
)
3946 if (mem_ranges_overlap (r
.start
, r
.length
, memaddr
, len
))
3948 ULONGEST lo1
, hi1
, lo2
, hi2
;
3951 hi1
= memaddr
+ len
;
3954 hi2
= r
.start
+ r
.length
;
3956 CORE_ADDR start
= std::max (lo1
, lo2
);
3957 int length
= std::min (hi1
, hi2
) - start
;
3959 result
->emplace_back (start
, length
);
3962 normalize_mem_ranges (result
);
3969 /* Implementation of `sdata' variable. */
3971 static const struct internalvar_funcs sdata_funcs
=
3978 /* See tracepoint.h. */
3979 cmd_list_element
*while_stepping_cmd_element
= nullptr;
3981 /* module initialization */
3983 _initialize_tracepoint (void)
3985 struct cmd_list_element
*c
;
3987 /* Explicitly create without lookup, since that tries to create a
3988 value with a void typed value, and when we get here, gdbarch
3989 isn't initialized yet. At this point, we're quite sure there
3990 isn't another convenience variable of the same name. */
3991 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
3993 traceframe_number
= -1;
3994 tracepoint_number
= -1;
3996 add_info ("scope", info_scope_command
,
3997 _("List the variables local to a scope."));
3999 add_cmd ("tracepoints", class_trace
,
4000 _("Tracing of program execution without stopping the program."),
4003 add_com ("tdump", class_trace
, tdump_command
,
4004 _("Print everything collected at the current tracepoint."));
4006 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4007 Define a trace state variable.\n\
4008 Argument is a $-prefixed name, optionally followed\n\
4009 by '=' and an expression that sets the initial value\n\
4010 at the start of tracing."));
4011 set_cmd_completer (c
, expression_completer
);
4013 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4014 Delete one or more trace state variables.\n\
4015 Arguments are the names of the variables to delete.\n\
4016 If no arguments are supplied, delete all variables."), &deletelist
);
4017 /* FIXME add a trace variable completer. */
4019 add_info ("tvariables", info_tvariables_command
, _("\
4020 Status of trace state variables and their values."));
4022 add_info ("static-tracepoint-markers",
4023 info_static_tracepoint_markers_command
, _("\
4024 List target static tracepoints markers."));
4026 add_prefix_cmd ("tfind", class_trace
, tfind_command
, _("\
4027 Select a trace frame.\n\
4028 No argument means forward by one frame; '-' means backward by one frame."),
4029 &tfindlist
, "tfind ", 1, &cmdlist
);
4031 add_cmd ("outside", class_trace
, tfind_outside_command
, _("\
4032 Select a trace frame whose PC is outside the given range (exclusive).\n\
4033 Usage: tfind outside ADDR1, ADDR2"),
4036 add_cmd ("range", class_trace
, tfind_range_command
, _("\
4037 Select a trace frame whose PC is in the given range (inclusive).\n\
4038 Usage: tfind range ADDR1, ADDR2"),
4041 add_cmd ("line", class_trace
, tfind_line_command
, _("\
4042 Select a trace frame by source line.\n\
4043 Argument can be a line number (with optional source file),\n\
4044 a function name, or '*' followed by an address.\n\
4045 Default argument is 'the next source line that was traced'."),
4048 add_cmd ("tracepoint", class_trace
, tfind_tracepoint_command
, _("\
4049 Select a trace frame by tracepoint number.\n\
4050 Default is the tracepoint for the current trace frame."),
4053 add_cmd ("pc", class_trace
, tfind_pc_command
, _("\
4054 Select a trace frame by PC.\n\
4055 Default is the current PC, or the PC of the current trace frame."),
4058 add_cmd ("end", class_trace
, tfind_end_command
, _("\
4059 De-select any trace frame and resume 'live' debugging."),
4062 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4064 add_cmd ("start", class_trace
, tfind_start_command
,
4065 _("Select the first trace frame in the trace buffer."),
4068 add_com ("tstatus", class_trace
, tstatus_command
,
4069 _("Display the status of the current trace data collection."));
4071 add_com ("tstop", class_trace
, tstop_command
, _("\
4072 Stop trace data collection.\n\
4073 Usage: tstop [NOTES]...\n\
4074 Any arguments supplied are recorded with the trace as a stop reason and\n\
4075 reported by tstatus (if the target supports trace notes)."));
4077 add_com ("tstart", class_trace
, tstart_command
, _("\
4078 Start trace data collection.\n\
4079 Usage: tstart [NOTES]...\n\
4080 Any arguments supplied are recorded with the trace as a note and\n\
4081 reported by tstatus (if the target supports trace notes)."));
4083 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4084 Ends a list of commands or actions.\n\
4085 Several GDB commands allow you to enter a list of commands or actions.\n\
4086 Entering \"end\" on a line by itself is the normal way to terminate\n\
4088 Note: the \"end\" command cannot be used at the gdb prompt."));
4090 while_stepping_cmd_element
= add_com ("while-stepping", class_trace
,
4091 while_stepping_pseudocommand
, _("\
4092 Specify single-stepping behavior at a tracepoint.\n\
4093 Argument is number of instructions to trace in single-step mode\n\
4094 following the tracepoint. This command is normally followed by\n\
4095 one or more \"collect\" commands, to specify what to collect\n\
4096 while single-stepping.\n\n\
4097 Note: this command can only be used in a tracepoint \"actions\" list."));
4099 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4100 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4102 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4103 Specify one or more data items to be collected at a tracepoint.\n\
4104 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4105 collect all data (variables, registers) referenced by that expression.\n\
4106 Also accepts the following special arguments:\n\
4107 $regs -- all registers.\n\
4108 $args -- all function arguments.\n\
4109 $locals -- all variables local to the block/function scope.\n\
4110 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4111 Note: this command can only be used in a tracepoint \"actions\" list."));
4113 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4114 Specify one or more expressions to be evaluated at a tracepoint.\n\
4115 Accepts a comma-separated list of (one or more) expressions.\n\
4116 The result of each evaluation will be discarded.\n\
4117 Note: this command can only be used in a tracepoint \"actions\" list."));
4119 add_com ("actions", class_trace
, actions_command
, _("\
4120 Specify the actions to be taken at a tracepoint.\n\
4121 Tracepoint actions may include collecting of specified data,\n\
4122 single-stepping, or enabling/disabling other tracepoints,\n\
4123 depending on target's capabilities."));
4125 default_collect
= xstrdup ("");
4126 add_setshow_string_cmd ("default-collect", class_trace
,
4127 &default_collect
, _("\
4128 Set the list of expressions to collect by default."), _("\
4129 Show the list of expressions to collect by default."), NULL
,
4131 &setlist
, &showlist
);
4133 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4134 &disconnected_tracing
, _("\
4135 Set whether tracing continues after GDB disconnects."), _("\
4136 Show whether tracing continues after GDB disconnects."), _("\
4137 Use this to continue a tracing run even if GDB disconnects\n\
4138 or detaches from the target. You can reconnect later and look at\n\
4139 trace data collected in the meantime."),
4140 set_disconnected_tracing
,
4145 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4146 &circular_trace_buffer
, _("\
4147 Set target's use of circular trace buffer."), _("\
4148 Show target's use of circular trace buffer."), _("\
4149 Use this to make the trace buffer into a circular buffer,\n\
4150 which will discard traceframes (oldest first) instead of filling\n\
4151 up and stopping the trace run."),
4152 set_circular_trace_buffer
,
4157 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4158 &trace_buffer_size
, _("\
4159 Set requested size of trace buffer."), _("\
4160 Show requested size of trace buffer."), _("\
4161 Use this to choose a size for the trace buffer. Some targets\n\
4162 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4163 disables any attempt to set the buffer size and lets the target choose."),
4164 set_trace_buffer_size
, NULL
,
4165 &setlist
, &showlist
);
4167 add_setshow_string_cmd ("trace-user", class_trace
,
4169 Set the user name to use for current and future trace runs."), _("\
4170 Show the user name to use for current and future trace runs."), NULL
,
4171 set_trace_user
, NULL
,
4172 &setlist
, &showlist
);
4174 add_setshow_string_cmd ("trace-notes", class_trace
,
4176 Set notes string to use for current and future trace runs."), _("\
4177 Show the notes string to use for current and future trace runs."), NULL
,
4178 set_trace_notes
, NULL
,
4179 &setlist
, &showlist
);
4181 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4182 &trace_stop_notes
, _("\
4183 Set notes string to use for future tstop commands."), _("\
4184 Show the notes string to use for future tstop commands."), NULL
,
4185 set_trace_stop_notes
, NULL
,
4186 &setlist
, &showlist
);