1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2015 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"
59 /* readline include files */
60 #include "readline/readline.h"
61 #include "readline/history.h"
63 /* readline defines this. */
68 /* Maximum length of an agent aexpression.
69 This accounts for the fact that packets are limited to 400 bytes
70 (which includes everything -- including the checksum), and assumes
71 the worst case of maximum length for each of the pieces of a
74 NOTE: expressions get mem2hex'ed otherwise this would be twice as
75 large. (400 - 31)/2 == 184 */
76 #define MAX_AGENT_EXPR_LEN 184
78 /* A hook used to notify the UI of tracepoint operations. */
80 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
81 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
86 This module defines the following debugger commands:
87 trace : set a tracepoint on a function, line, or address.
88 info trace : list all debugger-defined tracepoints.
89 delete trace : delete one or more tracepoints.
90 enable trace : enable one or more tracepoints.
91 disable trace : disable one or more tracepoints.
92 actions : specify actions to be taken at a tracepoint.
93 passcount : specify a pass count for a tracepoint.
94 tstart : start a trace experiment.
95 tstop : stop a trace experiment.
96 tstatus : query the status of a trace experiment.
97 tfind : find a trace frame in the trace buffer.
98 tdump : print everything collected at the current tracepoint.
99 save-tracepoints : write tracepoint setup into a file.
101 This module defines the following user-visible debugger variables:
102 $trace_frame : sequence number of trace frame currently being debugged.
103 $trace_line : source line of trace frame currently being debugged.
104 $trace_file : source file of trace frame currently being debugged.
105 $tracepoint : tracepoint number of trace frame currently being debugged.
109 /* ======= Important global variables: ======= */
111 /* The list of all trace state variables. We don't retain pointers to
112 any of these for any reason - API is by name or number only - so it
113 works to have a vector of objects. */
115 typedef struct trace_state_variable tsv_s
;
118 static VEC(tsv_s
) *tvariables
;
120 /* The next integer to assign to a variable. */
122 static int next_tsv_number
= 1;
124 /* Number of last traceframe collected. */
125 static int traceframe_number
;
127 /* Tracepoint for last traceframe collected. */
128 static int tracepoint_number
;
130 /* The traceframe info of the current traceframe. NULL if we haven't
131 yet attempted to fetch it, or if the target does not support
132 fetching this object, or if we're not inspecting a traceframe
134 static struct traceframe_info
*traceframe_info
;
136 /* Tracing command lists. */
137 static struct cmd_list_element
*tfindlist
;
139 /* List of expressions to collect by default at each tracepoint hit. */
140 char *default_collect
= "";
142 static int disconnected_tracing
;
144 /* This variable controls whether we ask the target for a linear or
145 circular trace buffer. */
147 static int circular_trace_buffer
;
149 /* This variable is the requested trace buffer size, or -1 to indicate
150 that we don't care and leave it up to the target to set a size. */
152 static int trace_buffer_size
= -1;
154 /* Textual notes applying to the current and/or future trace runs. */
156 char *trace_user
= NULL
;
158 /* Textual notes applying to the current and/or future trace runs. */
160 char *trace_notes
= NULL
;
162 /* Textual notes applying to the stopping of a trace. */
164 char *trace_stop_notes
= NULL
;
166 /* ======= Important command functions: ======= */
167 static void trace_actions_command (char *, int);
168 static void trace_start_command (char *, int);
169 static void trace_stop_command (char *, int);
170 static void trace_status_command (char *, int);
171 static void trace_find_command (char *, int);
172 static void trace_find_pc_command (char *, int);
173 static void trace_find_tracepoint_command (char *, int);
174 static void trace_find_line_command (char *, int);
175 static void trace_find_range_command (char *, int);
176 static void trace_find_outside_command (char *, int);
177 static void trace_dump_command (char *, int);
179 /* support routines */
181 struct collection_list
;
182 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
183 static char *mem2hex (gdb_byte
*, char *, int);
184 static void add_register (struct collection_list
*collection
,
187 static struct command_line
*
188 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
190 extern void _initialize_tracepoint (void);
192 static struct trace_status trace_status
;
194 const char *stop_reason_names
[] = {
204 struct trace_status
*
205 current_trace_status (void)
207 return &trace_status
;
213 free_traceframe_info (struct traceframe_info
*info
)
217 VEC_free (mem_range_s
, info
->memory
);
218 VEC_free (int, info
->tvars
);
224 /* Free and clear the traceframe info cache of the current
228 clear_traceframe_info (void)
230 free_traceframe_info (traceframe_info
);
231 traceframe_info
= NULL
;
234 /* Set traceframe number to NUM. */
236 set_traceframe_num (int num
)
238 traceframe_number
= num
;
239 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
242 /* Set tracepoint number to NUM. */
244 set_tracepoint_num (int num
)
246 tracepoint_number
= num
;
247 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
250 /* Set externally visible debug variables for querying/printing
251 the traceframe context (line, function, file). */
254 set_traceframe_context (struct frame_info
*trace_frame
)
257 struct symbol
*traceframe_fun
;
258 struct symtab_and_line traceframe_sal
;
260 /* Save as globals for internal use. */
261 if (trace_frame
!= NULL
262 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
264 traceframe_sal
= find_pc_line (trace_pc
, 0);
265 traceframe_fun
= find_pc_function (trace_pc
);
267 /* Save linenumber as "$trace_line", a debugger variable visible to
269 set_internalvar_integer (lookup_internalvar ("trace_line"),
270 traceframe_sal
.line
);
274 init_sal (&traceframe_sal
);
275 traceframe_fun
= NULL
;
276 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
279 /* Save func name as "$trace_func", a debugger variable visible to
281 if (traceframe_fun
== NULL
282 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
283 clear_internalvar (lookup_internalvar ("trace_func"));
285 set_internalvar_string (lookup_internalvar ("trace_func"),
286 SYMBOL_LINKAGE_NAME (traceframe_fun
));
288 /* Save file name as "$trace_file", a debugger variable visible to
290 if (traceframe_sal
.symtab
== NULL
)
291 clear_internalvar (lookup_internalvar ("trace_file"));
293 set_internalvar_string (lookup_internalvar ("trace_file"),
294 symtab_to_filename_for_display (traceframe_sal
.symtab
));
297 /* Create a new trace state variable with the given name. */
299 struct trace_state_variable
*
300 create_trace_state_variable (const char *name
)
302 struct trace_state_variable tsv
;
304 memset (&tsv
, 0, sizeof (tsv
));
305 tsv
.name
= xstrdup (name
);
306 tsv
.number
= next_tsv_number
++;
307 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
310 /* Look for a trace state variable of the given name. */
312 struct trace_state_variable
*
313 find_trace_state_variable (const char *name
)
315 struct trace_state_variable
*tsv
;
318 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
319 if (strcmp (name
, tsv
->name
) == 0)
325 /* Look for a trace state variable of the given number. Return NULL if
328 struct trace_state_variable
*
329 find_trace_state_variable_by_number (int number
)
331 struct trace_state_variable
*tsv
;
334 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
335 if (tsv
->number
== number
)
342 delete_trace_state_variable (const char *name
)
344 struct trace_state_variable
*tsv
;
347 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
348 if (strcmp (name
, tsv
->name
) == 0)
350 observer_notify_tsv_deleted (tsv
);
352 xfree ((void *)tsv
->name
);
353 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
358 warning (_("No trace variable named \"$%s\", not deleting"), name
);
361 /* Throws an error if NAME is not valid syntax for a trace state
365 validate_trace_state_variable_name (const char *name
)
370 error (_("Must supply a non-empty variable name"));
372 /* All digits in the name is reserved for value history
374 for (p
= name
; isdigit (*p
); p
++)
377 error (_("$%s is not a valid trace state variable name"), name
);
379 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
382 error (_("$%s is not a valid trace state variable name"), name
);
385 /* The 'tvariable' command collects a name and optional expression to
386 evaluate into an initial value. */
389 trace_variable_command (char *args
, int from_tty
)
391 struct cleanup
*old_chain
;
393 struct trace_state_variable
*tsv
;
397 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
399 /* Only allow two syntaxes; "$name" and "$name=value". */
400 p
= skip_spaces (args
);
403 error (_("Name of trace variable should start with '$'"));
406 while (isalnum (*p
) || *p
== '_')
408 name
= savestring (name
, p
- name
);
409 old_chain
= make_cleanup (xfree
, name
);
412 if (*p
!= '=' && *p
!= '\0')
413 error (_("Syntax must be $NAME [ = EXPR ]"));
415 validate_trace_state_variable_name (name
);
418 initval
= value_as_long (parse_and_eval (++p
));
420 /* If the variable already exists, just change its initial value. */
421 tsv
= find_trace_state_variable (name
);
424 if (tsv
->initial_value
!= initval
)
426 tsv
->initial_value
= initval
;
427 observer_notify_tsv_modified (tsv
);
429 printf_filtered (_("Trace state variable $%s "
430 "now has initial value %s.\n"),
431 tsv
->name
, plongest (tsv
->initial_value
));
432 do_cleanups (old_chain
);
436 /* Create a new variable. */
437 tsv
= create_trace_state_variable (name
);
438 tsv
->initial_value
= initval
;
440 observer_notify_tsv_created (tsv
);
442 printf_filtered (_("Trace state variable $%s "
443 "created, with initial value %s.\n"),
444 tsv
->name
, plongest (tsv
->initial_value
));
446 do_cleanups (old_chain
);
450 delete_trace_variable_command (char *args
, int from_tty
)
454 struct cleanup
*back_to
;
458 if (query (_("Delete all trace state variables? ")))
459 VEC_free (tsv_s
, tvariables
);
461 observer_notify_tsv_deleted (NULL
);
465 argv
= gdb_buildargv (args
);
466 back_to
= make_cleanup_freeargv (argv
);
468 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
470 if (*argv
[ix
] == '$')
471 delete_trace_state_variable (argv
[ix
] + 1);
473 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
476 do_cleanups (back_to
);
482 tvariables_info_1 (void)
484 struct trace_state_variable
*tsv
;
487 struct cleanup
*back_to
;
488 struct ui_out
*uiout
= current_uiout
;
490 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
492 printf_filtered (_("No trace state variables.\n"));
496 /* Try to acquire values from the target. */
497 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
498 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
501 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
502 count
, "trace-variables");
503 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
504 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
505 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
507 ui_out_table_body (uiout
);
509 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
511 struct cleanup
*back_to2
;
515 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
517 name
= concat ("$", tsv
->name
, (char *) NULL
);
518 make_cleanup (xfree
, name
);
519 ui_out_field_string (uiout
, "name", name
);
520 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
522 if (tsv
->value_known
)
523 c
= plongest (tsv
->value
);
524 else if (ui_out_is_mi_like_p (uiout
))
525 /* For MI, we prefer not to use magic string constants, but rather
526 omit the field completely. The difference between unknown and
527 undefined does not seem important enough to represent. */
529 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
530 /* The value is/was defined, but we don't have it. */
533 /* It is not meaningful to ask about the value. */
536 ui_out_field_string (uiout
, "current", c
);
537 ui_out_text (uiout
, "\n");
539 do_cleanups (back_to2
);
542 do_cleanups (back_to
);
545 /* List all the trace state variables. */
548 tvariables_info (char *args
, int from_tty
)
550 tvariables_info_1 ();
553 /* Stash definitions of tsvs into the given file. */
556 save_trace_state_variables (struct ui_file
*fp
)
558 struct trace_state_variable
*tsv
;
561 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
563 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
564 if (tsv
->initial_value
)
565 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
566 fprintf_unfiltered (fp
, "\n");
570 /* ACTIONS functions: */
572 /* The three functions:
573 collect_pseudocommand,
574 while_stepping_pseudocommand, and
575 end_actions_pseudocommand
576 are placeholders for "commands" that are actually ONLY to be used
577 within a tracepoint action list. If the actual function is ever called,
578 it means that somebody issued the "command" at the top level,
579 which is always an error. */
582 end_actions_pseudocommand (char *args
, int from_tty
)
584 error (_("This command cannot be used at the top level."));
588 while_stepping_pseudocommand (char *args
, int from_tty
)
590 error (_("This command can only be used in a tracepoint actions list."));
594 collect_pseudocommand (char *args
, int from_tty
)
596 error (_("This command can only be used in a tracepoint actions list."));
600 teval_pseudocommand (char *args
, int from_tty
)
602 error (_("This command can only be used in a tracepoint actions list."));
605 /* Parse any collection options, such as /s for strings. */
608 decode_agent_options (const char *exp
, int *trace_string
)
610 struct value_print_options opts
;
617 /* Call this to borrow the print elements default for collection
619 get_user_print_options (&opts
);
624 if (target_supports_string_tracing ())
626 /* Allow an optional decimal number giving an explicit maximum
627 string length, defaulting it to the "print elements" value;
628 so "collect/s80 mystr" gets at most 80 bytes of string. */
629 *trace_string
= opts
.print_max
;
631 if (*exp
>= '0' && *exp
<= '9')
632 *trace_string
= atoi (exp
);
633 while (*exp
>= '0' && *exp
<= '9')
637 error (_("Target does not support \"/s\" option for string tracing."));
640 error (_("Undefined collection format \"%c\"."), *exp
);
642 exp
= skip_spaces_const (exp
);
647 /* Enter a list of actions for a tracepoint. */
649 trace_actions_command (char *args
, int from_tty
)
651 struct tracepoint
*t
;
652 struct command_line
*l
;
654 t
= get_tracepoint_by_number (&args
, NULL
);
658 xstrprintf ("Enter actions for tracepoint %d, one per line.",
660 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
662 l
= read_command_lines (tmpbuf
, from_tty
, 1,
663 check_tracepoint_command
, t
);
664 do_cleanups (cleanups
);
665 breakpoint_set_commands (&t
->base
, l
);
667 /* else just return */
670 /* Report the results of checking the agent expression, as errors or
674 report_agent_reqs_errors (struct agent_expr
*aexpr
)
676 /* All of the "flaws" are serious bytecode generation issues that
677 should never occur. */
678 if (aexpr
->flaw
!= agent_flaw_none
)
679 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
681 /* If analysis shows a stack underflow, GDB must have done something
682 badly wrong in its bytecode generation. */
683 if (aexpr
->min_height
< 0)
684 internal_error (__FILE__
, __LINE__
,
685 _("expression has min height < 0"));
687 /* Issue this error if the stack is predicted to get too deep. The
688 limit is rather arbitrary; a better scheme might be for the
689 target to report how much stack it will have available. The
690 depth roughly corresponds to parenthesization, so a limit of 20
691 amounts to 20 levels of expression nesting, which is actually
692 a pretty big hairy expression. */
693 if (aexpr
->max_height
> 20)
694 error (_("Expression is too complicated."));
697 /* worker function */
699 validate_actionline (const char *line
, struct breakpoint
*b
)
701 struct cmd_list_element
*c
;
702 struct expression
*exp
= NULL
;
703 struct cleanup
*old_chain
= NULL
;
706 struct bp_location
*loc
;
707 struct agent_expr
*aexpr
;
708 struct tracepoint
*t
= (struct tracepoint
*) b
;
710 /* If EOF is typed, *line is NULL. */
714 p
= skip_spaces_const (line
);
716 /* Symbol lookup etc. */
717 if (*p
== '\0') /* empty line: just prompt for another line. */
720 if (*p
== '#') /* comment line */
723 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
725 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
727 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
729 int trace_string
= 0;
732 p
= decode_agent_options (p
, &trace_string
);
735 { /* Repeat over a comma-separated list. */
736 QUIT
; /* Allow user to bail out with ^C. */
737 p
= skip_spaces_const (p
);
739 if (*p
== '$') /* Look for special pseudo-symbols. */
741 if (0 == strncasecmp ("reg", p
+ 1, 3)
742 || 0 == strncasecmp ("arg", p
+ 1, 3)
743 || 0 == strncasecmp ("loc", p
+ 1, 3)
744 || 0 == strncasecmp ("_ret", p
+ 1, 4)
745 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
750 /* else fall thru, treat p as an expression and parse it! */
753 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
756 exp
= parse_exp_1 (&p
, loc
->address
,
757 block_for_pc (loc
->address
), 1);
758 old_chain
= make_cleanup (free_current_contents
, &exp
);
760 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
762 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
764 error (_("constant `%s' (value %s) "
765 "will not be collected."),
766 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
767 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
769 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
770 == LOC_OPTIMIZED_OUT
)
772 error (_("`%s' is optimized away "
773 "and cannot be collected."),
774 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
778 /* We have something to collect, make sure that the expr to
779 bytecode translator can handle it and that it's not too
781 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
782 make_cleanup_free_agent_expr (aexpr
);
784 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
785 error (_("Expression is too complicated."));
789 report_agent_reqs_errors (aexpr
);
791 do_cleanups (old_chain
);
794 while (p
&& *p
++ == ',');
797 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
800 { /* Repeat over a comma-separated list. */
801 QUIT
; /* Allow user to bail out with ^C. */
802 p
= skip_spaces_const (p
);
805 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
809 /* Only expressions are allowed for this action. */
810 exp
= parse_exp_1 (&p
, loc
->address
,
811 block_for_pc (loc
->address
), 1);
812 old_chain
= make_cleanup (free_current_contents
, &exp
);
814 /* We have something to evaluate, make sure that the expr to
815 bytecode translator can handle it and that it's not too
817 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
818 make_cleanup_free_agent_expr (aexpr
);
820 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
821 error (_("Expression is too complicated."));
824 report_agent_reqs_errors (aexpr
);
826 do_cleanups (old_chain
);
829 while (p
&& *p
++ == ',');
832 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
836 p
= skip_spaces_const (p
);
837 t
->step_count
= strtol (p
, &endp
, 0);
838 if (endp
== p
|| t
->step_count
== 0)
839 error (_("while-stepping step count `%s' is malformed."), line
);
843 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
847 error (_("`%s' is not a supported tracepoint action."), line
);
851 memrange_absolute
= -1
854 /* MEMRANGE functions: */
856 static int memrange_cmp (const void *, const void *);
858 /* Compare memranges for qsort. */
860 memrange_cmp (const void *va
, const void *vb
)
862 const struct memrange
*a
= va
, *b
= vb
;
864 if (a
->type
< b
->type
)
866 if (a
->type
> b
->type
)
868 if (a
->type
== memrange_absolute
)
870 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
872 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
877 if (a
->start
< b
->start
)
879 if (a
->start
> b
->start
)
885 /* Sort the memrange list using qsort, and merge adjacent memranges. */
887 memrange_sortmerge (struct collection_list
*memranges
)
891 qsort (memranges
->list
, memranges
->next_memrange
,
892 sizeof (struct memrange
), memrange_cmp
);
893 if (memranges
->next_memrange
> 0)
895 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
897 /* If memrange b overlaps or is adjacent to memrange a,
899 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
900 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
902 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
903 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
904 continue; /* next b, same a */
908 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
909 sizeof (struct memrange
));
911 memranges
->next_memrange
= a
+ 1;
915 /* Add a register to a collection list. */
917 add_register (struct collection_list
*collection
, unsigned int regno
)
920 printf_filtered ("collect register %d\n", regno
);
921 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
922 error (_("Internal: register number %d too large for tracepoint"),
924 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
927 /* Add a memrange to a collection list. */
929 add_memrange (struct collection_list
*memranges
,
930 int type
, bfd_signed_vma base
,
935 printf_filtered ("(%d,", type
);
937 printf_filtered (",%ld)\n", len
);
940 /* type: memrange_absolute == memory, other n == basereg */
941 memranges
->list
[memranges
->next_memrange
].type
= type
;
942 /* base: addr if memory, offset if reg relative. */
943 memranges
->list
[memranges
->next_memrange
].start
= base
;
944 /* len: we actually save end (base + len) for convenience */
945 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
946 memranges
->next_memrange
++;
947 if (memranges
->next_memrange
>= memranges
->listsize
)
949 memranges
->listsize
*= 2;
950 memranges
->list
= xrealloc (memranges
->list
,
951 memranges
->listsize
);
954 if (type
!= memrange_absolute
) /* Better collect the base register! */
955 add_register (memranges
, type
);
958 /* Add a symbol to a collection list. */
960 collect_symbol (struct collection_list
*collect
,
962 struct gdbarch
*gdbarch
,
963 long frame_regno
, long frame_offset
,
969 bfd_signed_vma offset
;
970 int treat_as_expr
= 0;
972 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
973 switch (SYMBOL_CLASS (sym
))
976 printf_filtered ("%s: don't know symbol class %d\n",
977 SYMBOL_PRINT_NAME (sym
),
981 printf_filtered ("constant %s (value %s) will not be collected.\n",
982 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
985 offset
= SYMBOL_VALUE_ADDRESS (sym
);
990 sprintf_vma (tmp
, offset
);
991 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
992 SYMBOL_PRINT_NAME (sym
), len
,
995 /* A struct may be a C++ class with static fields, go to general
996 expression handling. */
997 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1000 add_memrange (collect
, memrange_absolute
, offset
, len
);
1003 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1005 printf_filtered ("LOC_REG[parm] %s: ",
1006 SYMBOL_PRINT_NAME (sym
));
1007 add_register (collect
, reg
);
1008 /* Check for doubles stored in two registers. */
1009 /* FIXME: how about larger types stored in 3 or more regs? */
1010 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1011 len
> register_size (gdbarch
, reg
))
1012 add_register (collect
, reg
+ 1);
1015 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1016 printf_filtered (" (will not collect %s)\n",
1017 SYMBOL_PRINT_NAME (sym
));
1021 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1024 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1025 SYMBOL_PRINT_NAME (sym
), len
);
1026 printf_vma (offset
);
1027 printf_filtered (" from frame ptr reg %d\n", reg
);
1029 add_memrange (collect
, reg
, offset
, len
);
1031 case LOC_REGPARM_ADDR
:
1032 reg
= SYMBOL_VALUE (sym
);
1036 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1037 SYMBOL_PRINT_NAME (sym
), len
);
1038 printf_vma (offset
);
1039 printf_filtered (" from reg %d\n", reg
);
1041 add_memrange (collect
, reg
, offset
, len
);
1045 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1048 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1049 SYMBOL_PRINT_NAME (sym
), len
);
1050 printf_vma (offset
);
1051 printf_filtered (" from frame ptr reg %d\n", reg
);
1053 add_memrange (collect
, reg
, offset
, len
);
1056 case LOC_UNRESOLVED
:
1060 case LOC_OPTIMIZED_OUT
:
1061 printf_filtered ("%s has been optimized out of existence.\n",
1062 SYMBOL_PRINT_NAME (sym
));
1070 /* Expressions are the most general case. */
1073 struct agent_expr
*aexpr
;
1074 struct cleanup
*old_chain1
= NULL
;
1076 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1078 /* It can happen that the symbol is recorded as a computed
1079 location, but it's been optimized away and doesn't actually
1080 have a location expression. */
1083 printf_filtered ("%s has been optimized out of existence.\n",
1084 SYMBOL_PRINT_NAME (sym
));
1088 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1092 report_agent_reqs_errors (aexpr
);
1094 discard_cleanups (old_chain1
);
1095 add_aexpr (collect
, aexpr
);
1097 /* Take care of the registers. */
1098 if (aexpr
->reg_mask_len
> 0)
1102 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1104 QUIT
; /* Allow user to bail out with ^C. */
1105 if (aexpr
->reg_mask
[ndx1
] != 0)
1107 /* Assume chars have 8 bits. */
1108 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1109 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1110 /* It's used -- record it. */
1111 add_register (collect
, ndx1
* 8 + ndx2
);
1118 /* Data to be passed around in the calls to the locals and args
1121 struct add_local_symbols_data
1123 struct collection_list
*collect
;
1124 struct gdbarch
*gdbarch
;
1132 /* The callback for the locals and args iterators. */
1135 do_collect_symbol (const char *print_name
,
1139 struct add_local_symbols_data
*p
= cb_data
;
1141 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1142 p
->frame_offset
, p
->pc
, p
->trace_string
);
1145 VEC_safe_push (char_ptr
, p
->collect
->wholly_collected
,
1146 xstrdup (print_name
));
1149 /* Add all locals (or args) symbols to collection list. */
1151 add_local_symbols (struct collection_list
*collect
,
1152 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1153 long frame_regno
, long frame_offset
, int type
,
1156 const struct block
*block
;
1157 struct add_local_symbols_data cb_data
;
1159 cb_data
.collect
= collect
;
1160 cb_data
.gdbarch
= gdbarch
;
1162 cb_data
.frame_regno
= frame_regno
;
1163 cb_data
.frame_offset
= frame_offset
;
1165 cb_data
.trace_string
= trace_string
;
1169 block
= block_for_pc (pc
);
1172 warning (_("Can't collect locals; "
1173 "no symbol table info available.\n"));
1177 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1178 if (cb_data
.count
== 0)
1179 warning (_("No locals found in scope."));
1183 pc
= get_pc_function_start (pc
);
1184 block
= block_for_pc (pc
);
1187 warning (_("Can't collect args; no symbol table info available."));
1191 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1192 if (cb_data
.count
== 0)
1193 warning (_("No args found in scope."));
1198 add_static_trace_data (struct collection_list
*collection
)
1201 printf_filtered ("collect static trace data\n");
1202 collection
->strace_data
= 1;
1205 /* worker function */
1207 clear_collection_list (struct collection_list
*list
)
1211 list
->next_memrange
= 0;
1212 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1214 free_agent_expr (list
->aexpr_list
[ndx
]);
1215 list
->aexpr_list
[ndx
] = NULL
;
1217 list
->next_aexpr_elt
= 0;
1218 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1219 list
->strace_data
= 0;
1221 xfree (list
->aexpr_list
);
1224 VEC_free (char_ptr
, list
->wholly_collected
);
1225 VEC_free (char_ptr
, list
->computed
);
1228 /* A cleanup wrapper for function clear_collection_list. */
1231 do_clear_collection_list (void *list
)
1233 struct collection_list
*l
= list
;
1235 clear_collection_list (l
);
1238 /* Initialize collection_list CLIST. */
1241 init_collection_list (struct collection_list
*clist
)
1243 memset (clist
, 0, sizeof *clist
);
1245 clist
->listsize
= 128;
1246 clist
->list
= xcalloc (clist
->listsize
,
1247 sizeof (struct memrange
));
1249 clist
->aexpr_listsize
= 128;
1250 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1251 sizeof (struct agent_expr
*));
1254 /* Reduce a collection list to string form (for gdb protocol). */
1256 stringify_collection_list (struct collection_list
*list
)
1258 char temp_buf
[2048];
1262 char *(*str_list
)[];
1266 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1267 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1269 if (list
->strace_data
)
1272 printf_filtered ("\nCollecting static trace data\n");
1275 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1279 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1280 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1282 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1285 printf_filtered ("\nCollecting registers (mask): 0x");
1290 QUIT
; /* Allow user to bail out with ^C. */
1292 printf_filtered ("%02X", list
->regs_mask
[i
]);
1293 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1296 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1300 printf_filtered ("\n");
1301 if (list
->next_memrange
> 0 && info_verbose
)
1302 printf_filtered ("Collecting memranges: \n");
1303 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1305 QUIT
; /* Allow user to bail out with ^C. */
1306 sprintf_vma (tmp2
, list
->list
[i
].start
);
1309 printf_filtered ("(%d, %s, %ld)\n",
1312 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1314 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1316 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1323 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1325 /* The "%X" conversion specifier expects an unsigned argument,
1326 so passing -1 (memrange_absolute) to it directly gives you
1327 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1329 if (list
->list
[i
].type
== memrange_absolute
)
1330 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1332 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1335 count
+= strlen (end
);
1336 end
= temp_buf
+ count
;
1339 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1341 QUIT
; /* Allow user to bail out with ^C. */
1342 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1344 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1349 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1350 end
+= 10; /* 'X' + 8 hex digits + ',' */
1353 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1354 end
, list
->aexpr_list
[i
]->len
);
1355 count
+= 2 * list
->aexpr_list
[i
]->len
;
1360 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1365 (*str_list
)[ndx
] = NULL
;
1376 /* Add the printed expression EXP to *LIST. */
1379 append_exp (struct expression
*exp
, VEC(char_ptr
) **list
)
1381 struct ui_file
*tmp_stream
= mem_fileopen ();
1384 print_expression (exp
, tmp_stream
);
1386 text
= ui_file_xstrdup (tmp_stream
, NULL
);
1388 VEC_safe_push (char_ptr
, *list
, text
);
1389 ui_file_delete (tmp_stream
);
1393 encode_actions_1 (struct command_line
*action
,
1394 struct bp_location
*tloc
,
1396 LONGEST frame_offset
,
1397 struct collection_list
*collect
,
1398 struct collection_list
*stepping_list
)
1400 const char *action_exp
;
1401 struct expression
*exp
= NULL
;
1403 struct value
*tempval
;
1404 struct cmd_list_element
*cmd
;
1405 struct agent_expr
*aexpr
;
1407 for (; action
; action
= action
->next
)
1409 QUIT
; /* Allow user to bail out with ^C. */
1410 action_exp
= action
->line
;
1411 action_exp
= skip_spaces_const (action_exp
);
1413 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1415 error (_("Bad action list item: %s"), action_exp
);
1417 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1419 int trace_string
= 0;
1421 if (*action_exp
== '/')
1422 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1425 { /* Repeat over a comma-separated list. */
1426 QUIT
; /* Allow user to bail out with ^C. */
1427 action_exp
= skip_spaces_const (action_exp
);
1429 if (0 == strncasecmp ("$reg", action_exp
, 4))
1431 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1432 add_register (collect
, i
);
1433 action_exp
= strchr (action_exp
, ','); /* more? */
1435 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1437 add_local_symbols (collect
,
1444 action_exp
= strchr (action_exp
, ','); /* more? */
1446 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1448 add_local_symbols (collect
,
1455 action_exp
= strchr (action_exp
, ','); /* more? */
1457 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1459 struct cleanup
*old_chain1
= NULL
;
1461 aexpr
= gen_trace_for_return_address (tloc
->address
,
1465 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1468 report_agent_reqs_errors (aexpr
);
1470 discard_cleanups (old_chain1
);
1471 add_aexpr (collect
, aexpr
);
1473 /* take care of the registers */
1474 if (aexpr
->reg_mask_len
> 0)
1478 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1480 QUIT
; /* allow user to bail out with ^C */
1481 if (aexpr
->reg_mask
[ndx1
] != 0)
1483 /* assume chars have 8 bits */
1484 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1485 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1486 /* it's used -- record it */
1487 add_register (collect
,
1493 action_exp
= strchr (action_exp
, ','); /* more? */
1495 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1497 add_static_trace_data (collect
);
1498 action_exp
= strchr (action_exp
, ','); /* more? */
1503 struct cleanup
*old_chain
= NULL
;
1504 struct cleanup
*old_chain1
= NULL
;
1506 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1507 block_for_pc (tloc
->address
), 1);
1508 old_chain
= make_cleanup (free_current_contents
, &exp
);
1510 switch (exp
->elts
[0].opcode
)
1514 const char *name
= &exp
->elts
[2].string
;
1516 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1517 name
, strlen (name
));
1519 internal_error (__FILE__
, __LINE__
,
1520 _("Register $%s not available"),
1523 printf_filtered ("OP_REGISTER: ");
1524 add_register (collect
, i
);
1529 /* Safe because we know it's a simple expression. */
1530 tempval
= evaluate_expression (exp
);
1531 addr
= value_address (tempval
);
1532 /* Initialize the TYPE_LENGTH if it is a typedef. */
1533 check_typedef (exp
->elts
[1].type
);
1534 add_memrange (collect
, memrange_absolute
, addr
,
1535 TYPE_LENGTH (exp
->elts
[1].type
));
1536 append_exp (exp
, &collect
->computed
);
1541 struct symbol
*sym
= exp
->elts
[2].symbol
;
1542 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1544 collect_symbol (collect
,
1545 exp
->elts
[2].symbol
,
1551 VEC_safe_push (char_ptr
,
1552 collect
->wholly_collected
,
1557 default: /* Full-fledged expression. */
1558 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1561 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1565 report_agent_reqs_errors (aexpr
);
1567 discard_cleanups (old_chain1
);
1568 add_aexpr (collect
, aexpr
);
1570 /* Take care of the registers. */
1571 if (aexpr
->reg_mask_len
> 0)
1576 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1578 QUIT
; /* Allow user to bail out with ^C. */
1579 if (aexpr
->reg_mask
[ndx1
] != 0)
1581 /* Assume chars have 8 bits. */
1582 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1583 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1584 /* It's used -- record it. */
1585 add_register (collect
,
1591 append_exp (exp
, &collect
->computed
);
1594 do_cleanups (old_chain
);
1597 while (action_exp
&& *action_exp
++ == ',');
1599 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1602 { /* Repeat over a comma-separated list. */
1603 QUIT
; /* Allow user to bail out with ^C. */
1604 action_exp
= skip_spaces_const (action_exp
);
1607 struct cleanup
*old_chain
= NULL
;
1608 struct cleanup
*old_chain1
= NULL
;
1610 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1611 block_for_pc (tloc
->address
), 1);
1612 old_chain
= make_cleanup (free_current_contents
, &exp
);
1614 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1615 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1618 report_agent_reqs_errors (aexpr
);
1620 discard_cleanups (old_chain1
);
1621 /* Even though we're not officially collecting, add
1622 to the collect list anyway. */
1623 add_aexpr (collect
, aexpr
);
1625 do_cleanups (old_chain
);
1628 while (action_exp
&& *action_exp
++ == ',');
1630 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1632 /* We check against nested while-stepping when setting
1633 breakpoint action, so no way to run into nested
1635 gdb_assert (stepping_list
);
1637 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1638 frame_offset
, stepping_list
, NULL
);
1641 error (_("Invalid tracepoint command '%s'"), action
->line
);
1645 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1646 and STEPPING_LIST. Return a cleanup pointer to clean up both
1647 TRACEPOINT_LIST and STEPPING_LIST. */
1650 encode_actions_and_make_cleanup (struct bp_location
*tloc
,
1651 struct collection_list
*tracepoint_list
,
1652 struct collection_list
*stepping_list
)
1654 char *default_collect_line
= NULL
;
1655 struct command_line
*actions
;
1656 struct command_line
*default_collect_action
= NULL
;
1658 LONGEST frame_offset
;
1659 struct cleanup
*back_to
, *return_chain
;
1661 return_chain
= make_cleanup (null_cleanup
, NULL
);
1662 init_collection_list (tracepoint_list
);
1663 init_collection_list (stepping_list
);
1665 make_cleanup (do_clear_collection_list
, tracepoint_list
);
1666 make_cleanup (do_clear_collection_list
, stepping_list
);
1668 back_to
= make_cleanup (null_cleanup
, NULL
);
1669 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1670 tloc
->address
, &frame_reg
, &frame_offset
);
1672 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1674 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1675 tracepoint_list
, stepping_list
);
1677 memrange_sortmerge (tracepoint_list
);
1678 memrange_sortmerge (stepping_list
);
1680 do_cleanups (back_to
);
1681 return return_chain
;
1684 /* Render all actions into gdb protocol. */
1687 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1688 char ***stepping_actions
)
1690 struct collection_list tracepoint_list
, stepping_list
;
1691 struct cleanup
*cleanup
;
1693 *tdp_actions
= NULL
;
1694 *stepping_actions
= NULL
;
1696 cleanup
= encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
1699 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1700 *stepping_actions
= stringify_collection_list (&stepping_list
);
1702 do_cleanups (cleanup
);
1706 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1708 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1710 collect
->aexpr_list
=
1711 xrealloc (collect
->aexpr_list
,
1712 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1713 collect
->aexpr_listsize
*= 2;
1715 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1716 collect
->next_aexpr_elt
++;
1720 process_tracepoint_on_disconnect (void)
1722 VEC(breakpoint_p
) *tp_vec
= NULL
;
1724 struct breakpoint
*b
;
1725 int has_pending_p
= 0;
1727 /* Check whether we still have pending tracepoint. If we have, warn the
1728 user that pending tracepoint will no longer work. */
1729 tp_vec
= all_tracepoints ();
1730 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1739 struct bp_location
*loc1
;
1741 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1743 if (loc1
->shlib_disabled
)
1754 VEC_free (breakpoint_p
, tp_vec
);
1757 warning (_("Pending tracepoints will not be resolved while"
1758 " GDB is disconnected\n"));
1761 /* Reset local state of tracing. */
1764 trace_reset_local_state (void)
1766 set_traceframe_num (-1);
1767 set_tracepoint_num (-1);
1768 set_traceframe_context (NULL
);
1769 clear_traceframe_info ();
1773 start_tracing (char *notes
)
1775 VEC(breakpoint_p
) *tp_vec
= NULL
;
1777 struct breakpoint
*b
;
1778 struct trace_state_variable
*tsv
;
1779 int any_enabled
= 0, num_to_download
= 0;
1782 tp_vec
= all_tracepoints ();
1784 /* No point in tracing without any tracepoints... */
1785 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1787 VEC_free (breakpoint_p
, tp_vec
);
1788 error (_("No tracepoints defined, not starting trace"));
1791 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1793 struct tracepoint
*t
= (struct tracepoint
*) b
;
1794 struct bp_location
*loc
;
1796 if (b
->enable_state
== bp_enabled
)
1799 if ((b
->type
== bp_fast_tracepoint
1800 ? may_insert_fast_tracepoints
1801 : may_insert_tracepoints
))
1804 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1805 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1810 if (target_supports_enable_disable_tracepoint ())
1811 warning (_("No tracepoints enabled"));
1814 /* No point in tracing with only disabled tracepoints that
1815 cannot be re-enabled. */
1816 VEC_free (breakpoint_p
, tp_vec
);
1817 error (_("No tracepoints enabled, not starting trace"));
1821 if (num_to_download
<= 0)
1823 VEC_free (breakpoint_p
, tp_vec
);
1824 error (_("No tracepoints that may be downloaded, not starting trace"));
1827 target_trace_init ();
1829 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1831 struct tracepoint
*t
= (struct tracepoint
*) b
;
1832 struct bp_location
*loc
;
1833 int bp_location_downloaded
= 0;
1835 /* Clear `inserted' flag. */
1836 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1839 if ((b
->type
== bp_fast_tracepoint
1840 ? !may_insert_fast_tracepoints
1841 : !may_insert_tracepoints
))
1844 t
->number_on_target
= 0;
1846 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1848 /* Since tracepoint locations are never duplicated, `inserted'
1849 flag should be zero. */
1850 gdb_assert (!loc
->inserted
);
1852 target_download_tracepoint (loc
);
1855 bp_location_downloaded
= 1;
1858 t
->number_on_target
= b
->number
;
1860 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1861 if (loc
->probe
.probe
!= NULL
1862 && loc
->probe
.probe
->pops
->set_semaphore
!= NULL
)
1863 loc
->probe
.probe
->pops
->set_semaphore (loc
->probe
.probe
,
1867 if (bp_location_downloaded
)
1868 observer_notify_breakpoint_modified (b
);
1870 VEC_free (breakpoint_p
, tp_vec
);
1872 /* Send down all the trace state variables too. */
1873 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1875 target_download_trace_state_variable (tsv
);
1878 /* Tell target to treat text-like sections as transparent. */
1879 target_trace_set_readonly_regions ();
1880 /* Set some mode flags. */
1881 target_set_disconnected_tracing (disconnected_tracing
);
1882 target_set_circular_trace_buffer (circular_trace_buffer
);
1883 target_set_trace_buffer_size (trace_buffer_size
);
1886 notes
= trace_notes
;
1887 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1889 if (!ret
&& (trace_user
|| notes
))
1890 warning (_("Target does not support trace user/notes, info ignored"));
1892 /* Now insert traps and begin collecting data. */
1893 target_trace_start ();
1895 /* Reset our local state. */
1896 trace_reset_local_state ();
1897 current_trace_status()->running
= 1;
1900 /* The tstart command requests the target to start a new trace run.
1901 The command passes any arguments it has to the target verbatim, as
1902 an optional "trace note". This is useful as for instance a warning
1903 to other users if the trace runs disconnected, and you don't want
1904 anybody else messing with the target. */
1907 trace_start_command (char *args
, int from_tty
)
1909 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1911 if (current_trace_status ()->running
)
1914 && !query (_("A trace is running already. Start a new run? ")))
1915 error (_("New trace run not started."));
1918 start_tracing (args
);
1921 /* The tstop command stops the tracing run. The command passes any
1922 supplied arguments to the target verbatim as a "stop note"; if the
1923 target supports trace notes, then it will be reported back as part
1924 of the trace run's status. */
1927 trace_stop_command (char *args
, int from_tty
)
1929 if (!current_trace_status ()->running
)
1930 error (_("Trace is not running."));
1932 stop_tracing (args
);
1936 stop_tracing (char *note
)
1939 VEC(breakpoint_p
) *tp_vec
= NULL
;
1941 struct breakpoint
*t
;
1943 target_trace_stop ();
1945 tp_vec
= all_tracepoints ();
1946 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1948 struct bp_location
*loc
;
1950 if ((t
->type
== bp_fast_tracepoint
1951 ? !may_insert_fast_tracepoints
1952 : !may_insert_tracepoints
))
1955 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1957 /* GDB can be totally absent in some disconnected trace scenarios,
1958 but we don't really care if this semaphore goes out of sync.
1959 That's why we are decrementing it here, but not taking care
1961 if (loc
->probe
.probe
!= NULL
1962 && loc
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
1963 loc
->probe
.probe
->pops
->clear_semaphore (loc
->probe
.probe
,
1969 VEC_free (breakpoint_p
, tp_vec
);
1972 note
= trace_stop_notes
;
1973 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1976 warning (_("Target does not support trace notes, note ignored"));
1978 /* Should change in response to reply? */
1979 current_trace_status ()->running
= 0;
1982 /* tstatus command */
1984 trace_status_command (char *args
, int from_tty
)
1986 struct trace_status
*ts
= current_trace_status ();
1988 VEC(breakpoint_p
) *tp_vec
= NULL
;
1989 struct breakpoint
*t
;
1991 status
= target_get_trace_status (ts
);
1995 if (ts
->filename
!= NULL
)
1996 printf_filtered (_("Using a trace file.\n"));
1999 printf_filtered (_("Trace can not be run on this target.\n"));
2004 if (!ts
->running_known
)
2006 printf_filtered (_("Run/stop status is unknown.\n"));
2008 else if (ts
->running
)
2010 printf_filtered (_("Trace is running on the target.\n"));
2014 switch (ts
->stop_reason
)
2016 case trace_never_run
:
2017 printf_filtered (_("No trace has been run on the target.\n"));
2021 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2024 printf_filtered (_("Trace stopped by a tstop command.\n"));
2026 case trace_buffer_full
:
2027 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2029 case trace_disconnected
:
2030 printf_filtered (_("Trace stopped because of disconnection.\n"));
2032 case tracepoint_passcount
:
2033 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2034 ts
->stopping_tracepoint
);
2036 case tracepoint_error
:
2037 if (ts
->stopping_tracepoint
)
2038 printf_filtered (_("Trace stopped by an "
2039 "error (%s, tracepoint %d).\n"),
2040 ts
->stop_desc
, ts
->stopping_tracepoint
);
2042 printf_filtered (_("Trace stopped by an error (%s).\n"),
2045 case trace_stop_reason_unknown
:
2046 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2049 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2055 if (ts
->traceframes_created
>= 0
2056 && ts
->traceframe_count
!= ts
->traceframes_created
)
2058 printf_filtered (_("Buffer contains %d trace "
2059 "frames (of %d created total).\n"),
2060 ts
->traceframe_count
, ts
->traceframes_created
);
2062 else if (ts
->traceframe_count
>= 0)
2064 printf_filtered (_("Collected %d trace frames.\n"),
2065 ts
->traceframe_count
);
2068 if (ts
->buffer_free
>= 0)
2070 if (ts
->buffer_size
>= 0)
2072 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2073 ts
->buffer_free
, ts
->buffer_size
);
2074 if (ts
->buffer_size
> 0)
2075 printf_filtered (_(" (%d%% full)"),
2076 ((int) ((((long long) (ts
->buffer_size
2077 - ts
->buffer_free
)) * 100)
2078 / ts
->buffer_size
)));
2079 printf_filtered (_(".\n"));
2082 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2086 if (ts
->disconnected_tracing
)
2087 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2089 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2091 if (ts
->circular_buffer
)
2092 printf_filtered (_("Trace buffer is circular.\n"));
2094 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2095 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2097 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2098 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2100 /* Now report on what we're doing with tfind. */
2101 if (traceframe_number
>= 0)
2102 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2103 traceframe_number
, tracepoint_number
);
2105 printf_filtered (_("Not looking at any trace frame.\n"));
2107 /* Report start/stop times if supplied. */
2112 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2114 /* Reporting a run time is more readable than two long numbers. */
2115 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2116 (long int) (ts
->start_time
/ 1000000),
2117 (long int) (ts
->start_time
% 1000000),
2118 (long int) (run_time
/ 1000000),
2119 (long int) (run_time
% 1000000));
2122 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2123 (long int) (ts
->start_time
/ 1000000),
2124 (long int) (ts
->start_time
% 1000000));
2126 else if (ts
->stop_time
)
2127 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2128 (long int) (ts
->stop_time
/ 1000000),
2129 (long int) (ts
->stop_time
% 1000000));
2131 /* Now report any per-tracepoint status available. */
2132 tp_vec
= all_tracepoints ();
2134 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2135 target_get_tracepoint_status (t
, NULL
);
2137 VEC_free (breakpoint_p
, tp_vec
);
2140 /* Report the trace status to uiout, in a way suitable for MI, and not
2141 suitable for CLI. If ON_STOP is true, suppress a few fields that
2142 are not meaningful in the -trace-stop response.
2144 The implementation is essentially parallel to trace_status_command, but
2145 merging them will result in unreadable code. */
2147 trace_status_mi (int on_stop
)
2149 struct ui_out
*uiout
= current_uiout
;
2150 struct trace_status
*ts
= current_trace_status ();
2153 status
= target_get_trace_status (ts
);
2155 if (status
== -1 && ts
->filename
== NULL
)
2157 ui_out_field_string (uiout
, "supported", "0");
2161 if (ts
->filename
!= NULL
)
2162 ui_out_field_string (uiout
, "supported", "file");
2164 ui_out_field_string (uiout
, "supported", "1");
2166 if (ts
->filename
!= NULL
)
2167 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2169 gdb_assert (ts
->running_known
);
2173 ui_out_field_string (uiout
, "running", "1");
2175 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2176 Given that the frontend gets the status either on -trace-stop, or from
2177 -trace-status after re-connection, it does not seem like this
2178 information is necessary for anything. It is not necessary for either
2179 figuring the vital state of the target nor for navigation of trace
2180 frames. If the frontend wants to show the current state is some
2181 configure dialog, it can request the value when such dialog is
2182 invoked by the user. */
2186 char *stop_reason
= NULL
;
2187 int stopping_tracepoint
= -1;
2190 ui_out_field_string (uiout
, "running", "0");
2192 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2194 switch (ts
->stop_reason
)
2197 stop_reason
= "request";
2199 case trace_buffer_full
:
2200 stop_reason
= "overflow";
2202 case trace_disconnected
:
2203 stop_reason
= "disconnection";
2205 case tracepoint_passcount
:
2206 stop_reason
= "passcount";
2207 stopping_tracepoint
= ts
->stopping_tracepoint
;
2209 case tracepoint_error
:
2210 stop_reason
= "error";
2211 stopping_tracepoint
= ts
->stopping_tracepoint
;
2217 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2218 if (stopping_tracepoint
!= -1)
2219 ui_out_field_int (uiout
, "stopping-tracepoint",
2220 stopping_tracepoint
);
2221 if (ts
->stop_reason
== tracepoint_error
)
2222 ui_out_field_string (uiout
, "error-description",
2228 if (ts
->traceframe_count
!= -1)
2229 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2230 if (ts
->traceframes_created
!= -1)
2231 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2232 if (ts
->buffer_size
!= -1)
2233 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2234 if (ts
->buffer_free
!= -1)
2235 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2237 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2238 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2240 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2241 ui_out_field_string (uiout
, "notes", ts
->notes
);
2246 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2247 (long int) (ts
->start_time
/ 1000000),
2248 (long int) (ts
->start_time
% 1000000));
2249 ui_out_field_string (uiout
, "start-time", buf
);
2250 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2251 (long int) (ts
->stop_time
/ 1000000),
2252 (long int) (ts
->stop_time
% 1000000));
2253 ui_out_field_string (uiout
, "stop-time", buf
);
2257 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2258 user if she really wants to detach. */
2261 query_if_trace_running (int from_tty
)
2266 /* It can happen that the target that was tracing went away on its
2267 own, and we didn't notice. Get a status update, and if the
2268 current target doesn't even do tracing, then assume it's not
2270 if (target_get_trace_status (current_trace_status ()) < 0)
2271 current_trace_status ()->running
= 0;
2273 /* If running interactively, give the user the option to cancel and
2274 then decide what to do differently with the run. Scripts are
2275 just going to disconnect and let the target deal with it,
2276 according to how it's been instructed previously via
2277 disconnected-tracing. */
2278 if (current_trace_status ()->running
)
2280 process_tracepoint_on_disconnect ();
2282 if (current_trace_status ()->disconnected_tracing
)
2284 if (!query (_("Trace is running and will "
2285 "continue after detach; detach anyway? ")))
2286 error (_("Not confirmed."));
2290 if (!query (_("Trace is running but will "
2291 "stop on detach; detach anyway? ")))
2292 error (_("Not confirmed."));
2297 /* This function handles the details of what to do about an ongoing
2298 tracing run if the user has asked to detach or otherwise disconnect
2302 disconnect_tracing (void)
2304 /* Also we want to be out of tfind mode, otherwise things can get
2305 confusing upon reconnection. Just use these calls instead of
2306 full tfind_1 behavior because we're in the middle of detaching,
2307 and there's no point to updating current stack frame etc. */
2308 trace_reset_local_state ();
2311 /* Worker function for the various flavors of the tfind command. */
2313 tfind_1 (enum trace_find_type type
, int num
,
2314 CORE_ADDR addr1
, CORE_ADDR addr2
,
2317 int target_frameno
= -1, target_tracept
= -1;
2318 struct frame_id old_frame_id
= null_frame_id
;
2319 struct tracepoint
*tp
;
2320 struct ui_out
*uiout
= current_uiout
;
2322 /* Only try to get the current stack frame if we have a chance of
2323 succeeding. In particular, if we're trying to get a first trace
2324 frame while all threads are running, it's not going to succeed,
2325 so leave it with a default value and let the frame comparison
2326 below (correctly) decide to print out the source location of the
2328 if (!(type
== tfind_number
&& num
== -1)
2329 && (has_stack_frames () || traceframe_number
>= 0))
2330 old_frame_id
= get_frame_id (get_current_frame ());
2332 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2335 if (type
== tfind_number
2337 && target_frameno
== -1)
2339 /* We told the target to get out of tfind mode, and it did. */
2341 else if (target_frameno
== -1)
2343 /* A request for a non-existent trace frame has failed.
2344 Our response will be different, depending on FROM_TTY:
2346 If FROM_TTY is true, meaning that this command was
2347 typed interactively by the user, then give an error
2348 and DO NOT change the state of traceframe_number etc.
2350 However if FROM_TTY is false, meaning that we're either
2351 in a script, a loop, or a user-defined command, then
2352 DON'T give an error, but DO change the state of
2353 traceframe_number etc. to invalid.
2355 The rationalle is that if you typed the command, you
2356 might just have committed a typo or something, and you'd
2357 like to NOT lose your current debugging state. However
2358 if you're in a user-defined command or especially in a
2359 loop, then you need a way to detect that the command
2360 failed WITHOUT aborting. This allows you to write
2361 scripts that search thru the trace buffer until the end,
2362 and then continue on to do something else. */
2365 error (_("Target failed to find requested trace frame."));
2369 printf_filtered ("End of trace buffer.\n");
2370 #if 0 /* dubious now? */
2371 /* The following will not recurse, since it's
2373 trace_find_command ("-1", from_tty
);
2378 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2380 reinit_frame_cache ();
2381 target_dcache_invalidate ();
2383 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2385 if (target_frameno
!= get_traceframe_number ())
2386 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2388 set_current_traceframe (target_frameno
);
2390 if (target_frameno
== -1)
2391 set_traceframe_context (NULL
);
2393 set_traceframe_context (get_current_frame ());
2395 if (traceframe_number
>= 0)
2397 /* Use different branches for MI and CLI to make CLI messages
2399 if (ui_out_is_mi_like_p (uiout
))
2401 ui_out_field_string (uiout
, "found", "1");
2402 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2403 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2407 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2408 traceframe_number
, tracepoint_number
);
2413 if (ui_out_is_mi_like_p (uiout
))
2414 ui_out_field_string (uiout
, "found", "0");
2415 else if (type
== tfind_number
&& num
== -1)
2416 printf_unfiltered (_("No longer looking at any trace frame\n"));
2417 else /* This case may never occur, check. */
2418 printf_unfiltered (_("No trace frame found\n"));
2421 /* If we're in nonstop mode and getting out of looking at trace
2422 frames, there won't be any current frame to go back to and
2425 && (has_stack_frames () || traceframe_number
>= 0))
2427 enum print_what print_what
;
2429 /* NOTE: in imitation of the step command, try to determine
2430 whether we have made a transition from one function to
2431 another. If so, we'll print the "stack frame" (ie. the new
2432 function and it's arguments) -- otherwise we'll just show the
2435 if (frame_id_eq (old_frame_id
,
2436 get_frame_id (get_current_frame ())))
2437 print_what
= SRC_LINE
;
2439 print_what
= SRC_AND_LOC
;
2441 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2446 /* Error on looking at traceframes while trace is running. */
2449 check_trace_running (struct trace_status
*status
)
2451 if (status
->running
&& status
->filename
== NULL
)
2452 error (_("May not look at trace frames while trace is running."));
2455 /* trace_find_command takes a trace frame number n,
2456 sends "QTFrame:<n>" to the target,
2457 and accepts a reply that may contain several optional pieces
2458 of information: a frame number, a tracepoint number, and an
2459 indication of whether this is a trap frame or a stepping frame.
2461 The minimal response is just "OK" (which indicates that the
2462 target does not give us a frame number or a tracepoint number).
2463 Instead of that, the target may send us a string containing
2465 F<hexnum> (gives the selected frame number)
2466 T<hexnum> (gives the selected tracepoint number)
2471 trace_find_command (char *args
, int from_tty
)
2472 { /* This should only be called with a numeric argument. */
2475 check_trace_running (current_trace_status ());
2477 if (args
== 0 || *args
== 0)
2478 { /* TFIND with no args means find NEXT trace frame. */
2479 if (traceframe_number
== -1)
2480 frameno
= 0; /* "next" is first one. */
2482 frameno
= traceframe_number
+ 1;
2484 else if (0 == strcmp (args
, "-"))
2486 if (traceframe_number
== -1)
2487 error (_("not debugging trace buffer"));
2488 else if (from_tty
&& traceframe_number
== 0)
2489 error (_("already at start of trace buffer"));
2491 frameno
= traceframe_number
- 1;
2493 /* A hack to work around eval's need for fp to have been collected. */
2494 else if (0 == strcmp (args
, "-1"))
2497 frameno
= parse_and_eval_long (args
);
2500 error (_("invalid input (%d is less than zero)"), frameno
);
2502 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2507 trace_find_end_command (char *args
, int from_tty
)
2509 trace_find_command ("-1", from_tty
);
2514 trace_find_start_command (char *args
, int from_tty
)
2516 trace_find_command ("0", from_tty
);
2519 /* tfind pc command */
2521 trace_find_pc_command (char *args
, int from_tty
)
2525 check_trace_running (current_trace_status ());
2527 if (args
== 0 || *args
== 0)
2528 pc
= regcache_read_pc (get_current_regcache ());
2530 pc
= parse_and_eval_address (args
);
2532 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2535 /* tfind tracepoint command */
2537 trace_find_tracepoint_command (char *args
, int from_tty
)
2540 struct tracepoint
*tp
;
2542 check_trace_running (current_trace_status ());
2544 if (args
== 0 || *args
== 0)
2546 if (tracepoint_number
== -1)
2547 error (_("No current tracepoint -- please supply an argument."));
2549 tdp
= tracepoint_number
; /* Default is current TDP. */
2552 tdp
= parse_and_eval_long (args
);
2554 /* If we have the tracepoint on hand, use the number that the
2555 target knows about (which may be different if we disconnected
2556 and reconnected). */
2557 tp
= get_tracepoint (tdp
);
2559 tdp
= tp
->number_on_target
;
2561 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2564 /* TFIND LINE command:
2566 This command will take a sourceline for argument, just like BREAK
2567 or TRACE (ie. anything that "decode_line_1" can handle).
2569 With no argument, this command will find the next trace frame
2570 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2573 trace_find_line_command (char *args
, int from_tty
)
2575 static CORE_ADDR start_pc
, end_pc
;
2576 struct symtabs_and_lines sals
;
2577 struct symtab_and_line sal
;
2578 struct cleanup
*old_chain
;
2580 check_trace_running (current_trace_status ());
2582 if (args
== 0 || *args
== 0)
2584 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2586 sals
.sals
= (struct symtab_and_line
*)
2587 xmalloc (sizeof (struct symtab_and_line
));
2592 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2596 old_chain
= make_cleanup (xfree
, sals
.sals
);
2597 if (sal
.symtab
== 0)
2598 error (_("No line number information available."));
2600 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2602 if (start_pc
== end_pc
)
2604 printf_filtered ("Line %d of \"%s\"",
2606 symtab_to_filename_for_display (sal
.symtab
));
2608 printf_filtered (" is at address ");
2609 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2611 printf_filtered (" but contains no code.\n");
2612 sal
= find_pc_line (start_pc
, 0);
2614 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2615 && start_pc
!= end_pc
)
2616 printf_filtered ("Attempting to find line %d instead.\n",
2619 error (_("Cannot find a good line."));
2623 /* Is there any case in which we get here, and have an address
2624 which the user would want to see? If we have debugging
2625 symbols and no line numbers? */
2626 error (_("Line number %d is out of range for \"%s\"."),
2627 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2629 /* Find within range of stated line. */
2631 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2633 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2634 do_cleanups (old_chain
);
2637 /* tfind range command */
2639 trace_find_range_command (char *args
, int from_tty
)
2641 static CORE_ADDR start
, stop
;
2644 check_trace_running (current_trace_status ());
2646 if (args
== 0 || *args
== 0)
2647 { /* XXX FIXME: what should default behavior be? */
2648 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2652 if (0 != (tmp
= strchr (args
, ',')))
2654 *tmp
++ = '\0'; /* Terminate start address. */
2655 tmp
= skip_spaces (tmp
);
2656 start
= parse_and_eval_address (args
);
2657 stop
= parse_and_eval_address (tmp
);
2660 { /* No explicit end address? */
2661 start
= parse_and_eval_address (args
);
2662 stop
= start
+ 1; /* ??? */
2665 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2668 /* tfind outside command */
2670 trace_find_outside_command (char *args
, int from_tty
)
2672 CORE_ADDR start
, stop
;
2675 if (current_trace_status ()->running
2676 && current_trace_status ()->filename
== NULL
)
2677 error (_("May not look at trace frames while trace is running."));
2679 if (args
== 0 || *args
== 0)
2680 { /* XXX FIXME: what should default behavior be? */
2681 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2685 if (0 != (tmp
= strchr (args
, ',')))
2687 *tmp
++ = '\0'; /* Terminate start address. */
2688 tmp
= skip_spaces (tmp
);
2689 start
= parse_and_eval_address (args
);
2690 stop
= parse_and_eval_address (tmp
);
2693 { /* No explicit end address? */
2694 start
= parse_and_eval_address (args
);
2695 stop
= start
+ 1; /* ??? */
2698 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2701 /* info scope command: list the locals for a scope. */
2703 scope_info (char *args
, int from_tty
)
2705 struct symtabs_and_lines sals
;
2707 struct bound_minimal_symbol msym
;
2708 const struct block
*block
;
2709 const char *symname
;
2710 char *save_args
= args
;
2711 struct block_iterator iter
;
2713 struct gdbarch
*gdbarch
;
2716 if (args
== 0 || *args
== 0)
2717 error (_("requires an argument (function, "
2718 "line or *addr) to define a scope"));
2720 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2721 if (sals
.nelts
== 0)
2722 return; /* Presumably decode_line_1 has already warned. */
2724 /* Resolve line numbers to PC. */
2725 resolve_sal_pc (&sals
.sals
[0]);
2726 block
= block_for_pc (sals
.sals
[0].pc
);
2730 QUIT
; /* Allow user to bail out with ^C. */
2731 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2733 QUIT
; /* Allow user to bail out with ^C. */
2735 printf_filtered ("Scope for %s:\n", save_args
);
2738 symname
= SYMBOL_PRINT_NAME (sym
);
2739 if (symname
== NULL
|| *symname
== '\0')
2740 continue; /* Probably botched, certainly useless. */
2742 gdbarch
= symbol_arch (sym
);
2744 printf_filtered ("Symbol %s is ", symname
);
2746 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2747 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2748 BLOCK_START (block
),
2752 switch (SYMBOL_CLASS (sym
))
2755 case LOC_UNDEF
: /* Messed up symbol? */
2756 printf_filtered ("a bogus symbol, class %d.\n",
2757 SYMBOL_CLASS (sym
));
2758 count
--; /* Don't count this one. */
2761 printf_filtered ("a constant with value %s (%s)",
2762 plongest (SYMBOL_VALUE (sym
)),
2763 hex_string (SYMBOL_VALUE (sym
)));
2765 case LOC_CONST_BYTES
:
2766 printf_filtered ("constant bytes: ");
2767 if (SYMBOL_TYPE (sym
))
2768 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2769 fprintf_filtered (gdb_stdout
, " %02x",
2770 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2773 printf_filtered ("in static storage at address ");
2774 printf_filtered ("%s", paddress (gdbarch
,
2775 SYMBOL_VALUE_ADDRESS (sym
)));
2778 /* GDBARCH is the architecture associated with the objfile
2779 the symbol is defined in; the target architecture may be
2780 different, and may provide additional registers. However,
2781 we do not know the target architecture at this point.
2782 We assume the objfile architecture will contain all the
2783 standard registers that occur in debug info in that
2785 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2788 if (SYMBOL_IS_ARGUMENT (sym
))
2789 printf_filtered ("an argument in register $%s",
2790 gdbarch_register_name (gdbarch
, regno
));
2792 printf_filtered ("a local variable in register $%s",
2793 gdbarch_register_name (gdbarch
, regno
));
2796 printf_filtered ("an argument at stack/frame offset %s",
2797 plongest (SYMBOL_VALUE (sym
)));
2800 printf_filtered ("a local variable at frame offset %s",
2801 plongest (SYMBOL_VALUE (sym
)));
2804 printf_filtered ("a reference argument at offset %s",
2805 plongest (SYMBOL_VALUE (sym
)));
2807 case LOC_REGPARM_ADDR
:
2808 /* Note comment at LOC_REGISTER. */
2809 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2811 printf_filtered ("the address of an argument, in register $%s",
2812 gdbarch_register_name (gdbarch
, regno
));
2815 printf_filtered ("a typedef.\n");
2818 printf_filtered ("a label at address ");
2819 printf_filtered ("%s", paddress (gdbarch
,
2820 SYMBOL_VALUE_ADDRESS (sym
)));
2823 printf_filtered ("a function at address ");
2824 printf_filtered ("%s",
2825 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2827 case LOC_UNRESOLVED
:
2828 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2830 if (msym
.minsym
== NULL
)
2831 printf_filtered ("Unresolved Static");
2834 printf_filtered ("static storage at address ");
2835 printf_filtered ("%s",
2837 BMSYMBOL_VALUE_ADDRESS (msym
)));
2840 case LOC_OPTIMIZED_OUT
:
2841 printf_filtered ("optimized out.\n");
2844 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2847 if (SYMBOL_TYPE (sym
))
2848 printf_filtered (", length %d.\n",
2849 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2851 if (BLOCK_FUNCTION (block
))
2854 block
= BLOCK_SUPERBLOCK (block
);
2857 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2861 /* Helper for trace_dump_command. Dump the action list starting at
2862 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2863 actions of the body of a while-stepping action. STEPPING_FRAME is
2864 set if the current traceframe was determined to be a while-stepping
2868 trace_dump_actions (struct command_line
*action
,
2869 int stepping_actions
, int stepping_frame
,
2872 const char *action_exp
, *next_comma
;
2874 for (; action
!= NULL
; action
= action
->next
)
2876 struct cmd_list_element
*cmd
;
2878 QUIT
; /* Allow user to bail out with ^C. */
2879 action_exp
= action
->line
;
2880 action_exp
= skip_spaces_const (action_exp
);
2882 /* The collection actions to be done while stepping are
2883 bracketed by the commands "while-stepping" and "end". */
2885 if (*action_exp
== '#') /* comment line */
2888 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2890 error (_("Bad action list item: %s"), action_exp
);
2892 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2896 for (i
= 0; i
< action
->body_count
; ++i
)
2897 trace_dump_actions (action
->body_list
[i
],
2898 1, stepping_frame
, from_tty
);
2900 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2902 /* Display the collected data.
2903 For the trap frame, display only what was collected at
2904 the trap. Likewise for stepping frames, display only
2905 what was collected while stepping. This means that the
2906 two boolean variables, STEPPING_FRAME and
2907 STEPPING_ACTIONS should be equal. */
2908 if (stepping_frame
== stepping_actions
)
2911 struct cleanup
*old_chain
2912 = make_cleanup (free_current_contents
, &cmd
);
2913 int trace_string
= 0;
2915 if (*action_exp
== '/')
2916 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2919 { /* Repeat over a comma-separated list. */
2920 QUIT
; /* Allow user to bail out with ^C. */
2921 if (*action_exp
== ',')
2923 action_exp
= skip_spaces_const (action_exp
);
2925 next_comma
= strchr (action_exp
, ',');
2927 if (0 == strncasecmp (action_exp
, "$reg", 4))
2928 registers_info (NULL
, from_tty
);
2929 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2931 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2932 locals_info (NULL
, from_tty
);
2933 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2934 args_info (NULL
, from_tty
);
2937 if (next_comma
!= NULL
)
2939 size_t len
= next_comma
- action_exp
;
2941 cmd
= xrealloc (cmd
, len
+ 1);
2942 memcpy (cmd
, action_exp
, len
);
2947 size_t len
= strlen (action_exp
);
2949 cmd
= xrealloc (cmd
, len
+ 1);
2950 memcpy (cmd
, action_exp
, len
+ 1);
2953 printf_filtered ("%s = ", cmd
);
2954 output_command_const (cmd
, from_tty
);
2955 printf_filtered ("\n");
2957 action_exp
= next_comma
;
2959 while (action_exp
&& *action_exp
== ',');
2961 do_cleanups (old_chain
);
2967 /* Return bp_location of the tracepoint associated with the current
2968 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2969 is a stepping traceframe. */
2971 struct bp_location
*
2972 get_traceframe_location (int *stepping_frame_p
)
2974 struct tracepoint
*t
;
2975 struct bp_location
*tloc
;
2976 struct regcache
*regcache
;
2978 if (tracepoint_number
== -1)
2979 error (_("No current trace frame."));
2981 t
= get_tracepoint (tracepoint_number
);
2984 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2987 /* The current frame is a trap frame if the frame PC is equal to the
2988 tracepoint PC. If not, then the current frame was collected
2989 during single-stepping. */
2990 regcache
= get_current_regcache ();
2992 /* If the traceframe's address matches any of the tracepoint's
2993 locations, assume it is a direct hit rather than a while-stepping
2994 frame. (FIXME this is not reliable, should record each frame's
2996 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
2997 if (tloc
->address
== regcache_read_pc (regcache
))
2999 *stepping_frame_p
= 0;
3003 /* If this is a stepping frame, we don't know which location
3004 triggered. The first is as good (or bad) a guess as any... */
3005 *stepping_frame_p
= 1;
3009 /* Return all the actions, including default collect, of a tracepoint
3010 T. It constructs cleanups into the chain, and leaves the caller to
3011 handle them (call do_cleanups). */
3013 static struct command_line
*
3014 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3016 struct command_line
*actions
;
3018 actions
= breakpoint_commands (t
);
3020 /* If there are default expressions to collect, make up a collect
3021 action and prepend to the action list to encode. Note that since
3022 validation is per-tracepoint (local var "xyz" might be valid for
3023 one tracepoint and not another, etc), we make up the action on
3024 the fly, and don't cache it. */
3025 if (*default_collect
)
3027 struct command_line
*default_collect_action
;
3028 char *default_collect_line
;
3030 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3031 make_cleanup (xfree
, default_collect_line
);
3033 validate_actionline (default_collect_line
, t
);
3034 default_collect_action
= xmalloc (sizeof (struct command_line
));
3035 make_cleanup (xfree
, default_collect_action
);
3036 default_collect_action
->next
= actions
;
3037 default_collect_action
->line
= default_collect_line
;
3038 actions
= default_collect_action
;
3044 /* The tdump command. */
3047 trace_dump_command (char *args
, int from_tty
)
3049 int stepping_frame
= 0;
3050 struct bp_location
*loc
;
3051 struct cleanup
*old_chain
;
3052 struct command_line
*actions
;
3054 /* This throws an error is not inspecting a trace frame. */
3055 loc
= get_traceframe_location (&stepping_frame
);
3057 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3058 tracepoint_number
, traceframe_number
);
3060 old_chain
= make_cleanup (null_cleanup
, NULL
);
3062 /* This command only makes sense for the current frame, not the
3064 make_cleanup_restore_current_thread ();
3065 select_frame (get_current_frame ());
3067 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3069 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3071 do_cleanups (old_chain
);
3074 /* Encode a piece of a tracepoint's source-level definition in a form
3075 that is suitable for both protocol and saving in files. */
3076 /* This version does not do multiple encodes for long strings; it should
3077 return an offset to the next piece to encode. FIXME */
3080 encode_source_string (int tpnum
, ULONGEST addr
,
3081 char *srctype
, char *src
, char *buf
, int buf_size
)
3083 if (80 + strlen (srctype
) > buf_size
)
3084 error (_("Buffer too small for source encoding"));
3085 sprintf (buf
, "%x:%s:%s:%x:%x:",
3086 tpnum
, phex_nz (addr
, sizeof (addr
)),
3087 srctype
, 0, (int) strlen (src
));
3088 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3089 error (_("Source string too long for buffer"));
3090 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
3094 /* Tell the target what to do with an ongoing tracing run if GDB
3095 disconnects for some reason. */
3098 set_disconnected_tracing (char *args
, int from_tty
,
3099 struct cmd_list_element
*c
)
3101 target_set_disconnected_tracing (disconnected_tracing
);
3105 set_circular_trace_buffer (char *args
, int from_tty
,
3106 struct cmd_list_element
*c
)
3108 target_set_circular_trace_buffer (circular_trace_buffer
);
3112 set_trace_buffer_size (char *args
, int from_tty
,
3113 struct cmd_list_element
*c
)
3115 target_set_trace_buffer_size (trace_buffer_size
);
3119 set_trace_user (char *args
, int from_tty
,
3120 struct cmd_list_element
*c
)
3124 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3127 warning (_("Target does not support trace notes, user ignored"));
3131 set_trace_notes (char *args
, int from_tty
,
3132 struct cmd_list_element
*c
)
3136 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3139 warning (_("Target does not support trace notes, note ignored"));
3143 set_trace_stop_notes (char *args
, int from_tty
,
3144 struct cmd_list_element
*c
)
3148 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3151 warning (_("Target does not support trace notes, stop note ignored"));
3154 /* Convert the memory pointed to by mem into hex, placing result in buf.
3155 * Return a pointer to the last char put in buf (null)
3156 * "stolen" from sparc-stub.c
3159 static const char hexchars
[] = "0123456789abcdef";
3162 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3170 *buf
++ = hexchars
[ch
>> 4];
3171 *buf
++ = hexchars
[ch
& 0xf];
3180 get_traceframe_number (void)
3182 return traceframe_number
;
3186 get_tracepoint_number (void)
3188 return tracepoint_number
;
3191 /* Make the traceframe NUM be the current trace frame. Does nothing
3192 if NUM is already current. */
3195 set_current_traceframe (int num
)
3199 if (traceframe_number
== num
)
3201 /* Nothing to do. */
3205 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3208 warning (_("could not change traceframe"));
3210 set_traceframe_num (newnum
);
3212 /* Changing the traceframe changes our view of registers and of the
3214 registers_changed ();
3216 clear_traceframe_info ();
3219 /* A cleanup used when switching away and back from tfind mode. */
3221 struct current_traceframe_cleanup
3223 /* The traceframe we were inspecting. */
3224 int traceframe_number
;
3228 do_restore_current_traceframe_cleanup (void *arg
)
3230 struct current_traceframe_cleanup
*old
= arg
;
3232 set_current_traceframe (old
->traceframe_number
);
3236 restore_current_traceframe_cleanup_dtor (void *arg
)
3238 struct current_traceframe_cleanup
*old
= arg
;
3244 make_cleanup_restore_current_traceframe (void)
3246 struct current_traceframe_cleanup
*old
;
3248 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3249 old
->traceframe_number
= traceframe_number
;
3251 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3252 restore_current_traceframe_cleanup_dtor
);
3255 /* Given a number and address, return an uploaded tracepoint with that
3256 number, creating if necessary. */
3258 struct uploaded_tp
*
3259 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3261 struct uploaded_tp
*utp
;
3263 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3264 if (utp
->number
== num
&& utp
->addr
== addr
)
3266 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3267 memset (utp
, 0, sizeof (struct uploaded_tp
));
3270 utp
->actions
= NULL
;
3271 utp
->step_actions
= NULL
;
3272 utp
->cmd_strings
= NULL
;
3279 free_uploaded_tps (struct uploaded_tp
**utpp
)
3281 struct uploaded_tp
*next_one
;
3285 next_one
= (*utpp
)->next
;
3291 /* Given a number and address, return an uploaded tracepoint with that
3292 number, creating if necessary. */
3294 struct uploaded_tsv
*
3295 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3297 struct uploaded_tsv
*utsv
;
3299 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3300 if (utsv
->number
== num
)
3302 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3303 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3305 utsv
->next
= *utsvp
;
3311 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3313 struct uploaded_tsv
*next_one
;
3317 next_one
= (*utsvp
)->next
;
3323 /* FIXME this function is heuristic and will miss the cases where the
3324 conditional is semantically identical but differs in whitespace,
3325 such as "x == 0" vs "x==0". */
3328 cond_string_is_same (char *str1
, char *str2
)
3330 if (str1
== NULL
|| str2
== NULL
)
3331 return (str1
== str2
);
3333 return (strcmp (str1
, str2
) == 0);
3336 /* Look for an existing tracepoint that seems similar enough to the
3337 uploaded one. Enablement isn't compared, because the user can
3338 toggle that freely, and may have done so in anticipation of the
3339 next trace run. Return the location of matched tracepoint. */
3341 static struct bp_location
*
3342 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3344 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3346 struct breakpoint
*b
;
3347 struct bp_location
*loc
;
3349 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3351 struct tracepoint
*t
= (struct tracepoint
*) b
;
3353 if (b
->type
== utp
->type
3354 && t
->step_count
== utp
->step
3355 && t
->pass_count
== utp
->pass
3356 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3357 /* FIXME also test actions. */
3360 /* Scan the locations for an address match. */
3361 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3363 if (loc
->address
== utp
->addr
)
3371 /* Given a list of tracepoints uploaded from a target, attempt to
3372 match them up with existing tracepoints, and create new ones if not
3376 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3378 struct uploaded_tp
*utp
;
3379 /* A set of tracepoints which are modified. */
3380 VEC(breakpoint_p
) *modified_tp
= NULL
;
3382 struct breakpoint
*b
;
3384 /* Look for GDB tracepoints that match up with our uploaded versions. */
3385 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3387 struct bp_location
*loc
;
3388 struct tracepoint
*t
;
3390 loc
= find_matching_tracepoint_location (utp
);
3395 /* Mark this location as already inserted. */
3397 t
= (struct tracepoint
*) loc
->owner
;
3398 printf_filtered (_("Assuming tracepoint %d is same "
3399 "as target's tracepoint %d at %s.\n"),
3400 loc
->owner
->number
, utp
->number
,
3401 paddress (loc
->gdbarch
, utp
->addr
));
3403 /* The tracepoint LOC->owner was modified (the location LOC
3404 was marked as inserted in the target). Save it in
3405 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3406 observers will be notified later once for each tracepoint
3407 saved in MODIFIED_TP. */
3409 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3411 if (b
== loc
->owner
)
3417 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3421 t
= create_tracepoint_from_upload (utp
);
3423 printf_filtered (_("Created tracepoint %d for "
3424 "target's tracepoint %d at %s.\n"),
3425 t
->base
.number
, utp
->number
,
3426 paddress (get_current_arch (), utp
->addr
));
3428 printf_filtered (_("Failed to create tracepoint for target's "
3429 "tracepoint %d at %s, skipping it.\n"),
3431 paddress (get_current_arch (), utp
->addr
));
3433 /* Whether found or created, record the number used by the
3434 target, to help with mapping target tracepoints back to their
3435 counterparts here. */
3437 t
->number_on_target
= utp
->number
;
3440 /* Notify 'breakpoint-modified' observer that at least one of B's
3441 locations was changed. */
3442 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3443 observer_notify_breakpoint_modified (b
);
3445 VEC_free (breakpoint_p
, modified_tp
);
3446 free_uploaded_tps (uploaded_tps
);
3449 /* Trace state variables don't have much to identify them beyond their
3450 name, so just use that to detect matches. */
3452 static struct trace_state_variable
*
3453 find_matching_tsv (struct uploaded_tsv
*utsv
)
3458 return find_trace_state_variable (utsv
->name
);
3461 static struct trace_state_variable
*
3462 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3464 const char *namebase
;
3467 struct trace_state_variable
*tsv
;
3468 struct cleanup
*old_chain
;
3472 namebase
= utsv
->name
;
3473 buf
= xstrprintf ("%s", namebase
);
3478 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3481 /* Fish for a name that is not in use. */
3482 /* (should check against all internal vars?) */
3483 while (find_trace_state_variable (buf
))
3486 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3489 old_chain
= make_cleanup (xfree
, buf
);
3491 /* We have an available name, create the variable. */
3492 tsv
= create_trace_state_variable (buf
);
3493 tsv
->initial_value
= utsv
->initial_value
;
3494 tsv
->builtin
= utsv
->builtin
;
3496 observer_notify_tsv_created (tsv
);
3498 do_cleanups (old_chain
);
3503 /* Given a list of uploaded trace state variables, try to match them
3504 up with existing variables, or create additional ones. */
3507 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3510 struct uploaded_tsv
*utsv
;
3511 struct trace_state_variable
*tsv
;
3514 /* Most likely some numbers will have to be reassigned as part of
3515 the merge, so clear them all in anticipation. */
3516 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3519 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3521 tsv
= find_matching_tsv (utsv
);
3525 printf_filtered (_("Assuming trace state variable $%s "
3526 "is same as target's variable %d.\n"),
3527 tsv
->name
, utsv
->number
);
3531 tsv
= create_tsv_from_upload (utsv
);
3533 printf_filtered (_("Created trace state variable "
3534 "$%s for target's variable %d.\n"),
3535 tsv
->name
, utsv
->number
);
3537 /* Give precedence to numberings that come from the target. */
3539 tsv
->number
= utsv
->number
;
3542 /* Renumber everything that didn't get a target-assigned number. */
3544 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3545 if (tsv
->number
> highest
)
3546 highest
= tsv
->number
;
3549 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3550 if (tsv
->number
== 0)
3551 tsv
->number
= highest
++;
3553 free_uploaded_tsvs (uploaded_tsvs
);
3556 /* Parse the part of trace status syntax that is shared between
3557 the remote protocol and the trace file reader. */
3560 parse_trace_status (char *line
, struct trace_status
*ts
)
3562 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3566 ts
->running_known
= 1;
3567 ts
->running
= (*p
++ == '1');
3568 ts
->stop_reason
= trace_stop_reason_unknown
;
3569 xfree (ts
->stop_desc
);
3570 ts
->stop_desc
= NULL
;
3571 ts
->traceframe_count
= -1;
3572 ts
->traceframes_created
= -1;
3573 ts
->buffer_free
= -1;
3574 ts
->buffer_size
= -1;
3575 ts
->disconnected_tracing
= 0;
3576 ts
->circular_buffer
= 0;
3577 xfree (ts
->user_name
);
3578 ts
->user_name
= NULL
;
3581 ts
->start_time
= ts
->stop_time
= 0;
3585 p1
= strchr (p
, ':');
3587 error (_("Malformed trace status, at %s\n\
3588 Status line: '%s'\n"), p
, line
);
3589 p3
= strchr (p
, ';');
3591 p3
= p
+ strlen (p
);
3592 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3594 p
= unpack_varlen_hex (++p1
, &val
);
3595 ts
->stop_reason
= trace_buffer_full
;
3597 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3599 p
= unpack_varlen_hex (++p1
, &val
);
3600 ts
->stop_reason
= trace_never_run
;
3602 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3605 p
= unpack_varlen_hex (++p1
, &val
);
3606 ts
->stop_reason
= tracepoint_passcount
;
3607 ts
->stopping_tracepoint
= val
;
3609 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3611 p2
= strchr (++p1
, ':');
3619 ts
->stop_desc
= xmalloc (strlen (line
));
3620 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3621 ts
->stop_desc
[end
] = '\0';
3624 ts
->stop_desc
= xstrdup ("");
3626 p
= unpack_varlen_hex (++p2
, &val
);
3627 ts
->stop_reason
= tstop_command
;
3629 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3631 p
= unpack_varlen_hex (++p1
, &val
);
3632 ts
->stop_reason
= trace_disconnected
;
3634 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3636 p2
= strchr (++p1
, ':');
3639 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3640 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3641 ts
->stop_desc
[end
] = '\0';
3644 ts
->stop_desc
= xstrdup ("");
3646 p
= unpack_varlen_hex (++p2
, &val
);
3647 ts
->stopping_tracepoint
= val
;
3648 ts
->stop_reason
= tracepoint_error
;
3650 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3652 p
= unpack_varlen_hex (++p1
, &val
);
3653 ts
->traceframe_count
= val
;
3655 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3657 p
= unpack_varlen_hex (++p1
, &val
);
3658 ts
->traceframes_created
= val
;
3660 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3662 p
= unpack_varlen_hex (++p1
, &val
);
3663 ts
->buffer_free
= val
;
3665 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3667 p
= unpack_varlen_hex (++p1
, &val
);
3668 ts
->buffer_size
= val
;
3670 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3672 p
= unpack_varlen_hex (++p1
, &val
);
3673 ts
->disconnected_tracing
= val
;
3675 else if (strncmp (p
, "circular", p1
- p
) == 0)
3677 p
= unpack_varlen_hex (++p1
, &val
);
3678 ts
->circular_buffer
= val
;
3680 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3682 p
= unpack_varlen_hex (++p1
, &val
);
3683 ts
->start_time
= val
;
3685 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3687 p
= unpack_varlen_hex (++p1
, &val
);
3688 ts
->stop_time
= val
;
3690 else if (strncmp (p
, "username", p1
- p
) == 0)
3693 ts
->user_name
= xmalloc (strlen (p
) / 2);
3694 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3695 ts
->user_name
[end
] = '\0';
3698 else if (strncmp (p
, "notes", p1
- p
) == 0)
3701 ts
->notes
= xmalloc (strlen (p
) / 2);
3702 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3703 ts
->notes
[end
] = '\0';
3708 /* Silently skip unknown optional info. */
3709 p_temp
= strchr (p1
+ 1, ';');
3713 /* Must be at the end. */
3720 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3721 struct uploaded_tp
*utp
)
3724 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3726 p
= unpack_varlen_hex (p
, &uval
);
3728 tp
->base
.hit_count
+= uval
;
3730 utp
->hit_count
+= uval
;
3731 p
= unpack_varlen_hex (p
+ 1, &uval
);
3733 tp
->traceframe_usage
+= uval
;
3735 utp
->traceframe_usage
+= uval
;
3736 /* Ignore any extra, allowing for future extensions. */
3739 /* Given a line of text defining a part of a tracepoint, parse it into
3740 an "uploaded tracepoint". */
3743 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3747 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3750 char *cond
, *srctype
, *buf
;
3751 struct uploaded_tp
*utp
= NULL
;
3754 /* Both tracepoint and action definitions start with the same number
3755 and address sequence. */
3757 p
= unpack_varlen_hex (p
, &num
);
3758 p
++; /* skip a colon */
3759 p
= unpack_varlen_hex (p
, &addr
);
3760 p
++; /* skip a colon */
3763 enabled
= (*p
++ == 'E');
3764 p
++; /* skip a colon */
3765 p
= unpack_varlen_hex (p
, &step
);
3766 p
++; /* skip a colon */
3767 p
= unpack_varlen_hex (p
, &pass
);
3768 type
= bp_tracepoint
;
3770 /* Thumb through optional fields. */
3773 p
++; /* skip a colon */
3776 type
= bp_fast_tracepoint
;
3778 p
= unpack_varlen_hex (p
, &orig_size
);
3782 type
= bp_static_tracepoint
;
3788 p
= unpack_varlen_hex (p
, &xlen
);
3789 p
++; /* skip a comma */
3790 cond
= (char *) xmalloc (2 * xlen
+ 1);
3791 strncpy (cond
, p
, 2 * xlen
);
3792 cond
[2 * xlen
] = '\0';
3796 warning (_("Unrecognized char '%c' in tracepoint "
3797 "definition, skipping rest"), *p
);
3799 utp
= get_uploaded_tp (num
, addr
, utpp
);
3801 utp
->enabled
= enabled
;
3806 else if (piece
== 'A')
3808 utp
= get_uploaded_tp (num
, addr
, utpp
);
3809 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3811 else if (piece
== 'S')
3813 utp
= get_uploaded_tp (num
, addr
, utpp
);
3814 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3816 else if (piece
== 'Z')
3818 /* Parse a chunk of source form definition. */
3819 utp
= get_uploaded_tp (num
, addr
, utpp
);
3821 p
= strchr (p
, ':');
3822 p
++; /* skip a colon */
3823 p
= unpack_varlen_hex (p
, &start
);
3824 p
++; /* skip a colon */
3825 p
= unpack_varlen_hex (p
, &xlen
);
3826 p
++; /* skip a colon */
3828 buf
= alloca (strlen (line
));
3830 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3833 if (startswith (srctype
, "at:"))
3834 utp
->at_string
= xstrdup (buf
);
3835 else if (startswith (srctype
, "cond:"))
3836 utp
->cond_string
= xstrdup (buf
);
3837 else if (startswith (srctype
, "cmd:"))
3838 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3840 else if (piece
== 'V')
3842 utp
= get_uploaded_tp (num
, addr
, utpp
);
3844 parse_tracepoint_status (p
, NULL
, utp
);
3848 /* Don't error out, the target might be sending us optional
3849 info that we don't care about. */
3850 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3854 /* Convert a textual description of a trace state variable into an
3858 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3861 ULONGEST num
, initval
, builtin
;
3863 struct uploaded_tsv
*utsv
= NULL
;
3865 buf
= alloca (strlen (line
));
3868 p
= unpack_varlen_hex (p
, &num
);
3869 p
++; /* skip a colon */
3870 p
= unpack_varlen_hex (p
, &initval
);
3871 p
++; /* skip a colon */
3872 p
= unpack_varlen_hex (p
, &builtin
);
3873 p
++; /* skip a colon */
3874 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3877 utsv
= get_uploaded_tsv (num
, utsvp
);
3878 utsv
->initial_value
= initval
;
3879 utsv
->builtin
= builtin
;
3880 utsv
->name
= xstrdup (buf
);
3884 free_current_marker (void *arg
)
3886 struct static_tracepoint_marker
**marker_p
= arg
;
3888 if (*marker_p
!= NULL
)
3890 release_static_tracepoint_marker (*marker_p
);
3897 /* Given a line of text defining a static tracepoint marker, parse it
3898 into a "static tracepoint marker" object. Throws an error is
3899 parsing fails. If PP is non-null, it points to one past the end of
3900 the parsed marker definition. */
3903 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
3904 struct static_tracepoint_marker
*marker
)
3911 p
= unpack_varlen_hex (p
, &addr
);
3912 p
++; /* skip a colon */
3914 marker
->gdbarch
= target_gdbarch ();
3915 marker
->address
= (CORE_ADDR
) addr
;
3917 endp
= strchr (p
, ':');
3919 error (_("bad marker definition: %s"), line
);
3921 marker
->str_id
= xmalloc (endp
- p
+ 1);
3922 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
3923 marker
->str_id
[end
] = '\0';
3926 p
++; /* skip a colon */
3928 marker
->extra
= xmalloc (strlen (p
) + 1);
3929 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
3930 marker
->extra
[end
] = '\0';
3936 /* Release a static tracepoint marker's contents. Note that the
3937 object itself isn't released here. There objects are usually on
3941 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
3943 xfree (marker
->str_id
);
3944 marker
->str_id
= NULL
;
3947 /* Print MARKER to gdb_stdout. */
3950 print_one_static_tracepoint_marker (int count
,
3951 struct static_tracepoint_marker
*marker
)
3953 struct command_line
*l
;
3956 char wrap_indent
[80];
3957 char extra_field_indent
[80];
3958 struct ui_out
*uiout
= current_uiout
;
3959 struct cleanup
*bkpt_chain
;
3960 VEC(breakpoint_p
) *tracepoints
;
3962 struct symtab_and_line sal
;
3966 sal
.pc
= marker
->address
;
3968 tracepoints
= static_tracepoints_here (marker
->address
);
3970 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
3972 /* A counter field to help readability. This is not a stable
3974 ui_out_field_int (uiout
, "count", count
);
3976 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
3978 ui_out_field_fmt (uiout
, "enabled", "%c",
3979 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
3980 ui_out_spaces (uiout
, 2);
3982 strcpy (wrap_indent
, " ");
3984 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
3985 strcat (wrap_indent
, " ");
3987 strcat (wrap_indent
, " ");
3989 strcpy (extra_field_indent
, " ");
3991 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
3993 sal
= find_pc_line (marker
->address
, 0);
3994 sym
= find_pc_sect_function (marker
->address
, NULL
);
3997 ui_out_text (uiout
, "in ");
3998 ui_out_field_string (uiout
, "func",
3999 SYMBOL_PRINT_NAME (sym
));
4000 ui_out_wrap_hint (uiout
, wrap_indent
);
4001 ui_out_text (uiout
, " at ");
4004 ui_out_field_skip (uiout
, "func");
4006 if (sal
.symtab
!= NULL
)
4008 ui_out_field_string (uiout
, "file",
4009 symtab_to_filename_for_display (sal
.symtab
));
4010 ui_out_text (uiout
, ":");
4012 if (ui_out_is_mi_like_p (uiout
))
4014 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4016 ui_out_field_string (uiout
, "fullname", fullname
);
4019 ui_out_field_skip (uiout
, "fullname");
4021 ui_out_field_int (uiout
, "line", sal
.line
);
4025 ui_out_field_skip (uiout
, "fullname");
4026 ui_out_field_skip (uiout
, "line");
4029 ui_out_text (uiout
, "\n");
4030 ui_out_text (uiout
, extra_field_indent
);
4031 ui_out_text (uiout
, _("Data: \""));
4032 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4033 ui_out_text (uiout
, "\"\n");
4035 if (!VEC_empty (breakpoint_p
, tracepoints
))
4037 struct cleanup
*cleanup_chain
;
4039 struct breakpoint
*b
;
4041 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4044 ui_out_text (uiout
, extra_field_indent
);
4045 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4046 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4049 ui_out_text (uiout
, ", ");
4050 ui_out_text (uiout
, "#");
4051 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4054 do_cleanups (cleanup_chain
);
4056 if (ui_out_is_mi_like_p (uiout
))
4057 ui_out_field_int (uiout
, "number-of-tracepoints",
4058 VEC_length(breakpoint_p
, tracepoints
));
4060 ui_out_text (uiout
, "\n");
4062 VEC_free (breakpoint_p
, tracepoints
);
4064 do_cleanups (bkpt_chain
);
4068 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4070 VEC(static_tracepoint_marker_p
) *markers
;
4071 struct cleanup
*old_chain
;
4072 struct static_tracepoint_marker
*marker
;
4073 struct ui_out
*uiout
= current_uiout
;
4076 /* We don't have to check target_can_use_agent and agent's capability on
4077 static tracepoint here, in order to be compatible with older GDBserver.
4078 We don't check USE_AGENT is true or not, because static tracepoints
4079 don't work without in-process agent, so we don't bother users to type
4080 `set agent on' when to use static tracepoint. */
4083 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4084 "StaticTracepointMarkersTable");
4086 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4088 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4090 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4091 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4092 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4094 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4095 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4097 ui_out_table_body (uiout
);
4099 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4100 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4103 VEC_iterate (static_tracepoint_marker_p
,
4104 markers
, i
, marker
);
4107 print_one_static_tracepoint_marker (i
+ 1, marker
);
4108 release_static_tracepoint_marker (marker
);
4111 do_cleanups (old_chain
);
4114 /* The $_sdata convenience variable is a bit special. We don't know
4115 for sure type of the value until we actually have a chance to fetch
4116 the data --- the size of the object depends on what has been
4117 collected. We solve this by making $_sdata be an internalvar that
4118 creates a new value on access. */
4120 /* Return a new value with the correct type for the sdata object of
4121 the current trace frame. Return a void value if there's no object
4124 static struct value
*
4125 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4131 /* We need to read the whole object before we know its size. */
4132 size
= target_read_alloc (¤t_target
,
4133 TARGET_OBJECT_STATIC_TRACE_DATA
,
4140 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4142 v
= allocate_value (type
);
4143 memcpy (value_contents_raw (v
), buf
, size
);
4148 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4151 #if !defined(HAVE_LIBEXPAT)
4153 struct traceframe_info
*
4154 parse_traceframe_info (const char *tframe_info
)
4156 static int have_warned
;
4161 warning (_("Can not parse XML trace frame info; XML support "
4162 "was disabled at compile time"));
4168 #else /* HAVE_LIBEXPAT */
4170 #include "xml-support.h"
4172 /* Handle the start of a <memory> element. */
4175 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4176 const struct gdb_xml_element
*element
,
4177 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4179 struct traceframe_info
*info
= user_data
;
4180 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4181 ULONGEST
*start_p
, *length_p
;
4183 start_p
= xml_find_attribute (attributes
, "start")->value
;
4184 length_p
= xml_find_attribute (attributes
, "length")->value
;
4186 r
->start
= *start_p
;
4187 r
->length
= *length_p
;
4190 /* Handle the start of a <tvar> element. */
4193 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
4194 const struct gdb_xml_element
*element
,
4196 VEC(gdb_xml_value_s
) *attributes
)
4198 struct traceframe_info
*info
= user_data
;
4199 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
4200 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
4202 VEC_safe_push (int, info
->tvars
, id
);
4205 /* Discard the constructed trace frame info (if an error occurs). */
4208 free_result (void *p
)
4210 struct traceframe_info
*result
= p
;
4212 free_traceframe_info (result
);
4215 /* The allowed elements and attributes for an XML memory map. */
4217 static const struct gdb_xml_attribute memory_attributes
[] = {
4218 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4219 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4220 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4223 static const struct gdb_xml_attribute tvar_attributes
[] = {
4224 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
4225 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4228 static const struct gdb_xml_element traceframe_info_children
[] = {
4229 { "memory", memory_attributes
, NULL
,
4230 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4231 traceframe_info_start_memory
, NULL
},
4232 { "tvar", tvar_attributes
, NULL
,
4233 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4234 traceframe_info_start_tvar
, NULL
},
4235 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4238 static const struct gdb_xml_element traceframe_info_elements
[] = {
4239 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4241 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4244 /* Parse a traceframe-info XML document. */
4246 struct traceframe_info
*
4247 parse_traceframe_info (const char *tframe_info
)
4249 struct traceframe_info
*result
;
4250 struct cleanup
*back_to
;
4252 result
= XCNEW (struct traceframe_info
);
4253 back_to
= make_cleanup (free_result
, result
);
4255 if (gdb_xml_parse_quick (_("trace frame info"),
4256 "traceframe-info.dtd", traceframe_info_elements
,
4257 tframe_info
, result
) == 0)
4259 /* Parsed successfully, keep the result. */
4260 discard_cleanups (back_to
);
4265 do_cleanups (back_to
);
4269 #endif /* HAVE_LIBEXPAT */
4271 /* Returns the traceframe_info object for the current traceframe.
4272 This is where we avoid re-fetching the object from the target if we
4273 already have it cached. */
4275 struct traceframe_info
*
4276 get_traceframe_info (void)
4278 if (traceframe_info
== NULL
)
4279 traceframe_info
= target_traceframe_info ();
4281 return traceframe_info
;
4284 /* If the target supports the query, return in RESULT the set of
4285 collected memory in the current traceframe, found within the LEN
4286 bytes range starting at MEMADDR. Returns true if the target
4287 supports the query, otherwise returns false, and RESULT is left
4291 traceframe_available_memory (VEC(mem_range_s
) **result
,
4292 CORE_ADDR memaddr
, ULONGEST len
)
4294 struct traceframe_info
*info
= get_traceframe_info ();
4298 struct mem_range
*r
;
4303 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4304 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4306 ULONGEST lo1
, hi1
, lo2
, hi2
;
4307 struct mem_range
*nr
;
4310 hi1
= memaddr
+ len
;
4313 hi2
= r
->start
+ r
->length
;
4315 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4317 nr
->start
= max (lo1
, lo2
);
4318 nr
->length
= min (hi1
, hi2
) - nr
->start
;
4321 normalize_mem_ranges (*result
);
4328 /* Implementation of `sdata' variable. */
4330 static const struct internalvar_funcs sdata_funcs
=
4337 /* module initialization */
4339 _initialize_tracepoint (void)
4341 struct cmd_list_element
*c
;
4343 /* Explicitly create without lookup, since that tries to create a
4344 value with a void typed value, and when we get here, gdbarch
4345 isn't initialized yet. At this point, we're quite sure there
4346 isn't another convenience variable of the same name. */
4347 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4349 traceframe_number
= -1;
4350 tracepoint_number
= -1;
4352 add_info ("scope", scope_info
,
4353 _("List the variables local to a scope"));
4355 add_cmd ("tracepoints", class_trace
, NULL
,
4356 _("Tracing of program execution without stopping the program."),
4359 add_com ("tdump", class_trace
, trace_dump_command
,
4360 _("Print everything collected at the current tracepoint."));
4362 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4363 Define a trace state variable.\n\
4364 Argument is a $-prefixed name, optionally followed\n\
4365 by '=' and an expression that sets the initial value\n\
4366 at the start of tracing."));
4367 set_cmd_completer (c
, expression_completer
);
4369 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4370 Delete one or more trace state variables.\n\
4371 Arguments are the names of the variables to delete.\n\
4372 If no arguments are supplied, delete all variables."), &deletelist
);
4373 /* FIXME add a trace variable completer. */
4375 add_info ("tvariables", tvariables_info
, _("\
4376 Status of trace state variables and their values.\n\
4379 add_info ("static-tracepoint-markers",
4380 info_static_tracepoint_markers_command
, _("\
4381 List target static tracepoints markers.\n\
4384 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4385 Select a trace frame;\n\
4386 No argument means forward by one frame; '-' means backward by one frame."),
4387 &tfindlist
, "tfind ", 1, &cmdlist
);
4389 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4390 Select a trace frame whose PC is outside the given range (exclusive).\n\
4391 Usage: tfind outside addr1, addr2"),
4394 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4395 Select a trace frame whose PC is in the given range (inclusive).\n\
4396 Usage: tfind range addr1,addr2"),
4399 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4400 Select a trace frame by source line.\n\
4401 Argument can be a line number (with optional source file),\n\
4402 a function name, or '*' followed by an address.\n\
4403 Default argument is 'the next source line that was traced'."),
4406 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4407 Select a trace frame by tracepoint number.\n\
4408 Default is the tracepoint for the current trace frame."),
4411 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4412 Select a trace frame by PC.\n\
4413 Default is the current PC, or the PC of the current trace frame."),
4416 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4417 De-select any trace frame and resume 'live' debugging."),
4420 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4422 add_cmd ("start", class_trace
, trace_find_start_command
,
4423 _("Select the first trace frame in the trace buffer."),
4426 add_com ("tstatus", class_trace
, trace_status_command
,
4427 _("Display the status of the current trace data collection."));
4429 add_com ("tstop", class_trace
, trace_stop_command
, _("\
4430 Stop trace data collection.\n\
4431 Usage: tstop [ <notes> ... ]\n\
4432 Any arguments supplied are recorded with the trace as a stop reason and\n\
4433 reported by tstatus (if the target supports trace notes)."));
4435 add_com ("tstart", class_trace
, trace_start_command
, _("\
4436 Start trace data collection.\n\
4437 Usage: tstart [ <notes> ... ]\n\
4438 Any arguments supplied are recorded with the trace as a note and\n\
4439 reported by tstatus (if the target supports trace notes)."));
4441 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4442 Ends a list of commands or actions.\n\
4443 Several GDB commands allow you to enter a list of commands or actions.\n\
4444 Entering \"end\" on a line by itself is the normal way to terminate\n\
4446 Note: the \"end\" command cannot be used at the gdb prompt."));
4448 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4449 Specify single-stepping behavior at a tracepoint.\n\
4450 Argument is number of instructions to trace in single-step mode\n\
4451 following the tracepoint. This command is normally followed by\n\
4452 one or more \"collect\" commands, to specify what to collect\n\
4453 while single-stepping.\n\n\
4454 Note: this command can only be used in a tracepoint \"actions\" list."));
4456 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4457 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4459 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4460 Specify one or more data items to be collected at a tracepoint.\n\
4461 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4462 collect all data (variables, registers) referenced by that expression.\n\
4463 Also accepts the following special arguments:\n\
4464 $regs -- all registers.\n\
4465 $args -- all function arguments.\n\
4466 $locals -- all variables local to the block/function scope.\n\
4467 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4468 Note: this command can only be used in a tracepoint \"actions\" list."));
4470 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4471 Specify one or more expressions to be evaluated at a tracepoint.\n\
4472 Accepts a comma-separated list of (one or more) expressions.\n\
4473 The result of each evaluation will be discarded.\n\
4474 Note: this command can only be used in a tracepoint \"actions\" list."));
4476 add_com ("actions", class_trace
, trace_actions_command
, _("\
4477 Specify the actions to be taken at a tracepoint.\n\
4478 Tracepoint actions may include collecting of specified data,\n\
4479 single-stepping, or enabling/disabling other tracepoints,\n\
4480 depending on target's capabilities."));
4482 default_collect
= xstrdup ("");
4483 add_setshow_string_cmd ("default-collect", class_trace
,
4484 &default_collect
, _("\
4485 Set the list of expressions to collect by default"), _("\
4486 Show the list of expressions to collect by default"), NULL
,
4488 &setlist
, &showlist
);
4490 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4491 &disconnected_tracing
, _("\
4492 Set whether tracing continues after GDB disconnects."), _("\
4493 Show whether tracing continues after GDB disconnects."), _("\
4494 Use this to continue a tracing run even if GDB disconnects\n\
4495 or detaches from the target. You can reconnect later and look at\n\
4496 trace data collected in the meantime."),
4497 set_disconnected_tracing
,
4502 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4503 &circular_trace_buffer
, _("\
4504 Set target's use of circular trace buffer."), _("\
4505 Show target's use of circular trace buffer."), _("\
4506 Use this to make the trace buffer into a circular buffer,\n\
4507 which will discard traceframes (oldest first) instead of filling\n\
4508 up and stopping the trace run."),
4509 set_circular_trace_buffer
,
4514 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4515 &trace_buffer_size
, _("\
4516 Set requested size of trace buffer."), _("\
4517 Show requested size of trace buffer."), _("\
4518 Use this to choose a size for the trace buffer. Some targets\n\
4519 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4520 disables any attempt to set the buffer size and lets the target choose."),
4521 set_trace_buffer_size
, NULL
,
4522 &setlist
, &showlist
);
4524 add_setshow_string_cmd ("trace-user", class_trace
,
4526 Set the user name to use for current and future trace runs"), _("\
4527 Show the user name to use for current and future trace runs"), NULL
,
4528 set_trace_user
, NULL
,
4529 &setlist
, &showlist
);
4531 add_setshow_string_cmd ("trace-notes", class_trace
,
4533 Set notes string to use for current and future trace runs"), _("\
4534 Show the notes string to use for current and future trace runs"), NULL
,
4535 set_trace_notes
, NULL
,
4536 &setlist
, &showlist
);
4538 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4539 &trace_stop_notes
, _("\
4540 Set notes string to use for future tstop commands"), _("\
4541 Show the notes string to use for future tstop commands"), NULL
,
4542 set_trace_stop_notes
, NULL
,
4543 &setlist
, &showlist
);