1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2014 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 "exceptions.h"
53 #include "cli/cli-utils.h"
56 #include "filestuff.h"
58 #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 (loc
->probe
.probe
,
1867 if (bp_location_downloaded
)
1868 observer_notify_breakpoint_modified (b
);
1870 VEC_free (breakpoint_p
, tp_vec
);
1872 /* Send down all the trace state variables too. */
1873 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1875 target_download_trace_state_variable (tsv
);
1878 /* Tell target to treat text-like sections as transparent. */
1879 target_trace_set_readonly_regions ();
1880 /* Set some mode flags. */
1881 target_set_disconnected_tracing (disconnected_tracing
);
1882 target_set_circular_trace_buffer (circular_trace_buffer
);
1883 target_set_trace_buffer_size (trace_buffer_size
);
1886 notes
= trace_notes
;
1887 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1889 if (!ret
&& (trace_user
|| notes
))
1890 warning (_("Target does not support trace user/notes, info ignored"));
1892 /* Now insert traps and begin collecting data. */
1893 target_trace_start ();
1895 /* Reset our local state. */
1896 trace_reset_local_state ();
1897 current_trace_status()->running
= 1;
1900 /* The tstart command requests the target to start a new trace run.
1901 The command passes any arguments it has to the target verbatim, as
1902 an optional "trace note". This is useful as for instance a warning
1903 to other users if the trace runs disconnected, and you don't want
1904 anybody else messing with the target. */
1907 trace_start_command (char *args
, int from_tty
)
1909 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1911 if (current_trace_status ()->running
)
1914 && !query (_("A trace is running already. Start a new run? ")))
1915 error (_("New trace run not started."));
1918 start_tracing (args
);
1921 /* The tstop command stops the tracing run. The command passes any
1922 supplied arguments to the target verbatim as a "stop note"; if the
1923 target supports trace notes, then it will be reported back as part
1924 of the trace run's status. */
1927 trace_stop_command (char *args
, int from_tty
)
1929 if (!current_trace_status ()->running
)
1930 error (_("Trace is not running."));
1932 stop_tracing (args
);
1936 stop_tracing (char *note
)
1939 VEC(breakpoint_p
) *tp_vec
= NULL
;
1941 struct breakpoint
*t
;
1943 target_trace_stop ();
1945 tp_vec
= all_tracepoints ();
1946 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1948 struct bp_location
*loc
;
1950 if ((t
->type
== bp_fast_tracepoint
1951 ? !may_insert_fast_tracepoints
1952 : !may_insert_tracepoints
))
1955 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1957 /* GDB can be totally absent in some disconnected trace scenarios,
1958 but we don't really care if this semaphore goes out of sync.
1959 That's why we are decrementing it here, but not taking care
1961 if (loc
->probe
.probe
!= NULL
)
1962 loc
->probe
.probe
->pops
->clear_semaphore (loc
->probe
.probe
,
1968 VEC_free (breakpoint_p
, tp_vec
);
1971 note
= trace_stop_notes
;
1972 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1975 warning (_("Target does not support trace notes, note ignored"));
1977 /* Should change in response to reply? */
1978 current_trace_status ()->running
= 0;
1981 /* tstatus command */
1983 trace_status_command (char *args
, int from_tty
)
1985 struct trace_status
*ts
= current_trace_status ();
1987 VEC(breakpoint_p
) *tp_vec
= NULL
;
1988 struct breakpoint
*t
;
1990 status
= target_get_trace_status (ts
);
1994 if (ts
->filename
!= NULL
)
1995 printf_filtered (_("Using a trace file.\n"));
1998 printf_filtered (_("Trace can not be run on this target.\n"));
2003 if (!ts
->running_known
)
2005 printf_filtered (_("Run/stop status is unknown.\n"));
2007 else if (ts
->running
)
2009 printf_filtered (_("Trace is running on the target.\n"));
2013 switch (ts
->stop_reason
)
2015 case trace_never_run
:
2016 printf_filtered (_("No trace has been run on the target.\n"));
2020 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2023 printf_filtered (_("Trace stopped by a tstop command.\n"));
2025 case trace_buffer_full
:
2026 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2028 case trace_disconnected
:
2029 printf_filtered (_("Trace stopped because of disconnection.\n"));
2031 case tracepoint_passcount
:
2032 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2033 ts
->stopping_tracepoint
);
2035 case tracepoint_error
:
2036 if (ts
->stopping_tracepoint
)
2037 printf_filtered (_("Trace stopped by an "
2038 "error (%s, tracepoint %d).\n"),
2039 ts
->stop_desc
, ts
->stopping_tracepoint
);
2041 printf_filtered (_("Trace stopped by an error (%s).\n"),
2044 case trace_stop_reason_unknown
:
2045 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2048 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2054 if (ts
->traceframes_created
>= 0
2055 && ts
->traceframe_count
!= ts
->traceframes_created
)
2057 printf_filtered (_("Buffer contains %d trace "
2058 "frames (of %d created total).\n"),
2059 ts
->traceframe_count
, ts
->traceframes_created
);
2061 else if (ts
->traceframe_count
>= 0)
2063 printf_filtered (_("Collected %d trace frames.\n"),
2064 ts
->traceframe_count
);
2067 if (ts
->buffer_free
>= 0)
2069 if (ts
->buffer_size
>= 0)
2071 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2072 ts
->buffer_free
, ts
->buffer_size
);
2073 if (ts
->buffer_size
> 0)
2074 printf_filtered (_(" (%d%% full)"),
2075 ((int) ((((long long) (ts
->buffer_size
2076 - ts
->buffer_free
)) * 100)
2077 / ts
->buffer_size
)));
2078 printf_filtered (_(".\n"));
2081 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2085 if (ts
->disconnected_tracing
)
2086 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2088 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2090 if (ts
->circular_buffer
)
2091 printf_filtered (_("Trace buffer is circular.\n"));
2093 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2094 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2096 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2097 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2099 /* Now report on what we're doing with tfind. */
2100 if (traceframe_number
>= 0)
2101 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2102 traceframe_number
, tracepoint_number
);
2104 printf_filtered (_("Not looking at any trace frame.\n"));
2106 /* Report start/stop times if supplied. */
2111 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2113 /* Reporting a run time is more readable than two long numbers. */
2114 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2115 (long int) (ts
->start_time
/ 1000000),
2116 (long int) (ts
->start_time
% 1000000),
2117 (long int) (run_time
/ 1000000),
2118 (long int) (run_time
% 1000000));
2121 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2122 (long int) (ts
->start_time
/ 1000000),
2123 (long int) (ts
->start_time
% 1000000));
2125 else if (ts
->stop_time
)
2126 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2127 (long int) (ts
->stop_time
/ 1000000),
2128 (long int) (ts
->stop_time
% 1000000));
2130 /* Now report any per-tracepoint status available. */
2131 tp_vec
= all_tracepoints ();
2133 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2134 target_get_tracepoint_status (t
, NULL
);
2136 VEC_free (breakpoint_p
, tp_vec
);
2139 /* Report the trace status to uiout, in a way suitable for MI, and not
2140 suitable for CLI. If ON_STOP is true, suppress a few fields that
2141 are not meaningful in the -trace-stop response.
2143 The implementation is essentially parallel to trace_status_command, but
2144 merging them will result in unreadable code. */
2146 trace_status_mi (int on_stop
)
2148 struct ui_out
*uiout
= current_uiout
;
2149 struct trace_status
*ts
= current_trace_status ();
2152 status
= target_get_trace_status (ts
);
2154 if (status
== -1 && ts
->filename
== NULL
)
2156 ui_out_field_string (uiout
, "supported", "0");
2160 if (ts
->filename
!= NULL
)
2161 ui_out_field_string (uiout
, "supported", "file");
2163 ui_out_field_string (uiout
, "supported", "1");
2165 if (ts
->filename
!= NULL
)
2166 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2168 gdb_assert (ts
->running_known
);
2172 ui_out_field_string (uiout
, "running", "1");
2174 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2175 Given that the frontend gets the status either on -trace-stop, or from
2176 -trace-status after re-connection, it does not seem like this
2177 information is necessary for anything. It is not necessary for either
2178 figuring the vital state of the target nor for navigation of trace
2179 frames. If the frontend wants to show the current state is some
2180 configure dialog, it can request the value when such dialog is
2181 invoked by the user. */
2185 char *stop_reason
= NULL
;
2186 int stopping_tracepoint
= -1;
2189 ui_out_field_string (uiout
, "running", "0");
2191 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2193 switch (ts
->stop_reason
)
2196 stop_reason
= "request";
2198 case trace_buffer_full
:
2199 stop_reason
= "overflow";
2201 case trace_disconnected
:
2202 stop_reason
= "disconnection";
2204 case tracepoint_passcount
:
2205 stop_reason
= "passcount";
2206 stopping_tracepoint
= ts
->stopping_tracepoint
;
2208 case tracepoint_error
:
2209 stop_reason
= "error";
2210 stopping_tracepoint
= ts
->stopping_tracepoint
;
2216 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2217 if (stopping_tracepoint
!= -1)
2218 ui_out_field_int (uiout
, "stopping-tracepoint",
2219 stopping_tracepoint
);
2220 if (ts
->stop_reason
== tracepoint_error
)
2221 ui_out_field_string (uiout
, "error-description",
2227 if (ts
->traceframe_count
!= -1)
2228 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2229 if (ts
->traceframes_created
!= -1)
2230 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2231 if (ts
->buffer_size
!= -1)
2232 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2233 if (ts
->buffer_free
!= -1)
2234 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2236 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2237 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2239 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2240 ui_out_field_string (uiout
, "notes", ts
->notes
);
2245 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2246 (long int) (ts
->start_time
/ 1000000),
2247 (long int) (ts
->start_time
% 1000000));
2248 ui_out_field_string (uiout
, "start-time", buf
);
2249 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2250 (long int) (ts
->stop_time
/ 1000000),
2251 (long int) (ts
->stop_time
% 1000000));
2252 ui_out_field_string (uiout
, "stop-time", buf
);
2256 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2257 user if she really wants to detach. */
2260 query_if_trace_running (int from_tty
)
2265 /* It can happen that the target that was tracing went away on its
2266 own, and we didn't notice. Get a status update, and if the
2267 current target doesn't even do tracing, then assume it's not
2269 if (target_get_trace_status (current_trace_status ()) < 0)
2270 current_trace_status ()->running
= 0;
2272 /* If running interactively, give the user the option to cancel and
2273 then decide what to do differently with the run. Scripts are
2274 just going to disconnect and let the target deal with it,
2275 according to how it's been instructed previously via
2276 disconnected-tracing. */
2277 if (current_trace_status ()->running
)
2279 process_tracepoint_on_disconnect ();
2281 if (current_trace_status ()->disconnected_tracing
)
2283 if (!query (_("Trace is running and will "
2284 "continue after detach; detach anyway? ")))
2285 error (_("Not confirmed."));
2289 if (!query (_("Trace is running but will "
2290 "stop on detach; detach anyway? ")))
2291 error (_("Not confirmed."));
2296 /* This function handles the details of what to do about an ongoing
2297 tracing run if the user has asked to detach or otherwise disconnect
2301 disconnect_tracing (void)
2303 /* Also we want to be out of tfind mode, otherwise things can get
2304 confusing upon reconnection. Just use these calls instead of
2305 full tfind_1 behavior because we're in the middle of detaching,
2306 and there's no point to updating current stack frame etc. */
2307 trace_reset_local_state ();
2310 /* Worker function for the various flavors of the tfind command. */
2312 tfind_1 (enum trace_find_type type
, int num
,
2313 CORE_ADDR addr1
, CORE_ADDR addr2
,
2316 int target_frameno
= -1, target_tracept
= -1;
2317 struct frame_id old_frame_id
= null_frame_id
;
2318 struct tracepoint
*tp
;
2319 struct ui_out
*uiout
= current_uiout
;
2321 /* Only try to get the current stack frame if we have a chance of
2322 succeeding. In particular, if we're trying to get a first trace
2323 frame while all threads are running, it's not going to succeed,
2324 so leave it with a default value and let the frame comparison
2325 below (correctly) decide to print out the source location of the
2327 if (!(type
== tfind_number
&& num
== -1)
2328 && (has_stack_frames () || traceframe_number
>= 0))
2329 old_frame_id
= get_frame_id (get_current_frame ());
2331 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2334 if (type
== tfind_number
2336 && target_frameno
== -1)
2338 /* We told the target to get out of tfind mode, and it did. */
2340 else if (target_frameno
== -1)
2342 /* A request for a non-existent trace frame has failed.
2343 Our response will be different, depending on FROM_TTY:
2345 If FROM_TTY is true, meaning that this command was
2346 typed interactively by the user, then give an error
2347 and DO NOT change the state of traceframe_number etc.
2349 However if FROM_TTY is false, meaning that we're either
2350 in a script, a loop, or a user-defined command, then
2351 DON'T give an error, but DO change the state of
2352 traceframe_number etc. to invalid.
2354 The rationalle is that if you typed the command, you
2355 might just have committed a typo or something, and you'd
2356 like to NOT lose your current debugging state. However
2357 if you're in a user-defined command or especially in a
2358 loop, then you need a way to detect that the command
2359 failed WITHOUT aborting. This allows you to write
2360 scripts that search thru the trace buffer until the end,
2361 and then continue on to do something else. */
2364 error (_("Target failed to find requested trace frame."));
2368 printf_filtered ("End of trace buffer.\n");
2369 #if 0 /* dubious now? */
2370 /* The following will not recurse, since it's
2372 trace_find_command ("-1", from_tty
);
2377 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2379 reinit_frame_cache ();
2380 target_dcache_invalidate ();
2382 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2384 if (target_frameno
!= get_traceframe_number ())
2385 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2387 set_current_traceframe (target_frameno
);
2389 if (target_frameno
== -1)
2390 set_traceframe_context (NULL
);
2392 set_traceframe_context (get_current_frame ());
2394 if (traceframe_number
>= 0)
2396 /* Use different branches for MI and CLI to make CLI messages
2398 if (ui_out_is_mi_like_p (uiout
))
2400 ui_out_field_string (uiout
, "found", "1");
2401 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2402 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2406 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2407 traceframe_number
, tracepoint_number
);
2412 if (ui_out_is_mi_like_p (uiout
))
2413 ui_out_field_string (uiout
, "found", "0");
2414 else if (type
== tfind_number
&& num
== -1)
2415 printf_unfiltered (_("No longer looking at any trace frame\n"));
2416 else /* This case may never occur, check. */
2417 printf_unfiltered (_("No trace frame found\n"));
2420 /* If we're in nonstop mode and getting out of looking at trace
2421 frames, there won't be any current frame to go back to and
2424 && (has_stack_frames () || traceframe_number
>= 0))
2426 enum print_what print_what
;
2428 /* NOTE: in imitation of the step command, try to determine
2429 whether we have made a transition from one function to
2430 another. If so, we'll print the "stack frame" (ie. the new
2431 function and it's arguments) -- otherwise we'll just show the
2434 if (frame_id_eq (old_frame_id
,
2435 get_frame_id (get_current_frame ())))
2436 print_what
= SRC_LINE
;
2438 print_what
= SRC_AND_LOC
;
2440 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2445 /* Error on looking at traceframes while trace is running. */
2448 check_trace_running (struct trace_status
*status
)
2450 if (status
->running
&& status
->filename
== NULL
)
2451 error (_("May not look at trace frames while trace is running."));
2454 /* trace_find_command takes a trace frame number n,
2455 sends "QTFrame:<n>" to the target,
2456 and accepts a reply that may contain several optional pieces
2457 of information: a frame number, a tracepoint number, and an
2458 indication of whether this is a trap frame or a stepping frame.
2460 The minimal response is just "OK" (which indicates that the
2461 target does not give us a frame number or a tracepoint number).
2462 Instead of that, the target may send us a string containing
2464 F<hexnum> (gives the selected frame number)
2465 T<hexnum> (gives the selected tracepoint number)
2470 trace_find_command (char *args
, int from_tty
)
2471 { /* This should only be called with a numeric argument. */
2474 check_trace_running (current_trace_status ());
2476 if (args
== 0 || *args
== 0)
2477 { /* TFIND with no args means find NEXT trace frame. */
2478 if (traceframe_number
== -1)
2479 frameno
= 0; /* "next" is first one. */
2481 frameno
= traceframe_number
+ 1;
2483 else if (0 == strcmp (args
, "-"))
2485 if (traceframe_number
== -1)
2486 error (_("not debugging trace buffer"));
2487 else if (from_tty
&& traceframe_number
== 0)
2488 error (_("already at start of trace buffer"));
2490 frameno
= traceframe_number
- 1;
2492 /* A hack to work around eval's need for fp to have been collected. */
2493 else if (0 == strcmp (args
, "-1"))
2496 frameno
= parse_and_eval_long (args
);
2499 error (_("invalid input (%d is less than zero)"), frameno
);
2501 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2506 trace_find_end_command (char *args
, int from_tty
)
2508 trace_find_command ("-1", from_tty
);
2513 trace_find_start_command (char *args
, int from_tty
)
2515 trace_find_command ("0", from_tty
);
2518 /* tfind pc command */
2520 trace_find_pc_command (char *args
, int from_tty
)
2524 check_trace_running (current_trace_status ());
2526 if (args
== 0 || *args
== 0)
2527 pc
= regcache_read_pc (get_current_regcache ());
2529 pc
= parse_and_eval_address (args
);
2531 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2534 /* tfind tracepoint command */
2536 trace_find_tracepoint_command (char *args
, int from_tty
)
2539 struct tracepoint
*tp
;
2541 check_trace_running (current_trace_status ());
2543 if (args
== 0 || *args
== 0)
2545 if (tracepoint_number
== -1)
2546 error (_("No current tracepoint -- please supply an argument."));
2548 tdp
= tracepoint_number
; /* Default is current TDP. */
2551 tdp
= parse_and_eval_long (args
);
2553 /* If we have the tracepoint on hand, use the number that the
2554 target knows about (which may be different if we disconnected
2555 and reconnected). */
2556 tp
= get_tracepoint (tdp
);
2558 tdp
= tp
->number_on_target
;
2560 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2563 /* TFIND LINE command:
2565 This command will take a sourceline for argument, just like BREAK
2566 or TRACE (ie. anything that "decode_line_1" can handle).
2568 With no argument, this command will find the next trace frame
2569 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2572 trace_find_line_command (char *args
, int from_tty
)
2574 static CORE_ADDR start_pc
, end_pc
;
2575 struct symtabs_and_lines sals
;
2576 struct symtab_and_line sal
;
2577 struct cleanup
*old_chain
;
2579 check_trace_running (current_trace_status ());
2581 if (args
== 0 || *args
== 0)
2583 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2585 sals
.sals
= (struct symtab_and_line
*)
2586 xmalloc (sizeof (struct symtab_and_line
));
2591 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2595 old_chain
= make_cleanup (xfree
, sals
.sals
);
2596 if (sal
.symtab
== 0)
2597 error (_("No line number information available."));
2599 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2601 if (start_pc
== end_pc
)
2603 printf_filtered ("Line %d of \"%s\"",
2605 symtab_to_filename_for_display (sal
.symtab
));
2607 printf_filtered (" is at address ");
2608 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2610 printf_filtered (" but contains no code.\n");
2611 sal
= find_pc_line (start_pc
, 0);
2613 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2614 && start_pc
!= end_pc
)
2615 printf_filtered ("Attempting to find line %d instead.\n",
2618 error (_("Cannot find a good line."));
2622 /* Is there any case in which we get here, and have an address
2623 which the user would want to see? If we have debugging
2624 symbols and no line numbers? */
2625 error (_("Line number %d is out of range for \"%s\"."),
2626 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2628 /* Find within range of stated line. */
2630 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2632 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2633 do_cleanups (old_chain
);
2636 /* tfind range command */
2638 trace_find_range_command (char *args
, int from_tty
)
2640 static CORE_ADDR start
, stop
;
2643 check_trace_running (current_trace_status ());
2645 if (args
== 0 || *args
== 0)
2646 { /* XXX FIXME: what should default behavior be? */
2647 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2651 if (0 != (tmp
= strchr (args
, ',')))
2653 *tmp
++ = '\0'; /* Terminate start address. */
2654 tmp
= skip_spaces (tmp
);
2655 start
= parse_and_eval_address (args
);
2656 stop
= parse_and_eval_address (tmp
);
2659 { /* No explicit end address? */
2660 start
= parse_and_eval_address (args
);
2661 stop
= start
+ 1; /* ??? */
2664 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2667 /* tfind outside command */
2669 trace_find_outside_command (char *args
, int from_tty
)
2671 CORE_ADDR start
, stop
;
2674 if (current_trace_status ()->running
2675 && current_trace_status ()->filename
== NULL
)
2676 error (_("May not look at trace frames while trace is running."));
2678 if (args
== 0 || *args
== 0)
2679 { /* XXX FIXME: what should default behavior be? */
2680 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2684 if (0 != (tmp
= strchr (args
, ',')))
2686 *tmp
++ = '\0'; /* Terminate start address. */
2687 tmp
= skip_spaces (tmp
);
2688 start
= parse_and_eval_address (args
);
2689 stop
= parse_and_eval_address (tmp
);
2692 { /* No explicit end address? */
2693 start
= parse_and_eval_address (args
);
2694 stop
= start
+ 1; /* ??? */
2697 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2700 /* info scope command: list the locals for a scope. */
2702 scope_info (char *args
, int from_tty
)
2704 struct symtabs_and_lines sals
;
2706 struct bound_minimal_symbol msym
;
2707 const struct block
*block
;
2708 const char *symname
;
2709 char *save_args
= args
;
2710 struct block_iterator iter
;
2712 struct gdbarch
*gdbarch
;
2715 if (args
== 0 || *args
== 0)
2716 error (_("requires an argument (function, "
2717 "line or *addr) to define a scope"));
2719 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2720 if (sals
.nelts
== 0)
2721 return; /* Presumably decode_line_1 has already warned. */
2723 /* Resolve line numbers to PC. */
2724 resolve_sal_pc (&sals
.sals
[0]);
2725 block
= block_for_pc (sals
.sals
[0].pc
);
2729 QUIT
; /* Allow user to bail out with ^C. */
2730 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2732 QUIT
; /* Allow user to bail out with ^C. */
2734 printf_filtered ("Scope for %s:\n", save_args
);
2737 symname
= SYMBOL_PRINT_NAME (sym
);
2738 if (symname
== NULL
|| *symname
== '\0')
2739 continue; /* Probably botched, certainly useless. */
2741 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2743 printf_filtered ("Symbol %s is ", symname
);
2745 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2746 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2747 BLOCK_START (block
),
2751 switch (SYMBOL_CLASS (sym
))
2754 case LOC_UNDEF
: /* Messed up symbol? */
2755 printf_filtered ("a bogus symbol, class %d.\n",
2756 SYMBOL_CLASS (sym
));
2757 count
--; /* Don't count this one. */
2760 printf_filtered ("a constant with value %s (%s)",
2761 plongest (SYMBOL_VALUE (sym
)),
2762 hex_string (SYMBOL_VALUE (sym
)));
2764 case LOC_CONST_BYTES
:
2765 printf_filtered ("constant bytes: ");
2766 if (SYMBOL_TYPE (sym
))
2767 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2768 fprintf_filtered (gdb_stdout
, " %02x",
2769 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2772 printf_filtered ("in static storage at address ");
2773 printf_filtered ("%s", paddress (gdbarch
,
2774 SYMBOL_VALUE_ADDRESS (sym
)));
2777 /* GDBARCH is the architecture associated with the objfile
2778 the symbol is defined in; the target architecture may be
2779 different, and may provide additional registers. However,
2780 we do not know the target architecture at this point.
2781 We assume the objfile architecture will contain all the
2782 standard registers that occur in debug info in that
2784 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2787 if (SYMBOL_IS_ARGUMENT (sym
))
2788 printf_filtered ("an argument in register $%s",
2789 gdbarch_register_name (gdbarch
, regno
));
2791 printf_filtered ("a local variable in register $%s",
2792 gdbarch_register_name (gdbarch
, regno
));
2795 printf_filtered ("an argument at stack/frame offset %s",
2796 plongest (SYMBOL_VALUE (sym
)));
2799 printf_filtered ("a local variable at frame offset %s",
2800 plongest (SYMBOL_VALUE (sym
)));
2803 printf_filtered ("a reference argument at offset %s",
2804 plongest (SYMBOL_VALUE (sym
)));
2806 case LOC_REGPARM_ADDR
:
2807 /* Note comment at LOC_REGISTER. */
2808 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2810 printf_filtered ("the address of an argument, in register $%s",
2811 gdbarch_register_name (gdbarch
, regno
));
2814 printf_filtered ("a typedef.\n");
2817 printf_filtered ("a label at address ");
2818 printf_filtered ("%s", paddress (gdbarch
,
2819 SYMBOL_VALUE_ADDRESS (sym
)));
2822 printf_filtered ("a function at address ");
2823 printf_filtered ("%s",
2824 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2826 case LOC_UNRESOLVED
:
2827 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2829 if (msym
.minsym
== NULL
)
2830 printf_filtered ("Unresolved Static");
2833 printf_filtered ("static storage at address ");
2834 printf_filtered ("%s",
2836 BMSYMBOL_VALUE_ADDRESS (msym
)));
2839 case LOC_OPTIMIZED_OUT
:
2840 printf_filtered ("optimized out.\n");
2843 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2846 if (SYMBOL_TYPE (sym
))
2847 printf_filtered (", length %d.\n",
2848 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2850 if (BLOCK_FUNCTION (block
))
2853 block
= BLOCK_SUPERBLOCK (block
);
2856 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2860 /* Helper for trace_dump_command. Dump the action list starting at
2861 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2862 actions of the body of a while-stepping action. STEPPING_FRAME is
2863 set if the current traceframe was determined to be a while-stepping
2867 trace_dump_actions (struct command_line
*action
,
2868 int stepping_actions
, int stepping_frame
,
2871 const char *action_exp
, *next_comma
;
2873 for (; action
!= NULL
; action
= action
->next
)
2875 struct cmd_list_element
*cmd
;
2877 QUIT
; /* Allow user to bail out with ^C. */
2878 action_exp
= action
->line
;
2879 action_exp
= skip_spaces_const (action_exp
);
2881 /* The collection actions to be done while stepping are
2882 bracketed by the commands "while-stepping" and "end". */
2884 if (*action_exp
== '#') /* comment line */
2887 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2889 error (_("Bad action list item: %s"), action_exp
);
2891 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2895 for (i
= 0; i
< action
->body_count
; ++i
)
2896 trace_dump_actions (action
->body_list
[i
],
2897 1, stepping_frame
, from_tty
);
2899 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2901 /* Display the collected data.
2902 For the trap frame, display only what was collected at
2903 the trap. Likewise for stepping frames, display only
2904 what was collected while stepping. This means that the
2905 two boolean variables, STEPPING_FRAME and
2906 STEPPING_ACTIONS should be equal. */
2907 if (stepping_frame
== stepping_actions
)
2910 struct cleanup
*old_chain
2911 = make_cleanup (free_current_contents
, &cmd
);
2912 int trace_string
= 0;
2914 if (*action_exp
== '/')
2915 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2918 { /* Repeat over a comma-separated list. */
2919 QUIT
; /* Allow user to bail out with ^C. */
2920 if (*action_exp
== ',')
2922 action_exp
= skip_spaces_const (action_exp
);
2924 next_comma
= strchr (action_exp
, ',');
2926 if (0 == strncasecmp (action_exp
, "$reg", 4))
2927 registers_info (NULL
, from_tty
);
2928 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2930 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2931 locals_info (NULL
, from_tty
);
2932 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2933 args_info (NULL
, from_tty
);
2936 if (next_comma
!= NULL
)
2938 size_t len
= next_comma
- action_exp
;
2940 cmd
= xrealloc (cmd
, len
+ 1);
2941 memcpy (cmd
, action_exp
, len
);
2946 size_t len
= strlen (action_exp
);
2948 cmd
= xrealloc (cmd
, len
+ 1);
2949 memcpy (cmd
, action_exp
, len
+ 1);
2952 printf_filtered ("%s = ", cmd
);
2953 output_command_const (cmd
, from_tty
);
2954 printf_filtered ("\n");
2956 action_exp
= next_comma
;
2958 while (action_exp
&& *action_exp
== ',');
2960 do_cleanups (old_chain
);
2966 /* Return bp_location of the tracepoint associated with the current
2967 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2968 is a stepping traceframe. */
2970 struct bp_location
*
2971 get_traceframe_location (int *stepping_frame_p
)
2973 struct tracepoint
*t
;
2974 struct bp_location
*tloc
;
2975 struct regcache
*regcache
;
2977 if (tracepoint_number
== -1)
2978 error (_("No current trace frame."));
2980 t
= get_tracepoint (tracepoint_number
);
2983 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2986 /* The current frame is a trap frame if the frame PC is equal to the
2987 tracepoint PC. If not, then the current frame was collected
2988 during single-stepping. */
2989 regcache
= get_current_regcache ();
2991 /* If the traceframe's address matches any of the tracepoint's
2992 locations, assume it is a direct hit rather than a while-stepping
2993 frame. (FIXME this is not reliable, should record each frame's
2995 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
2996 if (tloc
->address
== regcache_read_pc (regcache
))
2998 *stepping_frame_p
= 0;
3002 /* If this is a stepping frame, we don't know which location
3003 triggered. The first is as good (or bad) a guess as any... */
3004 *stepping_frame_p
= 1;
3008 /* Return all the actions, including default collect, of a tracepoint
3009 T. It constructs cleanups into the chain, and leaves the caller to
3010 handle them (call do_cleanups). */
3012 static struct command_line
*
3013 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3015 struct command_line
*actions
;
3017 actions
= breakpoint_commands (t
);
3019 /* If there are default expressions to collect, make up a collect
3020 action and prepend to the action list to encode. Note that since
3021 validation is per-tracepoint (local var "xyz" might be valid for
3022 one tracepoint and not another, etc), we make up the action on
3023 the fly, and don't cache it. */
3024 if (*default_collect
)
3026 struct command_line
*default_collect_action
;
3027 char *default_collect_line
;
3029 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3030 make_cleanup (xfree
, default_collect_line
);
3032 validate_actionline (default_collect_line
, t
);
3033 default_collect_action
= xmalloc (sizeof (struct command_line
));
3034 make_cleanup (xfree
, default_collect_action
);
3035 default_collect_action
->next
= actions
;
3036 default_collect_action
->line
= default_collect_line
;
3037 actions
= default_collect_action
;
3043 /* The tdump command. */
3046 trace_dump_command (char *args
, int from_tty
)
3048 int stepping_frame
= 0;
3049 struct bp_location
*loc
;
3050 struct cleanup
*old_chain
;
3051 struct command_line
*actions
;
3053 /* This throws an error is not inspecting a trace frame. */
3054 loc
= get_traceframe_location (&stepping_frame
);
3056 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3057 tracepoint_number
, traceframe_number
);
3059 old_chain
= make_cleanup (null_cleanup
, NULL
);
3061 /* This command only makes sense for the current frame, not the
3063 make_cleanup_restore_current_thread ();
3064 select_frame (get_current_frame ());
3066 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3068 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3070 do_cleanups (old_chain
);
3073 /* Encode a piece of a tracepoint's source-level definition in a form
3074 that is suitable for both protocol and saving in files. */
3075 /* This version does not do multiple encodes for long strings; it should
3076 return an offset to the next piece to encode. FIXME */
3079 encode_source_string (int tpnum
, ULONGEST addr
,
3080 char *srctype
, char *src
, char *buf
, int buf_size
)
3082 if (80 + strlen (srctype
) > buf_size
)
3083 error (_("Buffer too small for source encoding"));
3084 sprintf (buf
, "%x:%s:%s:%x:%x:",
3085 tpnum
, phex_nz (addr
, sizeof (addr
)),
3086 srctype
, 0, (int) strlen (src
));
3087 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3088 error (_("Source string too long for buffer"));
3089 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
3093 /* Tell the target what to do with an ongoing tracing run if GDB
3094 disconnects for some reason. */
3097 set_disconnected_tracing (char *args
, int from_tty
,
3098 struct cmd_list_element
*c
)
3100 target_set_disconnected_tracing (disconnected_tracing
);
3104 set_circular_trace_buffer (char *args
, int from_tty
,
3105 struct cmd_list_element
*c
)
3107 target_set_circular_trace_buffer (circular_trace_buffer
);
3111 set_trace_buffer_size (char *args
, int from_tty
,
3112 struct cmd_list_element
*c
)
3114 target_set_trace_buffer_size (trace_buffer_size
);
3118 set_trace_user (char *args
, int from_tty
,
3119 struct cmd_list_element
*c
)
3123 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3126 warning (_("Target does not support trace notes, user ignored"));
3130 set_trace_notes (char *args
, int from_tty
,
3131 struct cmd_list_element
*c
)
3135 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3138 warning (_("Target does not support trace notes, note ignored"));
3142 set_trace_stop_notes (char *args
, int from_tty
,
3143 struct cmd_list_element
*c
)
3147 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3150 warning (_("Target does not support trace notes, stop note ignored"));
3153 /* Convert the memory pointed to by mem into hex, placing result in buf.
3154 * Return a pointer to the last char put in buf (null)
3155 * "stolen" from sparc-stub.c
3158 static const char hexchars
[] = "0123456789abcdef";
3161 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3169 *buf
++ = hexchars
[ch
>> 4];
3170 *buf
++ = hexchars
[ch
& 0xf];
3179 get_traceframe_number (void)
3181 return traceframe_number
;
3185 get_tracepoint_number (void)
3187 return tracepoint_number
;
3190 /* Make the traceframe NUM be the current trace frame. Does nothing
3191 if NUM is already current. */
3194 set_current_traceframe (int num
)
3198 if (traceframe_number
== num
)
3200 /* Nothing to do. */
3204 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3207 warning (_("could not change traceframe"));
3209 set_traceframe_num (newnum
);
3211 /* Changing the traceframe changes our view of registers and of the
3213 registers_changed ();
3215 clear_traceframe_info ();
3218 /* A cleanup used when switching away and back from tfind mode. */
3220 struct current_traceframe_cleanup
3222 /* The traceframe we were inspecting. */
3223 int traceframe_number
;
3227 do_restore_current_traceframe_cleanup (void *arg
)
3229 struct current_traceframe_cleanup
*old
= arg
;
3231 set_current_traceframe (old
->traceframe_number
);
3235 restore_current_traceframe_cleanup_dtor (void *arg
)
3237 struct current_traceframe_cleanup
*old
= arg
;
3243 make_cleanup_restore_current_traceframe (void)
3245 struct current_traceframe_cleanup
*old
;
3247 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3248 old
->traceframe_number
= traceframe_number
;
3250 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3251 restore_current_traceframe_cleanup_dtor
);
3254 /* Given a number and address, return an uploaded tracepoint with that
3255 number, creating if necessary. */
3257 struct uploaded_tp
*
3258 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3260 struct uploaded_tp
*utp
;
3262 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3263 if (utp
->number
== num
&& utp
->addr
== addr
)
3265 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3266 memset (utp
, 0, sizeof (struct uploaded_tp
));
3269 utp
->actions
= NULL
;
3270 utp
->step_actions
= NULL
;
3271 utp
->cmd_strings
= NULL
;
3278 free_uploaded_tps (struct uploaded_tp
**utpp
)
3280 struct uploaded_tp
*next_one
;
3284 next_one
= (*utpp
)->next
;
3290 /* Given a number and address, return an uploaded tracepoint with that
3291 number, creating if necessary. */
3293 struct uploaded_tsv
*
3294 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3296 struct uploaded_tsv
*utsv
;
3298 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3299 if (utsv
->number
== num
)
3301 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3302 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3304 utsv
->next
= *utsvp
;
3310 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3312 struct uploaded_tsv
*next_one
;
3316 next_one
= (*utsvp
)->next
;
3322 /* FIXME this function is heuristic and will miss the cases where the
3323 conditional is semantically identical but differs in whitespace,
3324 such as "x == 0" vs "x==0". */
3327 cond_string_is_same (char *str1
, char *str2
)
3329 if (str1
== NULL
|| str2
== NULL
)
3330 return (str1
== str2
);
3332 return (strcmp (str1
, str2
) == 0);
3335 /* Look for an existing tracepoint that seems similar enough to the
3336 uploaded one. Enablement isn't compared, because the user can
3337 toggle that freely, and may have done so in anticipation of the
3338 next trace run. Return the location of matched tracepoint. */
3340 static struct bp_location
*
3341 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3343 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3345 struct breakpoint
*b
;
3346 struct bp_location
*loc
;
3348 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3350 struct tracepoint
*t
= (struct tracepoint
*) b
;
3352 if (b
->type
== utp
->type
3353 && t
->step_count
== utp
->step
3354 && t
->pass_count
== utp
->pass
3355 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3356 /* FIXME also test actions. */
3359 /* Scan the locations for an address match. */
3360 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3362 if (loc
->address
== utp
->addr
)
3370 /* Given a list of tracepoints uploaded from a target, attempt to
3371 match them up with existing tracepoints, and create new ones if not
3375 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3377 struct uploaded_tp
*utp
;
3378 /* A set of tracepoints which are modified. */
3379 VEC(breakpoint_p
) *modified_tp
= NULL
;
3381 struct breakpoint
*b
;
3383 /* Look for GDB tracepoints that match up with our uploaded versions. */
3384 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3386 struct bp_location
*loc
;
3387 struct tracepoint
*t
;
3389 loc
= find_matching_tracepoint_location (utp
);
3394 /* Mark this location as already inserted. */
3396 t
= (struct tracepoint
*) loc
->owner
;
3397 printf_filtered (_("Assuming tracepoint %d is same "
3398 "as target's tracepoint %d at %s.\n"),
3399 loc
->owner
->number
, utp
->number
,
3400 paddress (loc
->gdbarch
, utp
->addr
));
3402 /* The tracepoint LOC->owner was modified (the location LOC
3403 was marked as inserted in the target). Save it in
3404 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3405 observers will be notified later once for each tracepoint
3406 saved in MODIFIED_TP. */
3408 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3410 if (b
== loc
->owner
)
3416 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3420 t
= create_tracepoint_from_upload (utp
);
3422 printf_filtered (_("Created tracepoint %d for "
3423 "target's tracepoint %d at %s.\n"),
3424 t
->base
.number
, utp
->number
,
3425 paddress (get_current_arch (), utp
->addr
));
3427 printf_filtered (_("Failed to create tracepoint for target's "
3428 "tracepoint %d at %s, skipping it.\n"),
3430 paddress (get_current_arch (), utp
->addr
));
3432 /* Whether found or created, record the number used by the
3433 target, to help with mapping target tracepoints back to their
3434 counterparts here. */
3436 t
->number_on_target
= utp
->number
;
3439 /* Notify 'breakpoint-modified' observer that at least one of B's
3440 locations was changed. */
3441 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3442 observer_notify_breakpoint_modified (b
);
3444 VEC_free (breakpoint_p
, modified_tp
);
3445 free_uploaded_tps (uploaded_tps
);
3448 /* Trace state variables don't have much to identify them beyond their
3449 name, so just use that to detect matches. */
3451 static struct trace_state_variable
*
3452 find_matching_tsv (struct uploaded_tsv
*utsv
)
3457 return find_trace_state_variable (utsv
->name
);
3460 static struct trace_state_variable
*
3461 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3463 const char *namebase
;
3466 struct trace_state_variable
*tsv
;
3467 struct cleanup
*old_chain
;
3471 namebase
= utsv
->name
;
3472 buf
= xstrprintf ("%s", namebase
);
3477 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3480 /* Fish for a name that is not in use. */
3481 /* (should check against all internal vars?) */
3482 while (find_trace_state_variable (buf
))
3485 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3488 old_chain
= make_cleanup (xfree
, buf
);
3490 /* We have an available name, create the variable. */
3491 tsv
= create_trace_state_variable (buf
);
3492 tsv
->initial_value
= utsv
->initial_value
;
3493 tsv
->builtin
= utsv
->builtin
;
3495 observer_notify_tsv_created (tsv
);
3497 do_cleanups (old_chain
);
3502 /* Given a list of uploaded trace state variables, try to match them
3503 up with existing variables, or create additional ones. */
3506 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3509 struct uploaded_tsv
*utsv
;
3510 struct trace_state_variable
*tsv
;
3513 /* Most likely some numbers will have to be reassigned as part of
3514 the merge, so clear them all in anticipation. */
3515 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3518 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3520 tsv
= find_matching_tsv (utsv
);
3524 printf_filtered (_("Assuming trace state variable $%s "
3525 "is same as target's variable %d.\n"),
3526 tsv
->name
, utsv
->number
);
3530 tsv
= create_tsv_from_upload (utsv
);
3532 printf_filtered (_("Created trace state variable "
3533 "$%s for target's variable %d.\n"),
3534 tsv
->name
, utsv
->number
);
3536 /* Give precedence to numberings that come from the target. */
3538 tsv
->number
= utsv
->number
;
3541 /* Renumber everything that didn't get a target-assigned number. */
3543 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3544 if (tsv
->number
> highest
)
3545 highest
= tsv
->number
;
3548 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3549 if (tsv
->number
== 0)
3550 tsv
->number
= highest
++;
3552 free_uploaded_tsvs (uploaded_tsvs
);
3555 /* Parse the part of trace status syntax that is shared between
3556 the remote protocol and the trace file reader. */
3559 parse_trace_status (char *line
, struct trace_status
*ts
)
3561 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3565 ts
->running_known
= 1;
3566 ts
->running
= (*p
++ == '1');
3567 ts
->stop_reason
= trace_stop_reason_unknown
;
3568 xfree (ts
->stop_desc
);
3569 ts
->stop_desc
= NULL
;
3570 ts
->traceframe_count
= -1;
3571 ts
->traceframes_created
= -1;
3572 ts
->buffer_free
= -1;
3573 ts
->buffer_size
= -1;
3574 ts
->disconnected_tracing
= 0;
3575 ts
->circular_buffer
= 0;
3576 xfree (ts
->user_name
);
3577 ts
->user_name
= NULL
;
3580 ts
->start_time
= ts
->stop_time
= 0;
3584 p1
= strchr (p
, ':');
3586 error (_("Malformed trace status, at %s\n\
3587 Status line: '%s'\n"), p
, line
);
3588 p3
= strchr (p
, ';');
3590 p3
= p
+ strlen (p
);
3591 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3593 p
= unpack_varlen_hex (++p1
, &val
);
3594 ts
->stop_reason
= trace_buffer_full
;
3596 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3598 p
= unpack_varlen_hex (++p1
, &val
);
3599 ts
->stop_reason
= trace_never_run
;
3601 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3604 p
= unpack_varlen_hex (++p1
, &val
);
3605 ts
->stop_reason
= tracepoint_passcount
;
3606 ts
->stopping_tracepoint
= val
;
3608 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3610 p2
= strchr (++p1
, ':');
3618 ts
->stop_desc
= xmalloc (strlen (line
));
3619 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3620 ts
->stop_desc
[end
] = '\0';
3623 ts
->stop_desc
= xstrdup ("");
3625 p
= unpack_varlen_hex (++p2
, &val
);
3626 ts
->stop_reason
= tstop_command
;
3628 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3630 p
= unpack_varlen_hex (++p1
, &val
);
3631 ts
->stop_reason
= trace_disconnected
;
3633 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3635 p2
= strchr (++p1
, ':');
3638 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3639 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
3640 ts
->stop_desc
[end
] = '\0';
3643 ts
->stop_desc
= xstrdup ("");
3645 p
= unpack_varlen_hex (++p2
, &val
);
3646 ts
->stopping_tracepoint
= val
;
3647 ts
->stop_reason
= tracepoint_error
;
3649 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3651 p
= unpack_varlen_hex (++p1
, &val
);
3652 ts
->traceframe_count
= val
;
3654 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3656 p
= unpack_varlen_hex (++p1
, &val
);
3657 ts
->traceframes_created
= val
;
3659 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3661 p
= unpack_varlen_hex (++p1
, &val
);
3662 ts
->buffer_free
= val
;
3664 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3666 p
= unpack_varlen_hex (++p1
, &val
);
3667 ts
->buffer_size
= val
;
3669 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3671 p
= unpack_varlen_hex (++p1
, &val
);
3672 ts
->disconnected_tracing
= val
;
3674 else if (strncmp (p
, "circular", p1
- p
) == 0)
3676 p
= unpack_varlen_hex (++p1
, &val
);
3677 ts
->circular_buffer
= val
;
3679 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3681 p
= unpack_varlen_hex (++p1
, &val
);
3682 ts
->start_time
= val
;
3684 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3686 p
= unpack_varlen_hex (++p1
, &val
);
3687 ts
->stop_time
= val
;
3689 else if (strncmp (p
, "username", p1
- p
) == 0)
3692 ts
->user_name
= xmalloc (strlen (p
) / 2);
3693 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
3694 ts
->user_name
[end
] = '\0';
3697 else if (strncmp (p
, "notes", p1
- p
) == 0)
3700 ts
->notes
= xmalloc (strlen (p
) / 2);
3701 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
3702 ts
->notes
[end
] = '\0';
3707 /* Silently skip unknown optional info. */
3708 p_temp
= strchr (p1
+ 1, ';');
3712 /* Must be at the end. */
3719 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3720 struct uploaded_tp
*utp
)
3723 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3725 p
= unpack_varlen_hex (p
, &uval
);
3727 tp
->base
.hit_count
+= uval
;
3729 utp
->hit_count
+= uval
;
3730 p
= unpack_varlen_hex (p
+ 1, &uval
);
3732 tp
->traceframe_usage
+= uval
;
3734 utp
->traceframe_usage
+= uval
;
3735 /* Ignore any extra, allowing for future extensions. */
3738 /* Given a line of text defining a part of a tracepoint, parse it into
3739 an "uploaded tracepoint". */
3742 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3746 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3749 char *cond
, *srctype
, *buf
;
3750 struct uploaded_tp
*utp
= NULL
;
3753 /* Both tracepoint and action definitions start with the same number
3754 and address sequence. */
3756 p
= unpack_varlen_hex (p
, &num
);
3757 p
++; /* skip a colon */
3758 p
= unpack_varlen_hex (p
, &addr
);
3759 p
++; /* skip a colon */
3762 enabled
= (*p
++ == 'E');
3763 p
++; /* skip a colon */
3764 p
= unpack_varlen_hex (p
, &step
);
3765 p
++; /* skip a colon */
3766 p
= unpack_varlen_hex (p
, &pass
);
3767 type
= bp_tracepoint
;
3769 /* Thumb through optional fields. */
3772 p
++; /* skip a colon */
3775 type
= bp_fast_tracepoint
;
3777 p
= unpack_varlen_hex (p
, &orig_size
);
3781 type
= bp_static_tracepoint
;
3787 p
= unpack_varlen_hex (p
, &xlen
);
3788 p
++; /* skip a comma */
3789 cond
= (char *) xmalloc (2 * xlen
+ 1);
3790 strncpy (cond
, p
, 2 * xlen
);
3791 cond
[2 * xlen
] = '\0';
3795 warning (_("Unrecognized char '%c' in tracepoint "
3796 "definition, skipping rest"), *p
);
3798 utp
= get_uploaded_tp (num
, addr
, utpp
);
3800 utp
->enabled
= enabled
;
3805 else if (piece
== 'A')
3807 utp
= get_uploaded_tp (num
, addr
, utpp
);
3808 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3810 else if (piece
== 'S')
3812 utp
= get_uploaded_tp (num
, addr
, utpp
);
3813 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3815 else if (piece
== 'Z')
3817 /* Parse a chunk of source form definition. */
3818 utp
= get_uploaded_tp (num
, addr
, utpp
);
3820 p
= strchr (p
, ':');
3821 p
++; /* skip a colon */
3822 p
= unpack_varlen_hex (p
, &start
);
3823 p
++; /* skip a colon */
3824 p
= unpack_varlen_hex (p
, &xlen
);
3825 p
++; /* skip a colon */
3827 buf
= alloca (strlen (line
));
3829 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3832 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3833 utp
->at_string
= xstrdup (buf
);
3834 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3835 utp
->cond_string
= xstrdup (buf
);
3836 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3837 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3839 else if (piece
== 'V')
3841 utp
= get_uploaded_tp (num
, addr
, utpp
);
3843 parse_tracepoint_status (p
, NULL
, utp
);
3847 /* Don't error out, the target might be sending us optional
3848 info that we don't care about. */
3849 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3853 /* Convert a textual description of a trace state variable into an
3857 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3860 ULONGEST num
, initval
, builtin
;
3862 struct uploaded_tsv
*utsv
= NULL
;
3864 buf
= alloca (strlen (line
));
3867 p
= unpack_varlen_hex (p
, &num
);
3868 p
++; /* skip a colon */
3869 p
= unpack_varlen_hex (p
, &initval
);
3870 p
++; /* skip a colon */
3871 p
= unpack_varlen_hex (p
, &builtin
);
3872 p
++; /* skip a colon */
3873 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3876 utsv
= get_uploaded_tsv (num
, utsvp
);
3877 utsv
->initial_value
= initval
;
3878 utsv
->builtin
= builtin
;
3879 utsv
->name
= xstrdup (buf
);
3883 free_current_marker (void *arg
)
3885 struct static_tracepoint_marker
**marker_p
= arg
;
3887 if (*marker_p
!= NULL
)
3889 release_static_tracepoint_marker (*marker_p
);
3896 /* Given a line of text defining a static tracepoint marker, parse it
3897 into a "static tracepoint marker" object. Throws an error is
3898 parsing fails. If PP is non-null, it points to one past the end of
3899 the parsed marker definition. */
3902 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
3903 struct static_tracepoint_marker
*marker
)
3910 p
= unpack_varlen_hex (p
, &addr
);
3911 p
++; /* skip a colon */
3913 marker
->gdbarch
= target_gdbarch ();
3914 marker
->address
= (CORE_ADDR
) addr
;
3916 endp
= strchr (p
, ':');
3918 error (_("bad marker definition: %s"), line
);
3920 marker
->str_id
= xmalloc (endp
- p
+ 1);
3921 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
3922 marker
->str_id
[end
] = '\0';
3925 p
++; /* skip a colon */
3927 marker
->extra
= xmalloc (strlen (p
) + 1);
3928 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
3929 marker
->extra
[end
] = '\0';
3935 /* Release a static tracepoint marker's contents. Note that the
3936 object itself isn't released here. There objects are usually on
3940 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
3942 xfree (marker
->str_id
);
3943 marker
->str_id
= NULL
;
3946 /* Print MARKER to gdb_stdout. */
3949 print_one_static_tracepoint_marker (int count
,
3950 struct static_tracepoint_marker
*marker
)
3952 struct command_line
*l
;
3955 char wrap_indent
[80];
3956 char extra_field_indent
[80];
3957 struct ui_out
*uiout
= current_uiout
;
3958 struct cleanup
*bkpt_chain
;
3959 VEC(breakpoint_p
) *tracepoints
;
3961 struct symtab_and_line sal
;
3965 sal
.pc
= marker
->address
;
3967 tracepoints
= static_tracepoints_here (marker
->address
);
3969 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
3971 /* A counter field to help readability. This is not a stable
3973 ui_out_field_int (uiout
, "count", count
);
3975 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
3977 ui_out_field_fmt (uiout
, "enabled", "%c",
3978 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
3979 ui_out_spaces (uiout
, 2);
3981 strcpy (wrap_indent
, " ");
3983 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
3984 strcat (wrap_indent
, " ");
3986 strcat (wrap_indent
, " ");
3988 strcpy (extra_field_indent
, " ");
3990 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
3992 sal
= find_pc_line (marker
->address
, 0);
3993 sym
= find_pc_sect_function (marker
->address
, NULL
);
3996 ui_out_text (uiout
, "in ");
3997 ui_out_field_string (uiout
, "func",
3998 SYMBOL_PRINT_NAME (sym
));
3999 ui_out_wrap_hint (uiout
, wrap_indent
);
4000 ui_out_text (uiout
, " at ");
4003 ui_out_field_skip (uiout
, "func");
4005 if (sal
.symtab
!= NULL
)
4007 ui_out_field_string (uiout
, "file",
4008 symtab_to_filename_for_display (sal
.symtab
));
4009 ui_out_text (uiout
, ":");
4011 if (ui_out_is_mi_like_p (uiout
))
4013 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4015 ui_out_field_string (uiout
, "fullname", fullname
);
4018 ui_out_field_skip (uiout
, "fullname");
4020 ui_out_field_int (uiout
, "line", sal
.line
);
4024 ui_out_field_skip (uiout
, "fullname");
4025 ui_out_field_skip (uiout
, "line");
4028 ui_out_text (uiout
, "\n");
4029 ui_out_text (uiout
, extra_field_indent
);
4030 ui_out_text (uiout
, _("Data: \""));
4031 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4032 ui_out_text (uiout
, "\"\n");
4034 if (!VEC_empty (breakpoint_p
, tracepoints
))
4036 struct cleanup
*cleanup_chain
;
4038 struct breakpoint
*b
;
4040 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4043 ui_out_text (uiout
, extra_field_indent
);
4044 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4045 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4048 ui_out_text (uiout
, ", ");
4049 ui_out_text (uiout
, "#");
4050 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4053 do_cleanups (cleanup_chain
);
4055 if (ui_out_is_mi_like_p (uiout
))
4056 ui_out_field_int (uiout
, "number-of-tracepoints",
4057 VEC_length(breakpoint_p
, tracepoints
));
4059 ui_out_text (uiout
, "\n");
4061 VEC_free (breakpoint_p
, tracepoints
);
4063 do_cleanups (bkpt_chain
);
4067 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4069 VEC(static_tracepoint_marker_p
) *markers
;
4070 struct cleanup
*old_chain
;
4071 struct static_tracepoint_marker
*marker
;
4072 struct ui_out
*uiout
= current_uiout
;
4075 /* We don't have to check target_can_use_agent and agent's capability on
4076 static tracepoint here, in order to be compatible with older GDBserver.
4077 We don't check USE_AGENT is true or not, because static tracepoints
4078 don't work without in-process agent, so we don't bother users to type
4079 `set agent on' when to use static tracepoint. */
4082 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4083 "StaticTracepointMarkersTable");
4085 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4087 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4089 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4090 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4091 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4093 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4094 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4096 ui_out_table_body (uiout
);
4098 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4099 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4102 VEC_iterate (static_tracepoint_marker_p
,
4103 markers
, i
, marker
);
4106 print_one_static_tracepoint_marker (i
+ 1, marker
);
4107 release_static_tracepoint_marker (marker
);
4110 do_cleanups (old_chain
);
4113 /* The $_sdata convenience variable is a bit special. We don't know
4114 for sure type of the value until we actually have a chance to fetch
4115 the data --- the size of the object depends on what has been
4116 collected. We solve this by making $_sdata be an internalvar that
4117 creates a new value on access. */
4119 /* Return a new value with the correct type for the sdata object of
4120 the current trace frame. Return a void value if there's no object
4123 static struct value
*
4124 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4130 /* We need to read the whole object before we know its size. */
4131 size
= target_read_alloc (¤t_target
,
4132 TARGET_OBJECT_STATIC_TRACE_DATA
,
4139 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4141 v
= allocate_value (type
);
4142 memcpy (value_contents_raw (v
), buf
, size
);
4147 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4150 #if !defined(HAVE_LIBEXPAT)
4152 struct traceframe_info
*
4153 parse_traceframe_info (const char *tframe_info
)
4155 static int have_warned
;
4160 warning (_("Can not parse XML trace frame info; XML support "
4161 "was disabled at compile time"));
4167 #else /* HAVE_LIBEXPAT */
4169 #include "xml-support.h"
4171 /* Handle the start of a <memory> element. */
4174 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4175 const struct gdb_xml_element
*element
,
4176 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4178 struct traceframe_info
*info
= user_data
;
4179 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4180 ULONGEST
*start_p
, *length_p
;
4182 start_p
= xml_find_attribute (attributes
, "start")->value
;
4183 length_p
= xml_find_attribute (attributes
, "length")->value
;
4185 r
->start
= *start_p
;
4186 r
->length
= *length_p
;
4189 /* Handle the start of a <tvar> element. */
4192 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
4193 const struct gdb_xml_element
*element
,
4195 VEC(gdb_xml_value_s
) *attributes
)
4197 struct traceframe_info
*info
= user_data
;
4198 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
4199 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
4201 VEC_safe_push (int, info
->tvars
, id
);
4204 /* Discard the constructed trace frame info (if an error occurs). */
4207 free_result (void *p
)
4209 struct traceframe_info
*result
= p
;
4211 free_traceframe_info (result
);
4214 /* The allowed elements and attributes for an XML memory map. */
4216 static const struct gdb_xml_attribute memory_attributes
[] = {
4217 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4218 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4219 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4222 static const struct gdb_xml_attribute tvar_attributes
[] = {
4223 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
4224 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4227 static const struct gdb_xml_element traceframe_info_children
[] = {
4228 { "memory", memory_attributes
, NULL
,
4229 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4230 traceframe_info_start_memory
, NULL
},
4231 { "tvar", tvar_attributes
, NULL
,
4232 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4233 traceframe_info_start_tvar
, NULL
},
4234 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4237 static const struct gdb_xml_element traceframe_info_elements
[] = {
4238 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4240 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4243 /* Parse a traceframe-info XML document. */
4245 struct traceframe_info
*
4246 parse_traceframe_info (const char *tframe_info
)
4248 struct traceframe_info
*result
;
4249 struct cleanup
*back_to
;
4251 result
= XCNEW (struct traceframe_info
);
4252 back_to
= make_cleanup (free_result
, result
);
4254 if (gdb_xml_parse_quick (_("trace frame info"),
4255 "traceframe-info.dtd", traceframe_info_elements
,
4256 tframe_info
, result
) == 0)
4258 /* Parsed successfully, keep the result. */
4259 discard_cleanups (back_to
);
4264 do_cleanups (back_to
);
4268 #endif /* HAVE_LIBEXPAT */
4270 /* Returns the traceframe_info object for the current traceframe.
4271 This is where we avoid re-fetching the object from the target if we
4272 already have it cached. */
4274 struct traceframe_info
*
4275 get_traceframe_info (void)
4277 if (traceframe_info
== NULL
)
4278 traceframe_info
= target_traceframe_info ();
4280 return traceframe_info
;
4283 /* If the target supports the query, return in RESULT the set of
4284 collected memory in the current traceframe, found within the LEN
4285 bytes range starting at MEMADDR. Returns true if the target
4286 supports the query, otherwise returns false, and RESULT is left
4290 traceframe_available_memory (VEC(mem_range_s
) **result
,
4291 CORE_ADDR memaddr
, ULONGEST len
)
4293 struct traceframe_info
*info
= get_traceframe_info ();
4297 struct mem_range
*r
;
4302 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4303 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4305 ULONGEST lo1
, hi1
, lo2
, hi2
;
4306 struct mem_range
*nr
;
4309 hi1
= memaddr
+ len
;
4312 hi2
= r
->start
+ r
->length
;
4314 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4316 nr
->start
= max (lo1
, lo2
);
4317 nr
->length
= min (hi1
, hi2
) - nr
->start
;
4320 normalize_mem_ranges (*result
);
4327 /* Implementation of `sdata' variable. */
4329 static const struct internalvar_funcs sdata_funcs
=
4336 /* module initialization */
4338 _initialize_tracepoint (void)
4340 struct cmd_list_element
*c
;
4342 /* Explicitly create without lookup, since that tries to create a
4343 value with a void typed value, and when we get here, gdbarch
4344 isn't initialized yet. At this point, we're quite sure there
4345 isn't another convenience variable of the same name. */
4346 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
4348 traceframe_number
= -1;
4349 tracepoint_number
= -1;
4351 add_info ("scope", scope_info
,
4352 _("List the variables local to a scope"));
4354 add_cmd ("tracepoints", class_trace
, NULL
,
4355 _("Tracing of program execution without stopping the program."),
4358 add_com ("tdump", class_trace
, trace_dump_command
,
4359 _("Print everything collected at the current tracepoint."));
4361 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4362 Define a trace state variable.\n\
4363 Argument is a $-prefixed name, optionally followed\n\
4364 by '=' and an expression that sets the initial value\n\
4365 at the start of tracing."));
4366 set_cmd_completer (c
, expression_completer
);
4368 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4369 Delete one or more trace state variables.\n\
4370 Arguments are the names of the variables to delete.\n\
4371 If no arguments are supplied, delete all variables."), &deletelist
);
4372 /* FIXME add a trace variable completer. */
4374 add_info ("tvariables", tvariables_info
, _("\
4375 Status of trace state variables and their values.\n\
4378 add_info ("static-tracepoint-markers",
4379 info_static_tracepoint_markers_command
, _("\
4380 List target static tracepoints markers.\n\
4383 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4384 Select a trace frame;\n\
4385 No argument means forward by one frame; '-' means backward by one frame."),
4386 &tfindlist
, "tfind ", 1, &cmdlist
);
4388 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4389 Select a trace frame whose PC is outside the given range (exclusive).\n\
4390 Usage: tfind outside addr1, addr2"),
4393 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4394 Select a trace frame whose PC is in the given range (inclusive).\n\
4395 Usage: tfind range addr1,addr2"),
4398 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4399 Select a trace frame by source line.\n\
4400 Argument can be a line number (with optional source file),\n\
4401 a function name, or '*' followed by an address.\n\
4402 Default argument is 'the next source line that was traced'."),
4405 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4406 Select a trace frame by tracepoint number.\n\
4407 Default is the tracepoint for the current trace frame."),
4410 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4411 Select a trace frame by PC.\n\
4412 Default is the current PC, or the PC of the current trace frame."),
4415 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4416 De-select any trace frame and resume 'live' debugging."),
4419 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
4421 add_cmd ("start", class_trace
, trace_find_start_command
,
4422 _("Select the first trace frame in the trace buffer."),
4425 add_com ("tstatus", class_trace
, trace_status_command
,
4426 _("Display the status of the current trace data collection."));
4428 add_com ("tstop", class_trace
, trace_stop_command
, _("\
4429 Stop trace data collection.\n\
4430 Usage: tstop [ <notes> ... ]\n\
4431 Any arguments supplied are recorded with the trace as a stop reason and\n\
4432 reported by tstatus (if the target supports trace notes)."));
4434 add_com ("tstart", class_trace
, trace_start_command
, _("\
4435 Start trace data collection.\n\
4436 Usage: tstart [ <notes> ... ]\n\
4437 Any arguments supplied are recorded with the trace as a note and\n\
4438 reported by tstatus (if the target supports trace notes)."));
4440 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4441 Ends a list of commands or actions.\n\
4442 Several GDB commands allow you to enter a list of commands or actions.\n\
4443 Entering \"end\" on a line by itself is the normal way to terminate\n\
4445 Note: the \"end\" command cannot be used at the gdb prompt."));
4447 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4448 Specify single-stepping behavior at a tracepoint.\n\
4449 Argument is number of instructions to trace in single-step mode\n\
4450 following the tracepoint. This command is normally followed by\n\
4451 one or more \"collect\" commands, to specify what to collect\n\
4452 while single-stepping.\n\n\
4453 Note: this command can only be used in a tracepoint \"actions\" list."));
4455 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4456 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4458 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4459 Specify one or more data items to be collected at a tracepoint.\n\
4460 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4461 collect all data (variables, registers) referenced by that expression.\n\
4462 Also accepts the following special arguments:\n\
4463 $regs -- all registers.\n\
4464 $args -- all function arguments.\n\
4465 $locals -- all variables local to the block/function scope.\n\
4466 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4467 Note: this command can only be used in a tracepoint \"actions\" list."));
4469 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4470 Specify one or more expressions to be evaluated at a tracepoint.\n\
4471 Accepts a comma-separated list of (one or more) expressions.\n\
4472 The result of each evaluation will be discarded.\n\
4473 Note: this command can only be used in a tracepoint \"actions\" list."));
4475 add_com ("actions", class_trace
, trace_actions_command
, _("\
4476 Specify the actions to be taken at a tracepoint.\n\
4477 Tracepoint actions may include collecting of specified data,\n\
4478 single-stepping, or enabling/disabling other tracepoints,\n\
4479 depending on target's capabilities."));
4481 default_collect
= xstrdup ("");
4482 add_setshow_string_cmd ("default-collect", class_trace
,
4483 &default_collect
, _("\
4484 Set the list of expressions to collect by default"), _("\
4485 Show the list of expressions to collect by default"), NULL
,
4487 &setlist
, &showlist
);
4489 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4490 &disconnected_tracing
, _("\
4491 Set whether tracing continues after GDB disconnects."), _("\
4492 Show whether tracing continues after GDB disconnects."), _("\
4493 Use this to continue a tracing run even if GDB disconnects\n\
4494 or detaches from the target. You can reconnect later and look at\n\
4495 trace data collected in the meantime."),
4496 set_disconnected_tracing
,
4501 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4502 &circular_trace_buffer
, _("\
4503 Set target's use of circular trace buffer."), _("\
4504 Show target's use of circular trace buffer."), _("\
4505 Use this to make the trace buffer into a circular buffer,\n\
4506 which will discard traceframes (oldest first) instead of filling\n\
4507 up and stopping the trace run."),
4508 set_circular_trace_buffer
,
4513 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
4514 &trace_buffer_size
, _("\
4515 Set requested size of trace buffer."), _("\
4516 Show requested size of trace buffer."), _("\
4517 Use this to choose a size for the trace buffer. Some targets\n\
4518 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4519 disables any attempt to set the buffer size and lets the target choose."),
4520 set_trace_buffer_size
, NULL
,
4521 &setlist
, &showlist
);
4523 add_setshow_string_cmd ("trace-user", class_trace
,
4525 Set the user name to use for current and future trace runs"), _("\
4526 Show the user name to use for current and future trace runs"), NULL
,
4527 set_trace_user
, NULL
,
4528 &setlist
, &showlist
);
4530 add_setshow_string_cmd ("trace-notes", class_trace
,
4532 Set notes string to use for current and future trace runs"), _("\
4533 Show the notes string to use for current and future trace runs"), NULL
,
4534 set_trace_notes
, NULL
,
4535 &setlist
, &showlist
);
4537 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
4538 &trace_stop_notes
, _("\
4539 Set notes string to use for future tstop commands"), _("\
4540 Show the notes string to use for future tstop commands"), NULL
,
4541 set_trace_stop_notes
, NULL
,
4542 &setlist
, &showlist
);