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"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
69 /* Maximum length of an agent aexpression.
70 This accounts for the fact that packets are limited to 400 bytes
71 (which includes everything -- including the checksum), and assumes
72 the worst case of maximum length for each of the pieces of a
75 NOTE: expressions get mem2hex'ed otherwise this would be twice as
76 large. (400 - 31)/2 == 184 */
77 #define MAX_AGENT_EXPR_LEN 184
79 /* A hook used to notify the UI of tracepoint operations. */
81 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
82 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
87 This module defines the following debugger commands:
88 trace : set a tracepoint on a function, line, or address.
89 info trace : list all debugger-defined tracepoints.
90 delete trace : delete one or more tracepoints.
91 enable trace : enable one or more tracepoints.
92 disable trace : disable one or more tracepoints.
93 actions : specify actions to be taken at a tracepoint.
94 passcount : specify a pass count for a tracepoint.
95 tstart : start a trace experiment.
96 tstop : stop a trace experiment.
97 tstatus : query the status of a trace experiment.
98 tfind : find a trace frame in the trace buffer.
99 tdump : print everything collected at the current tracepoint.
100 save-tracepoints : write tracepoint setup into a file.
102 This module defines the following user-visible debugger variables:
103 $trace_frame : sequence number of trace frame currently being debugged.
104 $trace_line : source line of trace frame currently being debugged.
105 $trace_file : source file of trace frame currently being debugged.
106 $tracepoint : tracepoint number of trace frame currently being debugged.
110 /* ======= Important global variables: ======= */
112 /* The list of all trace state variables. We don't retain pointers to
113 any of these for any reason - API is by name or number only - so it
114 works to have a vector of objects. */
116 typedef struct trace_state_variable tsv_s
;
119 static VEC(tsv_s
) *tvariables
;
121 /* The next integer to assign to a variable. */
123 static int next_tsv_number
= 1;
125 /* Number of last traceframe collected. */
126 static int traceframe_number
;
128 /* Tracepoint for last traceframe collected. */
129 static int tracepoint_number
;
131 /* The traceframe info of the current traceframe. NULL if we haven't
132 yet attempted to fetch it, or if the target does not support
133 fetching this object, or if we're not inspecting a traceframe
135 static struct traceframe_info
*traceframe_info
;
137 /* Tracing command lists. */
138 static struct cmd_list_element
*tfindlist
;
140 /* List of expressions to collect by default at each tracepoint hit. */
141 char *default_collect
= "";
143 static int disconnected_tracing
;
145 /* This variable controls whether we ask the target for a linear or
146 circular trace buffer. */
148 static int circular_trace_buffer
;
150 /* This variable is the requested trace buffer size, or -1 to indicate
151 that we don't care and leave it up to the target to set a size. */
153 static int trace_buffer_size
= -1;
155 /* Textual notes applying to the current and/or future trace runs. */
157 char *trace_user
= NULL
;
159 /* Textual notes applying to the current and/or future trace runs. */
161 char *trace_notes
= NULL
;
163 /* Textual notes applying to the stopping of a trace. */
165 char *trace_stop_notes
= NULL
;
167 /* ======= Important command functions: ======= */
168 static void trace_actions_command (char *, int);
169 static void trace_start_command (char *, int);
170 static void trace_stop_command (char *, int);
171 static void trace_status_command (char *, int);
172 static void trace_find_command (char *, int);
173 static void trace_find_pc_command (char *, int);
174 static void trace_find_tracepoint_command (char *, int);
175 static void trace_find_line_command (char *, int);
176 static void trace_find_range_command (char *, int);
177 static void trace_find_outside_command (char *, int);
178 static void trace_dump_command (char *, int);
180 /* support routines */
182 struct collection_list
;
183 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
184 static char *mem2hex (gdb_byte
*, char *, int);
185 static void add_register (struct collection_list
*collection
,
188 static struct command_line
*
189 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
191 extern void _initialize_tracepoint (void);
193 static struct trace_status trace_status
;
195 const char *stop_reason_names
[] = {
205 struct trace_status
*
206 current_trace_status (void)
208 return &trace_status
;
214 free_traceframe_info (struct traceframe_info
*info
)
218 VEC_free (mem_range_s
, info
->memory
);
219 VEC_free (int, info
->tvars
);
225 /* Free and clear the traceframe info cache of the current
229 clear_traceframe_info (void)
231 free_traceframe_info (traceframe_info
);
232 traceframe_info
= NULL
;
235 /* Set traceframe number to NUM. */
237 set_traceframe_num (int num
)
239 traceframe_number
= num
;
240 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
243 /* Set tracepoint number to NUM. */
245 set_tracepoint_num (int num
)
247 tracepoint_number
= num
;
248 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
251 /* Set externally visible debug variables for querying/printing
252 the traceframe context (line, function, file). */
255 set_traceframe_context (struct frame_info
*trace_frame
)
258 struct symbol
*traceframe_fun
;
259 struct symtab_and_line traceframe_sal
;
261 /* Save as globals for internal use. */
262 if (trace_frame
!= NULL
263 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
265 traceframe_sal
= find_pc_line (trace_pc
, 0);
266 traceframe_fun
= find_pc_function (trace_pc
);
268 /* Save linenumber as "$trace_line", a debugger variable visible to
270 set_internalvar_integer (lookup_internalvar ("trace_line"),
271 traceframe_sal
.line
);
275 init_sal (&traceframe_sal
);
276 traceframe_fun
= NULL
;
277 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
280 /* Save func name as "$trace_func", a debugger variable visible to
282 if (traceframe_fun
== NULL
283 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
284 clear_internalvar (lookup_internalvar ("trace_func"));
286 set_internalvar_string (lookup_internalvar ("trace_func"),
287 SYMBOL_LINKAGE_NAME (traceframe_fun
));
289 /* Save file name as "$trace_file", a debugger variable visible to
291 if (traceframe_sal
.symtab
== NULL
)
292 clear_internalvar (lookup_internalvar ("trace_file"));
294 set_internalvar_string (lookup_internalvar ("trace_file"),
295 symtab_to_filename_for_display (traceframe_sal
.symtab
));
298 /* Create a new trace state variable with the given name. */
300 struct trace_state_variable
*
301 create_trace_state_variable (const char *name
)
303 struct trace_state_variable tsv
;
305 memset (&tsv
, 0, sizeof (tsv
));
306 tsv
.name
= xstrdup (name
);
307 tsv
.number
= next_tsv_number
++;
308 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
311 /* Look for a trace state variable of the given name. */
313 struct trace_state_variable
*
314 find_trace_state_variable (const char *name
)
316 struct trace_state_variable
*tsv
;
319 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
320 if (strcmp (name
, tsv
->name
) == 0)
326 /* Look for a trace state variable of the given number. Return NULL if
329 struct trace_state_variable
*
330 find_trace_state_variable_by_number (int number
)
332 struct trace_state_variable
*tsv
;
335 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
336 if (tsv
->number
== number
)
343 delete_trace_state_variable (const char *name
)
345 struct trace_state_variable
*tsv
;
348 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
349 if (strcmp (name
, tsv
->name
) == 0)
351 observer_notify_tsv_deleted (tsv
);
353 xfree ((void *)tsv
->name
);
354 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
359 warning (_("No trace variable named \"$%s\", not deleting"), name
);
362 /* Throws an error if NAME is not valid syntax for a trace state
366 validate_trace_state_variable_name (const char *name
)
371 error (_("Must supply a non-empty variable name"));
373 /* All digits in the name is reserved for value history
375 for (p
= name
; isdigit (*p
); p
++)
378 error (_("$%s is not a valid trace state variable name"), name
);
380 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
383 error (_("$%s is not a valid trace state variable name"), name
);
386 /* The 'tvariable' command collects a name and optional expression to
387 evaluate into an initial value. */
390 trace_variable_command (char *args
, int from_tty
)
392 struct cleanup
*old_chain
;
394 struct trace_state_variable
*tsv
;
398 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
400 /* Only allow two syntaxes; "$name" and "$name=value". */
401 p
= skip_spaces (args
);
404 error (_("Name of trace variable should start with '$'"));
407 while (isalnum (*p
) || *p
== '_')
409 name
= savestring (name
, p
- name
);
410 old_chain
= make_cleanup (xfree
, name
);
413 if (*p
!= '=' && *p
!= '\0')
414 error (_("Syntax must be $NAME [ = EXPR ]"));
416 validate_trace_state_variable_name (name
);
419 initval
= value_as_long (parse_and_eval (++p
));
421 /* If the variable already exists, just change its initial value. */
422 tsv
= find_trace_state_variable (name
);
425 if (tsv
->initial_value
!= initval
)
427 tsv
->initial_value
= initval
;
428 observer_notify_tsv_modified (tsv
);
430 printf_filtered (_("Trace state variable $%s "
431 "now has initial value %s.\n"),
432 tsv
->name
, plongest (tsv
->initial_value
));
433 do_cleanups (old_chain
);
437 /* Create a new variable. */
438 tsv
= create_trace_state_variable (name
);
439 tsv
->initial_value
= initval
;
441 observer_notify_tsv_created (tsv
);
443 printf_filtered (_("Trace state variable $%s "
444 "created, with initial value %s.\n"),
445 tsv
->name
, plongest (tsv
->initial_value
));
447 do_cleanups (old_chain
);
451 delete_trace_variable_command (char *args
, int from_tty
)
455 struct cleanup
*back_to
;
459 if (query (_("Delete all trace state variables? ")))
460 VEC_free (tsv_s
, tvariables
);
462 observer_notify_tsv_deleted (NULL
);
466 argv
= gdb_buildargv (args
);
467 back_to
= make_cleanup_freeargv (argv
);
469 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
471 if (*argv
[ix
] == '$')
472 delete_trace_state_variable (argv
[ix
] + 1);
474 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
477 do_cleanups (back_to
);
483 tvariables_info_1 (void)
485 struct trace_state_variable
*tsv
;
488 struct cleanup
*back_to
;
489 struct ui_out
*uiout
= current_uiout
;
491 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
493 printf_filtered (_("No trace state variables.\n"));
497 /* Try to acquire values from the target. */
498 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
499 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
502 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
503 count
, "trace-variables");
504 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
505 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
506 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
508 ui_out_table_body (uiout
);
510 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
512 struct cleanup
*back_to2
;
516 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
518 name
= concat ("$", tsv
->name
, (char *) NULL
);
519 make_cleanup (xfree
, name
);
520 ui_out_field_string (uiout
, "name", name
);
521 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
523 if (tsv
->value_known
)
524 c
= plongest (tsv
->value
);
525 else if (ui_out_is_mi_like_p (uiout
))
526 /* For MI, we prefer not to use magic string constants, but rather
527 omit the field completely. The difference between unknown and
528 undefined does not seem important enough to represent. */
530 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
531 /* The value is/was defined, but we don't have it. */
534 /* It is not meaningful to ask about the value. */
537 ui_out_field_string (uiout
, "current", c
);
538 ui_out_text (uiout
, "\n");
540 do_cleanups (back_to2
);
543 do_cleanups (back_to
);
546 /* List all the trace state variables. */
549 tvariables_info (char *args
, int from_tty
)
551 tvariables_info_1 ();
554 /* Stash definitions of tsvs into the given file. */
557 save_trace_state_variables (struct ui_file
*fp
)
559 struct trace_state_variable
*tsv
;
562 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
564 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
565 if (tsv
->initial_value
)
566 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
567 fprintf_unfiltered (fp
, "\n");
571 /* ACTIONS functions: */
573 /* The three functions:
574 collect_pseudocommand,
575 while_stepping_pseudocommand, and
576 end_actions_pseudocommand
577 are placeholders for "commands" that are actually ONLY to be used
578 within a tracepoint action list. If the actual function is ever called,
579 it means that somebody issued the "command" at the top level,
580 which is always an error. */
583 end_actions_pseudocommand (char *args
, int from_tty
)
585 error (_("This command cannot be used at the top level."));
589 while_stepping_pseudocommand (char *args
, int from_tty
)
591 error (_("This command can only be used in a tracepoint actions list."));
595 collect_pseudocommand (char *args
, int from_tty
)
597 error (_("This command can only be used in a tracepoint actions list."));
601 teval_pseudocommand (char *args
, int from_tty
)
603 error (_("This command can only be used in a tracepoint actions list."));
606 /* Parse any collection options, such as /s for strings. */
609 decode_agent_options (const char *exp
, int *trace_string
)
611 struct value_print_options opts
;
618 /* Call this to borrow the print elements default for collection
620 get_user_print_options (&opts
);
625 if (target_supports_string_tracing ())
627 /* Allow an optional decimal number giving an explicit maximum
628 string length, defaulting it to the "print elements" value;
629 so "collect/s80 mystr" gets at most 80 bytes of string. */
630 *trace_string
= opts
.print_max
;
632 if (*exp
>= '0' && *exp
<= '9')
633 *trace_string
= atoi (exp
);
634 while (*exp
>= '0' && *exp
<= '9')
638 error (_("Target does not support \"/s\" option for string tracing."));
641 error (_("Undefined collection format \"%c\"."), *exp
);
643 exp
= skip_spaces_const (exp
);
648 /* Enter a list of actions for a tracepoint. */
650 trace_actions_command (char *args
, int from_tty
)
652 struct tracepoint
*t
;
653 struct command_line
*l
;
655 t
= get_tracepoint_by_number (&args
, NULL
);
659 xstrprintf ("Enter actions for tracepoint %d, one per line.",
661 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
663 l
= read_command_lines (tmpbuf
, from_tty
, 1,
664 check_tracepoint_command
, t
);
665 do_cleanups (cleanups
);
666 breakpoint_set_commands (&t
->base
, l
);
668 /* else just return */
671 /* Report the results of checking the agent expression, as errors or
675 report_agent_reqs_errors (struct agent_expr
*aexpr
)
677 /* All of the "flaws" are serious bytecode generation issues that
678 should never occur. */
679 if (aexpr
->flaw
!= agent_flaw_none
)
680 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
682 /* If analysis shows a stack underflow, GDB must have done something
683 badly wrong in its bytecode generation. */
684 if (aexpr
->min_height
< 0)
685 internal_error (__FILE__
, __LINE__
,
686 _("expression has min height < 0"));
688 /* Issue this error if the stack is predicted to get too deep. The
689 limit is rather arbitrary; a better scheme might be for the
690 target to report how much stack it will have available. The
691 depth roughly corresponds to parenthesization, so a limit of 20
692 amounts to 20 levels of expression nesting, which is actually
693 a pretty big hairy expression. */
694 if (aexpr
->max_height
> 20)
695 error (_("Expression is too complicated."));
698 /* worker function */
700 validate_actionline (const char *line
, struct breakpoint
*b
)
702 struct cmd_list_element
*c
;
703 struct expression
*exp
= NULL
;
704 struct cleanup
*old_chain
= NULL
;
707 struct bp_location
*loc
;
708 struct agent_expr
*aexpr
;
709 struct tracepoint
*t
= (struct tracepoint
*) b
;
711 /* If EOF is typed, *line is NULL. */
715 p
= skip_spaces_const (line
);
717 /* Symbol lookup etc. */
718 if (*p
== '\0') /* empty line: just prompt for another line. */
721 if (*p
== '#') /* comment line */
724 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
726 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
728 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
730 int trace_string
= 0;
733 p
= decode_agent_options (p
, &trace_string
);
736 { /* Repeat over a comma-separated list. */
737 QUIT
; /* Allow user to bail out with ^C. */
738 p
= skip_spaces_const (p
);
740 if (*p
== '$') /* Look for special pseudo-symbols. */
742 if (0 == strncasecmp ("reg", p
+ 1, 3)
743 || 0 == strncasecmp ("arg", p
+ 1, 3)
744 || 0 == strncasecmp ("loc", p
+ 1, 3)
745 || 0 == strncasecmp ("_ret", p
+ 1, 4)
746 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
751 /* else fall thru, treat p as an expression and parse it! */
754 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
757 exp
= parse_exp_1 (&p
, loc
->address
,
758 block_for_pc (loc
->address
), 1);
759 old_chain
= make_cleanup (free_current_contents
, &exp
);
761 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
763 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
765 error (_("constant `%s' (value %s) "
766 "will not be collected."),
767 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
768 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
770 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
771 == LOC_OPTIMIZED_OUT
)
773 error (_("`%s' is optimized away "
774 "and cannot be collected."),
775 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
779 /* We have something to collect, make sure that the expr to
780 bytecode translator can handle it and that it's not too
782 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
783 make_cleanup_free_agent_expr (aexpr
);
785 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
786 error (_("Expression is too complicated."));
790 report_agent_reqs_errors (aexpr
);
792 do_cleanups (old_chain
);
795 while (p
&& *p
++ == ',');
798 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
801 { /* Repeat over a comma-separated list. */
802 QUIT
; /* Allow user to bail out with ^C. */
803 p
= skip_spaces_const (p
);
806 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
810 /* Only expressions are allowed for this action. */
811 exp
= parse_exp_1 (&p
, loc
->address
,
812 block_for_pc (loc
->address
), 1);
813 old_chain
= make_cleanup (free_current_contents
, &exp
);
815 /* We have something to evaluate, make sure that the expr to
816 bytecode translator can handle it and that it's not too
818 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
819 make_cleanup_free_agent_expr (aexpr
);
821 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
822 error (_("Expression is too complicated."));
825 report_agent_reqs_errors (aexpr
);
827 do_cleanups (old_chain
);
830 while (p
&& *p
++ == ',');
833 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
837 p
= skip_spaces_const (p
);
838 t
->step_count
= strtol (p
, &endp
, 0);
839 if (endp
== p
|| t
->step_count
== 0)
840 error (_("while-stepping step count `%s' is malformed."), line
);
844 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
848 error (_("`%s' is not a supported tracepoint action."), line
);
852 memrange_absolute
= -1
855 /* MEMRANGE functions: */
857 static int memrange_cmp (const void *, const void *);
859 /* Compare memranges for qsort. */
861 memrange_cmp (const void *va
, const void *vb
)
863 const struct memrange
*a
= va
, *b
= vb
;
865 if (a
->type
< b
->type
)
867 if (a
->type
> b
->type
)
869 if (a
->type
== memrange_absolute
)
871 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
873 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
878 if (a
->start
< b
->start
)
880 if (a
->start
> b
->start
)
886 /* Sort the memrange list using qsort, and merge adjacent memranges. */
888 memrange_sortmerge (struct collection_list
*memranges
)
892 qsort (memranges
->list
, memranges
->next_memrange
,
893 sizeof (struct memrange
), memrange_cmp
);
894 if (memranges
->next_memrange
> 0)
896 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
898 /* If memrange b overlaps or is adjacent to memrange a,
900 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
901 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
903 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
904 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
905 continue; /* next b, same a */
909 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
910 sizeof (struct memrange
));
912 memranges
->next_memrange
= a
+ 1;
916 /* Add a register to a collection list. */
918 add_register (struct collection_list
*collection
, unsigned int regno
)
921 printf_filtered ("collect register %d\n", regno
);
922 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
923 error (_("Internal: register number %d too large for tracepoint"),
925 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
928 /* Add a memrange to a collection list. */
930 add_memrange (struct collection_list
*memranges
,
931 int type
, bfd_signed_vma base
,
936 printf_filtered ("(%d,", type
);
938 printf_filtered (",%ld)\n", len
);
941 /* type: memrange_absolute == memory, other n == basereg */
942 memranges
->list
[memranges
->next_memrange
].type
= type
;
943 /* base: addr if memory, offset if reg relative. */
944 memranges
->list
[memranges
->next_memrange
].start
= base
;
945 /* len: we actually save end (base + len) for convenience */
946 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
947 memranges
->next_memrange
++;
948 if (memranges
->next_memrange
>= memranges
->listsize
)
950 memranges
->listsize
*= 2;
951 memranges
->list
= xrealloc (memranges
->list
,
952 memranges
->listsize
);
955 if (type
!= memrange_absolute
) /* Better collect the base register! */
956 add_register (memranges
, type
);
959 /* Add a symbol to a collection list. */
961 collect_symbol (struct collection_list
*collect
,
963 struct gdbarch
*gdbarch
,
964 long frame_regno
, long frame_offset
,
970 bfd_signed_vma offset
;
971 int treat_as_expr
= 0;
973 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
974 switch (SYMBOL_CLASS (sym
))
977 printf_filtered ("%s: don't know symbol class %d\n",
978 SYMBOL_PRINT_NAME (sym
),
982 printf_filtered ("constant %s (value %s) will not be collected.\n",
983 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
986 offset
= SYMBOL_VALUE_ADDRESS (sym
);
991 sprintf_vma (tmp
, offset
);
992 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
993 SYMBOL_PRINT_NAME (sym
), len
,
996 /* A struct may be a C++ class with static fields, go to general
997 expression handling. */
998 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1001 add_memrange (collect
, memrange_absolute
, offset
, len
);
1004 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1006 printf_filtered ("LOC_REG[parm] %s: ",
1007 SYMBOL_PRINT_NAME (sym
));
1008 add_register (collect
, reg
);
1009 /* Check for doubles stored in two registers. */
1010 /* FIXME: how about larger types stored in 3 or more regs? */
1011 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1012 len
> register_size (gdbarch
, reg
))
1013 add_register (collect
, reg
+ 1);
1016 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1017 printf_filtered (" (will not collect %s)\n",
1018 SYMBOL_PRINT_NAME (sym
));
1022 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1025 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1026 SYMBOL_PRINT_NAME (sym
), len
);
1027 printf_vma (offset
);
1028 printf_filtered (" from frame ptr reg %d\n", reg
);
1030 add_memrange (collect
, reg
, offset
, len
);
1032 case LOC_REGPARM_ADDR
:
1033 reg
= SYMBOL_VALUE (sym
);
1037 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1038 SYMBOL_PRINT_NAME (sym
), len
);
1039 printf_vma (offset
);
1040 printf_filtered (" from reg %d\n", reg
);
1042 add_memrange (collect
, reg
, offset
, len
);
1046 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1049 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1050 SYMBOL_PRINT_NAME (sym
), len
);
1051 printf_vma (offset
);
1052 printf_filtered (" from frame ptr reg %d\n", reg
);
1054 add_memrange (collect
, reg
, offset
, len
);
1057 case LOC_UNRESOLVED
:
1061 case LOC_OPTIMIZED_OUT
:
1062 printf_filtered ("%s has been optimized out of existence.\n",
1063 SYMBOL_PRINT_NAME (sym
));
1071 /* Expressions are the most general case. */
1074 struct agent_expr
*aexpr
;
1075 struct cleanup
*old_chain1
= NULL
;
1077 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1079 /* It can happen that the symbol is recorded as a computed
1080 location, but it's been optimized away and doesn't actually
1081 have a location expression. */
1084 printf_filtered ("%s has been optimized out of existence.\n",
1085 SYMBOL_PRINT_NAME (sym
));
1089 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1093 report_agent_reqs_errors (aexpr
);
1095 discard_cleanups (old_chain1
);
1096 add_aexpr (collect
, aexpr
);
1098 /* Take care of the registers. */
1099 if (aexpr
->reg_mask_len
> 0)
1103 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1105 QUIT
; /* Allow user to bail out with ^C. */
1106 if (aexpr
->reg_mask
[ndx1
] != 0)
1108 /* Assume chars have 8 bits. */
1109 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1110 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1111 /* It's used -- record it. */
1112 add_register (collect
, ndx1
* 8 + ndx2
);
1119 /* Data to be passed around in the calls to the locals and args
1122 struct add_local_symbols_data
1124 struct collection_list
*collect
;
1125 struct gdbarch
*gdbarch
;
1133 /* The callback for the locals and args iterators. */
1136 do_collect_symbol (const char *print_name
,
1140 struct add_local_symbols_data
*p
= cb_data
;
1142 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1143 p
->frame_offset
, p
->pc
, p
->trace_string
);
1146 VEC_safe_push (char_ptr
, p
->collect
->wholly_collected
,
1147 xstrdup (print_name
));
1150 /* Add all locals (or args) symbols to collection list. */
1152 add_local_symbols (struct collection_list
*collect
,
1153 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1154 long frame_regno
, long frame_offset
, int type
,
1157 const struct block
*block
;
1158 struct add_local_symbols_data cb_data
;
1160 cb_data
.collect
= collect
;
1161 cb_data
.gdbarch
= gdbarch
;
1163 cb_data
.frame_regno
= frame_regno
;
1164 cb_data
.frame_offset
= frame_offset
;
1166 cb_data
.trace_string
= trace_string
;
1170 block
= block_for_pc (pc
);
1173 warning (_("Can't collect locals; "
1174 "no symbol table info available.\n"));
1178 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1179 if (cb_data
.count
== 0)
1180 warning (_("No locals found in scope."));
1184 pc
= get_pc_function_start (pc
);
1185 block
= block_for_pc (pc
);
1188 warning (_("Can't collect args; no symbol table info available."));
1192 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1193 if (cb_data
.count
== 0)
1194 warning (_("No args found in scope."));
1199 add_static_trace_data (struct collection_list
*collection
)
1202 printf_filtered ("collect static trace data\n");
1203 collection
->strace_data
= 1;
1206 /* worker function */
1208 clear_collection_list (struct collection_list
*list
)
1212 list
->next_memrange
= 0;
1213 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1215 free_agent_expr (list
->aexpr_list
[ndx
]);
1216 list
->aexpr_list
[ndx
] = NULL
;
1218 list
->next_aexpr_elt
= 0;
1219 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1220 list
->strace_data
= 0;
1222 xfree (list
->aexpr_list
);
1225 VEC_free (char_ptr
, list
->wholly_collected
);
1226 VEC_free (char_ptr
, list
->computed
);
1229 /* A cleanup wrapper for function clear_collection_list. */
1232 do_clear_collection_list (void *list
)
1234 struct collection_list
*l
= list
;
1236 clear_collection_list (l
);
1239 /* Initialize collection_list CLIST. */
1242 init_collection_list (struct collection_list
*clist
)
1244 memset (clist
, 0, sizeof *clist
);
1246 clist
->listsize
= 128;
1247 clist
->list
= xcalloc (clist
->listsize
,
1248 sizeof (struct memrange
));
1250 clist
->aexpr_listsize
= 128;
1251 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1252 sizeof (struct agent_expr
*));
1255 /* Reduce a collection list to string form (for gdb protocol). */
1257 stringify_collection_list (struct collection_list
*list
)
1259 char temp_buf
[2048];
1263 char *(*str_list
)[];
1267 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1268 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1270 if (list
->strace_data
)
1273 printf_filtered ("\nCollecting static trace data\n");
1276 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1280 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1281 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1283 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1286 printf_filtered ("\nCollecting registers (mask): 0x");
1291 QUIT
; /* Allow user to bail out with ^C. */
1293 printf_filtered ("%02X", list
->regs_mask
[i
]);
1294 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1297 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1301 printf_filtered ("\n");
1302 if (list
->next_memrange
> 0 && info_verbose
)
1303 printf_filtered ("Collecting memranges: \n");
1304 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1306 QUIT
; /* Allow user to bail out with ^C. */
1307 sprintf_vma (tmp2
, list
->list
[i
].start
);
1310 printf_filtered ("(%d, %s, %ld)\n",
1313 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1315 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1317 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1324 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1326 /* The "%X" conversion specifier expects an unsigned argument,
1327 so passing -1 (memrange_absolute) to it directly gives you
1328 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1330 if (list
->list
[i
].type
== memrange_absolute
)
1331 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1333 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1336 count
+= strlen (end
);
1337 end
= temp_buf
+ count
;
1340 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1342 QUIT
; /* Allow user to bail out with ^C. */
1343 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1345 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1350 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1351 end
+= 10; /* 'X' + 8 hex digits + ',' */
1354 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1355 end
, list
->aexpr_list
[i
]->len
);
1356 count
+= 2 * list
->aexpr_list
[i
]->len
;
1361 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1366 (*str_list
)[ndx
] = NULL
;
1377 /* Add the printed expression EXP to *LIST. */
1380 append_exp (struct expression
*exp
, VEC(char_ptr
) **list
)
1382 struct ui_file
*tmp_stream
= mem_fileopen ();
1385 print_expression (exp
, tmp_stream
);
1387 text
= ui_file_xstrdup (tmp_stream
, NULL
);
1389 VEC_safe_push (char_ptr
, *list
, text
);
1390 ui_file_delete (tmp_stream
);
1394 encode_actions_1 (struct command_line
*action
,
1395 struct bp_location
*tloc
,
1397 LONGEST frame_offset
,
1398 struct collection_list
*collect
,
1399 struct collection_list
*stepping_list
)
1401 const char *action_exp
;
1402 struct expression
*exp
= NULL
;
1404 struct value
*tempval
;
1405 struct cmd_list_element
*cmd
;
1406 struct agent_expr
*aexpr
;
1408 for (; action
; action
= action
->next
)
1410 QUIT
; /* Allow user to bail out with ^C. */
1411 action_exp
= action
->line
;
1412 action_exp
= skip_spaces_const (action_exp
);
1414 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1416 error (_("Bad action list item: %s"), action_exp
);
1418 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1420 int trace_string
= 0;
1422 if (*action_exp
== '/')
1423 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1426 { /* Repeat over a comma-separated list. */
1427 QUIT
; /* Allow user to bail out with ^C. */
1428 action_exp
= skip_spaces_const (action_exp
);
1430 if (0 == strncasecmp ("$reg", action_exp
, 4))
1432 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1433 add_register (collect
, i
);
1434 action_exp
= strchr (action_exp
, ','); /* more? */
1436 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1438 add_local_symbols (collect
,
1445 action_exp
= strchr (action_exp
, ','); /* more? */
1447 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1449 add_local_symbols (collect
,
1456 action_exp
= strchr (action_exp
, ','); /* more? */
1458 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1460 struct cleanup
*old_chain1
= NULL
;
1462 aexpr
= gen_trace_for_return_address (tloc
->address
,
1466 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1469 report_agent_reqs_errors (aexpr
);
1471 discard_cleanups (old_chain1
);
1472 add_aexpr (collect
, aexpr
);
1474 /* take care of the registers */
1475 if (aexpr
->reg_mask_len
> 0)
1479 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1481 QUIT
; /* allow user to bail out with ^C */
1482 if (aexpr
->reg_mask
[ndx1
] != 0)
1484 /* assume chars have 8 bits */
1485 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1486 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1487 /* it's used -- record it */
1488 add_register (collect
,
1494 action_exp
= strchr (action_exp
, ','); /* more? */
1496 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1498 add_static_trace_data (collect
);
1499 action_exp
= strchr (action_exp
, ','); /* more? */
1504 struct cleanup
*old_chain
= NULL
;
1505 struct cleanup
*old_chain1
= NULL
;
1507 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1508 block_for_pc (tloc
->address
), 1);
1509 old_chain
= make_cleanup (free_current_contents
, &exp
);
1511 switch (exp
->elts
[0].opcode
)
1515 const char *name
= &exp
->elts
[2].string
;
1517 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1518 name
, strlen (name
));
1520 internal_error (__FILE__
, __LINE__
,
1521 _("Register $%s not available"),
1524 printf_filtered ("OP_REGISTER: ");
1525 add_register (collect
, i
);
1530 /* Safe because we know it's a simple expression. */
1531 tempval
= evaluate_expression (exp
);
1532 addr
= value_address (tempval
);
1533 /* Initialize the TYPE_LENGTH if it is a typedef. */
1534 check_typedef (exp
->elts
[1].type
);
1535 add_memrange (collect
, memrange_absolute
, addr
,
1536 TYPE_LENGTH (exp
->elts
[1].type
));
1537 append_exp (exp
, &collect
->computed
);
1542 struct symbol
*sym
= exp
->elts
[2].symbol
;
1543 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1545 collect_symbol (collect
,
1546 exp
->elts
[2].symbol
,
1552 VEC_safe_push (char_ptr
,
1553 collect
->wholly_collected
,
1558 default: /* Full-fledged expression. */
1559 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1562 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1566 report_agent_reqs_errors (aexpr
);
1568 discard_cleanups (old_chain1
);
1569 add_aexpr (collect
, aexpr
);
1571 /* Take care of the registers. */
1572 if (aexpr
->reg_mask_len
> 0)
1577 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1579 QUIT
; /* Allow user to bail out with ^C. */
1580 if (aexpr
->reg_mask
[ndx1
] != 0)
1582 /* Assume chars have 8 bits. */
1583 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1584 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1585 /* It's used -- record it. */
1586 add_register (collect
,
1592 append_exp (exp
, &collect
->computed
);
1595 do_cleanups (old_chain
);
1598 while (action_exp
&& *action_exp
++ == ',');
1600 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1603 { /* Repeat over a comma-separated list. */
1604 QUIT
; /* Allow user to bail out with ^C. */
1605 action_exp
= skip_spaces_const (action_exp
);
1608 struct cleanup
*old_chain
= NULL
;
1609 struct cleanup
*old_chain1
= NULL
;
1611 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1612 block_for_pc (tloc
->address
), 1);
1613 old_chain
= make_cleanup (free_current_contents
, &exp
);
1615 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1616 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1619 report_agent_reqs_errors (aexpr
);
1621 discard_cleanups (old_chain1
);
1622 /* Even though we're not officially collecting, add
1623 to the collect list anyway. */
1624 add_aexpr (collect
, aexpr
);
1626 do_cleanups (old_chain
);
1629 while (action_exp
&& *action_exp
++ == ',');
1631 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1633 /* We check against nested while-stepping when setting
1634 breakpoint action, so no way to run into nested
1636 gdb_assert (stepping_list
);
1638 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1639 frame_offset
, stepping_list
, NULL
);
1642 error (_("Invalid tracepoint command '%s'"), action
->line
);
1646 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1647 and STEPPING_LIST. Return a cleanup pointer to clean up both
1648 TRACEPOINT_LIST and STEPPING_LIST. */
1651 encode_actions_and_make_cleanup (struct bp_location
*tloc
,
1652 struct collection_list
*tracepoint_list
,
1653 struct collection_list
*stepping_list
)
1655 char *default_collect_line
= NULL
;
1656 struct command_line
*actions
;
1657 struct command_line
*default_collect_action
= NULL
;
1659 LONGEST frame_offset
;
1660 struct cleanup
*back_to
, *return_chain
;
1662 return_chain
= make_cleanup (null_cleanup
, NULL
);
1663 init_collection_list (tracepoint_list
);
1664 init_collection_list (stepping_list
);
1666 make_cleanup (do_clear_collection_list
, tracepoint_list
);
1667 make_cleanup (do_clear_collection_list
, stepping_list
);
1669 back_to
= make_cleanup (null_cleanup
, NULL
);
1670 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1671 tloc
->address
, &frame_reg
, &frame_offset
);
1673 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1675 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1676 tracepoint_list
, stepping_list
);
1678 memrange_sortmerge (tracepoint_list
);
1679 memrange_sortmerge (stepping_list
);
1681 do_cleanups (back_to
);
1682 return return_chain
;
1685 /* Render all actions into gdb protocol. */
1688 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1689 char ***stepping_actions
)
1691 struct collection_list tracepoint_list
, stepping_list
;
1692 struct cleanup
*cleanup
;
1694 *tdp_actions
= NULL
;
1695 *stepping_actions
= NULL
;
1697 cleanup
= encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
1700 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1701 *stepping_actions
= stringify_collection_list (&stepping_list
);
1703 do_cleanups (cleanup
);
1707 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1709 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1711 collect
->aexpr_list
=
1712 xrealloc (collect
->aexpr_list
,
1713 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1714 collect
->aexpr_listsize
*= 2;
1716 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1717 collect
->next_aexpr_elt
++;
1721 process_tracepoint_on_disconnect (void)
1723 VEC(breakpoint_p
) *tp_vec
= NULL
;
1725 struct breakpoint
*b
;
1726 int has_pending_p
= 0;
1728 /* Check whether we still have pending tracepoint. If we have, warn the
1729 user that pending tracepoint will no longer work. */
1730 tp_vec
= all_tracepoints ();
1731 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1740 struct bp_location
*loc1
;
1742 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1744 if (loc1
->shlib_disabled
)
1755 VEC_free (breakpoint_p
, tp_vec
);
1758 warning (_("Pending tracepoints will not be resolved while"
1759 " GDB is disconnected\n"));
1762 /* Reset local state of tracing. */
1765 trace_reset_local_state (void)
1767 set_traceframe_num (-1);
1768 set_tracepoint_num (-1);
1769 set_traceframe_context (NULL
);
1770 clear_traceframe_info ();
1774 start_tracing (char *notes
)
1776 VEC(breakpoint_p
) *tp_vec
= NULL
;
1778 struct breakpoint
*b
;
1779 struct trace_state_variable
*tsv
;
1780 int any_enabled
= 0, num_to_download
= 0;
1783 tp_vec
= all_tracepoints ();
1785 /* No point in tracing without any tracepoints... */
1786 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1788 VEC_free (breakpoint_p
, tp_vec
);
1789 error (_("No tracepoints defined, not starting trace"));
1792 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1794 struct tracepoint
*t
= (struct tracepoint
*) b
;
1795 struct bp_location
*loc
;
1797 if (b
->enable_state
== bp_enabled
)
1800 if ((b
->type
== bp_fast_tracepoint
1801 ? may_insert_fast_tracepoints
1802 : may_insert_tracepoints
))
1805 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1806 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1811 if (target_supports_enable_disable_tracepoint ())
1812 warning (_("No tracepoints enabled"));
1815 /* No point in tracing with only disabled tracepoints that
1816 cannot be re-enabled. */
1817 VEC_free (breakpoint_p
, tp_vec
);
1818 error (_("No tracepoints enabled, not starting trace"));
1822 if (num_to_download
<= 0)
1824 VEC_free (breakpoint_p
, tp_vec
);
1825 error (_("No tracepoints that may be downloaded, not starting trace"));
1828 target_trace_init ();
1830 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1832 struct tracepoint
*t
= (struct tracepoint
*) b
;
1833 struct bp_location
*loc
;
1834 int bp_location_downloaded
= 0;
1836 /* Clear `inserted' flag. */
1837 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1840 if ((b
->type
== bp_fast_tracepoint
1841 ? !may_insert_fast_tracepoints
1842 : !may_insert_tracepoints
))
1845 t
->number_on_target
= 0;
1847 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1849 /* Since tracepoint locations are never duplicated, `inserted'
1850 flag should be zero. */
1851 gdb_assert (!loc
->inserted
);
1853 target_download_tracepoint (loc
);
1856 bp_location_downloaded
= 1;
1859 t
->number_on_target
= b
->number
;
1861 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1862 if (loc
->probe
.probe
!= NULL
1863 && loc
->probe
.probe
->pops
->set_semaphore
!= NULL
)
1864 loc
->probe
.probe
->pops
->set_semaphore (loc
->probe
.probe
,
1868 if (bp_location_downloaded
)
1869 observer_notify_breakpoint_modified (b
);
1871 VEC_free (breakpoint_p
, tp_vec
);
1873 /* Send down all the trace state variables too. */
1874 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1876 target_download_trace_state_variable (tsv
);
1879 /* Tell target to treat text-like sections as transparent. */
1880 target_trace_set_readonly_regions ();
1881 /* Set some mode flags. */
1882 target_set_disconnected_tracing (disconnected_tracing
);
1883 target_set_circular_trace_buffer (circular_trace_buffer
);
1884 target_set_trace_buffer_size (trace_buffer_size
);
1887 notes
= trace_notes
;
1888 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1890 if (!ret
&& (trace_user
|| notes
))
1891 warning (_("Target does not support trace user/notes, info ignored"));
1893 /* Now insert traps and begin collecting data. */
1894 target_trace_start ();
1896 /* Reset our local state. */
1897 trace_reset_local_state ();
1898 current_trace_status()->running
= 1;
1901 /* The tstart command requests the target to start a new trace run.
1902 The command passes any arguments it has to the target verbatim, as
1903 an optional "trace note". This is useful as for instance a warning
1904 to other users if the trace runs disconnected, and you don't want
1905 anybody else messing with the target. */
1908 trace_start_command (char *args
, int from_tty
)
1910 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1912 if (current_trace_status ()->running
)
1915 && !query (_("A trace is running already. Start a new run? ")))
1916 error (_("New trace run not started."));
1919 start_tracing (args
);
1922 /* The tstop command stops the tracing run. The command passes any
1923 supplied arguments to the target verbatim as a "stop note"; if the
1924 target supports trace notes, then it will be reported back as part
1925 of the trace run's status. */
1928 trace_stop_command (char *args
, int from_tty
)
1930 if (!current_trace_status ()->running
)
1931 error (_("Trace is not running."));
1933 stop_tracing (args
);
1937 stop_tracing (char *note
)
1940 VEC(breakpoint_p
) *tp_vec
= NULL
;
1942 struct breakpoint
*t
;
1944 target_trace_stop ();
1946 tp_vec
= all_tracepoints ();
1947 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1949 struct bp_location
*loc
;
1951 if ((t
->type
== bp_fast_tracepoint
1952 ? !may_insert_fast_tracepoints
1953 : !may_insert_tracepoints
))
1956 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1958 /* GDB can be totally absent in some disconnected trace scenarios,
1959 but we don't really care if this semaphore goes out of sync.
1960 That's why we are decrementing it here, but not taking care
1962 if (loc
->probe
.probe
!= NULL
1963 && loc
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
1964 loc
->probe
.probe
->pops
->clear_semaphore (loc
->probe
.probe
,
1970 VEC_free (breakpoint_p
, tp_vec
);
1973 note
= trace_stop_notes
;
1974 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1977 warning (_("Target does not support trace notes, note ignored"));
1979 /* Should change in response to reply? */
1980 current_trace_status ()->running
= 0;
1983 /* tstatus command */
1985 trace_status_command (char *args
, int from_tty
)
1987 struct trace_status
*ts
= current_trace_status ();
1989 VEC(breakpoint_p
) *tp_vec
= NULL
;
1990 struct breakpoint
*t
;
1992 status
= target_get_trace_status (ts
);
1996 if (ts
->filename
!= NULL
)
1997 printf_filtered (_("Using a trace file.\n"));
2000 printf_filtered (_("Trace can not be run on this target.\n"));
2005 if (!ts
->running_known
)
2007 printf_filtered (_("Run/stop status is unknown.\n"));
2009 else if (ts
->running
)
2011 printf_filtered (_("Trace is running on the target.\n"));
2015 switch (ts
->stop_reason
)
2017 case trace_never_run
:
2018 printf_filtered (_("No trace has been run on the target.\n"));
2022 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2025 printf_filtered (_("Trace stopped by a tstop command.\n"));
2027 case trace_buffer_full
:
2028 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2030 case trace_disconnected
:
2031 printf_filtered (_("Trace stopped because of disconnection.\n"));
2033 case tracepoint_passcount
:
2034 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2035 ts
->stopping_tracepoint
);
2037 case tracepoint_error
:
2038 if (ts
->stopping_tracepoint
)
2039 printf_filtered (_("Trace stopped by an "
2040 "error (%s, tracepoint %d).\n"),
2041 ts
->stop_desc
, ts
->stopping_tracepoint
);
2043 printf_filtered (_("Trace stopped by an error (%s).\n"),
2046 case trace_stop_reason_unknown
:
2047 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2050 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2056 if (ts
->traceframes_created
>= 0
2057 && ts
->traceframe_count
!= ts
->traceframes_created
)
2059 printf_filtered (_("Buffer contains %d trace "
2060 "frames (of %d created total).\n"),
2061 ts
->traceframe_count
, ts
->traceframes_created
);
2063 else if (ts
->traceframe_count
>= 0)
2065 printf_filtered (_("Collected %d trace frames.\n"),
2066 ts
->traceframe_count
);
2069 if (ts
->buffer_free
>= 0)
2071 if (ts
->buffer_size
>= 0)
2073 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2074 ts
->buffer_free
, ts
->buffer_size
);
2075 if (ts
->buffer_size
> 0)
2076 printf_filtered (_(" (%d%% full)"),
2077 ((int) ((((long long) (ts
->buffer_size
2078 - ts
->buffer_free
)) * 100)
2079 / ts
->buffer_size
)));
2080 printf_filtered (_(".\n"));
2083 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2087 if (ts
->disconnected_tracing
)
2088 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2090 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2092 if (ts
->circular_buffer
)
2093 printf_filtered (_("Trace buffer is circular.\n"));
2095 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2096 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2098 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2099 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2101 /* Now report on what we're doing with tfind. */
2102 if (traceframe_number
>= 0)
2103 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2104 traceframe_number
, tracepoint_number
);
2106 printf_filtered (_("Not looking at any trace frame.\n"));
2108 /* Report start/stop times if supplied. */
2113 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2115 /* Reporting a run time is more readable than two long numbers. */
2116 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2117 (long int) (ts
->start_time
/ 1000000),
2118 (long int) (ts
->start_time
% 1000000),
2119 (long int) (run_time
/ 1000000),
2120 (long int) (run_time
% 1000000));
2123 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2124 (long int) (ts
->start_time
/ 1000000),
2125 (long int) (ts
->start_time
% 1000000));
2127 else if (ts
->stop_time
)
2128 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2129 (long int) (ts
->stop_time
/ 1000000),
2130 (long int) (ts
->stop_time
% 1000000));
2132 /* Now report any per-tracepoint status available. */
2133 tp_vec
= all_tracepoints ();
2135 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2136 target_get_tracepoint_status (t
, NULL
);
2138 VEC_free (breakpoint_p
, tp_vec
);
2141 /* Report the trace status to uiout, in a way suitable for MI, and not
2142 suitable for CLI. If ON_STOP is true, suppress a few fields that
2143 are not meaningful in the -trace-stop response.
2145 The implementation is essentially parallel to trace_status_command, but
2146 merging them will result in unreadable code. */
2148 trace_status_mi (int on_stop
)
2150 struct ui_out
*uiout
= current_uiout
;
2151 struct trace_status
*ts
= current_trace_status ();
2154 status
= target_get_trace_status (ts
);
2156 if (status
== -1 && ts
->filename
== NULL
)
2158 ui_out_field_string (uiout
, "supported", "0");
2162 if (ts
->filename
!= NULL
)
2163 ui_out_field_string (uiout
, "supported", "file");
2165 ui_out_field_string (uiout
, "supported", "1");
2167 if (ts
->filename
!= NULL
)
2168 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2170 gdb_assert (ts
->running_known
);
2174 ui_out_field_string (uiout
, "running", "1");
2176 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2177 Given that the frontend gets the status either on -trace-stop, or from
2178 -trace-status after re-connection, it does not seem like this
2179 information is necessary for anything. It is not necessary for either
2180 figuring the vital state of the target nor for navigation of trace
2181 frames. If the frontend wants to show the current state is some
2182 configure dialog, it can request the value when such dialog is
2183 invoked by the user. */
2187 char *stop_reason
= NULL
;
2188 int stopping_tracepoint
= -1;
2191 ui_out_field_string (uiout
, "running", "0");
2193 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2195 switch (ts
->stop_reason
)
2198 stop_reason
= "request";
2200 case trace_buffer_full
:
2201 stop_reason
= "overflow";
2203 case trace_disconnected
:
2204 stop_reason
= "disconnection";
2206 case tracepoint_passcount
:
2207 stop_reason
= "passcount";
2208 stopping_tracepoint
= ts
->stopping_tracepoint
;
2210 case tracepoint_error
:
2211 stop_reason
= "error";
2212 stopping_tracepoint
= ts
->stopping_tracepoint
;
2218 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2219 if (stopping_tracepoint
!= -1)
2220 ui_out_field_int (uiout
, "stopping-tracepoint",
2221 stopping_tracepoint
);
2222 if (ts
->stop_reason
== tracepoint_error
)
2223 ui_out_field_string (uiout
, "error-description",
2229 if (ts
->traceframe_count
!= -1)
2230 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2231 if (ts
->traceframes_created
!= -1)
2232 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2233 if (ts
->buffer_size
!= -1)
2234 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2235 if (ts
->buffer_free
!= -1)
2236 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2238 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2239 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2241 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2242 ui_out_field_string (uiout
, "notes", ts
->notes
);
2247 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2248 (long int) (ts
->start_time
/ 1000000),
2249 (long int) (ts
->start_time
% 1000000));
2250 ui_out_field_string (uiout
, "start-time", buf
);
2251 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2252 (long int) (ts
->stop_time
/ 1000000),
2253 (long int) (ts
->stop_time
% 1000000));
2254 ui_out_field_string (uiout
, "stop-time", buf
);
2258 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2259 user if she really wants to detach. */
2262 query_if_trace_running (int from_tty
)
2267 /* It can happen that the target that was tracing went away on its
2268 own, and we didn't notice. Get a status update, and if the
2269 current target doesn't even do tracing, then assume it's not
2271 if (target_get_trace_status (current_trace_status ()) < 0)
2272 current_trace_status ()->running
= 0;
2274 /* If running interactively, give the user the option to cancel and
2275 then decide what to do differently with the run. Scripts are
2276 just going to disconnect and let the target deal with it,
2277 according to how it's been instructed previously via
2278 disconnected-tracing. */
2279 if (current_trace_status ()->running
)
2281 process_tracepoint_on_disconnect ();
2283 if (current_trace_status ()->disconnected_tracing
)
2285 if (!query (_("Trace is running and will "
2286 "continue after detach; detach anyway? ")))
2287 error (_("Not confirmed."));
2291 if (!query (_("Trace is running but will "
2292 "stop on detach; detach anyway? ")))
2293 error (_("Not confirmed."));
2298 /* This function handles the details of what to do about an ongoing
2299 tracing run if the user has asked to detach or otherwise disconnect
2303 disconnect_tracing (void)
2305 /* Also we want to be out of tfind mode, otherwise things can get
2306 confusing upon reconnection. Just use these calls instead of
2307 full tfind_1 behavior because we're in the middle of detaching,
2308 and there's no point to updating current stack frame etc. */
2309 trace_reset_local_state ();
2312 /* Worker function for the various flavors of the tfind command. */
2314 tfind_1 (enum trace_find_type type
, int num
,
2315 CORE_ADDR addr1
, CORE_ADDR addr2
,
2318 int target_frameno
= -1, target_tracept
= -1;
2319 struct frame_id old_frame_id
= null_frame_id
;
2320 struct tracepoint
*tp
;
2321 struct ui_out
*uiout
= current_uiout
;
2323 /* Only try to get the current stack frame if we have a chance of
2324 succeeding. In particular, if we're trying to get a first trace
2325 frame while all threads are running, it's not going to succeed,
2326 so leave it with a default value and let the frame comparison
2327 below (correctly) decide to print out the source location of the
2329 if (!(type
== tfind_number
&& num
== -1)
2330 && (has_stack_frames () || traceframe_number
>= 0))
2331 old_frame_id
= get_frame_id (get_current_frame ());
2333 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2336 if (type
== tfind_number
2338 && target_frameno
== -1)
2340 /* We told the target to get out of tfind mode, and it did. */
2342 else if (target_frameno
== -1)
2344 /* A request for a non-existent trace frame has failed.
2345 Our response will be different, depending on FROM_TTY:
2347 If FROM_TTY is true, meaning that this command was
2348 typed interactively by the user, then give an error
2349 and DO NOT change the state of traceframe_number etc.
2351 However if FROM_TTY is false, meaning that we're either
2352 in a script, a loop, or a user-defined command, then
2353 DON'T give an error, but DO change the state of
2354 traceframe_number etc. to invalid.
2356 The rationalle is that if you typed the command, you
2357 might just have committed a typo or something, and you'd
2358 like to NOT lose your current debugging state. However
2359 if you're in a user-defined command or especially in a
2360 loop, then you need a way to detect that the command
2361 failed WITHOUT aborting. This allows you to write
2362 scripts that search thru the trace buffer until the end,
2363 and then continue on to do something else. */
2366 error (_("Target failed to find requested trace frame."));
2370 printf_filtered ("End of trace buffer.\n");
2371 #if 0 /* dubious now? */
2372 /* The following will not recurse, since it's
2374 trace_find_command ("-1", from_tty
);
2379 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2381 reinit_frame_cache ();
2382 target_dcache_invalidate ();
2384 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2386 if (target_frameno
!= get_traceframe_number ())
2387 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2389 set_current_traceframe (target_frameno
);
2391 if (target_frameno
== -1)
2392 set_traceframe_context (NULL
);
2394 set_traceframe_context (get_current_frame ());
2396 if (traceframe_number
>= 0)
2398 /* Use different branches for MI and CLI to make CLI messages
2400 if (ui_out_is_mi_like_p (uiout
))
2402 ui_out_field_string (uiout
, "found", "1");
2403 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2404 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2408 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2409 traceframe_number
, tracepoint_number
);
2414 if (ui_out_is_mi_like_p (uiout
))
2415 ui_out_field_string (uiout
, "found", "0");
2416 else if (type
== tfind_number
&& num
== -1)
2417 printf_unfiltered (_("No longer looking at any trace frame\n"));
2418 else /* This case may never occur, check. */
2419 printf_unfiltered (_("No trace frame found\n"));
2422 /* If we're in nonstop mode and getting out of looking at trace
2423 frames, there won't be any current frame to go back to and
2426 && (has_stack_frames () || traceframe_number
>= 0))
2428 enum print_what print_what
;
2430 /* NOTE: in imitation of the step command, try to determine
2431 whether we have made a transition from one function to
2432 another. If so, we'll print the "stack frame" (ie. the new
2433 function and it's arguments) -- otherwise we'll just show the
2436 if (frame_id_eq (old_frame_id
,
2437 get_frame_id (get_current_frame ())))
2438 print_what
= SRC_LINE
;
2440 print_what
= SRC_AND_LOC
;
2442 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2447 /* Error on looking at traceframes while trace is running. */
2450 check_trace_running (struct trace_status
*status
)
2452 if (status
->running
&& status
->filename
== NULL
)
2453 error (_("May not look at trace frames while trace is running."));
2456 /* trace_find_command takes a trace frame number n,
2457 sends "QTFrame:<n>" to the target,
2458 and accepts a reply that may contain several optional pieces
2459 of information: a frame number, a tracepoint number, and an
2460 indication of whether this is a trap frame or a stepping frame.
2462 The minimal response is just "OK" (which indicates that the
2463 target does not give us a frame number or a tracepoint number).
2464 Instead of that, the target may send us a string containing
2466 F<hexnum> (gives the selected frame number)
2467 T<hexnum> (gives the selected tracepoint number)
2472 trace_find_command (char *args
, int from_tty
)
2473 { /* This should only be called with a numeric argument. */
2476 check_trace_running (current_trace_status ());
2478 if (args
== 0 || *args
== 0)
2479 { /* TFIND with no args means find NEXT trace frame. */
2480 if (traceframe_number
== -1)
2481 frameno
= 0; /* "next" is first one. */
2483 frameno
= traceframe_number
+ 1;
2485 else if (0 == strcmp (args
, "-"))
2487 if (traceframe_number
== -1)
2488 error (_("not debugging trace buffer"));
2489 else if (from_tty
&& traceframe_number
== 0)
2490 error (_("already at start of trace buffer"));
2492 frameno
= traceframe_number
- 1;
2494 /* A hack to work around eval's need for fp to have been collected. */
2495 else if (0 == strcmp (args
, "-1"))
2498 frameno
= parse_and_eval_long (args
);
2501 error (_("invalid input (%d is less than zero)"), frameno
);
2503 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2508 trace_find_end_command (char *args
, int from_tty
)
2510 trace_find_command ("-1", from_tty
);
2515 trace_find_start_command (char *args
, int from_tty
)
2517 trace_find_command ("0", from_tty
);
2520 /* tfind pc command */
2522 trace_find_pc_command (char *args
, int from_tty
)
2526 check_trace_running (current_trace_status ());
2528 if (args
== 0 || *args
== 0)
2529 pc
= regcache_read_pc (get_current_regcache ());
2531 pc
= parse_and_eval_address (args
);
2533 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2536 /* tfind tracepoint command */
2538 trace_find_tracepoint_command (char *args
, int from_tty
)
2541 struct tracepoint
*tp
;
2543 check_trace_running (current_trace_status ());
2545 if (args
== 0 || *args
== 0)
2547 if (tracepoint_number
== -1)
2548 error (_("No current tracepoint -- please supply an argument."));
2550 tdp
= tracepoint_number
; /* Default is current TDP. */
2553 tdp
= parse_and_eval_long (args
);
2555 /* If we have the tracepoint on hand, use the number that the
2556 target knows about (which may be different if we disconnected
2557 and reconnected). */
2558 tp
= get_tracepoint (tdp
);
2560 tdp
= tp
->number_on_target
;
2562 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2565 /* TFIND LINE command:
2567 This command will take a sourceline for argument, just like BREAK
2568 or TRACE (ie. anything that "decode_line_1" can handle).
2570 With no argument, this command will find the next trace frame
2571 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2574 trace_find_line_command (char *args
, int from_tty
)
2576 static CORE_ADDR start_pc
, end_pc
;
2577 struct symtabs_and_lines sals
;
2578 struct symtab_and_line sal
;
2579 struct cleanup
*old_chain
;
2581 check_trace_running (current_trace_status ());
2583 if (args
== 0 || *args
== 0)
2585 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2587 sals
.sals
= (struct symtab_and_line
*)
2588 xmalloc (sizeof (struct symtab_and_line
));
2593 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2597 old_chain
= make_cleanup (xfree
, sals
.sals
);
2598 if (sal
.symtab
== 0)
2599 error (_("No line number information available."));
2601 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2603 if (start_pc
== end_pc
)
2605 printf_filtered ("Line %d of \"%s\"",
2607 symtab_to_filename_for_display (sal
.symtab
));
2609 printf_filtered (" is at address ");
2610 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2612 printf_filtered (" but contains no code.\n");
2613 sal
= find_pc_line (start_pc
, 0);
2615 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2616 && start_pc
!= end_pc
)
2617 printf_filtered ("Attempting to find line %d instead.\n",
2620 error (_("Cannot find a good line."));
2624 /* Is there any case in which we get here, and have an address
2625 which the user would want to see? If we have debugging
2626 symbols and no line numbers? */
2627 error (_("Line number %d is out of range for \"%s\"."),
2628 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2630 /* Find within range of stated line. */
2632 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2634 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2635 do_cleanups (old_chain
);
2638 /* tfind range command */
2640 trace_find_range_command (char *args
, int from_tty
)
2642 static CORE_ADDR start
, stop
;
2645 check_trace_running (current_trace_status ());
2647 if (args
== 0 || *args
== 0)
2648 { /* XXX FIXME: what should default behavior be? */
2649 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2653 if (0 != (tmp
= strchr (args
, ',')))
2655 *tmp
++ = '\0'; /* Terminate start address. */
2656 tmp
= skip_spaces (tmp
);
2657 start
= parse_and_eval_address (args
);
2658 stop
= parse_and_eval_address (tmp
);
2661 { /* No explicit end address? */
2662 start
= parse_and_eval_address (args
);
2663 stop
= start
+ 1; /* ??? */
2666 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2669 /* tfind outside command */
2671 trace_find_outside_command (char *args
, int from_tty
)
2673 CORE_ADDR start
, stop
;
2676 if (current_trace_status ()->running
2677 && current_trace_status ()->filename
== NULL
)
2678 error (_("May not look at trace frames while trace is running."));
2680 if (args
== 0 || *args
== 0)
2681 { /* XXX FIXME: what should default behavior be? */
2682 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2686 if (0 != (tmp
= strchr (args
, ',')))
2688 *tmp
++ = '\0'; /* Terminate start address. */
2689 tmp
= skip_spaces (tmp
);
2690 start
= parse_and_eval_address (args
);
2691 stop
= parse_and_eval_address (tmp
);
2694 { /* No explicit end address? */
2695 start
= parse_and_eval_address (args
);
2696 stop
= start
+ 1; /* ??? */
2699 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2702 /* info scope command: list the locals for a scope. */
2704 scope_info (char *args
, int from_tty
)
2706 struct symtabs_and_lines sals
;
2708 struct bound_minimal_symbol msym
;
2709 const struct block
*block
;
2710 const char *symname
;
2711 char *save_args
= args
;
2712 struct block_iterator iter
;
2714 struct gdbarch
*gdbarch
;
2716 struct event_location
*location
;
2717 struct cleanup
*back_to
;
2719 if (args
== 0 || *args
== 0)
2720 error (_("requires an argument (function, "
2721 "line or *addr) to define a scope"));
2723 location
= string_to_event_location (&args
, current_language
);
2724 back_to
= make_cleanup_delete_event_location (location
);
2725 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2726 if (sals
.nelts
== 0)
2728 /* Presumably decode_line_1 has already warned. */
2729 do_cleanups (back_to
);
2733 /* Resolve line numbers to PC. */
2734 resolve_sal_pc (&sals
.sals
[0]);
2735 block
= block_for_pc (sals
.sals
[0].pc
);
2739 QUIT
; /* Allow user to bail out with ^C. */
2740 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2742 QUIT
; /* Allow user to bail out with ^C. */
2744 printf_filtered ("Scope for %s:\n", save_args
);
2747 symname
= SYMBOL_PRINT_NAME (sym
);
2748 if (symname
== NULL
|| *symname
== '\0')
2749 continue; /* Probably botched, certainly useless. */
2751 gdbarch
= symbol_arch (sym
);
2753 printf_filtered ("Symbol %s is ", symname
);
2755 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2756 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2757 BLOCK_START (block
),
2761 switch (SYMBOL_CLASS (sym
))
2764 case LOC_UNDEF
: /* Messed up symbol? */
2765 printf_filtered ("a bogus symbol, class %d.\n",
2766 SYMBOL_CLASS (sym
));
2767 count
--; /* Don't count this one. */
2770 printf_filtered ("a constant with value %s (%s)",
2771 plongest (SYMBOL_VALUE (sym
)),
2772 hex_string (SYMBOL_VALUE (sym
)));
2774 case LOC_CONST_BYTES
:
2775 printf_filtered ("constant bytes: ");
2776 if (SYMBOL_TYPE (sym
))
2777 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2778 fprintf_filtered (gdb_stdout
, " %02x",
2779 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2782 printf_filtered ("in static storage at address ");
2783 printf_filtered ("%s", paddress (gdbarch
,
2784 SYMBOL_VALUE_ADDRESS (sym
)));
2787 /* GDBARCH is the architecture associated with the objfile
2788 the symbol is defined in; the target architecture may be
2789 different, and may provide additional registers. However,
2790 we do not know the target architecture at this point.
2791 We assume the objfile architecture will contain all the
2792 standard registers that occur in debug info in that
2794 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2797 if (SYMBOL_IS_ARGUMENT (sym
))
2798 printf_filtered ("an argument in register $%s",
2799 gdbarch_register_name (gdbarch
, regno
));
2801 printf_filtered ("a local variable in register $%s",
2802 gdbarch_register_name (gdbarch
, regno
));
2805 printf_filtered ("an argument at stack/frame offset %s",
2806 plongest (SYMBOL_VALUE (sym
)));
2809 printf_filtered ("a local variable at frame offset %s",
2810 plongest (SYMBOL_VALUE (sym
)));
2813 printf_filtered ("a reference argument at offset %s",
2814 plongest (SYMBOL_VALUE (sym
)));
2816 case LOC_REGPARM_ADDR
:
2817 /* Note comment at LOC_REGISTER. */
2818 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2820 printf_filtered ("the address of an argument, in register $%s",
2821 gdbarch_register_name (gdbarch
, regno
));
2824 printf_filtered ("a typedef.\n");
2827 printf_filtered ("a label at address ");
2828 printf_filtered ("%s", paddress (gdbarch
,
2829 SYMBOL_VALUE_ADDRESS (sym
)));
2832 printf_filtered ("a function at address ");
2833 printf_filtered ("%s",
2834 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2836 case LOC_UNRESOLVED
:
2837 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2839 if (msym
.minsym
== NULL
)
2840 printf_filtered ("Unresolved Static");
2843 printf_filtered ("static storage at address ");
2844 printf_filtered ("%s",
2846 BMSYMBOL_VALUE_ADDRESS (msym
)));
2849 case LOC_OPTIMIZED_OUT
:
2850 printf_filtered ("optimized out.\n");
2853 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2856 if (SYMBOL_TYPE (sym
))
2857 printf_filtered (", length %d.\n",
2858 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2860 if (BLOCK_FUNCTION (block
))
2863 block
= BLOCK_SUPERBLOCK (block
);
2866 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2868 do_cleanups (back_to
);
2871 /* Helper for trace_dump_command. Dump the action list starting at
2872 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2873 actions of the body of a while-stepping action. STEPPING_FRAME is
2874 set if the current traceframe was determined to be a while-stepping
2878 trace_dump_actions (struct command_line
*action
,
2879 int stepping_actions
, int stepping_frame
,
2882 const char *action_exp
, *next_comma
;
2884 for (; action
!= NULL
; action
= action
->next
)
2886 struct cmd_list_element
*cmd
;
2888 QUIT
; /* Allow user to bail out with ^C. */
2889 action_exp
= action
->line
;
2890 action_exp
= skip_spaces_const (action_exp
);
2892 /* The collection actions to be done while stepping are
2893 bracketed by the commands "while-stepping" and "end". */
2895 if (*action_exp
== '#') /* comment line */
2898 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2900 error (_("Bad action list item: %s"), action_exp
);
2902 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2906 for (i
= 0; i
< action
->body_count
; ++i
)
2907 trace_dump_actions (action
->body_list
[i
],
2908 1, stepping_frame
, from_tty
);
2910 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2912 /* Display the collected data.
2913 For the trap frame, display only what was collected at
2914 the trap. Likewise for stepping frames, display only
2915 what was collected while stepping. This means that the
2916 two boolean variables, STEPPING_FRAME and
2917 STEPPING_ACTIONS should be equal. */
2918 if (stepping_frame
== stepping_actions
)
2921 struct cleanup
*old_chain
2922 = make_cleanup (free_current_contents
, &cmd
);
2923 int trace_string
= 0;
2925 if (*action_exp
== '/')
2926 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2929 { /* Repeat over a comma-separated list. */
2930 QUIT
; /* Allow user to bail out with ^C. */
2931 if (*action_exp
== ',')
2933 action_exp
= skip_spaces_const (action_exp
);
2935 next_comma
= strchr (action_exp
, ',');
2937 if (0 == strncasecmp (action_exp
, "$reg", 4))
2938 registers_info (NULL
, from_tty
);
2939 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2941 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2942 locals_info (NULL
, from_tty
);
2943 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2944 args_info (NULL
, from_tty
);
2947 if (next_comma
!= NULL
)
2949 size_t len
= next_comma
- action_exp
;
2951 cmd
= xrealloc (cmd
, len
+ 1);
2952 memcpy (cmd
, action_exp
, len
);
2957 size_t len
= strlen (action_exp
);
2959 cmd
= xrealloc (cmd
, len
+ 1);
2960 memcpy (cmd
, action_exp
, len
+ 1);
2963 printf_filtered ("%s = ", cmd
);
2964 output_command_const (cmd
, from_tty
);
2965 printf_filtered ("\n");
2967 action_exp
= next_comma
;
2969 while (action_exp
&& *action_exp
== ',');
2971 do_cleanups (old_chain
);
2977 /* Return bp_location of the tracepoint associated with the current
2978 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2979 is a stepping traceframe. */
2981 struct bp_location
*
2982 get_traceframe_location (int *stepping_frame_p
)
2984 struct tracepoint
*t
;
2985 struct bp_location
*tloc
;
2986 struct regcache
*regcache
;
2988 if (tracepoint_number
== -1)
2989 error (_("No current trace frame."));
2991 t
= get_tracepoint (tracepoint_number
);
2994 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2997 /* The current frame is a trap frame if the frame PC is equal to the
2998 tracepoint PC. If not, then the current frame was collected
2999 during single-stepping. */
3000 regcache
= get_current_regcache ();
3002 /* If the traceframe's address matches any of the tracepoint's
3003 locations, assume it is a direct hit rather than a while-stepping
3004 frame. (FIXME this is not reliable, should record each frame's
3006 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
3007 if (tloc
->address
== regcache_read_pc (regcache
))
3009 *stepping_frame_p
= 0;
3013 /* If this is a stepping frame, we don't know which location
3014 triggered. The first is as good (or bad) a guess as any... */
3015 *stepping_frame_p
= 1;
3019 /* Return all the actions, including default collect, of a tracepoint
3020 T. It constructs cleanups into the chain, and leaves the caller to
3021 handle them (call do_cleanups). */
3023 static struct command_line
*
3024 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3026 struct command_line
*actions
;
3028 actions
= breakpoint_commands (t
);
3030 /* If there are default expressions to collect, make up a collect
3031 action and prepend to the action list to encode. Note that since
3032 validation is per-tracepoint (local var "xyz" might be valid for
3033 one tracepoint and not another, etc), we make up the action on
3034 the fly, and don't cache it. */
3035 if (*default_collect
)
3037 struct command_line
*default_collect_action
;
3038 char *default_collect_line
;
3040 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3041 make_cleanup (xfree
, default_collect_line
);
3043 validate_actionline (default_collect_line
, t
);
3044 default_collect_action
= xmalloc (sizeof (struct command_line
));
3045 make_cleanup (xfree
, default_collect_action
);
3046 default_collect_action
->next
= actions
;
3047 default_collect_action
->line
= default_collect_line
;
3048 actions
= default_collect_action
;
3054 /* The tdump command. */
3057 trace_dump_command (char *args
, int from_tty
)
3059 int stepping_frame
= 0;
3060 struct bp_location
*loc
;
3061 struct cleanup
*old_chain
;
3062 struct command_line
*actions
;
3064 /* This throws an error is not inspecting a trace frame. */
3065 loc
= get_traceframe_location (&stepping_frame
);
3067 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3068 tracepoint_number
, traceframe_number
);
3070 old_chain
= make_cleanup (null_cleanup
, NULL
);
3072 /* This command only makes sense for the current frame, not the
3074 make_cleanup_restore_current_thread ();
3075 select_frame (get_current_frame ());
3077 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3079 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3081 do_cleanups (old_chain
);
3084 /* Encode a piece of a tracepoint's source-level definition in a form
3085 that is suitable for both protocol and saving in files. */
3086 /* This version does not do multiple encodes for long strings; it should
3087 return an offset to the next piece to encode. FIXME */
3090 encode_source_string (int tpnum
, ULONGEST addr
,
3091 char *srctype
, const char *src
, char *buf
, int buf_size
)
3093 if (80 + strlen (srctype
) > buf_size
)
3094 error (_("Buffer too small for source encoding"));
3095 sprintf (buf
, "%x:%s:%s:%x:%x:",
3096 tpnum
, phex_nz (addr
, sizeof (addr
)),
3097 srctype
, 0, (int) strlen (src
));
3098 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3099 error (_("Source string too long for buffer"));
3100 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
3104 /* Tell the target what to do with an ongoing tracing run if GDB
3105 disconnects for some reason. */
3108 set_disconnected_tracing (char *args
, int from_tty
,
3109 struct cmd_list_element
*c
)
3111 target_set_disconnected_tracing (disconnected_tracing
);
3115 set_circular_trace_buffer (char *args
, int from_tty
,
3116 struct cmd_list_element
*c
)
3118 target_set_circular_trace_buffer (circular_trace_buffer
);
3122 set_trace_buffer_size (char *args
, int from_tty
,
3123 struct cmd_list_element
*c
)
3125 target_set_trace_buffer_size (trace_buffer_size
);
3129 set_trace_user (char *args
, int from_tty
,
3130 struct cmd_list_element
*c
)
3134 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3137 warning (_("Target does not support trace notes, user ignored"));
3141 set_trace_notes (char *args
, int from_tty
,
3142 struct cmd_list_element
*c
)
3146 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3149 warning (_("Target does not support trace notes, note ignored"));
3153 set_trace_stop_notes (char *args
, int from_tty
,
3154 struct cmd_list_element
*c
)
3158 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3161 warning (_("Target does not support trace notes, stop note ignored"));
3164 /* Convert the memory pointed to by mem into hex, placing result in buf.
3165 * Return a pointer to the last char put in buf (null)
3166 * "stolen" from sparc-stub.c
3169 static const char hexchars
[] = "0123456789abcdef";
3172 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3180 *buf
++ = hexchars
[ch
>> 4];
3181 *buf
++ = hexchars
[ch
& 0xf];
3190 get_traceframe_number (void)
3192 return traceframe_number
;
3196 get_tracepoint_number (void)
3198 return tracepoint_number
;
3201 /* Make the traceframe NUM be the current trace frame. Does nothing
3202 if NUM is already current. */
3205 set_current_traceframe (int num
)
3209 if (traceframe_number
== num
)
3211 /* Nothing to do. */
3215 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3218 warning (_("could not change traceframe"));
3220 set_traceframe_num (newnum
);
3222 /* Changing the traceframe changes our view of registers and of the
3224 registers_changed ();
3226 clear_traceframe_info ();
3229 /* A cleanup used when switching away and back from tfind mode. */
3231 struct current_traceframe_cleanup
3233 /* The traceframe we were inspecting. */
3234 int traceframe_number
;
3238 do_restore_current_traceframe_cleanup (void *arg
)
3240 struct current_traceframe_cleanup
*old
= arg
;
3242 set_current_traceframe (old
->traceframe_number
);
3246 restore_current_traceframe_cleanup_dtor (void *arg
)
3248 struct current_traceframe_cleanup
*old
= arg
;
3254 make_cleanup_restore_current_traceframe (void)
3256 struct current_traceframe_cleanup
*old
;
3258 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3259 old
->traceframe_number
= traceframe_number
;
3261 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3262 restore_current_traceframe_cleanup_dtor
);
3265 /* Given a number and address, return an uploaded tracepoint with that
3266 number, creating if necessary. */
3268 struct uploaded_tp
*
3269 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3271 struct uploaded_tp
*utp
;
3273 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3274 if (utp
->number
== num
&& utp
->addr
== addr
)
3276 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3277 memset (utp
, 0, sizeof (struct uploaded_tp
));
3280 utp
->actions
= NULL
;
3281 utp
->step_actions
= NULL
;
3282 utp
->cmd_strings
= NULL
;
3289 free_uploaded_tps (struct uploaded_tp
**utpp
)
3291 struct uploaded_tp
*next_one
;
3295 next_one
= (*utpp
)->next
;
3301 /* Given a number and address, return an uploaded tracepoint with that
3302 number, creating if necessary. */
3304 struct uploaded_tsv
*
3305 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3307 struct uploaded_tsv
*utsv
;
3309 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3310 if (utsv
->number
== num
)
3312 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3313 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3315 utsv
->next
= *utsvp
;
3321 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3323 struct uploaded_tsv
*next_one
;
3327 next_one
= (*utsvp
)->next
;
3333 /* FIXME this function is heuristic and will miss the cases where the
3334 conditional is semantically identical but differs in whitespace,
3335 such as "x == 0" vs "x==0". */
3338 cond_string_is_same (char *str1
, char *str2
)
3340 if (str1
== NULL
|| str2
== NULL
)
3341 return (str1
== str2
);
3343 return (strcmp (str1
, str2
) == 0);
3346 /* Look for an existing tracepoint that seems similar enough to the
3347 uploaded one. Enablement isn't compared, because the user can
3348 toggle that freely, and may have done so in anticipation of the
3349 next trace run. Return the location of matched tracepoint. */
3351 static struct bp_location
*
3352 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3354 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3356 struct breakpoint
*b
;
3357 struct bp_location
*loc
;
3359 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3361 struct tracepoint
*t
= (struct tracepoint
*) b
;
3363 if (b
->type
== utp
->type
3364 && t
->step_count
== utp
->step
3365 && t
->pass_count
== utp
->pass
3366 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3367 /* FIXME also test actions. */
3370 /* Scan the locations for an address match. */
3371 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3373 if (loc
->address
== utp
->addr
)
3381 /* Given a list of tracepoints uploaded from a target, attempt to
3382 match them up with existing tracepoints, and create new ones if not
3386 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3388 struct uploaded_tp
*utp
;
3389 /* A set of tracepoints which are modified. */
3390 VEC(breakpoint_p
) *modified_tp
= NULL
;
3392 struct breakpoint
*b
;
3394 /* Look for GDB tracepoints that match up with our uploaded versions. */
3395 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3397 struct bp_location
*loc
;
3398 struct tracepoint
*t
;
3400 loc
= find_matching_tracepoint_location (utp
);
3405 /* Mark this location as already inserted. */
3407 t
= (struct tracepoint
*) loc
->owner
;
3408 printf_filtered (_("Assuming tracepoint %d is same "
3409 "as target's tracepoint %d at %s.\n"),
3410 loc
->owner
->number
, utp
->number
,
3411 paddress (loc
->gdbarch
, utp
->addr
));
3413 /* The tracepoint LOC->owner was modified (the location LOC
3414 was marked as inserted in the target). Save it in
3415 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3416 observers will be notified later once for each tracepoint
3417 saved in MODIFIED_TP. */
3419 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3421 if (b
== loc
->owner
)
3427 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3431 t
= create_tracepoint_from_upload (utp
);
3433 printf_filtered (_("Created tracepoint %d for "
3434 "target's tracepoint %d at %s.\n"),
3435 t
->base
.number
, utp
->number
,
3436 paddress (get_current_arch (), utp
->addr
));
3438 printf_filtered (_("Failed to create tracepoint for target's "
3439 "tracepoint %d at %s, skipping it.\n"),
3441 paddress (get_current_arch (), utp
->addr
));
3443 /* Whether found or created, record the number used by the
3444 target, to help with mapping target tracepoints back to their
3445 counterparts here. */
3447 t
->number_on_target
= utp
->number
;
3450 /* Notify 'breakpoint-modified' observer that at least one of B's
3451 locations was changed. */
3452 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3453 observer_notify_breakpoint_modified (b
);
3455 VEC_free (breakpoint_p
, modified_tp
);
3456 free_uploaded_tps (uploaded_tps
);
3459 /* Trace state variables don't have much to identify them beyond their
3460 name, so just use that to detect matches. */
3462 static struct trace_state_variable
*
3463 find_matching_tsv (struct uploaded_tsv
*utsv
)
3468 return find_trace_state_variable (utsv
->name
);
3471 static struct trace_state_variable
*
3472 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3474 const char *namebase
;
3477 struct trace_state_variable
*tsv
;
3478 struct cleanup
*old_chain
;
3482 namebase
= utsv
->name
;
3483 buf
= xstrprintf ("%s", namebase
);
3488 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3491 /* Fish for a name that is not in use. */
3492 /* (should check against all internal vars?) */
3493 while (find_trace_state_variable (buf
))
3496 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3499 old_chain
= make_cleanup (xfree
, buf
);
3501 /* We have an available name, create the variable. */
3502 tsv
= create_trace_state_variable (buf
);
3503 tsv
->initial_value
= utsv
->initial_value
;
3504 tsv
->builtin
= utsv
->builtin
;
3506 observer_notify_tsv_created (tsv
);
3508 do_cleanups (old_chain
);
3513 /* Given a list of uploaded trace state variables, try to match them
3514 up with existing variables, or create additional ones. */
3517 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3520 struct uploaded_tsv
*utsv
;
3521 struct trace_state_variable
*tsv
;
3524 /* Most likely some numbers will have to be reassigned as part of
3525 the merge, so clear them all in anticipation. */
3526 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3529 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3531 tsv
= find_matching_tsv (utsv
);
3535 printf_filtered (_("Assuming trace state variable $%s "
3536 "is same as target's variable %d.\n"),
3537 tsv
->name
, utsv
->number
);
3541 tsv
= create_tsv_from_upload (utsv
);
3543 printf_filtered (_("Created trace state variable "
3544 "$%s for target's variable %d.\n"),
3545 tsv
->name
, utsv
->number
);
3547 /* Give precedence to numberings that come from the target. */
3549 tsv
->number
= utsv
->number
;
3552 /* Renumber everything that didn't get a target-assigned number. */
3554 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3555 if (tsv
->number
> highest
)
3556 highest
= tsv
->number
;
3559 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3560 if (tsv
->number
== 0)
3561 tsv
->number
= highest
++;
3563 free_uploaded_tsvs (uploaded_tsvs
);
3566 /* Parse the part of trace status syntax that is shared between
3567 the remote protocol and the trace file reader. */
3570 parse_trace_status (char *line
, struct trace_status
*ts
)
3572 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3576 ts
->running_known
= 1;
3577 ts
->running
= (*p
++ == '1');
3578 ts
->stop_reason
= trace_stop_reason_unknown
;
3579 xfree (ts
->stop_desc
);
3580 ts
->stop_desc
= NULL
;
3581 ts
->traceframe_count
= -1;
3582 ts
->traceframes_created
= -1;
3583 ts
->buffer_free
= -1;
3584 ts
->buffer_size
= -1;
3585 ts
->disconnected_tracing
= 0;
3586 ts
->circular_buffer
= 0;
3587 xfree (ts
->user_name
);
3588 ts
->user_name
= NULL
;
3591 ts
->start_time
= ts
->stop_time
= 0;
3595 p1
= strchr (p
, ':');
3597 error (_("Malformed trace status, at %s\n\
3598 Status line: '%s'\n"), p
, line
);
3599 p3
= strchr (p
, ';');
3601 p3
= p
+ strlen (p
);
3602 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3604 p
= unpack_varlen_hex (++p1
, &val
);
3605 ts
->stop_reason
= trace_buffer_full
;
3607 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3609 p
= unpack_varlen_hex (++p1
, &val
);
3610 ts
->stop_reason
= trace_never_run
;
3612 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3615 p
= unpack_varlen_hex (++p1
, &val
);
3616 ts
->stop_reason
= tracepoint_passcount
;
3617 ts
->stopping_tracepoint
= val
;
3619 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3621 p2
= strchr (++p1
, ':');
3629 ts
->stop_desc
= xmalloc (strlen (line
));
3630 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3631 ts
->stop_desc
[end
] = '\0';
3634 ts
->stop_desc
= xstrdup ("");
3636 p
= unpack_varlen_hex (++p2
, &val
);
3637 ts
->stop_reason
= tstop_command
;
3639 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3641 p
= unpack_varlen_hex (++p1
, &val
);
3642 ts
->stop_reason
= trace_disconnected
;
3644 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3646 p2
= strchr (++p1
, ':');
3649 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3650 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3651 ts
->stop_desc
[end
] = '\0';
3654 ts
->stop_desc
= xstrdup ("");
3656 p
= unpack_varlen_hex (++p2
, &val
);
3657 ts
->stopping_tracepoint
= val
;
3658 ts
->stop_reason
= tracepoint_error
;
3660 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3662 p
= unpack_varlen_hex (++p1
, &val
);
3663 ts
->traceframe_count
= val
;
3665 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3667 p
= unpack_varlen_hex (++p1
, &val
);
3668 ts
->traceframes_created
= val
;
3670 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3672 p
= unpack_varlen_hex (++p1
, &val
);
3673 ts
->buffer_free
= val
;
3675 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3677 p
= unpack_varlen_hex (++p1
, &val
);
3678 ts
->buffer_size
= val
;
3680 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3682 p
= unpack_varlen_hex (++p1
, &val
);
3683 ts
->disconnected_tracing
= val
;
3685 else if (strncmp (p
, "circular", p1
- p
) == 0)
3687 p
= unpack_varlen_hex (++p1
, &val
);
3688 ts
->circular_buffer
= val
;
3690 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3692 p
= unpack_varlen_hex (++p1
, &val
);
3693 ts
->start_time
= val
;
3695 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3697 p
= unpack_varlen_hex (++p1
, &val
);
3698 ts
->stop_time
= val
;
3700 else if (strncmp (p
, "username", p1
- p
) == 0)
3703 ts
->user_name
= xmalloc (strlen (p
) / 2);
3704 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3705 ts
->user_name
[end
] = '\0';
3708 else if (strncmp (p
, "notes", p1
- p
) == 0)
3711 ts
->notes
= xmalloc (strlen (p
) / 2);
3712 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3713 ts
->notes
[end
] = '\0';
3718 /* Silently skip unknown optional info. */
3719 p_temp
= strchr (p1
+ 1, ';');
3723 /* Must be at the end. */
3730 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3731 struct uploaded_tp
*utp
)
3734 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3736 p
= unpack_varlen_hex (p
, &uval
);
3738 tp
->base
.hit_count
+= uval
;
3740 utp
->hit_count
+= uval
;
3741 p
= unpack_varlen_hex (p
+ 1, &uval
);
3743 tp
->traceframe_usage
+= uval
;
3745 utp
->traceframe_usage
+= uval
;
3746 /* Ignore any extra, allowing for future extensions. */
3749 /* Given a line of text defining a part of a tracepoint, parse it into
3750 an "uploaded tracepoint". */
3753 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3757 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3760 char *cond
, *srctype
, *buf
;
3761 struct uploaded_tp
*utp
= NULL
;
3764 /* Both tracepoint and action definitions start with the same number
3765 and address sequence. */
3767 p
= unpack_varlen_hex (p
, &num
);
3768 p
++; /* skip a colon */
3769 p
= unpack_varlen_hex (p
, &addr
);
3770 p
++; /* skip a colon */
3773 enabled
= (*p
++ == 'E');
3774 p
++; /* skip a colon */
3775 p
= unpack_varlen_hex (p
, &step
);
3776 p
++; /* skip a colon */
3777 p
= unpack_varlen_hex (p
, &pass
);
3778 type
= bp_tracepoint
;
3780 /* Thumb through optional fields. */
3783 p
++; /* skip a colon */
3786 type
= bp_fast_tracepoint
;
3788 p
= unpack_varlen_hex (p
, &orig_size
);
3792 type
= bp_static_tracepoint
;
3798 p
= unpack_varlen_hex (p
, &xlen
);
3799 p
++; /* skip a comma */
3800 cond
= (char *) xmalloc (2 * xlen
+ 1);
3801 strncpy (cond
, p
, 2 * xlen
);
3802 cond
[2 * xlen
] = '\0';
3806 warning (_("Unrecognized char '%c' in tracepoint "
3807 "definition, skipping rest"), *p
);
3809 utp
= get_uploaded_tp (num
, addr
, utpp
);
3811 utp
->enabled
= enabled
;
3816 else if (piece
== 'A')
3818 utp
= get_uploaded_tp (num
, addr
, utpp
);
3819 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3821 else if (piece
== 'S')
3823 utp
= get_uploaded_tp (num
, addr
, utpp
);
3824 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3826 else if (piece
== 'Z')
3828 /* Parse a chunk of source form definition. */
3829 utp
= get_uploaded_tp (num
, addr
, utpp
);
3831 p
= strchr (p
, ':');
3832 p
++; /* skip a colon */
3833 p
= unpack_varlen_hex (p
, &start
);
3834 p
++; /* skip a colon */
3835 p
= unpack_varlen_hex (p
, &xlen
);
3836 p
++; /* skip a colon */
3838 buf
= alloca (strlen (line
));
3840 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3843 if (startswith (srctype
, "at:"))
3844 utp
->at_string
= xstrdup (buf
);
3845 else if (startswith (srctype
, "cond:"))
3846 utp
->cond_string
= xstrdup (buf
);
3847 else if (startswith (srctype
, "cmd:"))
3848 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3850 else if (piece
== 'V')
3852 utp
= get_uploaded_tp (num
, addr
, utpp
);
3854 parse_tracepoint_status (p
, NULL
, utp
);
3858 /* Don't error out, the target might be sending us optional
3859 info that we don't care about. */
3860 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3864 /* Convert a textual description of a trace state variable into an
3868 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3871 ULONGEST num
, initval
, builtin
;
3873 struct uploaded_tsv
*utsv
= NULL
;
3875 buf
= alloca (strlen (line
));
3878 p
= unpack_varlen_hex (p
, &num
);
3879 p
++; /* skip a colon */
3880 p
= unpack_varlen_hex (p
, &initval
);
3881 p
++; /* skip a colon */
3882 p
= unpack_varlen_hex (p
, &builtin
);
3883 p
++; /* skip a colon */
3884 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3887 utsv
= get_uploaded_tsv (num
, utsvp
);
3888 utsv
->initial_value
= initval
;
3889 utsv
->builtin
= builtin
;
3890 utsv
->name
= xstrdup (buf
);
3894 free_current_marker (void *arg
)
3896 struct static_tracepoint_marker
**marker_p
= arg
;
3898 if (*marker_p
!= NULL
)
3900 release_static_tracepoint_marker (*marker_p
);
3907 /* Given a line of text defining a static tracepoint marker, parse it
3908 into a "static tracepoint marker" object. Throws an error is
3909 parsing fails. If PP is non-null, it points to one past the end of
3910 the parsed marker definition. */
3913 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
3914 struct static_tracepoint_marker
*marker
)
3921 p
= unpack_varlen_hex (p
, &addr
);
3922 p
++; /* skip a colon */
3924 marker
->gdbarch
= target_gdbarch ();
3925 marker
->address
= (CORE_ADDR
) addr
;
3927 endp
= strchr (p
, ':');
3929 error (_("bad marker definition: %s"), line
);
3931 marker
->str_id
= xmalloc (endp
- p
+ 1);
3932 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
3933 marker
->str_id
[end
] = '\0';
3936 p
++; /* skip a colon */
3938 marker
->extra
= xmalloc (strlen (p
) + 1);
3939 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
3940 marker
->extra
[end
] = '\0';
3946 /* Release a static tracepoint marker's contents. Note that the
3947 object itself isn't released here. There objects are usually on
3951 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
3953 xfree (marker
->str_id
);
3954 marker
->str_id
= NULL
;
3957 /* Print MARKER to gdb_stdout. */
3960 print_one_static_tracepoint_marker (int count
,
3961 struct static_tracepoint_marker
*marker
)
3963 struct command_line
*l
;
3966 char wrap_indent
[80];
3967 char extra_field_indent
[80];
3968 struct ui_out
*uiout
= current_uiout
;
3969 struct cleanup
*bkpt_chain
;
3970 VEC(breakpoint_p
) *tracepoints
;
3972 struct symtab_and_line sal
;
3976 sal
.pc
= marker
->address
;
3978 tracepoints
= static_tracepoints_here (marker
->address
);
3980 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
3982 /* A counter field to help readability. This is not a stable
3984 ui_out_field_int (uiout
, "count", count
);
3986 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
3988 ui_out_field_fmt (uiout
, "enabled", "%c",
3989 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
3990 ui_out_spaces (uiout
, 2);
3992 strcpy (wrap_indent
, " ");
3994 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
3995 strcat (wrap_indent
, " ");
3997 strcat (wrap_indent
, " ");
3999 strcpy (extra_field_indent
, " ");
4001 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4003 sal
= find_pc_line (marker
->address
, 0);
4004 sym
= find_pc_sect_function (marker
->address
, NULL
);
4007 ui_out_text (uiout
, "in ");
4008 ui_out_field_string (uiout
, "func",
4009 SYMBOL_PRINT_NAME (sym
));
4010 ui_out_wrap_hint (uiout
, wrap_indent
);
4011 ui_out_text (uiout
, " at ");
4014 ui_out_field_skip (uiout
, "func");
4016 if (sal
.symtab
!= NULL
)
4018 ui_out_field_string (uiout
, "file",
4019 symtab_to_filename_for_display (sal
.symtab
));
4020 ui_out_text (uiout
, ":");
4022 if (ui_out_is_mi_like_p (uiout
))
4024 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4026 ui_out_field_string (uiout
, "fullname", fullname
);
4029 ui_out_field_skip (uiout
, "fullname");
4031 ui_out_field_int (uiout
, "line", sal
.line
);
4035 ui_out_field_skip (uiout
, "fullname");
4036 ui_out_field_skip (uiout
, "line");
4039 ui_out_text (uiout
, "\n");
4040 ui_out_text (uiout
, extra_field_indent
);
4041 ui_out_text (uiout
, _("Data: \""));
4042 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4043 ui_out_text (uiout
, "\"\n");
4045 if (!VEC_empty (breakpoint_p
, tracepoints
))
4047 struct cleanup
*cleanup_chain
;
4049 struct breakpoint
*b
;
4051 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4054 ui_out_text (uiout
, extra_field_indent
);
4055 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4056 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4059 ui_out_text (uiout
, ", ");
4060 ui_out_text (uiout
, "#");
4061 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4064 do_cleanups (cleanup_chain
);
4066 if (ui_out_is_mi_like_p (uiout
))
4067 ui_out_field_int (uiout
, "number-of-tracepoints",
4068 VEC_length(breakpoint_p
, tracepoints
));
4070 ui_out_text (uiout
, "\n");
4072 VEC_free (breakpoint_p
, tracepoints
);
4074 do_cleanups (bkpt_chain
);
4078 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4080 VEC(static_tracepoint_marker_p
) *markers
;
4081 struct cleanup
*old_chain
;
4082 struct static_tracepoint_marker
*marker
;
4083 struct ui_out
*uiout
= current_uiout
;
4086 /* We don't have to check target_can_use_agent and agent's capability on
4087 static tracepoint here, in order to be compatible with older GDBserver.
4088 We don't check USE_AGENT is true or not, because static tracepoints
4089 don't work without in-process agent, so we don't bother users to type
4090 `set agent on' when to use static tracepoint. */
4093 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4094 "StaticTracepointMarkersTable");
4096 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4098 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4100 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4101 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4102 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4104 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4105 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4107 ui_out_table_body (uiout
);
4109 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4110 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4113 VEC_iterate (static_tracepoint_marker_p
,
4114 markers
, i
, marker
);
4117 print_one_static_tracepoint_marker (i
+ 1, marker
);
4118 release_static_tracepoint_marker (marker
);
4121 do_cleanups (old_chain
);
4124 /* The $_sdata convenience variable is a bit special. We don't know
4125 for sure type of the value until we actually have a chance to fetch
4126 the data --- the size of the object depends on what has been
4127 collected. We solve this by making $_sdata be an internalvar that
4128 creates a new value on access. */
4130 /* Return a new value with the correct type for the sdata object of
4131 the current trace frame. Return a void value if there's no object
4134 static struct value
*
4135 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4141 /* We need to read the whole object before we know its size. */
4142 size
= target_read_alloc (¤t_target
,
4143 TARGET_OBJECT_STATIC_TRACE_DATA
,
4150 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4152 v
= allocate_value (type
);
4153 memcpy (value_contents_raw (v
), buf
, size
);
4158 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4161 #if !defined(HAVE_LIBEXPAT)
4163 struct traceframe_info
*
4164 parse_traceframe_info (const char *tframe_info
)
4166 static int have_warned
;
4171 warning (_("Can not parse XML trace frame info; XML support "
4172 "was disabled at compile time"));
4178 #else /* HAVE_LIBEXPAT */
4180 #include "xml-support.h"
4182 /* Handle the start of a <memory> element. */
4185 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4186 const struct gdb_xml_element
*element
,
4187 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4189 struct traceframe_info
*info
= user_data
;
4190 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4191 ULONGEST
*start_p
, *length_p
;
4193 start_p
= xml_find_attribute (attributes
, "start")->value
;
4194 length_p
= xml_find_attribute (attributes
, "length")->value
;
4196 r
->start
= *start_p
;
4197 r
->length
= *length_p
;
4200 /* Handle the start of a <tvar> element. */
4203 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
4204 const struct gdb_xml_element
*element
,
4206 VEC(gdb_xml_value_s
) *attributes
)
4208 struct traceframe_info
*info
= user_data
;
4209 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
4210 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
4212 VEC_safe_push (int, info
->tvars
, id
);
4215 /* Discard the constructed trace frame info (if an error occurs). */
4218 free_result (void *p
)
4220 struct traceframe_info
*result
= p
;
4222 free_traceframe_info (result
);
4225 /* The allowed elements and attributes for an XML memory map. */
4227 static const struct gdb_xml_attribute memory_attributes
[] = {
4228 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4229 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4230 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4233 static const struct gdb_xml_attribute tvar_attributes
[] = {
4234 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
4235 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4238 static const struct gdb_xml_element traceframe_info_children
[] = {
4239 { "memory", memory_attributes
, NULL
,
4240 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4241 traceframe_info_start_memory
, NULL
},
4242 { "tvar", tvar_attributes
, NULL
,
4243 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4244 traceframe_info_start_tvar
, NULL
},
4245 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4248 static const struct gdb_xml_element traceframe_info_elements
[] = {
4249 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4251 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4254 /* Parse a traceframe-info XML document. */
4256 struct traceframe_info
*
4257 parse_traceframe_info (const char *tframe_info
)
4259 struct traceframe_info
*result
;
4260 struct cleanup
*back_to
;
4262 result
= XCNEW (struct traceframe_info
);
4263 back_to
= make_cleanup (free_result
, result
);
4265 if (gdb_xml_parse_quick (_("trace frame info"),
4266 "traceframe-info.dtd", traceframe_info_elements
,
4267 tframe_info
, result
) == 0)
4269 /* Parsed successfully, keep the result. */
4270 discard_cleanups (back_to
);
4275 do_cleanups (back_to
);
4279 #endif /* HAVE_LIBEXPAT */
4281 /* Returns the traceframe_info object for the current traceframe.
4282 This is where we avoid re-fetching the object from the target if we
4283 already have it cached. */
4285 struct traceframe_info
*
4286 get_traceframe_info (void)
4288 if (traceframe_info
== NULL
)
4289 traceframe_info
= target_traceframe_info ();
4291 return traceframe_info
;
4294 /* If the target supports the query, return in RESULT the set of
4295 collected memory in the current traceframe, found within the LEN
4296 bytes range starting at MEMADDR. Returns true if the target
4297 supports the query, otherwise returns false, and RESULT is left
4301 traceframe_available_memory (VEC(mem_range_s
) **result
,
4302 CORE_ADDR memaddr
, ULONGEST len
)
4304 struct traceframe_info
*info
= get_traceframe_info ();
4308 struct mem_range
*r
;
4313 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4314 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4316 ULONGEST lo1
, hi1
, lo2
, hi2
;
4317 struct mem_range
*nr
;
4320 hi1
= memaddr
+ len
;
4323 hi2
= r
->start
+ r
->length
;
4325 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4327 nr
->start
= max (lo1
, lo2
);
4328 nr
->length
= min (hi1
, hi2
) - nr
->start
;
4331 normalize_mem_ranges (*result
);
4338 /* Implementation of `sdata' variable. */
4340 static const struct internalvar_funcs sdata_funcs
=
4347 /* module initialization */
4349 _initialize_tracepoint (void)
4351 struct cmd_list_element
*c
;
4353 /* Explicitly create without lookup, since that tries to create a
4354 value with a void typed value, and when we get here, gdbarch
4355 isn't initialized yet. At this point, we're quite sure there
4356 isn't another convenience variable of the same name. */
4357 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4359 traceframe_number
= -1;
4360 tracepoint_number
= -1;
4362 add_info ("scope", scope_info
,
4363 _("List the variables local to a scope"));
4365 add_cmd ("tracepoints", class_trace
, NULL
,
4366 _("Tracing of program execution without stopping the program."),
4369 add_com ("tdump", class_trace
, trace_dump_command
,
4370 _("Print everything collected at the current tracepoint."));
4372 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4373 Define a trace state variable.\n\
4374 Argument is a $-prefixed name, optionally followed\n\
4375 by '=' and an expression that sets the initial value\n\
4376 at the start of tracing."));
4377 set_cmd_completer (c
, expression_completer
);
4379 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4380 Delete one or more trace state variables.\n\
4381 Arguments are the names of the variables to delete.\n\
4382 If no arguments are supplied, delete all variables."), &deletelist
);
4383 /* FIXME add a trace variable completer. */
4385 add_info ("tvariables", tvariables_info
, _("\
4386 Status of trace state variables and their values.\n\
4389 add_info ("static-tracepoint-markers",
4390 info_static_tracepoint_markers_command
, _("\
4391 List target static tracepoints markers.\n\
4394 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4395 Select a trace frame;\n\
4396 No argument means forward by one frame; '-' means backward by one frame."),
4397 &tfindlist
, "tfind ", 1, &cmdlist
);
4399 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4400 Select a trace frame whose PC is outside the given range (exclusive).\n\
4401 Usage: tfind outside addr1, addr2"),
4404 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4405 Select a trace frame whose PC is in the given range (inclusive).\n\
4406 Usage: tfind range addr1,addr2"),
4409 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4410 Select a trace frame by source line.\n\
4411 Argument can be a line number (with optional source file),\n\
4412 a function name, or '*' followed by an address.\n\
4413 Default argument is 'the next source line that was traced'."),
4416 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4417 Select a trace frame by tracepoint number.\n\
4418 Default is the tracepoint for the current trace frame."),
4421 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4422 Select a trace frame by PC.\n\
4423 Default is the current PC, or the PC of the current trace frame."),
4426 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4427 De-select any trace frame and resume 'live' debugging."),
4430 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4432 add_cmd ("start", class_trace
, trace_find_start_command
,
4433 _("Select the first trace frame in the trace buffer."),
4436 add_com ("tstatus", class_trace
, trace_status_command
,
4437 _("Display the status of the current trace data collection."));
4439 add_com ("tstop", class_trace
, trace_stop_command
, _("\
4440 Stop trace data collection.\n\
4441 Usage: tstop [ <notes> ... ]\n\
4442 Any arguments supplied are recorded with the trace as a stop reason and\n\
4443 reported by tstatus (if the target supports trace notes)."));
4445 add_com ("tstart", class_trace
, trace_start_command
, _("\
4446 Start trace data collection.\n\
4447 Usage: tstart [ <notes> ... ]\n\
4448 Any arguments supplied are recorded with the trace as a note and\n\
4449 reported by tstatus (if the target supports trace notes)."));
4451 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4452 Ends a list of commands or actions.\n\
4453 Several GDB commands allow you to enter a list of commands or actions.\n\
4454 Entering \"end\" on a line by itself is the normal way to terminate\n\
4456 Note: the \"end\" command cannot be used at the gdb prompt."));
4458 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4459 Specify single-stepping behavior at a tracepoint.\n\
4460 Argument is number of instructions to trace in single-step mode\n\
4461 following the tracepoint. This command is normally followed by\n\
4462 one or more \"collect\" commands, to specify what to collect\n\
4463 while single-stepping.\n\n\
4464 Note: this command can only be used in a tracepoint \"actions\" list."));
4466 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4467 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4469 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4470 Specify one or more data items to be collected at a tracepoint.\n\
4471 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4472 collect all data (variables, registers) referenced by that expression.\n\
4473 Also accepts the following special arguments:\n\
4474 $regs -- all registers.\n\
4475 $args -- all function arguments.\n\
4476 $locals -- all variables local to the block/function scope.\n\
4477 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4478 Note: this command can only be used in a tracepoint \"actions\" list."));
4480 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4481 Specify one or more expressions to be evaluated at a tracepoint.\n\
4482 Accepts a comma-separated list of (one or more) expressions.\n\
4483 The result of each evaluation will be discarded.\n\
4484 Note: this command can only be used in a tracepoint \"actions\" list."));
4486 add_com ("actions", class_trace
, trace_actions_command
, _("\
4487 Specify the actions to be taken at a tracepoint.\n\
4488 Tracepoint actions may include collecting of specified data,\n\
4489 single-stepping, or enabling/disabling other tracepoints,\n\
4490 depending on target's capabilities."));
4492 default_collect
= xstrdup ("");
4493 add_setshow_string_cmd ("default-collect", class_trace
,
4494 &default_collect
, _("\
4495 Set the list of expressions to collect by default"), _("\
4496 Show the list of expressions to collect by default"), NULL
,
4498 &setlist
, &showlist
);
4500 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4501 &disconnected_tracing
, _("\
4502 Set whether tracing continues after GDB disconnects."), _("\
4503 Show whether tracing continues after GDB disconnects."), _("\
4504 Use this to continue a tracing run even if GDB disconnects\n\
4505 or detaches from the target. You can reconnect later and look at\n\
4506 trace data collected in the meantime."),
4507 set_disconnected_tracing
,
4512 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4513 &circular_trace_buffer
, _("\
4514 Set target's use of circular trace buffer."), _("\
4515 Show target's use of circular trace buffer."), _("\
4516 Use this to make the trace buffer into a circular buffer,\n\
4517 which will discard traceframes (oldest first) instead of filling\n\
4518 up and stopping the trace run."),
4519 set_circular_trace_buffer
,
4524 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4525 &trace_buffer_size
, _("\
4526 Set requested size of trace buffer."), _("\
4527 Show requested size of trace buffer."), _("\
4528 Use this to choose a size for the trace buffer. Some targets\n\
4529 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4530 disables any attempt to set the buffer size and lets the target choose."),
4531 set_trace_buffer_size
, NULL
,
4532 &setlist
, &showlist
);
4534 add_setshow_string_cmd ("trace-user", class_trace
,
4536 Set the user name to use for current and future trace runs"), _("\
4537 Show the user name to use for current and future trace runs"), NULL
,
4538 set_trace_user
, NULL
,
4539 &setlist
, &showlist
);
4541 add_setshow_string_cmd ("trace-notes", class_trace
,
4543 Set notes string to use for current and future trace runs"), _("\
4544 Show the notes string to use for current and future trace runs"), NULL
,
4545 set_trace_notes
, NULL
,
4546 &setlist
, &showlist
);
4548 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4549 &trace_stop_notes
, _("\
4550 Set notes string to use for future tstop commands"), _("\
4551 Show the notes string to use for future tstop commands"), NULL
,
4552 set_trace_stop_notes
, NULL
,
4553 &setlist
, &showlist
);