1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2016 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"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
52 #include "cli/cli-utils.h"
55 #include "filestuff.h"
57 #include "tracefile.h"
61 /* readline include files */
62 #include "readline/readline.h"
63 #include "readline/history.h"
65 /* readline defines this. */
70 /* Maximum length of an agent aexpression.
71 This accounts for the fact that packets are limited to 400 bytes
72 (which includes everything -- including the checksum), and assumes
73 the worst case of maximum length for each of the pieces of a
76 NOTE: expressions get mem2hex'ed otherwise this would be twice as
77 large. (400 - 31)/2 == 184 */
78 #define MAX_AGENT_EXPR_LEN 184
80 /* A hook used to notify the UI of tracepoint operations. */
82 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
83 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
88 This module defines the following debugger commands:
89 trace : set a tracepoint on a function, line, or address.
90 info trace : list all debugger-defined tracepoints.
91 delete trace : delete one or more tracepoints.
92 enable trace : enable one or more tracepoints.
93 disable trace : disable one or more tracepoints.
94 actions : specify actions to be taken at a tracepoint.
95 passcount : specify a pass count for a tracepoint.
96 tstart : start a trace experiment.
97 tstop : stop a trace experiment.
98 tstatus : query the status of a trace experiment.
99 tfind : find a trace frame in the trace buffer.
100 tdump : print everything collected at the current tracepoint.
101 save-tracepoints : write tracepoint setup into a file.
103 This module defines the following user-visible debugger variables:
104 $trace_frame : sequence number of trace frame currently being debugged.
105 $trace_line : source line of trace frame currently being debugged.
106 $trace_file : source file of trace frame currently being debugged.
107 $tracepoint : tracepoint number of trace frame currently being debugged.
111 /* ======= Important global variables: ======= */
113 /* The list of all trace state variables. We don't retain pointers to
114 any of these for any reason - API is by name or number only - so it
115 works to have a vector of objects. */
117 typedef struct trace_state_variable tsv_s
;
120 static VEC(tsv_s
) *tvariables
;
122 /* The next integer to assign to a variable. */
124 static int next_tsv_number
= 1;
126 /* Number of last traceframe collected. */
127 static int traceframe_number
;
129 /* Tracepoint for last traceframe collected. */
130 static int tracepoint_number
;
132 /* The traceframe info of the current traceframe. NULL if we haven't
133 yet attempted to fetch it, or if the target does not support
134 fetching this object, or if we're not inspecting a traceframe
136 static struct traceframe_info
*traceframe_info
;
138 /* Tracing command lists. */
139 static struct cmd_list_element
*tfindlist
;
141 /* List of expressions to collect by default at each tracepoint hit. */
142 char *default_collect
= "";
144 static int disconnected_tracing
;
146 /* This variable controls whether we ask the target for a linear or
147 circular trace buffer. */
149 static int circular_trace_buffer
;
151 /* This variable is the requested trace buffer size, or -1 to indicate
152 that we don't care and leave it up to the target to set a size. */
154 static int trace_buffer_size
= -1;
156 /* Textual notes applying to the current and/or future trace runs. */
158 char *trace_user
= NULL
;
160 /* Textual notes applying to the current and/or future trace runs. */
162 char *trace_notes
= NULL
;
164 /* Textual notes applying to the stopping of a trace. */
166 char *trace_stop_notes
= NULL
;
168 /* ======= Important command functions: ======= */
169 static void trace_actions_command (char *, int);
170 static void trace_start_command (char *, int);
171 static void trace_stop_command (char *, int);
172 static void trace_status_command (char *, int);
173 static void trace_find_command (char *, int);
174 static void trace_find_pc_command (char *, int);
175 static void trace_find_tracepoint_command (char *, int);
176 static void trace_find_line_command (char *, int);
177 static void trace_find_range_command (char *, int);
178 static void trace_find_outside_command (char *, int);
179 static void trace_dump_command (char *, int);
181 /* support routines */
183 struct collection_list
;
184 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
185 static char *mem2hex (gdb_byte
*, char *, int);
186 static void add_register (struct collection_list
*collection
,
189 static struct command_line
*
190 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
192 extern void _initialize_tracepoint (void);
194 static struct trace_status trace_status
;
196 const char *stop_reason_names
[] = {
206 struct trace_status
*
207 current_trace_status (void)
209 return &trace_status
;
215 free_traceframe_info (struct traceframe_info
*info
)
219 VEC_free (mem_range_s
, info
->memory
);
220 VEC_free (int, info
->tvars
);
226 /* Free and clear the traceframe info cache of the current
230 clear_traceframe_info (void)
232 free_traceframe_info (traceframe_info
);
233 traceframe_info
= NULL
;
236 /* Set traceframe number to NUM. */
238 set_traceframe_num (int num
)
240 traceframe_number
= num
;
241 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
244 /* Set tracepoint number to NUM. */
246 set_tracepoint_num (int num
)
248 tracepoint_number
= num
;
249 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
252 /* Set externally visible debug variables for querying/printing
253 the traceframe context (line, function, file). */
256 set_traceframe_context (struct frame_info
*trace_frame
)
259 struct symbol
*traceframe_fun
;
260 struct symtab_and_line traceframe_sal
;
262 /* Save as globals for internal use. */
263 if (trace_frame
!= NULL
264 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
266 traceframe_sal
= find_pc_line (trace_pc
, 0);
267 traceframe_fun
= find_pc_function (trace_pc
);
269 /* Save linenumber as "$trace_line", a debugger variable visible to
271 set_internalvar_integer (lookup_internalvar ("trace_line"),
272 traceframe_sal
.line
);
276 init_sal (&traceframe_sal
);
277 traceframe_fun
= NULL
;
278 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
281 /* Save func name as "$trace_func", a debugger variable visible to
283 if (traceframe_fun
== NULL
284 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
285 clear_internalvar (lookup_internalvar ("trace_func"));
287 set_internalvar_string (lookup_internalvar ("trace_func"),
288 SYMBOL_LINKAGE_NAME (traceframe_fun
));
290 /* Save file name as "$trace_file", a debugger variable visible to
292 if (traceframe_sal
.symtab
== NULL
)
293 clear_internalvar (lookup_internalvar ("trace_file"));
295 set_internalvar_string (lookup_internalvar ("trace_file"),
296 symtab_to_filename_for_display (traceframe_sal
.symtab
));
299 /* Create a new trace state variable with the given name. */
301 struct trace_state_variable
*
302 create_trace_state_variable (const char *name
)
304 struct trace_state_variable tsv
;
306 memset (&tsv
, 0, sizeof (tsv
));
307 tsv
.name
= xstrdup (name
);
308 tsv
.number
= next_tsv_number
++;
309 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
312 /* Look for a trace state variable of the given name. */
314 struct trace_state_variable
*
315 find_trace_state_variable (const char *name
)
317 struct trace_state_variable
*tsv
;
320 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
321 if (strcmp (name
, tsv
->name
) == 0)
327 /* Look for a trace state variable of the given number. Return NULL if
330 struct trace_state_variable
*
331 find_trace_state_variable_by_number (int number
)
333 struct trace_state_variable
*tsv
;
336 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
337 if (tsv
->number
== number
)
344 delete_trace_state_variable (const char *name
)
346 struct trace_state_variable
*tsv
;
349 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
350 if (strcmp (name
, tsv
->name
) == 0)
352 observer_notify_tsv_deleted (tsv
);
354 xfree ((void *)tsv
->name
);
355 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
360 warning (_("No trace variable named \"$%s\", not deleting"), name
);
363 /* Throws an error if NAME is not valid syntax for a trace state
367 validate_trace_state_variable_name (const char *name
)
372 error (_("Must supply a non-empty variable name"));
374 /* All digits in the name is reserved for value history
376 for (p
= name
; isdigit (*p
); p
++)
379 error (_("$%s is not a valid trace state variable name"), name
);
381 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
384 error (_("$%s is not a valid trace state variable name"), name
);
387 /* The 'tvariable' command collects a name and optional expression to
388 evaluate into an initial value. */
391 trace_variable_command (char *args
, int from_tty
)
393 struct cleanup
*old_chain
;
395 struct trace_state_variable
*tsv
;
399 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
401 /* Only allow two syntaxes; "$name" and "$name=value". */
402 p
= skip_spaces (args
);
405 error (_("Name of trace variable should start with '$'"));
408 while (isalnum (*p
) || *p
== '_')
410 name
= savestring (name
, p
- name
);
411 old_chain
= make_cleanup (xfree
, name
);
414 if (*p
!= '=' && *p
!= '\0')
415 error (_("Syntax must be $NAME [ = EXPR ]"));
417 validate_trace_state_variable_name (name
);
420 initval
= value_as_long (parse_and_eval (++p
));
422 /* If the variable already exists, just change its initial value. */
423 tsv
= find_trace_state_variable (name
);
426 if (tsv
->initial_value
!= initval
)
428 tsv
->initial_value
= initval
;
429 observer_notify_tsv_modified (tsv
);
431 printf_filtered (_("Trace state variable $%s "
432 "now has initial value %s.\n"),
433 tsv
->name
, plongest (tsv
->initial_value
));
434 do_cleanups (old_chain
);
438 /* Create a new variable. */
439 tsv
= create_trace_state_variable (name
);
440 tsv
->initial_value
= initval
;
442 observer_notify_tsv_created (tsv
);
444 printf_filtered (_("Trace state variable $%s "
445 "created, with initial value %s.\n"),
446 tsv
->name
, plongest (tsv
->initial_value
));
448 do_cleanups (old_chain
);
452 delete_trace_variable_command (char *args
, int from_tty
)
456 struct cleanup
*back_to
;
460 if (query (_("Delete all trace state variables? ")))
461 VEC_free (tsv_s
, tvariables
);
463 observer_notify_tsv_deleted (NULL
);
467 argv
= gdb_buildargv (args
);
468 back_to
= make_cleanup_freeargv (argv
);
470 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
472 if (*argv
[ix
] == '$')
473 delete_trace_state_variable (argv
[ix
] + 1);
475 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
478 do_cleanups (back_to
);
484 tvariables_info_1 (void)
486 struct trace_state_variable
*tsv
;
489 struct cleanup
*back_to
;
490 struct ui_out
*uiout
= current_uiout
;
492 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
494 printf_filtered (_("No trace state variables.\n"));
498 /* Try to acquire values from the target. */
499 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
500 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
503 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
504 count
, "trace-variables");
505 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
506 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
507 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
509 ui_out_table_body (uiout
);
511 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
513 struct cleanup
*back_to2
;
517 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
519 name
= concat ("$", tsv
->name
, (char *) NULL
);
520 make_cleanup (xfree
, name
);
521 ui_out_field_string (uiout
, "name", name
);
522 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
524 if (tsv
->value_known
)
525 c
= plongest (tsv
->value
);
526 else if (ui_out_is_mi_like_p (uiout
))
527 /* For MI, we prefer not to use magic string constants, but rather
528 omit the field completely. The difference between unknown and
529 undefined does not seem important enough to represent. */
531 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
532 /* The value is/was defined, but we don't have it. */
535 /* It is not meaningful to ask about the value. */
538 ui_out_field_string (uiout
, "current", c
);
539 ui_out_text (uiout
, "\n");
541 do_cleanups (back_to2
);
544 do_cleanups (back_to
);
547 /* List all the trace state variables. */
550 tvariables_info (char *args
, int from_tty
)
552 tvariables_info_1 ();
555 /* Stash definitions of tsvs into the given file. */
558 save_trace_state_variables (struct ui_file
*fp
)
560 struct trace_state_variable
*tsv
;
563 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
565 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
566 if (tsv
->initial_value
)
567 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
568 fprintf_unfiltered (fp
, "\n");
572 /* ACTIONS functions: */
574 /* The three functions:
575 collect_pseudocommand,
576 while_stepping_pseudocommand, and
577 end_actions_pseudocommand
578 are placeholders for "commands" that are actually ONLY to be used
579 within a tracepoint action list. If the actual function is ever called,
580 it means that somebody issued the "command" at the top level,
581 which is always an error. */
584 end_actions_pseudocommand (char *args
, int from_tty
)
586 error (_("This command cannot be used at the top level."));
590 while_stepping_pseudocommand (char *args
, int from_tty
)
592 error (_("This command can only be used in a tracepoint actions list."));
596 collect_pseudocommand (char *args
, int from_tty
)
598 error (_("This command can only be used in a tracepoint actions list."));
602 teval_pseudocommand (char *args
, int from_tty
)
604 error (_("This command can only be used in a tracepoint actions list."));
607 /* Parse any collection options, such as /s for strings. */
610 decode_agent_options (const char *exp
, int *trace_string
)
612 struct value_print_options opts
;
619 /* Call this to borrow the print elements default for collection
621 get_user_print_options (&opts
);
626 if (target_supports_string_tracing ())
628 /* Allow an optional decimal number giving an explicit maximum
629 string length, defaulting it to the "print elements" value;
630 so "collect/s80 mystr" gets at most 80 bytes of string. */
631 *trace_string
= opts
.print_max
;
633 if (*exp
>= '0' && *exp
<= '9')
634 *trace_string
= atoi (exp
);
635 while (*exp
>= '0' && *exp
<= '9')
639 error (_("Target does not support \"/s\" option for string tracing."));
642 error (_("Undefined collection format \"%c\"."), *exp
);
644 exp
= skip_spaces_const (exp
);
649 /* Enter a list of actions for a tracepoint. */
651 trace_actions_command (char *args
, int from_tty
)
653 struct tracepoint
*t
;
654 struct command_line
*l
;
656 t
= get_tracepoint_by_number (&args
, NULL
);
660 xstrprintf ("Enter actions for tracepoint %d, one per line.",
662 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
664 l
= read_command_lines (tmpbuf
, from_tty
, 1,
665 check_tracepoint_command
, t
);
666 do_cleanups (cleanups
);
667 breakpoint_set_commands (&t
->base
, l
);
669 /* else just return */
672 /* Report the results of checking the agent expression, as errors or
676 report_agent_reqs_errors (struct agent_expr
*aexpr
)
678 /* All of the "flaws" are serious bytecode generation issues that
679 should never occur. */
680 if (aexpr
->flaw
!= agent_flaw_none
)
681 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
683 /* If analysis shows a stack underflow, GDB must have done something
684 badly wrong in its bytecode generation. */
685 if (aexpr
->min_height
< 0)
686 internal_error (__FILE__
, __LINE__
,
687 _("expression has min height < 0"));
689 /* Issue this error if the stack is predicted to get too deep. The
690 limit is rather arbitrary; a better scheme might be for the
691 target to report how much stack it will have available. The
692 depth roughly corresponds to parenthesization, so a limit of 20
693 amounts to 20 levels of expression nesting, which is actually
694 a pretty big hairy expression. */
695 if (aexpr
->max_height
> 20)
696 error (_("Expression is too complicated."));
699 /* worker function */
701 validate_actionline (const char *line
, struct breakpoint
*b
)
703 struct cmd_list_element
*c
;
704 struct expression
*exp
= NULL
;
705 struct cleanup
*old_chain
= NULL
;
708 struct bp_location
*loc
;
709 struct agent_expr
*aexpr
;
710 struct tracepoint
*t
= (struct tracepoint
*) b
;
712 /* If EOF is typed, *line is NULL. */
716 p
= skip_spaces_const (line
);
718 /* Symbol lookup etc. */
719 if (*p
== '\0') /* empty line: just prompt for another line. */
722 if (*p
== '#') /* comment line */
725 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
727 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
729 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
731 int trace_string
= 0;
734 p
= decode_agent_options (p
, &trace_string
);
737 { /* Repeat over a comma-separated list. */
738 QUIT
; /* Allow user to bail out with ^C. */
739 p
= skip_spaces_const (p
);
741 if (*p
== '$') /* Look for special pseudo-symbols. */
743 if (0 == strncasecmp ("reg", p
+ 1, 3)
744 || 0 == strncasecmp ("arg", p
+ 1, 3)
745 || 0 == strncasecmp ("loc", p
+ 1, 3)
746 || 0 == strncasecmp ("_ret", p
+ 1, 4)
747 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
752 /* else fall thru, treat p as an expression and parse it! */
755 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
758 exp
= parse_exp_1 (&p
, loc
->address
,
759 block_for_pc (loc
->address
), 1);
760 old_chain
= make_cleanup (free_current_contents
, &exp
);
762 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
764 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
766 error (_("constant `%s' (value %s) "
767 "will not be collected."),
768 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
769 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
771 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
772 == LOC_OPTIMIZED_OUT
)
774 error (_("`%s' is optimized away "
775 "and cannot be collected."),
776 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
780 /* We have something to collect, make sure that the expr to
781 bytecode translator can handle it and that it's not too
783 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
784 make_cleanup_free_agent_expr (aexpr
);
786 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
787 error (_("Expression is too complicated."));
791 report_agent_reqs_errors (aexpr
);
793 do_cleanups (old_chain
);
796 while (p
&& *p
++ == ',');
799 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
802 { /* Repeat over a comma-separated list. */
803 QUIT
; /* Allow user to bail out with ^C. */
804 p
= skip_spaces_const (p
);
807 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
811 /* Only expressions are allowed for this action. */
812 exp
= parse_exp_1 (&p
, loc
->address
,
813 block_for_pc (loc
->address
), 1);
814 old_chain
= make_cleanup (free_current_contents
, &exp
);
816 /* We have something to evaluate, make sure that the expr to
817 bytecode translator can handle it and that it's not too
819 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
820 make_cleanup_free_agent_expr (aexpr
);
822 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
823 error (_("Expression is too complicated."));
826 report_agent_reqs_errors (aexpr
);
828 do_cleanups (old_chain
);
831 while (p
&& *p
++ == ',');
834 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
838 p
= skip_spaces_const (p
);
839 t
->step_count
= strtol (p
, &endp
, 0);
840 if (endp
== p
|| t
->step_count
== 0)
841 error (_("while-stepping step count `%s' is malformed."), line
);
845 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
849 error (_("`%s' is not a supported tracepoint action."), line
);
853 memrange_absolute
= -1
856 /* MEMRANGE functions: */
858 static int memrange_cmp (const void *, const void *);
860 /* Compare memranges for qsort. */
862 memrange_cmp (const void *va
, const void *vb
)
864 const struct memrange
*a
= (const struct memrange
*) va
;
865 const struct memrange
*b
= (const struct memrange
*) vb
;
867 if (a
->type
< b
->type
)
869 if (a
->type
> b
->type
)
871 if (a
->type
== memrange_absolute
)
873 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
875 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
880 if (a
->start
< b
->start
)
882 if (a
->start
> b
->start
)
888 /* Sort the memrange list using qsort, and merge adjacent memranges. */
890 memrange_sortmerge (struct collection_list
*memranges
)
894 qsort (memranges
->list
, memranges
->next_memrange
,
895 sizeof (struct memrange
), memrange_cmp
);
896 if (memranges
->next_memrange
> 0)
898 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
900 /* If memrange b overlaps or is adjacent to memrange a,
902 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
903 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
905 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
906 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
907 continue; /* next b, same a */
911 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
912 sizeof (struct memrange
));
914 memranges
->next_memrange
= a
+ 1;
918 /* Add a register to a collection list. */
920 add_register (struct collection_list
*collection
, unsigned int regno
)
923 printf_filtered ("collect register %d\n", regno
);
924 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
925 error (_("Internal: register number %d too large for tracepoint"),
927 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
930 /* Add a memrange to a collection list. */
932 add_memrange (struct collection_list
*memranges
,
933 int type
, bfd_signed_vma base
,
938 printf_filtered ("(%d,", type
);
940 printf_filtered (",%ld)\n", len
);
943 /* type: memrange_absolute == memory, other n == basereg */
944 memranges
->list
[memranges
->next_memrange
].type
= type
;
945 /* base: addr if memory, offset if reg relative. */
946 memranges
->list
[memranges
->next_memrange
].start
= base
;
947 /* len: we actually save end (base + len) for convenience */
948 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
949 memranges
->next_memrange
++;
950 if (memranges
->next_memrange
>= memranges
->listsize
)
952 memranges
->listsize
*= 2;
953 memranges
->list
= (struct memrange
*) xrealloc (memranges
->list
,
954 memranges
->listsize
);
957 if (type
!= memrange_absolute
) /* Better collect the base register! */
958 add_register (memranges
, type
);
961 /* Add a symbol to a collection list. */
963 collect_symbol (struct collection_list
*collect
,
965 struct gdbarch
*gdbarch
,
966 long frame_regno
, long frame_offset
,
972 bfd_signed_vma offset
;
973 int treat_as_expr
= 0;
975 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
976 switch (SYMBOL_CLASS (sym
))
979 printf_filtered ("%s: don't know symbol class %d\n",
980 SYMBOL_PRINT_NAME (sym
),
984 printf_filtered ("constant %s (value %s) will not be collected.\n",
985 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
988 offset
= SYMBOL_VALUE_ADDRESS (sym
);
993 sprintf_vma (tmp
, offset
);
994 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
995 SYMBOL_PRINT_NAME (sym
), len
,
998 /* A struct may be a C++ class with static fields, go to general
999 expression handling. */
1000 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1003 add_memrange (collect
, memrange_absolute
, offset
, len
);
1006 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1008 printf_filtered ("LOC_REG[parm] %s: ",
1009 SYMBOL_PRINT_NAME (sym
));
1010 add_register (collect
, reg
);
1011 /* Check for doubles stored in two registers. */
1012 /* FIXME: how about larger types stored in 3 or more regs? */
1013 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1014 len
> register_size (gdbarch
, reg
))
1015 add_register (collect
, reg
+ 1);
1018 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1019 printf_filtered (" (will not collect %s)\n",
1020 SYMBOL_PRINT_NAME (sym
));
1024 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1027 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1028 SYMBOL_PRINT_NAME (sym
), len
);
1029 printf_vma (offset
);
1030 printf_filtered (" from frame ptr reg %d\n", reg
);
1032 add_memrange (collect
, reg
, offset
, len
);
1034 case LOC_REGPARM_ADDR
:
1035 reg
= SYMBOL_VALUE (sym
);
1039 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1040 SYMBOL_PRINT_NAME (sym
), len
);
1041 printf_vma (offset
);
1042 printf_filtered (" from reg %d\n", reg
);
1044 add_memrange (collect
, reg
, offset
, len
);
1048 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1051 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1052 SYMBOL_PRINT_NAME (sym
), len
);
1053 printf_vma (offset
);
1054 printf_filtered (" from frame ptr reg %d\n", reg
);
1056 add_memrange (collect
, reg
, offset
, len
);
1059 case LOC_UNRESOLVED
:
1063 case LOC_OPTIMIZED_OUT
:
1064 printf_filtered ("%s has been optimized out of existence.\n",
1065 SYMBOL_PRINT_NAME (sym
));
1073 /* Expressions are the most general case. */
1076 struct agent_expr
*aexpr
;
1077 struct cleanup
*old_chain1
= NULL
;
1079 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1081 /* It can happen that the symbol is recorded as a computed
1082 location, but it's been optimized away and doesn't actually
1083 have a location expression. */
1086 printf_filtered ("%s has been optimized out of existence.\n",
1087 SYMBOL_PRINT_NAME (sym
));
1091 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1095 report_agent_reqs_errors (aexpr
);
1097 discard_cleanups (old_chain1
);
1098 add_aexpr (collect
, aexpr
);
1100 /* Take care of the registers. */
1101 if (aexpr
->reg_mask_len
> 0)
1105 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1107 QUIT
; /* Allow user to bail out with ^C. */
1108 if (aexpr
->reg_mask
[ndx1
] != 0)
1110 /* Assume chars have 8 bits. */
1111 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1112 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1113 /* It's used -- record it. */
1114 add_register (collect
, ndx1
* 8 + ndx2
);
1121 /* Data to be passed around in the calls to the locals and args
1124 struct add_local_symbols_data
1126 struct collection_list
*collect
;
1127 struct gdbarch
*gdbarch
;
1135 /* The callback for the locals and args iterators. */
1138 do_collect_symbol (const char *print_name
,
1142 struct add_local_symbols_data
*p
= (struct add_local_symbols_data
*) cb_data
;
1144 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1145 p
->frame_offset
, p
->pc
, p
->trace_string
);
1148 VEC_safe_push (char_ptr
, p
->collect
->wholly_collected
,
1149 xstrdup (print_name
));
1152 /* Add all locals (or args) symbols to collection list. */
1154 add_local_symbols (struct collection_list
*collect
,
1155 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1156 long frame_regno
, long frame_offset
, int type
,
1159 const struct block
*block
;
1160 struct add_local_symbols_data cb_data
;
1162 cb_data
.collect
= collect
;
1163 cb_data
.gdbarch
= gdbarch
;
1165 cb_data
.frame_regno
= frame_regno
;
1166 cb_data
.frame_offset
= frame_offset
;
1168 cb_data
.trace_string
= trace_string
;
1172 block
= block_for_pc (pc
);
1175 warning (_("Can't collect locals; "
1176 "no symbol table info available.\n"));
1180 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1181 if (cb_data
.count
== 0)
1182 warning (_("No locals found in scope."));
1186 pc
= get_pc_function_start (pc
);
1187 block
= block_for_pc (pc
);
1190 warning (_("Can't collect args; no symbol table info available."));
1194 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1195 if (cb_data
.count
== 0)
1196 warning (_("No args found in scope."));
1201 add_static_trace_data (struct collection_list
*collection
)
1204 printf_filtered ("collect static trace data\n");
1205 collection
->strace_data
= 1;
1208 /* worker function */
1210 clear_collection_list (struct collection_list
*list
)
1214 list
->next_memrange
= 0;
1215 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1217 free_agent_expr (list
->aexpr_list
[ndx
]);
1218 list
->aexpr_list
[ndx
] = NULL
;
1220 list
->next_aexpr_elt
= 0;
1221 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1222 list
->strace_data
= 0;
1224 xfree (list
->aexpr_list
);
1227 VEC_free (char_ptr
, list
->wholly_collected
);
1228 VEC_free (char_ptr
, list
->computed
);
1231 /* A cleanup wrapper for function clear_collection_list. */
1234 do_clear_collection_list (void *list
)
1236 struct collection_list
*l
= (struct collection_list
*) list
;
1238 clear_collection_list (l
);
1241 /* Initialize collection_list CLIST. */
1244 init_collection_list (struct collection_list
*clist
)
1246 memset (clist
, 0, sizeof *clist
);
1248 clist
->listsize
= 128;
1249 clist
->list
= XCNEWVEC (struct memrange
, clist
->listsize
);
1251 clist
->aexpr_listsize
= 128;
1252 clist
->aexpr_list
= XCNEWVEC (struct agent_expr
*, clist
->aexpr_listsize
);
1255 /* Reduce a collection list to string form (for gdb protocol). */
1257 stringify_collection_list (struct collection_list
*list
)
1259 char temp_buf
[2048];
1263 char *(*str_list
)[];
1267 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1268 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1270 if (list
->strace_data
)
1273 printf_filtered ("\nCollecting static trace data\n");
1276 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1280 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1281 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1283 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1286 printf_filtered ("\nCollecting registers (mask): 0x");
1291 QUIT
; /* Allow user to bail out with ^C. */
1293 printf_filtered ("%02X", list
->regs_mask
[i
]);
1294 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1297 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1301 printf_filtered ("\n");
1302 if (list
->next_memrange
> 0 && info_verbose
)
1303 printf_filtered ("Collecting memranges: \n");
1304 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1306 QUIT
; /* Allow user to bail out with ^C. */
1307 sprintf_vma (tmp2
, list
->list
[i
].start
);
1310 printf_filtered ("(%d, %s, %ld)\n",
1313 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1315 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1317 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1324 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1326 /* The "%X" conversion specifier expects an unsigned argument,
1327 so passing -1 (memrange_absolute) to it directly gives you
1328 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1330 if (list
->list
[i
].type
== memrange_absolute
)
1331 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1333 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1336 count
+= strlen (end
);
1337 end
= temp_buf
+ count
;
1340 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1342 QUIT
; /* Allow user to bail out with ^C. */
1343 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1345 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1350 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1351 end
+= 10; /* 'X' + 8 hex digits + ',' */
1354 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1355 end
, list
->aexpr_list
[i
]->len
);
1356 count
+= 2 * list
->aexpr_list
[i
]->len
;
1361 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1366 (*str_list
)[ndx
] = NULL
;
1377 /* Add the printed expression EXP to *LIST. */
1380 append_exp (struct expression
*exp
, VEC(char_ptr
) **list
)
1382 struct ui_file
*tmp_stream
= mem_fileopen ();
1385 print_expression (exp
, tmp_stream
);
1387 text
= ui_file_xstrdup (tmp_stream
, NULL
);
1389 VEC_safe_push (char_ptr
, *list
, text
);
1390 ui_file_delete (tmp_stream
);
1394 encode_actions_1 (struct command_line
*action
,
1395 struct bp_location
*tloc
,
1397 LONGEST frame_offset
,
1398 struct collection_list
*collect
,
1399 struct collection_list
*stepping_list
)
1401 const char *action_exp
;
1402 struct expression
*exp
= NULL
;
1404 struct value
*tempval
;
1405 struct cmd_list_element
*cmd
;
1406 struct agent_expr
*aexpr
;
1408 for (; action
; action
= action
->next
)
1410 QUIT
; /* Allow user to bail out with ^C. */
1411 action_exp
= action
->line
;
1412 action_exp
= skip_spaces_const (action_exp
);
1414 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1416 error (_("Bad action list item: %s"), action_exp
);
1418 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1420 int trace_string
= 0;
1422 if (*action_exp
== '/')
1423 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1426 { /* Repeat over a comma-separated list. */
1427 QUIT
; /* Allow user to bail out with ^C. */
1428 action_exp
= skip_spaces_const (action_exp
);
1430 if (0 == strncasecmp ("$reg", action_exp
, 4))
1432 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
1433 add_register (collect
, i
);
1434 action_exp
= strchr (action_exp
, ','); /* more? */
1436 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1438 add_local_symbols (collect
,
1445 action_exp
= strchr (action_exp
, ','); /* more? */
1447 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1449 add_local_symbols (collect
,
1456 action_exp
= strchr (action_exp
, ','); /* more? */
1458 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1460 struct cleanup
*old_chain1
= NULL
;
1462 aexpr
= gen_trace_for_return_address (tloc
->address
,
1466 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1469 report_agent_reqs_errors (aexpr
);
1471 discard_cleanups (old_chain1
);
1472 add_aexpr (collect
, aexpr
);
1474 /* take care of the registers */
1475 if (aexpr
->reg_mask_len
> 0)
1479 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1481 QUIT
; /* allow user to bail out with ^C */
1482 if (aexpr
->reg_mask
[ndx1
] != 0)
1484 /* assume chars have 8 bits */
1485 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1486 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1487 /* it's used -- record it */
1488 add_register (collect
,
1494 action_exp
= strchr (action_exp
, ','); /* more? */
1496 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1498 add_static_trace_data (collect
);
1499 action_exp
= strchr (action_exp
, ','); /* more? */
1504 struct cleanup
*old_chain
= NULL
;
1505 struct cleanup
*old_chain1
= NULL
;
1507 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1508 block_for_pc (tloc
->address
), 1);
1509 old_chain
= make_cleanup (free_current_contents
, &exp
);
1511 switch (exp
->elts
[0].opcode
)
1515 const char *name
= &exp
->elts
[2].string
;
1517 i
= user_reg_map_name_to_regnum (target_gdbarch (),
1518 name
, strlen (name
));
1520 internal_error (__FILE__
, __LINE__
,
1521 _("Register $%s not available"),
1524 printf_filtered ("OP_REGISTER: ");
1525 add_register (collect
, i
);
1530 /* Safe because we know it's a simple expression. */
1531 tempval
= evaluate_expression (exp
);
1532 addr
= value_address (tempval
);
1533 /* Initialize the TYPE_LENGTH if it is a typedef. */
1534 check_typedef (exp
->elts
[1].type
);
1535 add_memrange (collect
, memrange_absolute
, addr
,
1536 TYPE_LENGTH (exp
->elts
[1].type
));
1537 append_exp (exp
, &collect
->computed
);
1542 struct symbol
*sym
= exp
->elts
[2].symbol
;
1543 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1545 collect_symbol (collect
,
1546 exp
->elts
[2].symbol
,
1552 VEC_safe_push (char_ptr
,
1553 collect
->wholly_collected
,
1558 default: /* Full-fledged expression. */
1559 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1562 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1566 report_agent_reqs_errors (aexpr
);
1568 discard_cleanups (old_chain1
);
1569 add_aexpr (collect
, aexpr
);
1571 /* Take care of the registers. */
1572 if (aexpr
->reg_mask_len
> 0)
1577 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1579 QUIT
; /* Allow user to bail out with ^C. */
1580 if (aexpr
->reg_mask
[ndx1
] != 0)
1582 /* Assume chars have 8 bits. */
1583 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1584 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1585 /* It's used -- record it. */
1586 add_register (collect
,
1592 append_exp (exp
, &collect
->computed
);
1595 do_cleanups (old_chain
);
1598 while (action_exp
&& *action_exp
++ == ',');
1600 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1603 { /* Repeat over a comma-separated list. */
1604 QUIT
; /* Allow user to bail out with ^C. */
1605 action_exp
= skip_spaces_const (action_exp
);
1608 struct cleanup
*old_chain
= NULL
;
1609 struct cleanup
*old_chain1
= NULL
;
1611 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1612 block_for_pc (tloc
->address
), 1);
1613 old_chain
= make_cleanup (free_current_contents
, &exp
);
1615 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1616 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1619 report_agent_reqs_errors (aexpr
);
1621 discard_cleanups (old_chain1
);
1622 /* Even though we're not officially collecting, add
1623 to the collect list anyway. */
1624 add_aexpr (collect
, aexpr
);
1626 do_cleanups (old_chain
);
1629 while (action_exp
&& *action_exp
++ == ',');
1631 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1633 /* We check against nested while-stepping when setting
1634 breakpoint action, so no way to run into nested
1636 gdb_assert (stepping_list
);
1638 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1639 frame_offset
, stepping_list
, NULL
);
1642 error (_("Invalid tracepoint command '%s'"), action
->line
);
1646 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1647 and STEPPING_LIST. Return a cleanup pointer to clean up both
1648 TRACEPOINT_LIST and STEPPING_LIST. */
1651 encode_actions_and_make_cleanup (struct bp_location
*tloc
,
1652 struct collection_list
*tracepoint_list
,
1653 struct collection_list
*stepping_list
)
1655 struct command_line
*actions
;
1657 LONGEST frame_offset
;
1658 struct cleanup
*back_to
, *return_chain
;
1660 return_chain
= make_cleanup (null_cleanup
, NULL
);
1661 init_collection_list (tracepoint_list
);
1662 init_collection_list (stepping_list
);
1664 make_cleanup (do_clear_collection_list
, tracepoint_list
);
1665 make_cleanup (do_clear_collection_list
, stepping_list
);
1667 back_to
= make_cleanup (null_cleanup
, NULL
);
1668 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1669 tloc
->address
, &frame_reg
, &frame_offset
);
1671 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1673 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1674 tracepoint_list
, stepping_list
);
1676 memrange_sortmerge (tracepoint_list
);
1677 memrange_sortmerge (stepping_list
);
1679 do_cleanups (back_to
);
1680 return return_chain
;
1683 /* Render all actions into gdb protocol. */
1686 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1687 char ***stepping_actions
)
1689 struct collection_list tracepoint_list
, stepping_list
;
1690 struct cleanup
*cleanup
;
1692 *tdp_actions
= NULL
;
1693 *stepping_actions
= NULL
;
1695 cleanup
= encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
1698 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1699 *stepping_actions
= stringify_collection_list (&stepping_list
);
1701 do_cleanups (cleanup
);
1705 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1707 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1709 collect
->aexpr_list
= XRESIZEVEC (struct agent_expr
*,
1710 collect
->aexpr_list
,
1711 2 * collect
->aexpr_listsize
);
1712 collect
->aexpr_listsize
*= 2;
1714 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1715 collect
->next_aexpr_elt
++;
1719 process_tracepoint_on_disconnect (void)
1721 VEC(breakpoint_p
) *tp_vec
= NULL
;
1723 struct breakpoint
*b
;
1724 int has_pending_p
= 0;
1726 /* Check whether we still have pending tracepoint. If we have, warn the
1727 user that pending tracepoint will no longer work. */
1728 tp_vec
= all_tracepoints ();
1729 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1738 struct bp_location
*loc1
;
1740 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1742 if (loc1
->shlib_disabled
)
1753 VEC_free (breakpoint_p
, tp_vec
);
1756 warning (_("Pending tracepoints will not be resolved while"
1757 " GDB is disconnected\n"));
1760 /* Reset local state of tracing. */
1763 trace_reset_local_state (void)
1765 set_traceframe_num (-1);
1766 set_tracepoint_num (-1);
1767 set_traceframe_context (NULL
);
1768 clear_traceframe_info ();
1772 start_tracing (char *notes
)
1774 VEC(breakpoint_p
) *tp_vec
= NULL
;
1776 struct breakpoint
*b
;
1777 struct trace_state_variable
*tsv
;
1778 int any_enabled
= 0, num_to_download
= 0;
1781 tp_vec
= all_tracepoints ();
1783 /* No point in tracing without any tracepoints... */
1784 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1786 VEC_free (breakpoint_p
, tp_vec
);
1787 error (_("No tracepoints defined, not starting trace"));
1790 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1792 if (b
->enable_state
== bp_enabled
)
1795 if ((b
->type
== bp_fast_tracepoint
1796 ? may_insert_fast_tracepoints
1797 : may_insert_tracepoints
))
1800 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1801 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1806 if (target_supports_enable_disable_tracepoint ())
1807 warning (_("No tracepoints enabled"));
1810 /* No point in tracing with only disabled tracepoints that
1811 cannot be re-enabled. */
1812 VEC_free (breakpoint_p
, tp_vec
);
1813 error (_("No tracepoints enabled, not starting trace"));
1817 if (num_to_download
<= 0)
1819 VEC_free (breakpoint_p
, tp_vec
);
1820 error (_("No tracepoints that may be downloaded, not starting trace"));
1823 target_trace_init ();
1825 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1827 struct tracepoint
*t
= (struct tracepoint
*) b
;
1828 struct bp_location
*loc
;
1829 int bp_location_downloaded
= 0;
1831 /* Clear `inserted' flag. */
1832 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1835 if ((b
->type
== bp_fast_tracepoint
1836 ? !may_insert_fast_tracepoints
1837 : !may_insert_tracepoints
))
1840 t
->number_on_target
= 0;
1842 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1844 /* Since tracepoint locations are never duplicated, `inserted'
1845 flag should be zero. */
1846 gdb_assert (!loc
->inserted
);
1848 target_download_tracepoint (loc
);
1851 bp_location_downloaded
= 1;
1854 t
->number_on_target
= b
->number
;
1856 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1857 if (loc
->probe
.probe
!= NULL
1858 && loc
->probe
.probe
->pops
->set_semaphore
!= NULL
)
1859 loc
->probe
.probe
->pops
->set_semaphore (loc
->probe
.probe
,
1863 if (bp_location_downloaded
)
1864 observer_notify_breakpoint_modified (b
);
1866 VEC_free (breakpoint_p
, tp_vec
);
1868 /* Send down all the trace state variables too. */
1869 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1871 target_download_trace_state_variable (tsv
);
1874 /* Tell target to treat text-like sections as transparent. */
1875 target_trace_set_readonly_regions ();
1876 /* Set some mode flags. */
1877 target_set_disconnected_tracing (disconnected_tracing
);
1878 target_set_circular_trace_buffer (circular_trace_buffer
);
1879 target_set_trace_buffer_size (trace_buffer_size
);
1882 notes
= trace_notes
;
1883 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1885 if (!ret
&& (trace_user
|| notes
))
1886 warning (_("Target does not support trace user/notes, info ignored"));
1888 /* Now insert traps and begin collecting data. */
1889 target_trace_start ();
1891 /* Reset our local state. */
1892 trace_reset_local_state ();
1893 current_trace_status()->running
= 1;
1896 /* The tstart command requests the target to start a new trace run.
1897 The command passes any arguments it has to the target verbatim, as
1898 an optional "trace note". This is useful as for instance a warning
1899 to other users if the trace runs disconnected, and you don't want
1900 anybody else messing with the target. */
1903 trace_start_command (char *args
, int from_tty
)
1905 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1907 if (current_trace_status ()->running
)
1910 && !query (_("A trace is running already. Start a new run? ")))
1911 error (_("New trace run not started."));
1914 start_tracing (args
);
1917 /* The tstop command stops the tracing run. The command passes any
1918 supplied arguments to the target verbatim as a "stop note"; if the
1919 target supports trace notes, then it will be reported back as part
1920 of the trace run's status. */
1923 trace_stop_command (char *args
, int from_tty
)
1925 if (!current_trace_status ()->running
)
1926 error (_("Trace is not running."));
1928 stop_tracing (args
);
1932 stop_tracing (char *note
)
1935 VEC(breakpoint_p
) *tp_vec
= NULL
;
1937 struct breakpoint
*t
;
1939 target_trace_stop ();
1941 tp_vec
= all_tracepoints ();
1942 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1944 struct bp_location
*loc
;
1946 if ((t
->type
== bp_fast_tracepoint
1947 ? !may_insert_fast_tracepoints
1948 : !may_insert_tracepoints
))
1951 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1953 /* GDB can be totally absent in some disconnected trace scenarios,
1954 but we don't really care if this semaphore goes out of sync.
1955 That's why we are decrementing it here, but not taking care
1957 if (loc
->probe
.probe
!= NULL
1958 && loc
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
1959 loc
->probe
.probe
->pops
->clear_semaphore (loc
->probe
.probe
,
1965 VEC_free (breakpoint_p
, tp_vec
);
1968 note
= trace_stop_notes
;
1969 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1972 warning (_("Target does not support trace notes, note ignored"));
1974 /* Should change in response to reply? */
1975 current_trace_status ()->running
= 0;
1978 /* tstatus command */
1980 trace_status_command (char *args
, int from_tty
)
1982 struct trace_status
*ts
= current_trace_status ();
1984 VEC(breakpoint_p
) *tp_vec
= NULL
;
1985 struct breakpoint
*t
;
1987 status
= target_get_trace_status (ts
);
1991 if (ts
->filename
!= NULL
)
1992 printf_filtered (_("Using a trace file.\n"));
1995 printf_filtered (_("Trace can not be run on this target.\n"));
2000 if (!ts
->running_known
)
2002 printf_filtered (_("Run/stop status is unknown.\n"));
2004 else if (ts
->running
)
2006 printf_filtered (_("Trace is running on the target.\n"));
2010 switch (ts
->stop_reason
)
2012 case trace_never_run
:
2013 printf_filtered (_("No trace has been run on the target.\n"));
2017 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2020 printf_filtered (_("Trace stopped by a tstop command.\n"));
2022 case trace_buffer_full
:
2023 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2025 case trace_disconnected
:
2026 printf_filtered (_("Trace stopped because of disconnection.\n"));
2028 case tracepoint_passcount
:
2029 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2030 ts
->stopping_tracepoint
);
2032 case tracepoint_error
:
2033 if (ts
->stopping_tracepoint
)
2034 printf_filtered (_("Trace stopped by an "
2035 "error (%s, tracepoint %d).\n"),
2036 ts
->stop_desc
, ts
->stopping_tracepoint
);
2038 printf_filtered (_("Trace stopped by an error (%s).\n"),
2041 case trace_stop_reason_unknown
:
2042 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2045 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2051 if (ts
->traceframes_created
>= 0
2052 && ts
->traceframe_count
!= ts
->traceframes_created
)
2054 printf_filtered (_("Buffer contains %d trace "
2055 "frames (of %d created total).\n"),
2056 ts
->traceframe_count
, ts
->traceframes_created
);
2058 else if (ts
->traceframe_count
>= 0)
2060 printf_filtered (_("Collected %d trace frames.\n"),
2061 ts
->traceframe_count
);
2064 if (ts
->buffer_free
>= 0)
2066 if (ts
->buffer_size
>= 0)
2068 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2069 ts
->buffer_free
, ts
->buffer_size
);
2070 if (ts
->buffer_size
> 0)
2071 printf_filtered (_(" (%d%% full)"),
2072 ((int) ((((long long) (ts
->buffer_size
2073 - ts
->buffer_free
)) * 100)
2074 / ts
->buffer_size
)));
2075 printf_filtered (_(".\n"));
2078 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2082 if (ts
->disconnected_tracing
)
2083 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2085 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2087 if (ts
->circular_buffer
)
2088 printf_filtered (_("Trace buffer is circular.\n"));
2090 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2091 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2093 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2094 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2096 /* Now report on what we're doing with tfind. */
2097 if (traceframe_number
>= 0)
2098 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2099 traceframe_number
, tracepoint_number
);
2101 printf_filtered (_("Not looking at any trace frame.\n"));
2103 /* Report start/stop times if supplied. */
2108 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2110 /* Reporting a run time is more readable than two long numbers. */
2111 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2112 (long int) (ts
->start_time
/ 1000000),
2113 (long int) (ts
->start_time
% 1000000),
2114 (long int) (run_time
/ 1000000),
2115 (long int) (run_time
% 1000000));
2118 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2119 (long int) (ts
->start_time
/ 1000000),
2120 (long int) (ts
->start_time
% 1000000));
2122 else if (ts
->stop_time
)
2123 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2124 (long int) (ts
->stop_time
/ 1000000),
2125 (long int) (ts
->stop_time
% 1000000));
2127 /* Now report any per-tracepoint status available. */
2128 tp_vec
= all_tracepoints ();
2130 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2131 target_get_tracepoint_status (t
, NULL
);
2133 VEC_free (breakpoint_p
, tp_vec
);
2136 /* Report the trace status to uiout, in a way suitable for MI, and not
2137 suitable for CLI. If ON_STOP is true, suppress a few fields that
2138 are not meaningful in the -trace-stop response.
2140 The implementation is essentially parallel to trace_status_command, but
2141 merging them will result in unreadable code. */
2143 trace_status_mi (int on_stop
)
2145 struct ui_out
*uiout
= current_uiout
;
2146 struct trace_status
*ts
= current_trace_status ();
2149 status
= target_get_trace_status (ts
);
2151 if (status
== -1 && ts
->filename
== NULL
)
2153 ui_out_field_string (uiout
, "supported", "0");
2157 if (ts
->filename
!= NULL
)
2158 ui_out_field_string (uiout
, "supported", "file");
2160 ui_out_field_string (uiout
, "supported", "1");
2162 if (ts
->filename
!= NULL
)
2163 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2165 gdb_assert (ts
->running_known
);
2169 ui_out_field_string (uiout
, "running", "1");
2171 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2172 Given that the frontend gets the status either on -trace-stop, or from
2173 -trace-status after re-connection, it does not seem like this
2174 information is necessary for anything. It is not necessary for either
2175 figuring the vital state of the target nor for navigation of trace
2176 frames. If the frontend wants to show the current state is some
2177 configure dialog, it can request the value when such dialog is
2178 invoked by the user. */
2182 char *stop_reason
= NULL
;
2183 int stopping_tracepoint
= -1;
2186 ui_out_field_string (uiout
, "running", "0");
2188 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2190 switch (ts
->stop_reason
)
2193 stop_reason
= "request";
2195 case trace_buffer_full
:
2196 stop_reason
= "overflow";
2198 case trace_disconnected
:
2199 stop_reason
= "disconnection";
2201 case tracepoint_passcount
:
2202 stop_reason
= "passcount";
2203 stopping_tracepoint
= ts
->stopping_tracepoint
;
2205 case tracepoint_error
:
2206 stop_reason
= "error";
2207 stopping_tracepoint
= ts
->stopping_tracepoint
;
2213 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2214 if (stopping_tracepoint
!= -1)
2215 ui_out_field_int (uiout
, "stopping-tracepoint",
2216 stopping_tracepoint
);
2217 if (ts
->stop_reason
== tracepoint_error
)
2218 ui_out_field_string (uiout
, "error-description",
2224 if (ts
->traceframe_count
!= -1)
2225 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2226 if (ts
->traceframes_created
!= -1)
2227 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2228 if (ts
->buffer_size
!= -1)
2229 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2230 if (ts
->buffer_free
!= -1)
2231 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2233 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2234 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2236 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2237 ui_out_field_string (uiout
, "notes", ts
->notes
);
2242 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2243 (long int) (ts
->start_time
/ 1000000),
2244 (long int) (ts
->start_time
% 1000000));
2245 ui_out_field_string (uiout
, "start-time", buf
);
2246 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2247 (long int) (ts
->stop_time
/ 1000000),
2248 (long int) (ts
->stop_time
% 1000000));
2249 ui_out_field_string (uiout
, "stop-time", buf
);
2253 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2254 user if she really wants to detach. */
2257 query_if_trace_running (int from_tty
)
2262 /* It can happen that the target that was tracing went away on its
2263 own, and we didn't notice. Get a status update, and if the
2264 current target doesn't even do tracing, then assume it's not
2266 if (target_get_trace_status (current_trace_status ()) < 0)
2267 current_trace_status ()->running
= 0;
2269 /* If running interactively, give the user the option to cancel and
2270 then decide what to do differently with the run. Scripts are
2271 just going to disconnect and let the target deal with it,
2272 according to how it's been instructed previously via
2273 disconnected-tracing. */
2274 if (current_trace_status ()->running
)
2276 process_tracepoint_on_disconnect ();
2278 if (current_trace_status ()->disconnected_tracing
)
2280 if (!query (_("Trace is running and will "
2281 "continue after detach; detach anyway? ")))
2282 error (_("Not confirmed."));
2286 if (!query (_("Trace is running but will "
2287 "stop on detach; detach anyway? ")))
2288 error (_("Not confirmed."));
2293 /* This function handles the details of what to do about an ongoing
2294 tracing run if the user has asked to detach or otherwise disconnect
2298 disconnect_tracing (void)
2300 /* Also we want to be out of tfind mode, otherwise things can get
2301 confusing upon reconnection. Just use these calls instead of
2302 full tfind_1 behavior because we're in the middle of detaching,
2303 and there's no point to updating current stack frame etc. */
2304 trace_reset_local_state ();
2307 /* Worker function for the various flavors of the tfind command. */
2309 tfind_1 (enum trace_find_type type
, int num
,
2310 CORE_ADDR addr1
, CORE_ADDR addr2
,
2313 int target_frameno
= -1, target_tracept
= -1;
2314 struct frame_id old_frame_id
= null_frame_id
;
2315 struct tracepoint
*tp
;
2316 struct ui_out
*uiout
= current_uiout
;
2318 /* Only try to get the current stack frame if we have a chance of
2319 succeeding. In particular, if we're trying to get a first trace
2320 frame while all threads are running, it's not going to succeed,
2321 so leave it with a default value and let the frame comparison
2322 below (correctly) decide to print out the source location of the
2324 if (!(type
== tfind_number
&& num
== -1)
2325 && (has_stack_frames () || traceframe_number
>= 0))
2326 old_frame_id
= get_frame_id (get_current_frame ());
2328 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2331 if (type
== tfind_number
2333 && target_frameno
== -1)
2335 /* We told the target to get out of tfind mode, and it did. */
2337 else if (target_frameno
== -1)
2339 /* A request for a non-existent trace frame has failed.
2340 Our response will be different, depending on FROM_TTY:
2342 If FROM_TTY is true, meaning that this command was
2343 typed interactively by the user, then give an error
2344 and DO NOT change the state of traceframe_number etc.
2346 However if FROM_TTY is false, meaning that we're either
2347 in a script, a loop, or a user-defined command, then
2348 DON'T give an error, but DO change the state of
2349 traceframe_number etc. to invalid.
2351 The rationalle is that if you typed the command, you
2352 might just have committed a typo or something, and you'd
2353 like to NOT lose your current debugging state. However
2354 if you're in a user-defined command or especially in a
2355 loop, then you need a way to detect that the command
2356 failed WITHOUT aborting. This allows you to write
2357 scripts that search thru the trace buffer until the end,
2358 and then continue on to do something else. */
2361 error (_("Target failed to find requested trace frame."));
2365 printf_filtered ("End of trace buffer.\n");
2366 #if 0 /* dubious now? */
2367 /* The following will not recurse, since it's
2369 trace_find_command ("-1", from_tty
);
2374 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2376 reinit_frame_cache ();
2377 target_dcache_invalidate ();
2379 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2381 if (target_frameno
!= get_traceframe_number ())
2382 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2384 set_current_traceframe (target_frameno
);
2386 if (target_frameno
== -1)
2387 set_traceframe_context (NULL
);
2389 set_traceframe_context (get_current_frame ());
2391 if (traceframe_number
>= 0)
2393 /* Use different branches for MI and CLI to make CLI messages
2395 if (ui_out_is_mi_like_p (uiout
))
2397 ui_out_field_string (uiout
, "found", "1");
2398 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2399 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2403 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2404 traceframe_number
, tracepoint_number
);
2409 if (ui_out_is_mi_like_p (uiout
))
2410 ui_out_field_string (uiout
, "found", "0");
2411 else if (type
== tfind_number
&& num
== -1)
2412 printf_unfiltered (_("No longer looking at any trace frame\n"));
2413 else /* This case may never occur, check. */
2414 printf_unfiltered (_("No trace frame found\n"));
2417 /* If we're in nonstop mode and getting out of looking at trace
2418 frames, there won't be any current frame to go back to and
2421 && (has_stack_frames () || traceframe_number
>= 0))
2423 enum print_what print_what
;
2425 /* NOTE: in imitation of the step command, try to determine
2426 whether we have made a transition from one function to
2427 another. If so, we'll print the "stack frame" (ie. the new
2428 function and it's arguments) -- otherwise we'll just show the
2431 if (frame_id_eq (old_frame_id
,
2432 get_frame_id (get_current_frame ())))
2433 print_what
= SRC_LINE
;
2435 print_what
= SRC_AND_LOC
;
2437 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2442 /* Error on looking at traceframes while trace is running. */
2445 check_trace_running (struct trace_status
*status
)
2447 if (status
->running
&& status
->filename
== NULL
)
2448 error (_("May not look at trace frames while trace is running."));
2451 /* trace_find_command takes a trace frame number n,
2452 sends "QTFrame:<n>" to the target,
2453 and accepts a reply that may contain several optional pieces
2454 of information: a frame number, a tracepoint number, and an
2455 indication of whether this is a trap frame or a stepping frame.
2457 The minimal response is just "OK" (which indicates that the
2458 target does not give us a frame number or a tracepoint number).
2459 Instead of that, the target may send us a string containing
2461 F<hexnum> (gives the selected frame number)
2462 T<hexnum> (gives the selected tracepoint number)
2467 trace_find_command (char *args
, int from_tty
)
2468 { /* This should only be called with a numeric argument. */
2471 check_trace_running (current_trace_status ());
2473 if (args
== 0 || *args
== 0)
2474 { /* TFIND with no args means find NEXT trace frame. */
2475 if (traceframe_number
== -1)
2476 frameno
= 0; /* "next" is first one. */
2478 frameno
= traceframe_number
+ 1;
2480 else if (0 == strcmp (args
, "-"))
2482 if (traceframe_number
== -1)
2483 error (_("not debugging trace buffer"));
2484 else if (from_tty
&& traceframe_number
== 0)
2485 error (_("already at start of trace buffer"));
2487 frameno
= traceframe_number
- 1;
2489 /* A hack to work around eval's need for fp to have been collected. */
2490 else if (0 == strcmp (args
, "-1"))
2493 frameno
= parse_and_eval_long (args
);
2496 error (_("invalid input (%d is less than zero)"), frameno
);
2498 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2503 trace_find_end_command (char *args
, int from_tty
)
2505 trace_find_command ("-1", from_tty
);
2510 trace_find_start_command (char *args
, int from_tty
)
2512 trace_find_command ("0", from_tty
);
2515 /* tfind pc command */
2517 trace_find_pc_command (char *args
, int from_tty
)
2521 check_trace_running (current_trace_status ());
2523 if (args
== 0 || *args
== 0)
2524 pc
= regcache_read_pc (get_current_regcache ());
2526 pc
= parse_and_eval_address (args
);
2528 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2531 /* tfind tracepoint command */
2533 trace_find_tracepoint_command (char *args
, int from_tty
)
2536 struct tracepoint
*tp
;
2538 check_trace_running (current_trace_status ());
2540 if (args
== 0 || *args
== 0)
2542 if (tracepoint_number
== -1)
2543 error (_("No current tracepoint -- please supply an argument."));
2545 tdp
= tracepoint_number
; /* Default is current TDP. */
2548 tdp
= parse_and_eval_long (args
);
2550 /* If we have the tracepoint on hand, use the number that the
2551 target knows about (which may be different if we disconnected
2552 and reconnected). */
2553 tp
= get_tracepoint (tdp
);
2555 tdp
= tp
->number_on_target
;
2557 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2560 /* TFIND LINE command:
2562 This command will take a sourceline for argument, just like BREAK
2563 or TRACE (ie. anything that "decode_line_1" can handle).
2565 With no argument, this command will find the next trace frame
2566 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2569 trace_find_line_command (char *args
, int from_tty
)
2571 static CORE_ADDR start_pc
, end_pc
;
2572 struct symtabs_and_lines sals
;
2573 struct symtab_and_line sal
;
2574 struct cleanup
*old_chain
;
2576 check_trace_running (current_trace_status ());
2578 if (args
== 0 || *args
== 0)
2580 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2582 sals
.sals
= XNEW (struct symtab_and_line
);
2587 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2591 old_chain
= make_cleanup (xfree
, sals
.sals
);
2592 if (sal
.symtab
== 0)
2593 error (_("No line number information available."));
2595 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2597 if (start_pc
== end_pc
)
2599 printf_filtered ("Line %d of \"%s\"",
2601 symtab_to_filename_for_display (sal
.symtab
));
2603 printf_filtered (" is at address ");
2604 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2606 printf_filtered (" but contains no code.\n");
2607 sal
= find_pc_line (start_pc
, 0);
2609 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2610 && start_pc
!= end_pc
)
2611 printf_filtered ("Attempting to find line %d instead.\n",
2614 error (_("Cannot find a good line."));
2618 /* Is there any case in which we get here, and have an address
2619 which the user would want to see? If we have debugging
2620 symbols and no line numbers? */
2621 error (_("Line number %d is out of range for \"%s\"."),
2622 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2624 /* Find within range of stated line. */
2626 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2628 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2629 do_cleanups (old_chain
);
2632 /* tfind range command */
2634 trace_find_range_command (char *args
, int from_tty
)
2636 static CORE_ADDR start
, stop
;
2639 check_trace_running (current_trace_status ());
2641 if (args
== 0 || *args
== 0)
2642 { /* XXX FIXME: what should default behavior be? */
2643 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2647 if (0 != (tmp
= strchr (args
, ',')))
2649 *tmp
++ = '\0'; /* Terminate start address. */
2650 tmp
= skip_spaces (tmp
);
2651 start
= parse_and_eval_address (args
);
2652 stop
= parse_and_eval_address (tmp
);
2655 { /* No explicit end address? */
2656 start
= parse_and_eval_address (args
);
2657 stop
= start
+ 1; /* ??? */
2660 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2663 /* tfind outside command */
2665 trace_find_outside_command (char *args
, int from_tty
)
2667 CORE_ADDR start
, stop
;
2670 if (current_trace_status ()->running
2671 && current_trace_status ()->filename
== NULL
)
2672 error (_("May not look at trace frames while trace is running."));
2674 if (args
== 0 || *args
== 0)
2675 { /* XXX FIXME: what should default behavior be? */
2676 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2680 if (0 != (tmp
= strchr (args
, ',')))
2682 *tmp
++ = '\0'; /* Terminate start address. */
2683 tmp
= skip_spaces (tmp
);
2684 start
= parse_and_eval_address (args
);
2685 stop
= parse_and_eval_address (tmp
);
2688 { /* No explicit end address? */
2689 start
= parse_and_eval_address (args
);
2690 stop
= start
+ 1; /* ??? */
2693 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2696 /* info scope command: list the locals for a scope. */
2698 scope_info (char *args
, int from_tty
)
2700 struct symtabs_and_lines sals
;
2702 struct bound_minimal_symbol msym
;
2703 const struct block
*block
;
2704 const char *symname
;
2705 char *save_args
= args
;
2706 struct block_iterator iter
;
2708 struct gdbarch
*gdbarch
;
2710 struct event_location
*location
;
2711 struct cleanup
*back_to
;
2713 if (args
== 0 || *args
== 0)
2714 error (_("requires an argument (function, "
2715 "line or *addr) to define a scope"));
2717 location
= string_to_event_location (&args
, current_language
);
2718 back_to
= make_cleanup_delete_event_location (location
);
2719 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
, NULL
, 0);
2720 if (sals
.nelts
== 0)
2722 /* Presumably decode_line_1 has already warned. */
2723 do_cleanups (back_to
);
2727 /* Resolve line numbers to PC. */
2728 resolve_sal_pc (&sals
.sals
[0]);
2729 block
= block_for_pc (sals
.sals
[0].pc
);
2733 QUIT
; /* Allow user to bail out with ^C. */
2734 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2736 QUIT
; /* Allow user to bail out with ^C. */
2738 printf_filtered ("Scope for %s:\n", save_args
);
2741 symname
= SYMBOL_PRINT_NAME (sym
);
2742 if (symname
== NULL
|| *symname
== '\0')
2743 continue; /* Probably botched, certainly useless. */
2745 gdbarch
= symbol_arch (sym
);
2747 printf_filtered ("Symbol %s is ", symname
);
2749 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2750 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2751 BLOCK_START (block
),
2755 switch (SYMBOL_CLASS (sym
))
2758 case LOC_UNDEF
: /* Messed up symbol? */
2759 printf_filtered ("a bogus symbol, class %d.\n",
2760 SYMBOL_CLASS (sym
));
2761 count
--; /* Don't count this one. */
2764 printf_filtered ("a constant with value %s (%s)",
2765 plongest (SYMBOL_VALUE (sym
)),
2766 hex_string (SYMBOL_VALUE (sym
)));
2768 case LOC_CONST_BYTES
:
2769 printf_filtered ("constant bytes: ");
2770 if (SYMBOL_TYPE (sym
))
2771 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2772 fprintf_filtered (gdb_stdout
, " %02x",
2773 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2776 printf_filtered ("in static storage at address ");
2777 printf_filtered ("%s", paddress (gdbarch
,
2778 SYMBOL_VALUE_ADDRESS (sym
)));
2781 /* GDBARCH is the architecture associated with the objfile
2782 the symbol is defined in; the target architecture may be
2783 different, and may provide additional registers. However,
2784 we do not know the target architecture at this point.
2785 We assume the objfile architecture will contain all the
2786 standard registers that occur in debug info in that
2788 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2791 if (SYMBOL_IS_ARGUMENT (sym
))
2792 printf_filtered ("an argument in register $%s",
2793 gdbarch_register_name (gdbarch
, regno
));
2795 printf_filtered ("a local variable in register $%s",
2796 gdbarch_register_name (gdbarch
, regno
));
2799 printf_filtered ("an argument at stack/frame offset %s",
2800 plongest (SYMBOL_VALUE (sym
)));
2803 printf_filtered ("a local variable at frame offset %s",
2804 plongest (SYMBOL_VALUE (sym
)));
2807 printf_filtered ("a reference argument at offset %s",
2808 plongest (SYMBOL_VALUE (sym
)));
2810 case LOC_REGPARM_ADDR
:
2811 /* Note comment at LOC_REGISTER. */
2812 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2814 printf_filtered ("the address of an argument, in register $%s",
2815 gdbarch_register_name (gdbarch
, regno
));
2818 printf_filtered ("a typedef.\n");
2821 printf_filtered ("a label at address ");
2822 printf_filtered ("%s", paddress (gdbarch
,
2823 SYMBOL_VALUE_ADDRESS (sym
)));
2826 printf_filtered ("a function at address ");
2827 printf_filtered ("%s",
2828 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2830 case LOC_UNRESOLVED
:
2831 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2833 if (msym
.minsym
== NULL
)
2834 printf_filtered ("Unresolved Static");
2837 printf_filtered ("static storage at address ");
2838 printf_filtered ("%s",
2840 BMSYMBOL_VALUE_ADDRESS (msym
)));
2843 case LOC_OPTIMIZED_OUT
:
2844 printf_filtered ("optimized out.\n");
2847 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2850 if (SYMBOL_TYPE (sym
))
2851 printf_filtered (", length %d.\n",
2852 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2854 if (BLOCK_FUNCTION (block
))
2857 block
= BLOCK_SUPERBLOCK (block
);
2860 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2862 do_cleanups (back_to
);
2865 /* Helper for trace_dump_command. Dump the action list starting at
2866 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2867 actions of the body of a while-stepping action. STEPPING_FRAME is
2868 set if the current traceframe was determined to be a while-stepping
2872 trace_dump_actions (struct command_line
*action
,
2873 int stepping_actions
, int stepping_frame
,
2876 const char *action_exp
, *next_comma
;
2878 for (; action
!= NULL
; action
= action
->next
)
2880 struct cmd_list_element
*cmd
;
2882 QUIT
; /* Allow user to bail out with ^C. */
2883 action_exp
= action
->line
;
2884 action_exp
= skip_spaces_const (action_exp
);
2886 /* The collection actions to be done while stepping are
2887 bracketed by the commands "while-stepping" and "end". */
2889 if (*action_exp
== '#') /* comment line */
2892 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2894 error (_("Bad action list item: %s"), action_exp
);
2896 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2900 for (i
= 0; i
< action
->body_count
; ++i
)
2901 trace_dump_actions (action
->body_list
[i
],
2902 1, stepping_frame
, from_tty
);
2904 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2906 /* Display the collected data.
2907 For the trap frame, display only what was collected at
2908 the trap. Likewise for stepping frames, display only
2909 what was collected while stepping. This means that the
2910 two boolean variables, STEPPING_FRAME and
2911 STEPPING_ACTIONS should be equal. */
2912 if (stepping_frame
== stepping_actions
)
2915 struct cleanup
*old_chain
2916 = make_cleanup (free_current_contents
, &cmd
);
2917 int trace_string
= 0;
2919 if (*action_exp
== '/')
2920 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2923 { /* Repeat over a comma-separated list. */
2924 QUIT
; /* Allow user to bail out with ^C. */
2925 if (*action_exp
== ',')
2927 action_exp
= skip_spaces_const (action_exp
);
2929 next_comma
= strchr (action_exp
, ',');
2931 if (0 == strncasecmp (action_exp
, "$reg", 4))
2932 registers_info (NULL
, from_tty
);
2933 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2935 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2936 locals_info (NULL
, from_tty
);
2937 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2938 args_info (NULL
, from_tty
);
2941 if (next_comma
!= NULL
)
2943 size_t len
= next_comma
- action_exp
;
2945 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2946 memcpy (cmd
, action_exp
, len
);
2951 size_t len
= strlen (action_exp
);
2953 cmd
= (char *) xrealloc (cmd
, len
+ 1);
2954 memcpy (cmd
, action_exp
, len
+ 1);
2957 printf_filtered ("%s = ", cmd
);
2958 output_command_const (cmd
, from_tty
);
2959 printf_filtered ("\n");
2961 action_exp
= next_comma
;
2963 while (action_exp
&& *action_exp
== ',');
2965 do_cleanups (old_chain
);
2971 /* Return bp_location of the tracepoint associated with the current
2972 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2973 is a stepping traceframe. */
2975 struct bp_location
*
2976 get_traceframe_location (int *stepping_frame_p
)
2978 struct tracepoint
*t
;
2979 struct bp_location
*tloc
;
2980 struct regcache
*regcache
;
2982 if (tracepoint_number
== -1)
2983 error (_("No current trace frame."));
2985 t
= get_tracepoint (tracepoint_number
);
2988 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2991 /* The current frame is a trap frame if the frame PC is equal to the
2992 tracepoint PC. If not, then the current frame was collected
2993 during single-stepping. */
2994 regcache
= get_current_regcache ();
2996 /* If the traceframe's address matches any of the tracepoint's
2997 locations, assume it is a direct hit rather than a while-stepping
2998 frame. (FIXME this is not reliable, should record each frame's
3000 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
3001 if (tloc
->address
== regcache_read_pc (regcache
))
3003 *stepping_frame_p
= 0;
3007 /* If this is a stepping frame, we don't know which location
3008 triggered. The first is as good (or bad) a guess as any... */
3009 *stepping_frame_p
= 1;
3013 /* Return all the actions, including default collect, of a tracepoint
3014 T. It constructs cleanups into the chain, and leaves the caller to
3015 handle them (call do_cleanups). */
3017 static struct command_line
*
3018 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3020 struct command_line
*actions
;
3022 actions
= breakpoint_commands (t
);
3024 /* If there are default expressions to collect, make up a collect
3025 action and prepend to the action list to encode. Note that since
3026 validation is per-tracepoint (local var "xyz" might be valid for
3027 one tracepoint and not another, etc), we make up the action on
3028 the fly, and don't cache it. */
3029 if (*default_collect
)
3031 struct command_line
*default_collect_action
;
3032 char *default_collect_line
;
3034 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3035 make_cleanup (xfree
, default_collect_line
);
3037 validate_actionline (default_collect_line
, t
);
3038 default_collect_action
= XNEW (struct command_line
);
3039 make_cleanup (xfree
, default_collect_action
);
3040 default_collect_action
->next
= actions
;
3041 default_collect_action
->line
= default_collect_line
;
3042 actions
= default_collect_action
;
3048 /* The tdump command. */
3051 trace_dump_command (char *args
, int from_tty
)
3053 int stepping_frame
= 0;
3054 struct bp_location
*loc
;
3055 struct cleanup
*old_chain
;
3056 struct command_line
*actions
;
3058 /* This throws an error is not inspecting a trace frame. */
3059 loc
= get_traceframe_location (&stepping_frame
);
3061 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3062 tracepoint_number
, traceframe_number
);
3064 old_chain
= make_cleanup (null_cleanup
, NULL
);
3066 /* This command only makes sense for the current frame, not the
3068 make_cleanup_restore_current_thread ();
3069 select_frame (get_current_frame ());
3071 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3073 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3075 do_cleanups (old_chain
);
3078 /* Encode a piece of a tracepoint's source-level definition in a form
3079 that is suitable for both protocol and saving in files. */
3080 /* This version does not do multiple encodes for long strings; it should
3081 return an offset to the next piece to encode. FIXME */
3084 encode_source_string (int tpnum
, ULONGEST addr
,
3085 char *srctype
, const char *src
, char *buf
, int buf_size
)
3087 if (80 + strlen (srctype
) > buf_size
)
3088 error (_("Buffer too small for source encoding"));
3089 sprintf (buf
, "%x:%s:%s:%x:%x:",
3090 tpnum
, phex_nz (addr
, sizeof (addr
)),
3091 srctype
, 0, (int) strlen (src
));
3092 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3093 error (_("Source string too long for buffer"));
3094 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
3098 /* Tell the target what to do with an ongoing tracing run if GDB
3099 disconnects for some reason. */
3102 set_disconnected_tracing (char *args
, int from_tty
,
3103 struct cmd_list_element
*c
)
3105 target_set_disconnected_tracing (disconnected_tracing
);
3109 set_circular_trace_buffer (char *args
, int from_tty
,
3110 struct cmd_list_element
*c
)
3112 target_set_circular_trace_buffer (circular_trace_buffer
);
3116 set_trace_buffer_size (char *args
, int from_tty
,
3117 struct cmd_list_element
*c
)
3119 target_set_trace_buffer_size (trace_buffer_size
);
3123 set_trace_user (char *args
, int from_tty
,
3124 struct cmd_list_element
*c
)
3128 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3131 warning (_("Target does not support trace notes, user ignored"));
3135 set_trace_notes (char *args
, int from_tty
,
3136 struct cmd_list_element
*c
)
3140 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3143 warning (_("Target does not support trace notes, note ignored"));
3147 set_trace_stop_notes (char *args
, int from_tty
,
3148 struct cmd_list_element
*c
)
3152 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3155 warning (_("Target does not support trace notes, stop note ignored"));
3158 /* Convert the memory pointed to by mem into hex, placing result in buf.
3159 * Return a pointer to the last char put in buf (null)
3160 * "stolen" from sparc-stub.c
3163 static const char hexchars
[] = "0123456789abcdef";
3166 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3174 *buf
++ = hexchars
[ch
>> 4];
3175 *buf
++ = hexchars
[ch
& 0xf];
3184 get_traceframe_number (void)
3186 return traceframe_number
;
3190 get_tracepoint_number (void)
3192 return tracepoint_number
;
3195 /* Make the traceframe NUM be the current trace frame. Does nothing
3196 if NUM is already current. */
3199 set_current_traceframe (int num
)
3203 if (traceframe_number
== num
)
3205 /* Nothing to do. */
3209 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3212 warning (_("could not change traceframe"));
3214 set_traceframe_num (newnum
);
3216 /* Changing the traceframe changes our view of registers and of the
3218 registers_changed ();
3220 clear_traceframe_info ();
3223 /* A cleanup used when switching away and back from tfind mode. */
3225 struct current_traceframe_cleanup
3227 /* The traceframe we were inspecting. */
3228 int traceframe_number
;
3232 do_restore_current_traceframe_cleanup (void *arg
)
3234 struct current_traceframe_cleanup
*old
3235 = (struct current_traceframe_cleanup
*) arg
;
3237 set_current_traceframe (old
->traceframe_number
);
3241 restore_current_traceframe_cleanup_dtor (void *arg
)
3243 struct current_traceframe_cleanup
*old
3244 = (struct current_traceframe_cleanup
*) arg
;
3250 make_cleanup_restore_current_traceframe (void)
3252 struct current_traceframe_cleanup
*old
=
3253 XNEW (struct current_traceframe_cleanup
);
3255 old
->traceframe_number
= traceframe_number
;
3257 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3258 restore_current_traceframe_cleanup_dtor
);
3261 /* Given a number and address, return an uploaded tracepoint with that
3262 number, creating if necessary. */
3264 struct uploaded_tp
*
3265 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3267 struct uploaded_tp
*utp
;
3269 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3270 if (utp
->number
== num
&& utp
->addr
== addr
)
3273 utp
= XCNEW (struct uploaded_tp
);
3276 utp
->actions
= NULL
;
3277 utp
->step_actions
= NULL
;
3278 utp
->cmd_strings
= NULL
;
3286 free_uploaded_tps (struct uploaded_tp
**utpp
)
3288 struct uploaded_tp
*next_one
;
3292 next_one
= (*utpp
)->next
;
3298 /* Given a number and address, return an uploaded tracepoint with that
3299 number, creating if necessary. */
3301 struct uploaded_tsv
*
3302 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3304 struct uploaded_tsv
*utsv
;
3306 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3307 if (utsv
->number
== num
)
3310 utsv
= XCNEW (struct uploaded_tsv
);
3312 utsv
->next
= *utsvp
;
3319 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3321 struct uploaded_tsv
*next_one
;
3325 next_one
= (*utsvp
)->next
;
3331 /* FIXME this function is heuristic and will miss the cases where the
3332 conditional is semantically identical but differs in whitespace,
3333 such as "x == 0" vs "x==0". */
3336 cond_string_is_same (char *str1
, char *str2
)
3338 if (str1
== NULL
|| str2
== NULL
)
3339 return (str1
== str2
);
3341 return (strcmp (str1
, str2
) == 0);
3344 /* Look for an existing tracepoint that seems similar enough to the
3345 uploaded one. Enablement isn't compared, because the user can
3346 toggle that freely, and may have done so in anticipation of the
3347 next trace run. Return the location of matched tracepoint. */
3349 static struct bp_location
*
3350 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3352 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3354 struct breakpoint
*b
;
3355 struct bp_location
*loc
;
3357 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3359 struct tracepoint
*t
= (struct tracepoint
*) b
;
3361 if (b
->type
== utp
->type
3362 && t
->step_count
== utp
->step
3363 && t
->pass_count
== utp
->pass
3364 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3365 /* FIXME also test actions. */
3368 /* Scan the locations for an address match. */
3369 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3371 if (loc
->address
== utp
->addr
)
3379 /* Given a list of tracepoints uploaded from a target, attempt to
3380 match them up with existing tracepoints, and create new ones if not
3384 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3386 struct uploaded_tp
*utp
;
3387 /* A set of tracepoints which are modified. */
3388 VEC(breakpoint_p
) *modified_tp
= NULL
;
3390 struct breakpoint
*b
;
3392 /* Look for GDB tracepoints that match up with our uploaded versions. */
3393 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3395 struct bp_location
*loc
;
3396 struct tracepoint
*t
;
3398 loc
= find_matching_tracepoint_location (utp
);
3403 /* Mark this location as already inserted. */
3405 t
= (struct tracepoint
*) loc
->owner
;
3406 printf_filtered (_("Assuming tracepoint %d is same "
3407 "as target's tracepoint %d at %s.\n"),
3408 loc
->owner
->number
, utp
->number
,
3409 paddress (loc
->gdbarch
, utp
->addr
));
3411 /* The tracepoint LOC->owner was modified (the location LOC
3412 was marked as inserted in the target). Save it in
3413 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3414 observers will be notified later once for each tracepoint
3415 saved in MODIFIED_TP. */
3417 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3419 if (b
== loc
->owner
)
3425 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3429 t
= create_tracepoint_from_upload (utp
);
3431 printf_filtered (_("Created tracepoint %d for "
3432 "target's tracepoint %d at %s.\n"),
3433 t
->base
.number
, utp
->number
,
3434 paddress (get_current_arch (), utp
->addr
));
3436 printf_filtered (_("Failed to create tracepoint for target's "
3437 "tracepoint %d at %s, skipping it.\n"),
3439 paddress (get_current_arch (), utp
->addr
));
3441 /* Whether found or created, record the number used by the
3442 target, to help with mapping target tracepoints back to their
3443 counterparts here. */
3445 t
->number_on_target
= utp
->number
;
3448 /* Notify 'breakpoint-modified' observer that at least one of B's
3449 locations was changed. */
3450 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3451 observer_notify_breakpoint_modified (b
);
3453 VEC_free (breakpoint_p
, modified_tp
);
3454 free_uploaded_tps (uploaded_tps
);
3457 /* Trace state variables don't have much to identify them beyond their
3458 name, so just use that to detect matches. */
3460 static struct trace_state_variable
*
3461 find_matching_tsv (struct uploaded_tsv
*utsv
)
3466 return find_trace_state_variable (utsv
->name
);
3469 static struct trace_state_variable
*
3470 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3472 const char *namebase
;
3475 struct trace_state_variable
*tsv
;
3476 struct cleanup
*old_chain
;
3480 namebase
= utsv
->name
;
3481 buf
= xstrprintf ("%s", namebase
);
3486 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3489 /* Fish for a name that is not in use. */
3490 /* (should check against all internal vars?) */
3491 while (find_trace_state_variable (buf
))
3494 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3497 old_chain
= make_cleanup (xfree
, buf
);
3499 /* We have an available name, create the variable. */
3500 tsv
= create_trace_state_variable (buf
);
3501 tsv
->initial_value
= utsv
->initial_value
;
3502 tsv
->builtin
= utsv
->builtin
;
3504 observer_notify_tsv_created (tsv
);
3506 do_cleanups (old_chain
);
3511 /* Given a list of uploaded trace state variables, try to match them
3512 up with existing variables, or create additional ones. */
3515 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3518 struct uploaded_tsv
*utsv
;
3519 struct trace_state_variable
*tsv
;
3522 /* Most likely some numbers will have to be reassigned as part of
3523 the merge, so clear them all in anticipation. */
3524 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3527 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3529 tsv
= find_matching_tsv (utsv
);
3533 printf_filtered (_("Assuming trace state variable $%s "
3534 "is same as target's variable %d.\n"),
3535 tsv
->name
, utsv
->number
);
3539 tsv
= create_tsv_from_upload (utsv
);
3541 printf_filtered (_("Created trace state variable "
3542 "$%s for target's variable %d.\n"),
3543 tsv
->name
, utsv
->number
);
3545 /* Give precedence to numberings that come from the target. */
3547 tsv
->number
= utsv
->number
;
3550 /* Renumber everything that didn't get a target-assigned number. */
3552 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3553 if (tsv
->number
> highest
)
3554 highest
= tsv
->number
;
3557 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3558 if (tsv
->number
== 0)
3559 tsv
->number
= highest
++;
3561 free_uploaded_tsvs (uploaded_tsvs
);
3564 /* Parse the part of trace status syntax that is shared between
3565 the remote protocol and the trace file reader. */
3568 parse_trace_status (char *line
, struct trace_status
*ts
)
3570 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3574 ts
->running_known
= 1;
3575 ts
->running
= (*p
++ == '1');
3576 ts
->stop_reason
= trace_stop_reason_unknown
;
3577 xfree (ts
->stop_desc
);
3578 ts
->stop_desc
= NULL
;
3579 ts
->traceframe_count
= -1;
3580 ts
->traceframes_created
= -1;
3581 ts
->buffer_free
= -1;
3582 ts
->buffer_size
= -1;
3583 ts
->disconnected_tracing
= 0;
3584 ts
->circular_buffer
= 0;
3585 xfree (ts
->user_name
);
3586 ts
->user_name
= NULL
;
3589 ts
->start_time
= ts
->stop_time
= 0;
3593 p1
= strchr (p
, ':');
3595 error (_("Malformed trace status, at %s\n\
3596 Status line: '%s'\n"), p
, line
);
3597 p3
= strchr (p
, ';');
3599 p3
= p
+ strlen (p
);
3600 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3602 p
= unpack_varlen_hex (++p1
, &val
);
3603 ts
->stop_reason
= trace_buffer_full
;
3605 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3607 p
= unpack_varlen_hex (++p1
, &val
);
3608 ts
->stop_reason
= trace_never_run
;
3610 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3613 p
= unpack_varlen_hex (++p1
, &val
);
3614 ts
->stop_reason
= tracepoint_passcount
;
3615 ts
->stopping_tracepoint
= val
;
3617 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3619 p2
= strchr (++p1
, ':');
3627 ts
->stop_desc
= (char *) xmalloc (strlen (line
));
3628 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3629 ts
->stop_desc
[end
] = '\0';
3632 ts
->stop_desc
= xstrdup ("");
3634 p
= unpack_varlen_hex (++p2
, &val
);
3635 ts
->stop_reason
= tstop_command
;
3637 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3639 p
= unpack_varlen_hex (++p1
, &val
);
3640 ts
->stop_reason
= trace_disconnected
;
3642 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3644 p2
= strchr (++p1
, ':');
3647 ts
->stop_desc
= (char *) xmalloc ((p2
- p1
) / 2 + 1);
3648 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3649 ts
->stop_desc
[end
] = '\0';
3652 ts
->stop_desc
= xstrdup ("");
3654 p
= unpack_varlen_hex (++p2
, &val
);
3655 ts
->stopping_tracepoint
= val
;
3656 ts
->stop_reason
= tracepoint_error
;
3658 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3660 p
= unpack_varlen_hex (++p1
, &val
);
3661 ts
->traceframe_count
= val
;
3663 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3665 p
= unpack_varlen_hex (++p1
, &val
);
3666 ts
->traceframes_created
= val
;
3668 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3670 p
= unpack_varlen_hex (++p1
, &val
);
3671 ts
->buffer_free
= val
;
3673 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3675 p
= unpack_varlen_hex (++p1
, &val
);
3676 ts
->buffer_size
= val
;
3678 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3680 p
= unpack_varlen_hex (++p1
, &val
);
3681 ts
->disconnected_tracing
= val
;
3683 else if (strncmp (p
, "circular", p1
- p
) == 0)
3685 p
= unpack_varlen_hex (++p1
, &val
);
3686 ts
->circular_buffer
= val
;
3688 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3690 p
= unpack_varlen_hex (++p1
, &val
);
3691 ts
->start_time
= val
;
3693 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3695 p
= unpack_varlen_hex (++p1
, &val
);
3696 ts
->stop_time
= val
;
3698 else if (strncmp (p
, "username", p1
- p
) == 0)
3701 ts
->user_name
= (char *) xmalloc (strlen (p
) / 2);
3702 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3703 ts
->user_name
[end
] = '\0';
3706 else if (strncmp (p
, "notes", p1
- p
) == 0)
3709 ts
->notes
= (char *) xmalloc (strlen (p
) / 2);
3710 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3711 ts
->notes
[end
] = '\0';
3716 /* Silently skip unknown optional info. */
3717 p_temp
= strchr (p1
+ 1, ';');
3721 /* Must be at the end. */
3728 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3729 struct uploaded_tp
*utp
)
3732 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3734 p
= unpack_varlen_hex (p
, &uval
);
3736 tp
->base
.hit_count
+= uval
;
3738 utp
->hit_count
+= uval
;
3739 p
= unpack_varlen_hex (p
+ 1, &uval
);
3741 tp
->traceframe_usage
+= uval
;
3743 utp
->traceframe_usage
+= uval
;
3744 /* Ignore any extra, allowing for future extensions. */
3747 /* Given a line of text defining a part of a tracepoint, parse it into
3748 an "uploaded tracepoint". */
3751 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3755 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3758 char *cond
, *srctype
, *buf
;
3759 struct uploaded_tp
*utp
= NULL
;
3762 /* Both tracepoint and action definitions start with the same number
3763 and address sequence. */
3765 p
= unpack_varlen_hex (p
, &num
);
3766 p
++; /* skip a colon */
3767 p
= unpack_varlen_hex (p
, &addr
);
3768 p
++; /* skip a colon */
3771 enabled
= (*p
++ == 'E');
3772 p
++; /* skip a colon */
3773 p
= unpack_varlen_hex (p
, &step
);
3774 p
++; /* skip a colon */
3775 p
= unpack_varlen_hex (p
, &pass
);
3776 type
= bp_tracepoint
;
3778 /* Thumb through optional fields. */
3781 p
++; /* skip a colon */
3784 type
= bp_fast_tracepoint
;
3786 p
= unpack_varlen_hex (p
, &orig_size
);
3790 type
= bp_static_tracepoint
;
3796 p
= unpack_varlen_hex (p
, &xlen
);
3797 p
++; /* skip a comma */
3798 cond
= (char *) xmalloc (2 * xlen
+ 1);
3799 strncpy (cond
, p
, 2 * xlen
);
3800 cond
[2 * xlen
] = '\0';
3804 warning (_("Unrecognized char '%c' in tracepoint "
3805 "definition, skipping rest"), *p
);
3807 utp
= get_uploaded_tp (num
, addr
, utpp
);
3809 utp
->enabled
= enabled
;
3814 else if (piece
== 'A')
3816 utp
= get_uploaded_tp (num
, addr
, utpp
);
3817 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3819 else if (piece
== 'S')
3821 utp
= get_uploaded_tp (num
, addr
, utpp
);
3822 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3824 else if (piece
== 'Z')
3826 /* Parse a chunk of source form definition. */
3827 utp
= get_uploaded_tp (num
, addr
, utpp
);
3829 p
= strchr (p
, ':');
3830 p
++; /* skip a colon */
3831 p
= unpack_varlen_hex (p
, &start
);
3832 p
++; /* skip a colon */
3833 p
= unpack_varlen_hex (p
, &xlen
);
3834 p
++; /* skip a colon */
3836 buf
= (char *) alloca (strlen (line
));
3838 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3841 if (startswith (srctype
, "at:"))
3842 utp
->at_string
= xstrdup (buf
);
3843 else if (startswith (srctype
, "cond:"))
3844 utp
->cond_string
= xstrdup (buf
);
3845 else if (startswith (srctype
, "cmd:"))
3846 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3848 else if (piece
== 'V')
3850 utp
= get_uploaded_tp (num
, addr
, utpp
);
3852 parse_tracepoint_status (p
, NULL
, utp
);
3856 /* Don't error out, the target might be sending us optional
3857 info that we don't care about. */
3858 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3862 /* Convert a textual description of a trace state variable into an
3866 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3869 ULONGEST num
, initval
, builtin
;
3871 struct uploaded_tsv
*utsv
= NULL
;
3873 buf
= (char *) alloca (strlen (line
));
3876 p
= unpack_varlen_hex (p
, &num
);
3877 p
++; /* skip a colon */
3878 p
= unpack_varlen_hex (p
, &initval
);
3879 p
++; /* skip a colon */
3880 p
= unpack_varlen_hex (p
, &builtin
);
3881 p
++; /* skip a colon */
3882 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3885 utsv
= get_uploaded_tsv (num
, utsvp
);
3886 utsv
->initial_value
= initval
;
3887 utsv
->builtin
= builtin
;
3888 utsv
->name
= xstrdup (buf
);
3892 free_current_marker (void *arg
)
3894 struct static_tracepoint_marker
**marker_p
3895 = (struct static_tracepoint_marker
**) arg
;
3897 if (*marker_p
!= NULL
)
3899 release_static_tracepoint_marker (*marker_p
);
3906 /* Given a line of text defining a static tracepoint marker, parse it
3907 into a "static tracepoint marker" object. Throws an error is
3908 parsing fails. If PP is non-null, it points to one past the end of
3909 the parsed marker definition. */
3912 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
3913 struct static_tracepoint_marker
*marker
)
3920 p
= unpack_varlen_hex (p
, &addr
);
3921 p
++; /* skip a colon */
3923 marker
->gdbarch
= target_gdbarch ();
3924 marker
->address
= (CORE_ADDR
) addr
;
3926 endp
= strchr (p
, ':');
3928 error (_("bad marker definition: %s"), line
);
3930 marker
->str_id
= (char *) xmalloc (endp
- p
+ 1);
3931 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
3932 marker
->str_id
[end
] = '\0';
3935 p
++; /* skip a colon */
3937 marker
->extra
= (char *) xmalloc (strlen (p
) + 1);
3938 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
3939 marker
->extra
[end
] = '\0';
3945 /* Release a static tracepoint marker's contents. Note that the
3946 object itself isn't released here. There objects are usually on
3950 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
3952 xfree (marker
->str_id
);
3953 marker
->str_id
= NULL
;
3956 /* Print MARKER to gdb_stdout. */
3959 print_one_static_tracepoint_marker (int count
,
3960 struct static_tracepoint_marker
*marker
)
3964 char wrap_indent
[80];
3965 char extra_field_indent
[80];
3966 struct ui_out
*uiout
= current_uiout
;
3967 struct cleanup
*bkpt_chain
;
3968 VEC(breakpoint_p
) *tracepoints
;
3970 struct symtab_and_line sal
;
3974 sal
.pc
= marker
->address
;
3976 tracepoints
= static_tracepoints_here (marker
->address
);
3978 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
3980 /* A counter field to help readability. This is not a stable
3982 ui_out_field_int (uiout
, "count", count
);
3984 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
3986 ui_out_field_fmt (uiout
, "enabled", "%c",
3987 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
3988 ui_out_spaces (uiout
, 2);
3990 strcpy (wrap_indent
, " ");
3992 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
3993 strcat (wrap_indent
, " ");
3995 strcat (wrap_indent
, " ");
3997 strcpy (extra_field_indent
, " ");
3999 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4001 sal
= find_pc_line (marker
->address
, 0);
4002 sym
= find_pc_sect_function (marker
->address
, NULL
);
4005 ui_out_text (uiout
, "in ");
4006 ui_out_field_string (uiout
, "func",
4007 SYMBOL_PRINT_NAME (sym
));
4008 ui_out_wrap_hint (uiout
, wrap_indent
);
4009 ui_out_text (uiout
, " at ");
4012 ui_out_field_skip (uiout
, "func");
4014 if (sal
.symtab
!= NULL
)
4016 ui_out_field_string (uiout
, "file",
4017 symtab_to_filename_for_display (sal
.symtab
));
4018 ui_out_text (uiout
, ":");
4020 if (ui_out_is_mi_like_p (uiout
))
4022 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4024 ui_out_field_string (uiout
, "fullname", fullname
);
4027 ui_out_field_skip (uiout
, "fullname");
4029 ui_out_field_int (uiout
, "line", sal
.line
);
4033 ui_out_field_skip (uiout
, "fullname");
4034 ui_out_field_skip (uiout
, "line");
4037 ui_out_text (uiout
, "\n");
4038 ui_out_text (uiout
, extra_field_indent
);
4039 ui_out_text (uiout
, _("Data: \""));
4040 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4041 ui_out_text (uiout
, "\"\n");
4043 if (!VEC_empty (breakpoint_p
, tracepoints
))
4045 struct cleanup
*cleanup_chain
;
4047 struct breakpoint
*b
;
4049 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4052 ui_out_text (uiout
, extra_field_indent
);
4053 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4054 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4057 ui_out_text (uiout
, ", ");
4058 ui_out_text (uiout
, "#");
4059 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4062 do_cleanups (cleanup_chain
);
4064 if (ui_out_is_mi_like_p (uiout
))
4065 ui_out_field_int (uiout
, "number-of-tracepoints",
4066 VEC_length(breakpoint_p
, tracepoints
));
4068 ui_out_text (uiout
, "\n");
4070 VEC_free (breakpoint_p
, tracepoints
);
4072 do_cleanups (bkpt_chain
);
4076 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4078 VEC(static_tracepoint_marker_p
) *markers
;
4079 struct cleanup
*old_chain
;
4080 struct static_tracepoint_marker
*marker
;
4081 struct ui_out
*uiout
= current_uiout
;
4084 /* We don't have to check target_can_use_agent and agent's capability on
4085 static tracepoint here, in order to be compatible with older GDBserver.
4086 We don't check USE_AGENT is true or not, because static tracepoints
4087 don't work without in-process agent, so we don't bother users to type
4088 `set agent on' when to use static tracepoint. */
4091 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4092 "StaticTracepointMarkersTable");
4094 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4096 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4098 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4099 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4100 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4102 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4103 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4105 ui_out_table_body (uiout
);
4107 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4108 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4111 VEC_iterate (static_tracepoint_marker_p
,
4112 markers
, i
, marker
);
4115 print_one_static_tracepoint_marker (i
+ 1, marker
);
4116 release_static_tracepoint_marker (marker
);
4119 do_cleanups (old_chain
);
4122 /* The $_sdata convenience variable is a bit special. We don't know
4123 for sure type of the value until we actually have a chance to fetch
4124 the data --- the size of the object depends on what has been
4125 collected. We solve this by making $_sdata be an internalvar that
4126 creates a new value on access. */
4128 /* Return a new value with the correct type for the sdata object of
4129 the current trace frame. Return a void value if there's no object
4132 static struct value
*
4133 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4139 /* We need to read the whole object before we know its size. */
4140 size
= target_read_alloc (¤t_target
,
4141 TARGET_OBJECT_STATIC_TRACE_DATA
,
4148 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4150 v
= allocate_value (type
);
4151 memcpy (value_contents_raw (v
), buf
, size
);
4156 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4159 #if !defined(HAVE_LIBEXPAT)
4161 struct traceframe_info
*
4162 parse_traceframe_info (const char *tframe_info
)
4164 static int have_warned
;
4169 warning (_("Can not parse XML trace frame info; XML support "
4170 "was disabled at compile time"));
4176 #else /* HAVE_LIBEXPAT */
4178 #include "xml-support.h"
4180 /* Handle the start of a <memory> element. */
4183 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4184 const struct gdb_xml_element
*element
,
4185 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4187 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
4188 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4189 ULONGEST
*start_p
, *length_p
;
4192 = (ULONGEST
*) xml_find_attribute (attributes
, "start")->value
;
4194 = (ULONGEST
*) xml_find_attribute (attributes
, "length")->value
;
4196 r
->start
= *start_p
;
4197 r
->length
= *length_p
;
4200 /* Handle the start of a <tvar> element. */
4203 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
4204 const struct gdb_xml_element
*element
,
4206 VEC(gdb_xml_value_s
) *attributes
)
4208 struct traceframe_info
*info
= (struct traceframe_info
*) user_data
;
4209 const char *id_attrib
4210 = (const char *) xml_find_attribute (attributes
, "id")->value
;
4211 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
4213 VEC_safe_push (int, info
->tvars
, id
);
4216 /* Discard the constructed trace frame info (if an error occurs). */
4219 free_result (void *p
)
4221 struct traceframe_info
*result
= (struct traceframe_info
*) p
;
4223 free_traceframe_info (result
);
4226 /* The allowed elements and attributes for an XML memory map. */
4228 static const struct gdb_xml_attribute memory_attributes
[] = {
4229 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4230 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4231 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4234 static const struct gdb_xml_attribute tvar_attributes
[] = {
4235 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
4236 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4239 static const struct gdb_xml_element traceframe_info_children
[] = {
4240 { "memory", memory_attributes
, NULL
,
4241 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4242 traceframe_info_start_memory
, NULL
},
4243 { "tvar", tvar_attributes
, NULL
,
4244 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4245 traceframe_info_start_tvar
, NULL
},
4246 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4249 static const struct gdb_xml_element traceframe_info_elements
[] = {
4250 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4252 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4255 /* Parse a traceframe-info XML document. */
4257 struct traceframe_info
*
4258 parse_traceframe_info (const char *tframe_info
)
4260 struct traceframe_info
*result
;
4261 struct cleanup
*back_to
;
4263 result
= XCNEW (struct traceframe_info
);
4264 back_to
= make_cleanup (free_result
, result
);
4266 if (gdb_xml_parse_quick (_("trace frame info"),
4267 "traceframe-info.dtd", traceframe_info_elements
,
4268 tframe_info
, result
) == 0)
4270 /* Parsed successfully, keep the result. */
4271 discard_cleanups (back_to
);
4276 do_cleanups (back_to
);
4280 #endif /* HAVE_LIBEXPAT */
4282 /* Returns the traceframe_info object for the current traceframe.
4283 This is where we avoid re-fetching the object from the target if we
4284 already have it cached. */
4286 struct traceframe_info
*
4287 get_traceframe_info (void)
4289 if (traceframe_info
== NULL
)
4290 traceframe_info
= target_traceframe_info ();
4292 return traceframe_info
;
4295 /* If the target supports the query, return in RESULT the set of
4296 collected memory in the current traceframe, found within the LEN
4297 bytes range starting at MEMADDR. Returns true if the target
4298 supports the query, otherwise returns false, and RESULT is left
4302 traceframe_available_memory (VEC(mem_range_s
) **result
,
4303 CORE_ADDR memaddr
, ULONGEST len
)
4305 struct traceframe_info
*info
= get_traceframe_info ();
4309 struct mem_range
*r
;
4314 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4315 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4317 ULONGEST lo1
, hi1
, lo2
, hi2
;
4318 struct mem_range
*nr
;
4321 hi1
= memaddr
+ len
;
4324 hi2
= r
->start
+ r
->length
;
4326 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4328 nr
->start
= std::max (lo1
, lo2
);
4329 nr
->length
= std::min (hi1
, hi2
) - nr
->start
;
4332 normalize_mem_ranges (*result
);
4339 /* Implementation of `sdata' variable. */
4341 static const struct internalvar_funcs sdata_funcs
=
4348 /* module initialization */
4350 _initialize_tracepoint (void)
4352 struct cmd_list_element
*c
;
4354 /* Explicitly create without lookup, since that tries to create a
4355 value with a void typed value, and when we get here, gdbarch
4356 isn't initialized yet. At this point, we're quite sure there
4357 isn't another convenience variable of the same name. */
4358 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4360 traceframe_number
= -1;
4361 tracepoint_number
= -1;
4363 add_info ("scope", scope_info
,
4364 _("List the variables local to a scope"));
4366 add_cmd ("tracepoints", class_trace
, NULL
,
4367 _("Tracing of program execution without stopping the program."),
4370 add_com ("tdump", class_trace
, trace_dump_command
,
4371 _("Print everything collected at the current tracepoint."));
4373 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4374 Define a trace state variable.\n\
4375 Argument is a $-prefixed name, optionally followed\n\
4376 by '=' and an expression that sets the initial value\n\
4377 at the start of tracing."));
4378 set_cmd_completer (c
, expression_completer
);
4380 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4381 Delete one or more trace state variables.\n\
4382 Arguments are the names of the variables to delete.\n\
4383 If no arguments are supplied, delete all variables."), &deletelist
);
4384 /* FIXME add a trace variable completer. */
4386 add_info ("tvariables", tvariables_info
, _("\
4387 Status of trace state variables and their values.\n\
4390 add_info ("static-tracepoint-markers",
4391 info_static_tracepoint_markers_command
, _("\
4392 List target static tracepoints markers.\n\
4395 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4396 Select a trace frame;\n\
4397 No argument means forward by one frame; '-' means backward by one frame."),
4398 &tfindlist
, "tfind ", 1, &cmdlist
);
4400 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4401 Select a trace frame whose PC is outside the given range (exclusive).\n\
4402 Usage: tfind outside addr1, addr2"),
4405 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4406 Select a trace frame whose PC is in the given range (inclusive).\n\
4407 Usage: tfind range addr1,addr2"),
4410 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4411 Select a trace frame by source line.\n\
4412 Argument can be a line number (with optional source file),\n\
4413 a function name, or '*' followed by an address.\n\
4414 Default argument is 'the next source line that was traced'."),
4417 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4418 Select a trace frame by tracepoint number.\n\
4419 Default is the tracepoint for the current trace frame."),
4422 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4423 Select a trace frame by PC.\n\
4424 Default is the current PC, or the PC of the current trace frame."),
4427 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4428 De-select any trace frame and resume 'live' debugging."),
4431 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4433 add_cmd ("start", class_trace
, trace_find_start_command
,
4434 _("Select the first trace frame in the trace buffer."),
4437 add_com ("tstatus", class_trace
, trace_status_command
,
4438 _("Display the status of the current trace data collection."));
4440 add_com ("tstop", class_trace
, trace_stop_command
, _("\
4441 Stop trace data collection.\n\
4442 Usage: tstop [ <notes> ... ]\n\
4443 Any arguments supplied are recorded with the trace as a stop reason and\n\
4444 reported by tstatus (if the target supports trace notes)."));
4446 add_com ("tstart", class_trace
, trace_start_command
, _("\
4447 Start trace data collection.\n\
4448 Usage: tstart [ <notes> ... ]\n\
4449 Any arguments supplied are recorded with the trace as a note and\n\
4450 reported by tstatus (if the target supports trace notes)."));
4452 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4453 Ends a list of commands or actions.\n\
4454 Several GDB commands allow you to enter a list of commands or actions.\n\
4455 Entering \"end\" on a line by itself is the normal way to terminate\n\
4457 Note: the \"end\" command cannot be used at the gdb prompt."));
4459 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4460 Specify single-stepping behavior at a tracepoint.\n\
4461 Argument is number of instructions to trace in single-step mode\n\
4462 following the tracepoint. This command is normally followed by\n\
4463 one or more \"collect\" commands, to specify what to collect\n\
4464 while single-stepping.\n\n\
4465 Note: this command can only be used in a tracepoint \"actions\" list."));
4467 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4468 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4470 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4471 Specify one or more data items to be collected at a tracepoint.\n\
4472 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4473 collect all data (variables, registers) referenced by that expression.\n\
4474 Also accepts the following special arguments:\n\
4475 $regs -- all registers.\n\
4476 $args -- all function arguments.\n\
4477 $locals -- all variables local to the block/function scope.\n\
4478 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4479 Note: this command can only be used in a tracepoint \"actions\" list."));
4481 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4482 Specify one or more expressions to be evaluated at a tracepoint.\n\
4483 Accepts a comma-separated list of (one or more) expressions.\n\
4484 The result of each evaluation will be discarded.\n\
4485 Note: this command can only be used in a tracepoint \"actions\" list."));
4487 add_com ("actions", class_trace
, trace_actions_command
, _("\
4488 Specify the actions to be taken at a tracepoint.\n\
4489 Tracepoint actions may include collecting of specified data,\n\
4490 single-stepping, or enabling/disabling other tracepoints,\n\
4491 depending on target's capabilities."));
4493 default_collect
= xstrdup ("");
4494 add_setshow_string_cmd ("default-collect", class_trace
,
4495 &default_collect
, _("\
4496 Set the list of expressions to collect by default"), _("\
4497 Show the list of expressions to collect by default"), NULL
,
4499 &setlist
, &showlist
);
4501 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4502 &disconnected_tracing
, _("\
4503 Set whether tracing continues after GDB disconnects."), _("\
4504 Show whether tracing continues after GDB disconnects."), _("\
4505 Use this to continue a tracing run even if GDB disconnects\n\
4506 or detaches from the target. You can reconnect later and look at\n\
4507 trace data collected in the meantime."),
4508 set_disconnected_tracing
,
4513 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4514 &circular_trace_buffer
, _("\
4515 Set target's use of circular trace buffer."), _("\
4516 Show target's use of circular trace buffer."), _("\
4517 Use this to make the trace buffer into a circular buffer,\n\
4518 which will discard traceframes (oldest first) instead of filling\n\
4519 up and stopping the trace run."),
4520 set_circular_trace_buffer
,
4525 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4526 &trace_buffer_size
, _("\
4527 Set requested size of trace buffer."), _("\
4528 Show requested size of trace buffer."), _("\
4529 Use this to choose a size for the trace buffer. Some targets\n\
4530 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4531 disables any attempt to set the buffer size and lets the target choose."),
4532 set_trace_buffer_size
, NULL
,
4533 &setlist
, &showlist
);
4535 add_setshow_string_cmd ("trace-user", class_trace
,
4537 Set the user name to use for current and future trace runs"), _("\
4538 Show the user name to use for current and future trace runs"), NULL
,
4539 set_trace_user
, NULL
,
4540 &setlist
, &showlist
);
4542 add_setshow_string_cmd ("trace-notes", class_trace
,
4544 Set notes string to use for current and future trace runs"), _("\
4545 Show the notes string to use for current and future trace runs"), NULL
,
4546 set_trace_notes
, NULL
,
4547 &setlist
, &showlist
);
4549 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4550 &trace_stop_notes
, _("\
4551 Set notes string to use for future tstop commands"), _("\
4552 Show the notes string to use for future tstop commands"), NULL
,
4553 set_trace_stop_notes
, NULL
,
4554 &setlist
, &showlist
);