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"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "filestuff.h"
59 /* readline include files */
60 #include "readline/readline.h"
61 #include "readline/history.h"
63 /* readline defines this. */
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
82 /* A hook used to notify the UI of tracepoint operations. */
84 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
85 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
90 This module defines the following debugger commands:
91 trace : set a tracepoint on a function, line, or address.
92 info trace : list all debugger-defined tracepoints.
93 delete trace : delete one or more tracepoints.
94 enable trace : enable one or more tracepoints.
95 disable trace : disable one or more tracepoints.
96 actions : specify actions to be taken at a tracepoint.
97 passcount : specify a pass count for a tracepoint.
98 tstart : start a trace experiment.
99 tstop : stop a trace experiment.
100 tstatus : query the status of a trace experiment.
101 tfind : find a trace frame in the trace buffer.
102 tdump : print everything collected at the current tracepoint.
103 save-tracepoints : write tracepoint setup into a file.
105 This module defines the following user-visible debugger variables:
106 $trace_frame : sequence number of trace frame currently being debugged.
107 $trace_line : source line of trace frame currently being debugged.
108 $trace_file : source file of trace frame currently being debugged.
109 $tracepoint : tracepoint number of trace frame currently being debugged.
113 /* ======= Important global variables: ======= */
115 /* The list of all trace state variables. We don't retain pointers to
116 any of these for any reason - API is by name or number only - so it
117 works to have a vector of objects. */
119 typedef struct trace_state_variable tsv_s
;
122 static VEC(tsv_s
) *tvariables
;
124 /* The next integer to assign to a variable. */
126 static int next_tsv_number
= 1;
128 /* Number of last traceframe collected. */
129 static int traceframe_number
;
131 /* Tracepoint for last traceframe collected. */
132 static int tracepoint_number
;
134 /* The traceframe info of the current traceframe. NULL if we haven't
135 yet attempted to fetch it, or if the target does not support
136 fetching this object, or if we're not inspecting a traceframe
138 static struct traceframe_info
*traceframe_info
;
140 /* Tracing command lists. */
141 static struct cmd_list_element
*tfindlist
;
143 /* List of expressions to collect by default at each tracepoint hit. */
144 char *default_collect
= "";
146 static int disconnected_tracing
;
148 /* This variable controls whether we ask the target for a linear or
149 circular trace buffer. */
151 static int circular_trace_buffer
;
153 /* This variable is the requested trace buffer size, or -1 to indicate
154 that we don't care and leave it up to the target to set a size. */
156 static int trace_buffer_size
= -1;
158 /* Textual notes applying to the current and/or future trace runs. */
160 char *trace_user
= NULL
;
162 /* Textual notes applying to the current and/or future trace runs. */
164 char *trace_notes
= NULL
;
166 /* Textual notes applying to the stopping of a trace. */
168 char *trace_stop_notes
= NULL
;
170 /* ======= Important command functions: ======= */
171 static void trace_actions_command (char *, int);
172 static void trace_start_command (char *, int);
173 static void trace_stop_command (char *, int);
174 static void trace_status_command (char *, int);
175 static void trace_find_command (char *, int);
176 static void trace_find_pc_command (char *, int);
177 static void trace_find_tracepoint_command (char *, int);
178 static void trace_find_line_command (char *, int);
179 static void trace_find_range_command (char *, int);
180 static void trace_find_outside_command (char *, int);
181 static void trace_dump_command (char *, int);
183 /* support routines */
185 struct collection_list
;
186 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
187 static char *mem2hex (gdb_byte
*, char *, int);
188 static void add_register (struct collection_list
*collection
,
191 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
192 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
194 static struct command_line
*
195 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
197 extern void _initialize_tracepoint (void);
199 static struct trace_status trace_status
;
201 char *stop_reason_names
[] = {
211 struct trace_status
*
212 current_trace_status (void)
214 return &trace_status
;
220 free_traceframe_info (struct traceframe_info
*info
)
224 VEC_free (mem_range_s
, info
->memory
);
225 VEC_free (int, info
->tvars
);
231 /* Free and clear the traceframe info cache of the current
235 clear_traceframe_info (void)
237 free_traceframe_info (traceframe_info
);
238 traceframe_info
= NULL
;
241 /* Set traceframe number to NUM. */
243 set_traceframe_num (int num
)
245 traceframe_number
= num
;
246 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
249 /* Set tracepoint number to NUM. */
251 set_tracepoint_num (int num
)
253 tracepoint_number
= num
;
254 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
257 /* Set externally visible debug variables for querying/printing
258 the traceframe context (line, function, file). */
261 set_traceframe_context (struct frame_info
*trace_frame
)
264 struct symbol
*traceframe_fun
;
265 struct symtab_and_line traceframe_sal
;
267 /* Save as globals for internal use. */
268 if (trace_frame
!= NULL
269 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
271 traceframe_sal
= find_pc_line (trace_pc
, 0);
272 traceframe_fun
= find_pc_function (trace_pc
);
274 /* Save linenumber as "$trace_line", a debugger variable visible to
276 set_internalvar_integer (lookup_internalvar ("trace_line"),
277 traceframe_sal
.line
);
281 init_sal (&traceframe_sal
);
282 traceframe_fun
= NULL
;
283 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
286 /* Save func name as "$trace_func", a debugger variable visible to
288 if (traceframe_fun
== NULL
289 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
290 clear_internalvar (lookup_internalvar ("trace_func"));
292 set_internalvar_string (lookup_internalvar ("trace_func"),
293 SYMBOL_LINKAGE_NAME (traceframe_fun
));
295 /* Save file name as "$trace_file", a debugger variable visible to
297 if (traceframe_sal
.symtab
== NULL
)
298 clear_internalvar (lookup_internalvar ("trace_file"));
300 set_internalvar_string (lookup_internalvar ("trace_file"),
301 symtab_to_filename_for_display (traceframe_sal
.symtab
));
304 /* Create a new trace state variable with the given name. */
306 struct trace_state_variable
*
307 create_trace_state_variable (const char *name
)
309 struct trace_state_variable tsv
;
311 memset (&tsv
, 0, sizeof (tsv
));
312 tsv
.name
= xstrdup (name
);
313 tsv
.number
= next_tsv_number
++;
314 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
317 /* Look for a trace state variable of the given name. */
319 struct trace_state_variable
*
320 find_trace_state_variable (const char *name
)
322 struct trace_state_variable
*tsv
;
325 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
326 if (strcmp (name
, tsv
->name
) == 0)
332 /* Look for a trace state variable of the given number. Return NULL if
335 struct trace_state_variable
*
336 find_trace_state_variable_by_number (int number
)
338 struct trace_state_variable
*tsv
;
341 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
342 if (tsv
->number
== number
)
349 delete_trace_state_variable (const char *name
)
351 struct trace_state_variable
*tsv
;
354 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
355 if (strcmp (name
, tsv
->name
) == 0)
357 observer_notify_tsv_deleted (tsv
);
359 xfree ((void *)tsv
->name
);
360 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
365 warning (_("No trace variable named \"$%s\", not deleting"), name
);
368 /* Throws an error if NAME is not valid syntax for a trace state
372 validate_trace_state_variable_name (const char *name
)
377 error (_("Must supply a non-empty variable name"));
379 /* All digits in the name is reserved for value history
381 for (p
= name
; isdigit (*p
); p
++)
384 error (_("$%s is not a valid trace state variable name"), name
);
386 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
389 error (_("$%s is not a valid trace state variable name"), name
);
392 /* The 'tvariable' command collects a name and optional expression to
393 evaluate into an initial value. */
396 trace_variable_command (char *args
, int from_tty
)
398 struct cleanup
*old_chain
;
400 struct trace_state_variable
*tsv
;
404 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
406 /* Only allow two syntaxes; "$name" and "$name=value". */
407 p
= skip_spaces (args
);
410 error (_("Name of trace variable should start with '$'"));
413 while (isalnum (*p
) || *p
== '_')
415 name
= savestring (name
, p
- name
);
416 old_chain
= make_cleanup (xfree
, name
);
419 if (*p
!= '=' && *p
!= '\0')
420 error (_("Syntax must be $NAME [ = EXPR ]"));
422 validate_trace_state_variable_name (name
);
425 initval
= value_as_long (parse_and_eval (++p
));
427 /* If the variable already exists, just change its initial value. */
428 tsv
= find_trace_state_variable (name
);
431 if (tsv
->initial_value
!= initval
)
433 tsv
->initial_value
= initval
;
434 observer_notify_tsv_modified (tsv
);
436 printf_filtered (_("Trace state variable $%s "
437 "now has initial value %s.\n"),
438 tsv
->name
, plongest (tsv
->initial_value
));
439 do_cleanups (old_chain
);
443 /* Create a new variable. */
444 tsv
= create_trace_state_variable (name
);
445 tsv
->initial_value
= initval
;
447 observer_notify_tsv_created (tsv
);
449 printf_filtered (_("Trace state variable $%s "
450 "created, with initial value %s.\n"),
451 tsv
->name
, plongest (tsv
->initial_value
));
453 do_cleanups (old_chain
);
457 delete_trace_variable_command (char *args
, int from_tty
)
461 struct cleanup
*back_to
;
465 if (query (_("Delete all trace state variables? ")))
466 VEC_free (tsv_s
, tvariables
);
468 observer_notify_tsv_deleted (NULL
);
472 argv
= gdb_buildargv (args
);
473 back_to
= make_cleanup_freeargv (argv
);
475 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
477 if (*argv
[ix
] == '$')
478 delete_trace_state_variable (argv
[ix
] + 1);
480 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
483 do_cleanups (back_to
);
489 tvariables_info_1 (void)
491 struct trace_state_variable
*tsv
;
494 struct cleanup
*back_to
;
495 struct ui_out
*uiout
= current_uiout
;
497 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
499 printf_filtered (_("No trace state variables.\n"));
503 /* Try to acquire values from the target. */
504 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
505 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
508 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
509 count
, "trace-variables");
510 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
511 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
512 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
514 ui_out_table_body (uiout
);
516 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
518 struct cleanup
*back_to2
;
522 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
524 name
= concat ("$", tsv
->name
, (char *) NULL
);
525 make_cleanup (xfree
, name
);
526 ui_out_field_string (uiout
, "name", name
);
527 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
529 if (tsv
->value_known
)
530 c
= plongest (tsv
->value
);
531 else if (ui_out_is_mi_like_p (uiout
))
532 /* For MI, we prefer not to use magic string constants, but rather
533 omit the field completely. The difference between unknown and
534 undefined does not seem important enough to represent. */
536 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
537 /* The value is/was defined, but we don't have it. */
540 /* It is not meaningful to ask about the value. */
543 ui_out_field_string (uiout
, "current", c
);
544 ui_out_text (uiout
, "\n");
546 do_cleanups (back_to2
);
549 do_cleanups (back_to
);
552 /* List all the trace state variables. */
555 tvariables_info (char *args
, int from_tty
)
557 tvariables_info_1 ();
560 /* Stash definitions of tsvs into the given file. */
563 save_trace_state_variables (struct ui_file
*fp
)
565 struct trace_state_variable
*tsv
;
568 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
570 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
571 if (tsv
->initial_value
)
572 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
573 fprintf_unfiltered (fp
, "\n");
577 /* ACTIONS functions: */
579 /* The three functions:
580 collect_pseudocommand,
581 while_stepping_pseudocommand, and
582 end_actions_pseudocommand
583 are placeholders for "commands" that are actually ONLY to be used
584 within a tracepoint action list. If the actual function is ever called,
585 it means that somebody issued the "command" at the top level,
586 which is always an error. */
589 end_actions_pseudocommand (char *args
, int from_tty
)
591 error (_("This command cannot be used at the top level."));
595 while_stepping_pseudocommand (char *args
, int from_tty
)
597 error (_("This command can only be used in a tracepoint actions list."));
601 collect_pseudocommand (char *args
, int from_tty
)
603 error (_("This command can only be used in a tracepoint actions list."));
607 teval_pseudocommand (char *args
, int from_tty
)
609 error (_("This command can only be used in a tracepoint actions list."));
612 /* Parse any collection options, such as /s for strings. */
615 decode_agent_options (const char *exp
, int *trace_string
)
617 struct value_print_options opts
;
624 /* Call this to borrow the print elements default for collection
626 get_user_print_options (&opts
);
631 if (target_supports_string_tracing ())
633 /* Allow an optional decimal number giving an explicit maximum
634 string length, defaulting it to the "print elements" value;
635 so "collect/s80 mystr" gets at most 80 bytes of string. */
636 *trace_string
= opts
.print_max
;
638 if (*exp
>= '0' && *exp
<= '9')
639 *trace_string
= atoi (exp
);
640 while (*exp
>= '0' && *exp
<= '9')
644 error (_("Target does not support \"/s\" option for string tracing."));
647 error (_("Undefined collection format \"%c\"."), *exp
);
649 exp
= skip_spaces_const (exp
);
654 /* Enter a list of actions for a tracepoint. */
656 trace_actions_command (char *args
, int from_tty
)
658 struct tracepoint
*t
;
659 struct command_line
*l
;
661 t
= get_tracepoint_by_number (&args
, NULL
, 1);
665 xstrprintf ("Enter actions for tracepoint %d, one per line.",
667 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
669 l
= read_command_lines (tmpbuf
, from_tty
, 1,
670 check_tracepoint_command
, t
);
671 do_cleanups (cleanups
);
672 breakpoint_set_commands (&t
->base
, l
);
674 /* else just return */
677 /* Report the results of checking the agent expression, as errors or
681 report_agent_reqs_errors (struct agent_expr
*aexpr
)
683 /* All of the "flaws" are serious bytecode generation issues that
684 should never occur. */
685 if (aexpr
->flaw
!= agent_flaw_none
)
686 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
688 /* If analysis shows a stack underflow, GDB must have done something
689 badly wrong in its bytecode generation. */
690 if (aexpr
->min_height
< 0)
691 internal_error (__FILE__
, __LINE__
,
692 _("expression has min height < 0"));
694 /* Issue this error if the stack is predicted to get too deep. The
695 limit is rather arbitrary; a better scheme might be for the
696 target to report how much stack it will have available. The
697 depth roughly corresponds to parenthesization, so a limit of 20
698 amounts to 20 levels of expression nesting, which is actually
699 a pretty big hairy expression. */
700 if (aexpr
->max_height
> 20)
701 error (_("Expression is too complicated."));
704 /* worker function */
706 validate_actionline (const char *line
, struct breakpoint
*b
)
708 struct cmd_list_element
*c
;
709 struct expression
*exp
= NULL
;
710 struct cleanup
*old_chain
= NULL
;
713 struct bp_location
*loc
;
714 struct agent_expr
*aexpr
;
715 struct tracepoint
*t
= (struct tracepoint
*) b
;
717 /* If EOF is typed, *line is NULL. */
721 p
= skip_spaces_const (line
);
723 /* Symbol lookup etc. */
724 if (*p
== '\0') /* empty line: just prompt for another line. */
727 if (*p
== '#') /* comment line */
730 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
732 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
734 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
736 int trace_string
= 0;
739 p
= decode_agent_options (p
, &trace_string
);
742 { /* Repeat over a comma-separated list. */
743 QUIT
; /* Allow user to bail out with ^C. */
744 p
= skip_spaces_const (p
);
746 if (*p
== '$') /* Look for special pseudo-symbols. */
748 if (0 == strncasecmp ("reg", p
+ 1, 3)
749 || 0 == strncasecmp ("arg", p
+ 1, 3)
750 || 0 == strncasecmp ("loc", p
+ 1, 3)
751 || 0 == strncasecmp ("_ret", p
+ 1, 4)
752 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
757 /* else fall thru, treat p as an expression and parse it! */
760 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
763 exp
= parse_exp_1 (&p
, loc
->address
,
764 block_for_pc (loc
->address
), 1);
765 old_chain
= make_cleanup (free_current_contents
, &exp
);
767 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
769 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
771 error (_("constant `%s' (value %s) "
772 "will not be collected."),
773 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
774 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
776 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
777 == LOC_OPTIMIZED_OUT
)
779 error (_("`%s' is optimized away "
780 "and cannot be collected."),
781 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
785 /* We have something to collect, make sure that the expr to
786 bytecode translator can handle it and that it's not too
788 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
789 make_cleanup_free_agent_expr (aexpr
);
791 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
792 error (_("Expression is too complicated."));
796 report_agent_reqs_errors (aexpr
);
798 do_cleanups (old_chain
);
801 while (p
&& *p
++ == ',');
804 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
807 { /* Repeat over a comma-separated list. */
808 QUIT
; /* Allow user to bail out with ^C. */
809 p
= skip_spaces_const (p
);
812 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
816 /* Only expressions are allowed for this action. */
817 exp
= parse_exp_1 (&p
, loc
->address
,
818 block_for_pc (loc
->address
), 1);
819 old_chain
= make_cleanup (free_current_contents
, &exp
);
821 /* We have something to evaluate, make sure that the expr to
822 bytecode translator can handle it and that it's not too
824 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
825 make_cleanup_free_agent_expr (aexpr
);
827 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
828 error (_("Expression is too complicated."));
831 report_agent_reqs_errors (aexpr
);
833 do_cleanups (old_chain
);
836 while (p
&& *p
++ == ',');
839 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
843 p
= skip_spaces_const (p
);
844 t
->step_count
= strtol (p
, &endp
, 0);
845 if (endp
== p
|| t
->step_count
== 0)
846 error (_("while-stepping step count `%s' is malformed."), line
);
850 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
854 error (_("`%s' is not a supported tracepoint action."), line
);
858 memrange_absolute
= -1
861 /* MEMRANGE functions: */
863 static int memrange_cmp (const void *, const void *);
865 /* Compare memranges for qsort. */
867 memrange_cmp (const void *va
, const void *vb
)
869 const struct memrange
*a
= va
, *b
= vb
;
871 if (a
->type
< b
->type
)
873 if (a
->type
> b
->type
)
875 if (a
->type
== memrange_absolute
)
877 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
879 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
884 if (a
->start
< b
->start
)
886 if (a
->start
> b
->start
)
892 /* Sort the memrange list using qsort, and merge adjacent memranges. */
894 memrange_sortmerge (struct collection_list
*memranges
)
898 qsort (memranges
->list
, memranges
->next_memrange
,
899 sizeof (struct memrange
), memrange_cmp
);
900 if (memranges
->next_memrange
> 0)
902 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
904 /* If memrange b overlaps or is adjacent to memrange a,
906 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
907 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
909 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
910 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
911 continue; /* next b, same a */
915 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
916 sizeof (struct memrange
));
918 memranges
->next_memrange
= a
+ 1;
922 /* Add a register to a collection list. */
924 add_register (struct collection_list
*collection
, unsigned int regno
)
927 printf_filtered ("collect register %d\n", regno
);
928 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
929 error (_("Internal: register number %d too large for tracepoint"),
931 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
934 /* Add a memrange to a collection list. */
936 add_memrange (struct collection_list
*memranges
,
937 int type
, bfd_signed_vma base
,
942 printf_filtered ("(%d,", type
);
944 printf_filtered (",%ld)\n", len
);
947 /* type: memrange_absolute == memory, other n == basereg */
948 memranges
->list
[memranges
->next_memrange
].type
= type
;
949 /* base: addr if memory, offset if reg relative. */
950 memranges
->list
[memranges
->next_memrange
].start
= base
;
951 /* len: we actually save end (base + len) for convenience */
952 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
953 memranges
->next_memrange
++;
954 if (memranges
->next_memrange
>= memranges
->listsize
)
956 memranges
->listsize
*= 2;
957 memranges
->list
= xrealloc (memranges
->list
,
958 memranges
->listsize
);
961 if (type
!= memrange_absolute
) /* Better collect the base register! */
962 add_register (memranges
, type
);
965 /* Add a symbol to a collection list. */
967 collect_symbol (struct collection_list
*collect
,
969 struct gdbarch
*gdbarch
,
970 long frame_regno
, long frame_offset
,
976 bfd_signed_vma offset
;
977 int treat_as_expr
= 0;
979 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
980 switch (SYMBOL_CLASS (sym
))
983 printf_filtered ("%s: don't know symbol class %d\n",
984 SYMBOL_PRINT_NAME (sym
),
988 printf_filtered ("constant %s (value %s) will not be collected.\n",
989 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
992 offset
= SYMBOL_VALUE_ADDRESS (sym
);
997 sprintf_vma (tmp
, offset
);
998 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
999 SYMBOL_PRINT_NAME (sym
), len
,
1002 /* A struct may be a C++ class with static fields, go to general
1003 expression handling. */
1004 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1007 add_memrange (collect
, memrange_absolute
, offset
, len
);
1010 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1012 printf_filtered ("LOC_REG[parm] %s: ",
1013 SYMBOL_PRINT_NAME (sym
));
1014 add_register (collect
, reg
);
1015 /* Check for doubles stored in two registers. */
1016 /* FIXME: how about larger types stored in 3 or more regs? */
1017 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1018 len
> register_size (gdbarch
, reg
))
1019 add_register (collect
, reg
+ 1);
1022 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1023 printf_filtered (" (will not collect %s)\n",
1024 SYMBOL_PRINT_NAME (sym
));
1028 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1031 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1032 SYMBOL_PRINT_NAME (sym
), len
);
1033 printf_vma (offset
);
1034 printf_filtered (" from frame ptr reg %d\n", reg
);
1036 add_memrange (collect
, reg
, offset
, len
);
1038 case LOC_REGPARM_ADDR
:
1039 reg
= SYMBOL_VALUE (sym
);
1043 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1044 SYMBOL_PRINT_NAME (sym
), len
);
1045 printf_vma (offset
);
1046 printf_filtered (" from reg %d\n", reg
);
1048 add_memrange (collect
, reg
, offset
, len
);
1052 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1055 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1056 SYMBOL_PRINT_NAME (sym
), len
);
1057 printf_vma (offset
);
1058 printf_filtered (" from frame ptr reg %d\n", reg
);
1060 add_memrange (collect
, reg
, offset
, len
);
1063 case LOC_UNRESOLVED
:
1067 case LOC_OPTIMIZED_OUT
:
1068 printf_filtered ("%s has been optimized out of existence.\n",
1069 SYMBOL_PRINT_NAME (sym
));
1077 /* Expressions are the most general case. */
1080 struct agent_expr
*aexpr
;
1081 struct cleanup
*old_chain1
= NULL
;
1083 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1085 /* It can happen that the symbol is recorded as a computed
1086 location, but it's been optimized away and doesn't actually
1087 have a location expression. */
1090 printf_filtered ("%s has been optimized out of existence.\n",
1091 SYMBOL_PRINT_NAME (sym
));
1095 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1099 report_agent_reqs_errors (aexpr
);
1101 discard_cleanups (old_chain1
);
1102 add_aexpr (collect
, aexpr
);
1104 /* Take care of the registers. */
1105 if (aexpr
->reg_mask_len
> 0)
1109 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1111 QUIT
; /* Allow user to bail out with ^C. */
1112 if (aexpr
->reg_mask
[ndx1
] != 0)
1114 /* Assume chars have 8 bits. */
1115 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1116 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1117 /* It's used -- record it. */
1118 add_register (collect
, ndx1
* 8 + ndx2
);
1125 /* Data to be passed around in the calls to the locals and args
1128 struct add_local_symbols_data
1130 struct collection_list
*collect
;
1131 struct gdbarch
*gdbarch
;
1139 /* The callback for the locals and args iterators. */
1142 do_collect_symbol (const char *print_name
,
1146 struct add_local_symbols_data
*p
= cb_data
;
1148 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1149 p
->frame_offset
, p
->pc
, p
->trace_string
);
1152 VEC_safe_push (char_ptr
, p
->collect
->wholly_collected
,
1153 xstrdup (print_name
));
1156 /* Add all locals (or args) symbols to collection list. */
1158 add_local_symbols (struct collection_list
*collect
,
1159 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1160 long frame_regno
, long frame_offset
, int type
,
1163 struct block
*block
;
1164 struct add_local_symbols_data cb_data
;
1166 cb_data
.collect
= collect
;
1167 cb_data
.gdbarch
= gdbarch
;
1169 cb_data
.frame_regno
= frame_regno
;
1170 cb_data
.frame_offset
= frame_offset
;
1172 cb_data
.trace_string
= trace_string
;
1176 block
= block_for_pc (pc
);
1179 warning (_("Can't collect locals; "
1180 "no symbol table info available.\n"));
1184 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1185 if (cb_data
.count
== 0)
1186 warning (_("No locals found in scope."));
1190 pc
= get_pc_function_start (pc
);
1191 block
= block_for_pc (pc
);
1194 warning (_("Can't collect args; no symbol table info available."));
1198 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1199 if (cb_data
.count
== 0)
1200 warning (_("No args found in scope."));
1205 add_static_trace_data (struct collection_list
*collection
)
1208 printf_filtered ("collect static trace data\n");
1209 collection
->strace_data
= 1;
1212 /* worker function */
1214 clear_collection_list (struct collection_list
*list
)
1218 list
->next_memrange
= 0;
1219 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1221 free_agent_expr (list
->aexpr_list
[ndx
]);
1222 list
->aexpr_list
[ndx
] = NULL
;
1224 list
->next_aexpr_elt
= 0;
1225 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1226 list
->strace_data
= 0;
1228 xfree (list
->aexpr_list
);
1231 VEC_free (char_ptr
, list
->wholly_collected
);
1232 VEC_free (char_ptr
, list
->computed
);
1235 /* A cleanup wrapper for function clear_collection_list. */
1238 do_clear_collection_list (void *list
)
1240 struct collection_list
*l
= list
;
1242 clear_collection_list (l
);
1245 /* Initialize collection_list CLIST. */
1248 init_collection_list (struct collection_list
*clist
)
1250 memset (clist
, 0, sizeof *clist
);
1252 clist
->listsize
= 128;
1253 clist
->list
= xcalloc (clist
->listsize
,
1254 sizeof (struct memrange
));
1256 clist
->aexpr_listsize
= 128;
1257 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1258 sizeof (struct agent_expr
*));
1261 /* Reduce a collection list to string form (for gdb protocol). */
1263 stringify_collection_list (struct collection_list
*list
)
1265 char temp_buf
[2048];
1269 char *(*str_list
)[];
1273 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1274 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1276 if (list
->strace_data
)
1279 printf_filtered ("\nCollecting static trace data\n");
1282 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1286 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1287 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1289 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1292 printf_filtered ("\nCollecting registers (mask): 0x");
1297 QUIT
; /* Allow user to bail out with ^C. */
1299 printf_filtered ("%02X", list
->regs_mask
[i
]);
1300 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1303 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1307 printf_filtered ("\n");
1308 if (list
->next_memrange
> 0 && info_verbose
)
1309 printf_filtered ("Collecting memranges: \n");
1310 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1312 QUIT
; /* Allow user to bail out with ^C. */
1313 sprintf_vma (tmp2
, list
->list
[i
].start
);
1316 printf_filtered ("(%d, %s, %ld)\n",
1319 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1321 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1323 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1330 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1332 /* The "%X" conversion specifier expects an unsigned argument,
1333 so passing -1 (memrange_absolute) to it directly gives you
1334 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1336 if (list
->list
[i
].type
== memrange_absolute
)
1337 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1339 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1342 count
+= strlen (end
);
1343 end
= temp_buf
+ count
;
1346 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1348 QUIT
; /* Allow user to bail out with ^C. */
1349 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1351 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1356 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1357 end
+= 10; /* 'X' + 8 hex digits + ',' */
1360 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1361 end
, list
->aexpr_list
[i
]->len
);
1362 count
+= 2 * list
->aexpr_list
[i
]->len
;
1367 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1372 (*str_list
)[ndx
] = NULL
;
1383 /* Add the printed expression EXP to *LIST. */
1386 append_exp (struct expression
*exp
, VEC(char_ptr
) **list
)
1388 struct ui_file
*tmp_stream
= mem_fileopen ();
1391 print_expression (exp
, tmp_stream
);
1393 text
= ui_file_xstrdup (tmp_stream
, NULL
);
1395 VEC_safe_push (char_ptr
, *list
, text
);
1396 ui_file_delete (tmp_stream
);
1400 encode_actions_1 (struct command_line
*action
,
1401 struct bp_location
*tloc
,
1403 LONGEST frame_offset
,
1404 struct collection_list
*collect
,
1405 struct collection_list
*stepping_list
)
1407 const char *action_exp
;
1408 struct expression
*exp
= NULL
;
1410 struct value
*tempval
;
1411 struct cmd_list_element
*cmd
;
1412 struct agent_expr
*aexpr
;
1414 for (; action
; action
= action
->next
)
1416 QUIT
; /* Allow user to bail out with ^C. */
1417 action_exp
= action
->line
;
1418 action_exp
= skip_spaces_const (action_exp
);
1420 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1422 error (_("Bad action list item: %s"), action_exp
);
1424 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1426 int trace_string
= 0;
1428 if (*action_exp
== '/')
1429 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1432 { /* Repeat over a comma-separated list. */
1433 QUIT
; /* Allow user to bail out with ^C. */
1434 action_exp
= skip_spaces_const (action_exp
);
1436 if (0 == strncasecmp ("$reg", action_exp
, 4))
1438 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1439 add_register (collect
, i
);
1440 action_exp
= strchr (action_exp
, ','); /* more? */
1442 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1444 add_local_symbols (collect
,
1451 action_exp
= strchr (action_exp
, ','); /* more? */
1453 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1455 add_local_symbols (collect
,
1462 action_exp
= strchr (action_exp
, ','); /* more? */
1464 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1466 struct cleanup
*old_chain1
= NULL
;
1468 aexpr
= gen_trace_for_return_address (tloc
->address
,
1472 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1475 report_agent_reqs_errors (aexpr
);
1477 discard_cleanups (old_chain1
);
1478 add_aexpr (collect
, aexpr
);
1480 /* take care of the registers */
1481 if (aexpr
->reg_mask_len
> 0)
1485 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1487 QUIT
; /* allow user to bail out with ^C */
1488 if (aexpr
->reg_mask
[ndx1
] != 0)
1490 /* assume chars have 8 bits */
1491 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1492 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1493 /* it's used -- record it */
1494 add_register (collect
,
1500 action_exp
= strchr (action_exp
, ','); /* more? */
1502 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1504 add_static_trace_data (collect
);
1505 action_exp
= strchr (action_exp
, ','); /* more? */
1510 struct cleanup
*old_chain
= NULL
;
1511 struct cleanup
*old_chain1
= NULL
;
1513 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1514 block_for_pc (tloc
->address
), 1);
1515 old_chain
= make_cleanup (free_current_contents
, &exp
);
1517 switch (exp
->elts
[0].opcode
)
1521 const char *name
= &exp
->elts
[2].string
;
1523 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1524 name
, strlen (name
));
1526 internal_error (__FILE__
, __LINE__
,
1527 _("Register $%s not available"),
1530 printf_filtered ("OP_REGISTER: ");
1531 add_register (collect
, i
);
1536 /* Safe because we know it's a simple expression. */
1537 tempval
= evaluate_expression (exp
);
1538 addr
= value_address (tempval
);
1539 /* Initialize the TYPE_LENGTH if it is a typedef. */
1540 check_typedef (exp
->elts
[1].type
);
1541 add_memrange (collect
, memrange_absolute
, addr
,
1542 TYPE_LENGTH (exp
->elts
[1].type
));
1543 append_exp (exp
, &collect
->computed
);
1548 struct symbol
*sym
= exp
->elts
[2].symbol
;
1549 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1551 collect_symbol (collect
,
1552 exp
->elts
[2].symbol
,
1558 VEC_safe_push (char_ptr
,
1559 collect
->wholly_collected
,
1564 default: /* Full-fledged expression. */
1565 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1568 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1572 report_agent_reqs_errors (aexpr
);
1574 discard_cleanups (old_chain1
);
1575 add_aexpr (collect
, aexpr
);
1577 /* Take care of the registers. */
1578 if (aexpr
->reg_mask_len
> 0)
1583 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1585 QUIT
; /* Allow user to bail out with ^C. */
1586 if (aexpr
->reg_mask
[ndx1
] != 0)
1588 /* Assume chars have 8 bits. */
1589 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1590 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1591 /* It's used -- record it. */
1592 add_register (collect
,
1598 append_exp (exp
, &collect
->computed
);
1601 do_cleanups (old_chain
);
1604 while (action_exp
&& *action_exp
++ == ',');
1606 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1609 { /* Repeat over a comma-separated list. */
1610 QUIT
; /* Allow user to bail out with ^C. */
1611 action_exp
= skip_spaces_const (action_exp
);
1614 struct cleanup
*old_chain
= NULL
;
1615 struct cleanup
*old_chain1
= NULL
;
1617 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1618 block_for_pc (tloc
->address
), 1);
1619 old_chain
= make_cleanup (free_current_contents
, &exp
);
1621 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1622 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1625 report_agent_reqs_errors (aexpr
);
1627 discard_cleanups (old_chain1
);
1628 /* Even though we're not officially collecting, add
1629 to the collect list anyway. */
1630 add_aexpr (collect
, aexpr
);
1632 do_cleanups (old_chain
);
1635 while (action_exp
&& *action_exp
++ == ',');
1637 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1639 /* We check against nested while-stepping when setting
1640 breakpoint action, so no way to run into nested
1642 gdb_assert (stepping_list
);
1644 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1645 frame_offset
, stepping_list
, NULL
);
1648 error (_("Invalid tracepoint command '%s'"), action
->line
);
1652 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1653 and STEPPING_LIST. Return a cleanup pointer to clean up both
1654 TRACEPOINT_LIST and STEPPING_LIST. */
1657 encode_actions_and_make_cleanup (struct bp_location
*tloc
,
1658 struct collection_list
*tracepoint_list
,
1659 struct collection_list
*stepping_list
)
1661 char *default_collect_line
= NULL
;
1662 struct command_line
*actions
;
1663 struct command_line
*default_collect_action
= NULL
;
1665 LONGEST frame_offset
;
1666 struct cleanup
*back_to
, *return_chain
;
1668 return_chain
= make_cleanup (null_cleanup
, NULL
);
1669 init_collection_list (tracepoint_list
);
1670 init_collection_list (stepping_list
);
1672 make_cleanup (do_clear_collection_list
, tracepoint_list
);
1673 make_cleanup (do_clear_collection_list
, stepping_list
);
1675 back_to
= make_cleanup (null_cleanup
, NULL
);
1676 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1677 tloc
->address
, &frame_reg
, &frame_offset
);
1679 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1681 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1682 tracepoint_list
, stepping_list
);
1684 memrange_sortmerge (tracepoint_list
);
1685 memrange_sortmerge (stepping_list
);
1687 do_cleanups (back_to
);
1688 return return_chain
;
1691 /* Render all actions into gdb protocol. */
1694 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1695 char ***stepping_actions
)
1697 struct collection_list tracepoint_list
, stepping_list
;
1698 struct cleanup
*cleanup
;
1700 *tdp_actions
= NULL
;
1701 *stepping_actions
= NULL
;
1703 cleanup
= encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
1706 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1707 *stepping_actions
= stringify_collection_list (&stepping_list
);
1709 do_cleanups (cleanup
);
1713 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1715 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1717 collect
->aexpr_list
=
1718 xrealloc (collect
->aexpr_list
,
1719 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1720 collect
->aexpr_listsize
*= 2;
1722 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1723 collect
->next_aexpr_elt
++;
1727 process_tracepoint_on_disconnect (void)
1729 VEC(breakpoint_p
) *tp_vec
= NULL
;
1731 struct breakpoint
*b
;
1732 int has_pending_p
= 0;
1734 /* Check whether we still have pending tracepoint. If we have, warn the
1735 user that pending tracepoint will no longer work. */
1736 tp_vec
= all_tracepoints ();
1737 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1746 struct bp_location
*loc1
;
1748 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1750 if (loc1
->shlib_disabled
)
1761 VEC_free (breakpoint_p
, tp_vec
);
1764 warning (_("Pending tracepoints will not be resolved while"
1765 " GDB is disconnected\n"));
1768 /* Reset local state of tracing. */
1771 trace_reset_local_state (void)
1773 set_traceframe_num (-1);
1774 set_tracepoint_num (-1);
1775 set_traceframe_context (NULL
);
1776 clear_traceframe_info ();
1780 start_tracing (char *notes
)
1782 VEC(breakpoint_p
) *tp_vec
= NULL
;
1784 struct breakpoint
*b
;
1785 struct trace_state_variable
*tsv
;
1786 int any_enabled
= 0, num_to_download
= 0;
1789 tp_vec
= all_tracepoints ();
1791 /* No point in tracing without any tracepoints... */
1792 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1794 VEC_free (breakpoint_p
, tp_vec
);
1795 error (_("No tracepoints defined, not starting trace"));
1798 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1800 struct tracepoint
*t
= (struct tracepoint
*) b
;
1801 struct bp_location
*loc
;
1803 if (b
->enable_state
== bp_enabled
)
1806 if ((b
->type
== bp_fast_tracepoint
1807 ? may_insert_fast_tracepoints
1808 : may_insert_tracepoints
))
1811 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1812 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1817 if (target_supports_enable_disable_tracepoint ())
1818 warning (_("No tracepoints enabled"));
1821 /* No point in tracing with only disabled tracepoints that
1822 cannot be re-enabled. */
1823 VEC_free (breakpoint_p
, tp_vec
);
1824 error (_("No tracepoints enabled, not starting trace"));
1828 if (num_to_download
<= 0)
1830 VEC_free (breakpoint_p
, tp_vec
);
1831 error (_("No tracepoints that may be downloaded, not starting trace"));
1834 target_trace_init ();
1836 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1838 struct tracepoint
*t
= (struct tracepoint
*) b
;
1839 struct bp_location
*loc
;
1840 int bp_location_downloaded
= 0;
1842 /* Clear `inserted' flag. */
1843 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1846 if ((b
->type
== bp_fast_tracepoint
1847 ? !may_insert_fast_tracepoints
1848 : !may_insert_tracepoints
))
1851 t
->number_on_target
= 0;
1853 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1855 /* Since tracepoint locations are never duplicated, `inserted'
1856 flag should be zero. */
1857 gdb_assert (!loc
->inserted
);
1859 target_download_tracepoint (loc
);
1862 bp_location_downloaded
= 1;
1865 t
->number_on_target
= b
->number
;
1867 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1868 if (loc
->probe
!= NULL
)
1869 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1871 if (bp_location_downloaded
)
1872 observer_notify_breakpoint_modified (b
);
1874 VEC_free (breakpoint_p
, tp_vec
);
1876 /* Send down all the trace state variables too. */
1877 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1879 target_download_trace_state_variable (tsv
);
1882 /* Tell target to treat text-like sections as transparent. */
1883 target_trace_set_readonly_regions ();
1884 /* Set some mode flags. */
1885 target_set_disconnected_tracing (disconnected_tracing
);
1886 target_set_circular_trace_buffer (circular_trace_buffer
);
1887 target_set_trace_buffer_size (trace_buffer_size
);
1890 notes
= trace_notes
;
1891 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1893 if (!ret
&& (trace_user
|| notes
))
1894 warning (_("Target does not support trace user/notes, info ignored"));
1896 /* Now insert traps and begin collecting data. */
1897 target_trace_start ();
1899 /* Reset our local state. */
1900 trace_reset_local_state ();
1901 current_trace_status()->running
= 1;
1904 /* The tstart command requests the target to start a new trace run.
1905 The command passes any arguments it has to the target verbatim, as
1906 an optional "trace note". This is useful as for instance a warning
1907 to other users if the trace runs disconnected, and you don't want
1908 anybody else messing with the target. */
1911 trace_start_command (char *args
, int from_tty
)
1913 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1915 if (current_trace_status ()->running
)
1918 && !query (_("A trace is running already. Start a new run? ")))
1919 error (_("New trace run not started."));
1922 start_tracing (args
);
1925 /* The tstop command stops the tracing run. The command passes any
1926 supplied arguments to the target verbatim as a "stop note"; if the
1927 target supports trace notes, then it will be reported back as part
1928 of the trace run's status. */
1931 trace_stop_command (char *args
, int from_tty
)
1933 if (!current_trace_status ()->running
)
1934 error (_("Trace is not running."));
1936 stop_tracing (args
);
1940 stop_tracing (char *note
)
1943 VEC(breakpoint_p
) *tp_vec
= NULL
;
1945 struct breakpoint
*t
;
1947 target_trace_stop ();
1949 tp_vec
= all_tracepoints ();
1950 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1952 struct bp_location
*loc
;
1954 if ((t
->type
== bp_fast_tracepoint
1955 ? !may_insert_fast_tracepoints
1956 : !may_insert_tracepoints
))
1959 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1961 /* GDB can be totally absent in some disconnected trace scenarios,
1962 but we don't really care if this semaphore goes out of sync.
1963 That's why we are decrementing it here, but not taking care
1965 if (loc
->probe
!= NULL
)
1966 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1970 VEC_free (breakpoint_p
, tp_vec
);
1973 note
= trace_stop_notes
;
1974 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1977 warning (_("Target does not support trace notes, note ignored"));
1979 /* Should change in response to reply? */
1980 current_trace_status ()->running
= 0;
1983 /* tstatus command */
1985 trace_status_command (char *args
, int from_tty
)
1987 struct trace_status
*ts
= current_trace_status ();
1989 VEC(breakpoint_p
) *tp_vec
= NULL
;
1990 struct breakpoint
*t
;
1992 status
= target_get_trace_status (ts
);
1996 if (ts
->filename
!= NULL
)
1997 printf_filtered (_("Using a trace file.\n"));
2000 printf_filtered (_("Trace can not be run on this target.\n"));
2005 if (!ts
->running_known
)
2007 printf_filtered (_("Run/stop status is unknown.\n"));
2009 else if (ts
->running
)
2011 printf_filtered (_("Trace is running on the target.\n"));
2015 switch (ts
->stop_reason
)
2017 case trace_never_run
:
2018 printf_filtered (_("No trace has been run on the target.\n"));
2022 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2025 printf_filtered (_("Trace stopped by a tstop command.\n"));
2027 case trace_buffer_full
:
2028 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2030 case trace_disconnected
:
2031 printf_filtered (_("Trace stopped because of disconnection.\n"));
2033 case tracepoint_passcount
:
2034 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2035 ts
->stopping_tracepoint
);
2037 case tracepoint_error
:
2038 if (ts
->stopping_tracepoint
)
2039 printf_filtered (_("Trace stopped by an "
2040 "error (%s, tracepoint %d).\n"),
2041 ts
->stop_desc
, ts
->stopping_tracepoint
);
2043 printf_filtered (_("Trace stopped by an error (%s).\n"),
2046 case trace_stop_reason_unknown
:
2047 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2050 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2056 if (ts
->traceframes_created
>= 0
2057 && ts
->traceframe_count
!= ts
->traceframes_created
)
2059 printf_filtered (_("Buffer contains %d trace "
2060 "frames (of %d created total).\n"),
2061 ts
->traceframe_count
, ts
->traceframes_created
);
2063 else if (ts
->traceframe_count
>= 0)
2065 printf_filtered (_("Collected %d trace frames.\n"),
2066 ts
->traceframe_count
);
2069 if (ts
->buffer_free
>= 0)
2071 if (ts
->buffer_size
>= 0)
2073 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2074 ts
->buffer_free
, ts
->buffer_size
);
2075 if (ts
->buffer_size
> 0)
2076 printf_filtered (_(" (%d%% full)"),
2077 ((int) ((((long long) (ts
->buffer_size
2078 - ts
->buffer_free
)) * 100)
2079 / ts
->buffer_size
)));
2080 printf_filtered (_(".\n"));
2083 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2087 if (ts
->disconnected_tracing
)
2088 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2090 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2092 if (ts
->circular_buffer
)
2093 printf_filtered (_("Trace buffer is circular.\n"));
2095 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2096 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2098 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2099 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2101 /* Now report on what we're doing with tfind. */
2102 if (traceframe_number
>= 0)
2103 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2104 traceframe_number
, tracepoint_number
);
2106 printf_filtered (_("Not looking at any trace frame.\n"));
2108 /* Report start/stop times if supplied. */
2113 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2115 /* Reporting a run time is more readable than two long numbers. */
2116 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2117 (long int) (ts
->start_time
/ 1000000),
2118 (long int) (ts
->start_time
% 1000000),
2119 (long int) (run_time
/ 1000000),
2120 (long int) (run_time
% 1000000));
2123 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2124 (long int) (ts
->start_time
/ 1000000),
2125 (long int) (ts
->start_time
% 1000000));
2127 else if (ts
->stop_time
)
2128 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2129 (long int) (ts
->stop_time
/ 1000000),
2130 (long int) (ts
->stop_time
% 1000000));
2132 /* Now report any per-tracepoint status available. */
2133 tp_vec
= all_tracepoints ();
2135 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2136 target_get_tracepoint_status (t
, NULL
);
2138 VEC_free (breakpoint_p
, tp_vec
);
2141 /* Report the trace status to uiout, in a way suitable for MI, and not
2142 suitable for CLI. If ON_STOP is true, suppress a few fields that
2143 are not meaningful in the -trace-stop response.
2145 The implementation is essentially parallel to trace_status_command, but
2146 merging them will result in unreadable code. */
2148 trace_status_mi (int on_stop
)
2150 struct ui_out
*uiout
= current_uiout
;
2151 struct trace_status
*ts
= current_trace_status ();
2154 status
= target_get_trace_status (ts
);
2156 if (status
== -1 && ts
->filename
== NULL
)
2158 ui_out_field_string (uiout
, "supported", "0");
2162 if (ts
->filename
!= NULL
)
2163 ui_out_field_string (uiout
, "supported", "file");
2165 ui_out_field_string (uiout
, "supported", "1");
2167 if (ts
->filename
!= NULL
)
2168 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2170 gdb_assert (ts
->running_known
);
2174 ui_out_field_string (uiout
, "running", "1");
2176 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2177 Given that the frontend gets the status either on -trace-stop, or from
2178 -trace-status after re-connection, it does not seem like this
2179 information is necessary for anything. It is not necessary for either
2180 figuring the vital state of the target nor for navigation of trace
2181 frames. If the frontend wants to show the current state is some
2182 configure dialog, it can request the value when such dialog is
2183 invoked by the user. */
2187 char *stop_reason
= NULL
;
2188 int stopping_tracepoint
= -1;
2191 ui_out_field_string (uiout
, "running", "0");
2193 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2195 switch (ts
->stop_reason
)
2198 stop_reason
= "request";
2200 case trace_buffer_full
:
2201 stop_reason
= "overflow";
2203 case trace_disconnected
:
2204 stop_reason
= "disconnection";
2206 case tracepoint_passcount
:
2207 stop_reason
= "passcount";
2208 stopping_tracepoint
= ts
->stopping_tracepoint
;
2210 case tracepoint_error
:
2211 stop_reason
= "error";
2212 stopping_tracepoint
= ts
->stopping_tracepoint
;
2218 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2219 if (stopping_tracepoint
!= -1)
2220 ui_out_field_int (uiout
, "stopping-tracepoint",
2221 stopping_tracepoint
);
2222 if (ts
->stop_reason
== tracepoint_error
)
2223 ui_out_field_string (uiout
, "error-description",
2229 if (ts
->traceframe_count
!= -1)
2230 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2231 if (ts
->traceframes_created
!= -1)
2232 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2233 if (ts
->buffer_size
!= -1)
2234 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2235 if (ts
->buffer_free
!= -1)
2236 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2238 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2239 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2241 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2242 ui_out_field_string (uiout
, "notes", ts
->notes
);
2247 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2248 (long int) (ts
->start_time
/ 1000000),
2249 (long int) (ts
->start_time
% 1000000));
2250 ui_out_field_string (uiout
, "start-time", buf
);
2251 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2252 (long int) (ts
->stop_time
/ 1000000),
2253 (long int) (ts
->stop_time
% 1000000));
2254 ui_out_field_string (uiout
, "stop-time", buf
);
2258 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2259 user if she really wants to detach. */
2262 query_if_trace_running (int from_tty
)
2267 /* It can happen that the target that was tracing went away on its
2268 own, and we didn't notice. Get a status update, and if the
2269 current target doesn't even do tracing, then assume it's not
2271 if (target_get_trace_status (current_trace_status ()) < 0)
2272 current_trace_status ()->running
= 0;
2274 /* If running interactively, give the user the option to cancel and
2275 then decide what to do differently with the run. Scripts are
2276 just going to disconnect and let the target deal with it,
2277 according to how it's been instructed previously via
2278 disconnected-tracing. */
2279 if (current_trace_status ()->running
)
2281 process_tracepoint_on_disconnect ();
2283 if (current_trace_status ()->disconnected_tracing
)
2285 if (!query (_("Trace is running and will "
2286 "continue after detach; detach anyway? ")))
2287 error (_("Not confirmed."));
2291 if (!query (_("Trace is running but will "
2292 "stop on detach; detach anyway? ")))
2293 error (_("Not confirmed."));
2298 /* This function handles the details of what to do about an ongoing
2299 tracing run if the user has asked to detach or otherwise disconnect
2303 disconnect_tracing (void)
2305 /* Also we want to be out of tfind mode, otherwise things can get
2306 confusing upon reconnection. Just use these calls instead of
2307 full tfind_1 behavior because we're in the middle of detaching,
2308 and there's no point to updating current stack frame etc. */
2309 trace_reset_local_state ();
2312 /* Worker function for the various flavors of the tfind command. */
2314 tfind_1 (enum trace_find_type type
, int num
,
2315 CORE_ADDR addr1
, CORE_ADDR addr2
,
2318 int target_frameno
= -1, target_tracept
= -1;
2319 struct frame_id old_frame_id
= null_frame_id
;
2320 struct tracepoint
*tp
;
2321 struct ui_out
*uiout
= current_uiout
;
2323 /* Only try to get the current stack frame if we have a chance of
2324 succeeding. In particular, if we're trying to get a first trace
2325 frame while all threads are running, it's not going to succeed,
2326 so leave it with a default value and let the frame comparison
2327 below (correctly) decide to print out the source location of the
2329 if (!(type
== tfind_number
&& num
== -1)
2330 && (has_stack_frames () || traceframe_number
>= 0))
2331 old_frame_id
= get_frame_id (get_current_frame ());
2333 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2336 if (type
== tfind_number
2338 && target_frameno
== -1)
2340 /* We told the target to get out of tfind mode, and it did. */
2342 else if (target_frameno
== -1)
2344 /* A request for a non-existent trace frame has failed.
2345 Our response will be different, depending on FROM_TTY:
2347 If FROM_TTY is true, meaning that this command was
2348 typed interactively by the user, then give an error
2349 and DO NOT change the state of traceframe_number etc.
2351 However if FROM_TTY is false, meaning that we're either
2352 in a script, a loop, or a user-defined command, then
2353 DON'T give an error, but DO change the state of
2354 traceframe_number etc. to invalid.
2356 The rationalle is that if you typed the command, you
2357 might just have committed a typo or something, and you'd
2358 like to NOT lose your current debugging state. However
2359 if you're in a user-defined command or especially in a
2360 loop, then you need a way to detect that the command
2361 failed WITHOUT aborting. This allows you to write
2362 scripts that search thru the trace buffer until the end,
2363 and then continue on to do something else. */
2366 error (_("Target failed to find requested trace frame."));
2370 printf_filtered ("End of trace buffer.\n");
2371 #if 0 /* dubious now? */
2372 /* The following will not recurse, since it's
2374 trace_find_command ("-1", from_tty
);
2379 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2381 reinit_frame_cache ();
2382 target_dcache_invalidate ();
2384 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2386 if (target_frameno
!= get_traceframe_number ())
2387 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2389 set_current_traceframe (target_frameno
);
2391 if (target_frameno
== -1)
2392 set_traceframe_context (NULL
);
2394 set_traceframe_context (get_current_frame ());
2396 if (traceframe_number
>= 0)
2398 /* Use different branches for MI and CLI to make CLI messages
2400 if (ui_out_is_mi_like_p (uiout
))
2402 ui_out_field_string (uiout
, "found", "1");
2403 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2404 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2408 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2409 traceframe_number
, tracepoint_number
);
2414 if (ui_out_is_mi_like_p (uiout
))
2415 ui_out_field_string (uiout
, "found", "0");
2416 else if (type
== tfind_number
&& num
== -1)
2417 printf_unfiltered (_("No longer looking at any trace frame\n"));
2418 else /* This case may never occur, check. */
2419 printf_unfiltered (_("No trace frame found\n"));
2422 /* If we're in nonstop mode and getting out of looking at trace
2423 frames, there won't be any current frame to go back to and
2426 && (has_stack_frames () || traceframe_number
>= 0))
2428 enum print_what print_what
;
2430 /* NOTE: in imitation of the step command, try to determine
2431 whether we have made a transition from one function to
2432 another. If so, we'll print the "stack frame" (ie. the new
2433 function and it's arguments) -- otherwise we'll just show the
2436 if (frame_id_eq (old_frame_id
,
2437 get_frame_id (get_current_frame ())))
2438 print_what
= SRC_LINE
;
2440 print_what
= SRC_AND_LOC
;
2442 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2447 /* trace_find_command takes a trace frame number n,
2448 sends "QTFrame:<n>" to the target,
2449 and accepts a reply that may contain several optional pieces
2450 of information: a frame number, a tracepoint number, and an
2451 indication of whether this is a trap frame or a stepping frame.
2453 The minimal response is just "OK" (which indicates that the
2454 target does not give us a frame number or a tracepoint number).
2455 Instead of that, the target may send us a string containing
2457 F<hexnum> (gives the selected frame number)
2458 T<hexnum> (gives the selected tracepoint number)
2463 trace_find_command (char *args
, int from_tty
)
2464 { /* This should only be called with a numeric argument. */
2467 if (current_trace_status ()->running
2468 && current_trace_status ()->filename
== NULL
)
2469 error (_("May not look at trace frames while trace is running."));
2471 if (args
== 0 || *args
== 0)
2472 { /* TFIND with no args means find NEXT trace frame. */
2473 if (traceframe_number
== -1)
2474 frameno
= 0; /* "next" is first one. */
2476 frameno
= traceframe_number
+ 1;
2478 else if (0 == strcmp (args
, "-"))
2480 if (traceframe_number
== -1)
2481 error (_("not debugging trace buffer"));
2482 else if (from_tty
&& traceframe_number
== 0)
2483 error (_("already at start of trace buffer"));
2485 frameno
= traceframe_number
- 1;
2487 /* A hack to work around eval's need for fp to have been collected. */
2488 else if (0 == strcmp (args
, "-1"))
2491 frameno
= parse_and_eval_long (args
);
2494 error (_("invalid input (%d is less than zero)"), frameno
);
2496 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2501 trace_find_end_command (char *args
, int from_tty
)
2503 trace_find_command ("-1", from_tty
);
2508 trace_find_start_command (char *args
, int from_tty
)
2510 trace_find_command ("0", from_tty
);
2513 /* tfind pc command */
2515 trace_find_pc_command (char *args
, int from_tty
)
2519 if (current_trace_status ()->running
2520 && current_trace_status ()->filename
== NULL
)
2521 error (_("May not look at trace frames while trace is running."));
2523 if (args
== 0 || *args
== 0)
2524 pc
= regcache_read_pc (get_current_regcache ());
2526 pc
= parse_and_eval_address (args
);
2528 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2531 /* tfind tracepoint command */
2533 trace_find_tracepoint_command (char *args
, int from_tty
)
2536 struct tracepoint
*tp
;
2538 if (current_trace_status ()->running
2539 && current_trace_status ()->filename
== NULL
)
2540 error (_("May not look at trace frames while trace is running."));
2542 if (args
== 0 || *args
== 0)
2544 if (tracepoint_number
== -1)
2545 error (_("No current tracepoint -- please supply an argument."));
2547 tdp
= tracepoint_number
; /* Default is current TDP. */
2550 tdp
= parse_and_eval_long (args
);
2552 /* If we have the tracepoint on hand, use the number that the
2553 target knows about (which may be different if we disconnected
2554 and reconnected). */
2555 tp
= get_tracepoint (tdp
);
2557 tdp
= tp
->number_on_target
;
2559 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2562 /* TFIND LINE command:
2564 This command will take a sourceline for argument, just like BREAK
2565 or TRACE (ie. anything that "decode_line_1" can handle).
2567 With no argument, this command will find the next trace frame
2568 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2571 trace_find_line_command (char *args
, int from_tty
)
2573 static CORE_ADDR start_pc
, end_pc
;
2574 struct symtabs_and_lines sals
;
2575 struct symtab_and_line sal
;
2576 struct cleanup
*old_chain
;
2578 if (current_trace_status ()->running
2579 && current_trace_status ()->filename
== NULL
)
2580 error (_("May not look at trace frames while trace is running."));
2582 if (args
== 0 || *args
== 0)
2584 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2586 sals
.sals
= (struct symtab_and_line
*)
2587 xmalloc (sizeof (struct symtab_and_line
));
2592 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2596 old_chain
= make_cleanup (xfree
, sals
.sals
);
2597 if (sal
.symtab
== 0)
2598 error (_("No line number information available."));
2600 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2602 if (start_pc
== end_pc
)
2604 printf_filtered ("Line %d of \"%s\"",
2606 symtab_to_filename_for_display (sal
.symtab
));
2608 printf_filtered (" is at address ");
2609 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2611 printf_filtered (" but contains no code.\n");
2612 sal
= find_pc_line (start_pc
, 0);
2614 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2615 && start_pc
!= end_pc
)
2616 printf_filtered ("Attempting to find line %d instead.\n",
2619 error (_("Cannot find a good line."));
2623 /* Is there any case in which we get here, and have an address
2624 which the user would want to see? If we have debugging
2625 symbols and no line numbers? */
2626 error (_("Line number %d is out of range for \"%s\"."),
2627 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2629 /* Find within range of stated line. */
2631 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2633 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2634 do_cleanups (old_chain
);
2637 /* tfind range command */
2639 trace_find_range_command (char *args
, int from_tty
)
2641 static CORE_ADDR start
, stop
;
2644 if (current_trace_status ()->running
2645 && current_trace_status ()->filename
== NULL
)
2646 error (_("May not look at trace frames while trace is running."));
2648 if (args
== 0 || *args
== 0)
2649 { /* XXX FIXME: what should default behavior be? */
2650 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2654 if (0 != (tmp
= strchr (args
, ',')))
2656 *tmp
++ = '\0'; /* Terminate start address. */
2657 tmp
= skip_spaces (tmp
);
2658 start
= parse_and_eval_address (args
);
2659 stop
= parse_and_eval_address (tmp
);
2662 { /* No explicit end address? */
2663 start
= parse_and_eval_address (args
);
2664 stop
= start
+ 1; /* ??? */
2667 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2670 /* tfind outside command */
2672 trace_find_outside_command (char *args
, int from_tty
)
2674 CORE_ADDR start
, stop
;
2677 if (current_trace_status ()->running
2678 && current_trace_status ()->filename
== NULL
)
2679 error (_("May not look at trace frames while trace is running."));
2681 if (args
== 0 || *args
== 0)
2682 { /* XXX FIXME: what should default behavior be? */
2683 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2687 if (0 != (tmp
= strchr (args
, ',')))
2689 *tmp
++ = '\0'; /* Terminate start address. */
2690 tmp
= skip_spaces (tmp
);
2691 start
= parse_and_eval_address (args
);
2692 stop
= parse_and_eval_address (tmp
);
2695 { /* No explicit end address? */
2696 start
= parse_and_eval_address (args
);
2697 stop
= start
+ 1; /* ??? */
2700 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2703 /* info scope command: list the locals for a scope. */
2705 scope_info (char *args
, int from_tty
)
2707 struct symtabs_and_lines sals
;
2709 struct minimal_symbol
*msym
;
2710 struct block
*block
;
2711 const char *symname
;
2712 char *save_args
= args
;
2713 struct block_iterator iter
;
2715 struct gdbarch
*gdbarch
;
2718 if (args
== 0 || *args
== 0)
2719 error (_("requires an argument (function, "
2720 "line or *addr) to define a scope"));
2722 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2723 if (sals
.nelts
== 0)
2724 return; /* Presumably decode_line_1 has already warned. */
2726 /* Resolve line numbers to PC. */
2727 resolve_sal_pc (&sals
.sals
[0]);
2728 block
= block_for_pc (sals
.sals
[0].pc
);
2732 QUIT
; /* Allow user to bail out with ^C. */
2733 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2735 QUIT
; /* Allow user to bail out with ^C. */
2737 printf_filtered ("Scope for %s:\n", save_args
);
2740 symname
= SYMBOL_PRINT_NAME (sym
);
2741 if (symname
== NULL
|| *symname
== '\0')
2742 continue; /* Probably botched, certainly useless. */
2744 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2746 printf_filtered ("Symbol %s is ", symname
);
2748 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2749 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2750 BLOCK_START (block
),
2754 switch (SYMBOL_CLASS (sym
))
2757 case LOC_UNDEF
: /* Messed up symbol? */
2758 printf_filtered ("a bogus symbol, class %d.\n",
2759 SYMBOL_CLASS (sym
));
2760 count
--; /* Don't count this one. */
2763 printf_filtered ("a constant with value %s (%s)",
2764 plongest (SYMBOL_VALUE (sym
)),
2765 hex_string (SYMBOL_VALUE (sym
)));
2767 case LOC_CONST_BYTES
:
2768 printf_filtered ("constant bytes: ");
2769 if (SYMBOL_TYPE (sym
))
2770 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2771 fprintf_filtered (gdb_stdout
, " %02x",
2772 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2775 printf_filtered ("in static storage at address ");
2776 printf_filtered ("%s", paddress (gdbarch
,
2777 SYMBOL_VALUE_ADDRESS (sym
)));
2780 /* GDBARCH is the architecture associated with the objfile
2781 the symbol is defined in; the target architecture may be
2782 different, and may provide additional registers. However,
2783 we do not know the target architecture at this point.
2784 We assume the objfile architecture will contain all the
2785 standard registers that occur in debug info in that
2787 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2790 if (SYMBOL_IS_ARGUMENT (sym
))
2791 printf_filtered ("an argument in register $%s",
2792 gdbarch_register_name (gdbarch
, regno
));
2794 printf_filtered ("a local variable in register $%s",
2795 gdbarch_register_name (gdbarch
, regno
));
2798 printf_filtered ("an argument at stack/frame offset %s",
2799 plongest (SYMBOL_VALUE (sym
)));
2802 printf_filtered ("a local variable at frame offset %s",
2803 plongest (SYMBOL_VALUE (sym
)));
2806 printf_filtered ("a reference argument at offset %s",
2807 plongest (SYMBOL_VALUE (sym
)));
2809 case LOC_REGPARM_ADDR
:
2810 /* Note comment at LOC_REGISTER. */
2811 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2813 printf_filtered ("the address of an argument, in register $%s",
2814 gdbarch_register_name (gdbarch
, regno
));
2817 printf_filtered ("a typedef.\n");
2820 printf_filtered ("a label at address ");
2821 printf_filtered ("%s", paddress (gdbarch
,
2822 SYMBOL_VALUE_ADDRESS (sym
)));
2825 printf_filtered ("a function at address ");
2826 printf_filtered ("%s",
2827 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2829 case LOC_UNRESOLVED
:
2830 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2833 printf_filtered ("Unresolved Static");
2836 printf_filtered ("static storage at address ");
2837 printf_filtered ("%s",
2839 SYMBOL_VALUE_ADDRESS (msym
)));
2842 case LOC_OPTIMIZED_OUT
:
2843 printf_filtered ("optimized out.\n");
2846 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2849 if (SYMBOL_TYPE (sym
))
2850 printf_filtered (", length %d.\n",
2851 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2853 if (BLOCK_FUNCTION (block
))
2856 block
= BLOCK_SUPERBLOCK (block
);
2859 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2863 /* Helper for trace_dump_command. Dump the action list starting at
2864 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2865 actions of the body of a while-stepping action. STEPPING_FRAME is
2866 set if the current traceframe was determined to be a while-stepping
2870 trace_dump_actions (struct command_line
*action
,
2871 int stepping_actions
, int stepping_frame
,
2874 const char *action_exp
, *next_comma
;
2876 for (; action
!= NULL
; action
= action
->next
)
2878 struct cmd_list_element
*cmd
;
2880 QUIT
; /* Allow user to bail out with ^C. */
2881 action_exp
= action
->line
;
2882 action_exp
= skip_spaces_const (action_exp
);
2884 /* The collection actions to be done while stepping are
2885 bracketed by the commands "while-stepping" and "end". */
2887 if (*action_exp
== '#') /* comment line */
2890 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2892 error (_("Bad action list item: %s"), action_exp
);
2894 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2898 for (i
= 0; i
< action
->body_count
; ++i
)
2899 trace_dump_actions (action
->body_list
[i
],
2900 1, stepping_frame
, from_tty
);
2902 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2904 /* Display the collected data.
2905 For the trap frame, display only what was collected at
2906 the trap. Likewise for stepping frames, display only
2907 what was collected while stepping. This means that the
2908 two boolean variables, STEPPING_FRAME and
2909 STEPPING_ACTIONS should be equal. */
2910 if (stepping_frame
== stepping_actions
)
2913 struct cleanup
*old_chain
2914 = make_cleanup (free_current_contents
, &cmd
);
2915 int trace_string
= 0;
2917 if (*action_exp
== '/')
2918 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2921 { /* Repeat over a comma-separated list. */
2922 QUIT
; /* Allow user to bail out with ^C. */
2923 if (*action_exp
== ',')
2925 action_exp
= skip_spaces_const (action_exp
);
2927 next_comma
= strchr (action_exp
, ',');
2929 if (0 == strncasecmp (action_exp
, "$reg", 4))
2930 registers_info (NULL
, from_tty
);
2931 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2933 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2934 locals_info (NULL
, from_tty
);
2935 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2936 args_info (NULL
, from_tty
);
2939 if (next_comma
!= NULL
)
2941 size_t len
= next_comma
- action_exp
;
2943 cmd
= xrealloc (cmd
, len
+ 1);
2944 memcpy (cmd
, action_exp
, len
);
2949 size_t len
= strlen (action_exp
);
2951 cmd
= xrealloc (cmd
, len
+ 1);
2952 memcpy (cmd
, action_exp
, len
+ 1);
2955 printf_filtered ("%s = ", cmd
);
2956 output_command_const (cmd
, from_tty
);
2957 printf_filtered ("\n");
2959 action_exp
= next_comma
;
2961 while (action_exp
&& *action_exp
== ',');
2963 do_cleanups (old_chain
);
2969 /* Return bp_location of the tracepoint associated with the current
2970 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2971 is a stepping traceframe. */
2973 struct bp_location
*
2974 get_traceframe_location (int *stepping_frame_p
)
2976 struct tracepoint
*t
;
2977 struct bp_location
*tloc
;
2978 struct regcache
*regcache
;
2980 if (tracepoint_number
== -1)
2981 error (_("No current trace frame."));
2983 t
= get_tracepoint (tracepoint_number
);
2986 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2989 /* The current frame is a trap frame if the frame PC is equal to the
2990 tracepoint PC. If not, then the current frame was collected
2991 during single-stepping. */
2992 regcache
= get_current_regcache ();
2994 /* If the traceframe's address matches any of the tracepoint's
2995 locations, assume it is a direct hit rather than a while-stepping
2996 frame. (FIXME this is not reliable, should record each frame's
2998 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
2999 if (tloc
->address
== regcache_read_pc (regcache
))
3001 *stepping_frame_p
= 0;
3005 /* If this is a stepping frame, we don't know which location
3006 triggered. The first is as good (or bad) a guess as any... */
3007 *stepping_frame_p
= 1;
3011 /* Return all the actions, including default collect, of a tracepoint
3012 T. It constructs cleanups into the chain, and leaves the caller to
3013 handle them (call do_cleanups). */
3015 static struct command_line
*
3016 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3018 struct command_line
*actions
;
3020 actions
= breakpoint_commands (t
);
3022 /* If there are default expressions to collect, make up a collect
3023 action and prepend to the action list to encode. Note that since
3024 validation is per-tracepoint (local var "xyz" might be valid for
3025 one tracepoint and not another, etc), we make up the action on
3026 the fly, and don't cache it. */
3027 if (*default_collect
)
3029 struct command_line
*default_collect_action
;
3030 char *default_collect_line
;
3032 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3033 make_cleanup (xfree
, default_collect_line
);
3035 validate_actionline (default_collect_line
, t
);
3036 default_collect_action
= xmalloc (sizeof (struct command_line
));
3037 make_cleanup (xfree
, default_collect_action
);
3038 default_collect_action
->next
= actions
;
3039 default_collect_action
->line
= default_collect_line
;
3040 actions
= default_collect_action
;
3046 /* The tdump command. */
3049 trace_dump_command (char *args
, int from_tty
)
3051 int stepping_frame
= 0;
3052 struct bp_location
*loc
;
3053 struct cleanup
*old_chain
;
3054 struct command_line
*actions
;
3056 /* This throws an error is not inspecting a trace frame. */
3057 loc
= get_traceframe_location (&stepping_frame
);
3059 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3060 tracepoint_number
, traceframe_number
);
3062 old_chain
= make_cleanup (null_cleanup
, NULL
);
3064 /* This command only makes sense for the current frame, not the
3066 make_cleanup_restore_current_thread ();
3067 select_frame (get_current_frame ());
3069 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3071 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3073 do_cleanups (old_chain
);
3076 /* Encode a piece of a tracepoint's source-level definition in a form
3077 that is suitable for both protocol and saving in files. */
3078 /* This version does not do multiple encodes for long strings; it should
3079 return an offset to the next piece to encode. FIXME */
3082 encode_source_string (int tpnum
, ULONGEST addr
,
3083 char *srctype
, char *src
, char *buf
, int buf_size
)
3085 if (80 + strlen (srctype
) > buf_size
)
3086 error (_("Buffer too small for source encoding"));
3087 sprintf (buf
, "%x:%s:%s:%x:%x:",
3088 tpnum
, phex_nz (addr
, sizeof (addr
)),
3089 srctype
, 0, (int) strlen (src
));
3090 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3091 error (_("Source string too long for buffer"));
3092 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3096 /* Free trace file writer. */
3099 trace_file_writer_xfree (void *arg
)
3101 struct trace_file_writer
*writer
= arg
;
3103 writer
->ops
->dtor (writer
);
3107 /* TFILE trace writer. */
3109 struct tfile_trace_file_writer
3111 struct trace_file_writer base
;
3113 /* File pointer to tfile trace file. */
3115 /* Path name of the tfile trace file. */
3119 /* This is the implementation of trace_file_write_ops method
3120 target_save. We just call the generic target
3121 target_save_trace_data to do target-side saving. */
3124 tfile_target_save (struct trace_file_writer
*self
,
3125 const char *filename
)
3127 int err
= target_save_trace_data (filename
);
3132 /* This is the implementation of trace_file_write_ops method
3136 tfile_dtor (struct trace_file_writer
*self
)
3138 struct tfile_trace_file_writer
*writer
3139 = (struct tfile_trace_file_writer
*) self
;
3141 xfree (writer
->pathname
);
3143 if (writer
->fp
!= NULL
)
3144 fclose (writer
->fp
);
3147 /* This is the implementation of trace_file_write_ops method
3148 start. It creates the trace file FILENAME and registers some
3152 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3154 struct tfile_trace_file_writer
*writer
3155 = (struct tfile_trace_file_writer
*) self
;
3157 writer
->pathname
= tilde_expand (filename
);
3158 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3159 if (writer
->fp
== NULL
)
3160 error (_("Unable to open file '%s' for saving trace data (%s)"),
3161 writer
->pathname
, safe_strerror (errno
));
3164 /* This is the implementation of trace_file_write_ops method
3165 write_header. Write the TFILE header. */
3168 tfile_write_header (struct trace_file_writer
*self
)
3170 struct tfile_trace_file_writer
*writer
3171 = (struct tfile_trace_file_writer
*) self
;
3174 /* Write a file header, with a high-bit-set char to indicate a
3175 binary file, plus a hint as what this file is, and a version
3176 number in case of future needs. */
3177 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3179 perror_with_name (writer
->pathname
);
3182 /* This is the implementation of trace_file_write_ops method
3183 write_regblock_type. Write the size of register block. */
3186 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3188 struct tfile_trace_file_writer
*writer
3189 = (struct tfile_trace_file_writer
*) self
;
3191 fprintf (writer
->fp
, "R %x\n", size
);
3194 /* This is the implementation of trace_file_write_ops method
3198 tfile_write_status (struct trace_file_writer
*self
,
3199 struct trace_status
*ts
)
3201 struct tfile_trace_file_writer
*writer
3202 = (struct tfile_trace_file_writer
*) self
;
3204 fprintf (writer
->fp
, "status %c;%s",
3205 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3206 if (ts
->stop_reason
== tracepoint_error
3207 || ts
->stop_reason
== tstop_command
)
3209 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3211 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3212 fprintf (writer
->fp
, ":%s", buf
);
3214 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3215 if (ts
->traceframe_count
>= 0)
3216 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3217 if (ts
->traceframes_created
>= 0)
3218 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3219 if (ts
->buffer_free
>= 0)
3220 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3221 if (ts
->buffer_size
>= 0)
3222 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3223 if (ts
->disconnected_tracing
)
3224 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3225 if (ts
->circular_buffer
)
3226 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3229 fprintf (writer
->fp
, ";starttime:%s",
3230 phex_nz (ts
->start_time
, sizeof (ts
->start_time
)));
3234 fprintf (writer
->fp
, ";stoptime:%s",
3235 phex_nz (ts
->stop_time
, sizeof (ts
->stop_time
)));
3237 if (ts
->notes
!= NULL
)
3239 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3241 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3242 fprintf (writer
->fp
, ";notes:%s", buf
);
3244 if (ts
->user_name
!= NULL
)
3246 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3248 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3249 fprintf (writer
->fp
, ";username:%s", buf
);
3251 fprintf (writer
->fp
, "\n");
3254 /* This is the implementation of trace_file_write_ops method
3255 write_uploaded_tsv. */
3258 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3259 struct uploaded_tsv
*utsv
)
3262 struct tfile_trace_file_writer
*writer
3263 = (struct tfile_trace_file_writer
*) self
;
3267 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3268 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3271 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3272 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3273 utsv
->builtin
, buf
);
3279 #define MAX_TRACE_UPLOAD 2000
3281 /* This is the implementation of trace_file_write_ops method
3282 write_uploaded_tp. */
3285 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3286 struct uploaded_tp
*utp
)
3288 struct tfile_trace_file_writer
*writer
3289 = (struct tfile_trace_file_writer
*) self
;
3292 char buf
[MAX_TRACE_UPLOAD
];
3294 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3295 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3296 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3297 if (utp
->type
== bp_fast_tracepoint
)
3298 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3300 fprintf (writer
->fp
,
3301 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3303 fprintf (writer
->fp
, "\n");
3304 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3305 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3306 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3307 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3308 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3309 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3312 encode_source_string (utp
->number
, utp
->addr
,
3313 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3314 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3316 if (utp
->cond_string
)
3318 encode_source_string (utp
->number
, utp
->addr
,
3319 "cond", utp
->cond_string
,
3320 buf
, MAX_TRACE_UPLOAD
);
3321 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3323 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3325 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3326 buf
, MAX_TRACE_UPLOAD
);
3327 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3329 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3330 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3332 phex_nz (utp
->traceframe_usage
,
3333 sizeof (utp
->traceframe_usage
)));
3336 /* This is the implementation of trace_file_write_ops method
3337 write_definition_end. */
3340 tfile_write_definition_end (struct trace_file_writer
*self
)
3342 struct tfile_trace_file_writer
*writer
3343 = (struct tfile_trace_file_writer
*) self
;
3345 fprintf (writer
->fp
, "\n");
3348 /* This is the implementation of trace_file_write_ops method
3352 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3355 struct tfile_trace_file_writer
*writer
3356 = (struct tfile_trace_file_writer
*) self
;
3358 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3359 perror_with_name (writer
->pathname
);
3362 /* This is the implementation of trace_file_write_ops method
3366 tfile_end (struct trace_file_writer
*self
)
3368 struct tfile_trace_file_writer
*writer
3369 = (struct tfile_trace_file_writer
*) self
;
3370 uint32_t gotten
= 0;
3372 /* Mark the end of trace data. */
3373 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3374 perror_with_name (writer
->pathname
);
3377 /* Operations to write trace buffers into TFILE format. */
3379 static const struct trace_file_write_ops tfile_write_ops
=
3385 tfile_write_regblock_type
,
3387 tfile_write_uploaded_tsv
,
3388 tfile_write_uploaded_tp
,
3389 tfile_write_definition_end
,
3390 tfile_write_raw_data
,
3395 /* Helper macros. */
3397 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3398 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3399 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3400 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3402 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3403 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3405 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3406 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3408 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3409 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3410 the save is performed on the target, otherwise GDB obtains all trace
3411 data and saves it locally. */
3414 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3415 int target_does_save
)
3417 struct trace_status
*ts
= current_trace_status ();
3419 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3420 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3422 ULONGEST offset
= 0;
3423 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3424 #define MAX_TRACE_UPLOAD 2000
3426 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3428 /* If the target is to save the data to a file on its own, then just
3429 send the command and be done with it. */
3430 if (target_does_save
)
3432 if (!writer
->ops
->target_save (writer
, filename
))
3433 error (_("Target failed to save trace data to '%s'."),
3438 /* Get the trace status first before opening the file, so if the
3439 target is losing, we can get out without touching files. */
3440 status
= target_get_trace_status (ts
);
3442 writer
->ops
->start (writer
, filename
);
3444 writer
->ops
->write_header (writer
);
3446 /* Write descriptive info. */
3448 /* Write out the size of a register block. */
3449 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3451 /* Write out status of the tracing run (aka "tstatus" info). */
3452 writer
->ops
->write_status (writer
, ts
);
3454 /* Note that we want to upload tracepoints and save those, rather
3455 than simply writing out the local ones, because the user may have
3456 changed tracepoints in GDB in preparation for a future tracing
3457 run, or maybe just mass-deleted all types of breakpoints as part
3458 of cleaning up. So as not to contaminate the session, leave the
3459 data in its uploaded form, don't make into real tracepoints. */
3461 /* Get trace state variables first, they may be checked when parsing
3462 uploaded commands. */
3464 target_upload_trace_state_variables (&uploaded_tsvs
);
3466 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3467 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3469 free_uploaded_tsvs (&uploaded_tsvs
);
3471 target_upload_tracepoints (&uploaded_tps
);
3473 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3474 target_get_tracepoint_status (NULL
, utp
);
3476 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3477 writer
->ops
->write_uploaded_tp (writer
, utp
);
3479 free_uploaded_tps (&uploaded_tps
);
3481 /* Mark the end of the definition section. */
3482 writer
->ops
->write_definition_end (writer
);
3484 /* Get and write the trace data proper. */
3489 /* The writer supports writing the contents of trace buffer
3490 directly to trace file. Don't parse the contents of trace
3492 if (writer
->ops
->write_trace_buffer
!= NULL
)
3494 /* We ask for big blocks, in the hopes of efficiency, but
3495 will take less if the target has packet size limitations
3497 gotten
= target_get_raw_trace_data (buf
, offset
,
3500 error (_("Failure to get requested trace buffer data"));
3501 /* No more data is forthcoming, we're done. */
3505 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3513 /* Parse the trace buffers according to how data are stored
3514 in trace buffer in GDBserver. */
3516 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3521 /* Read the first six bytes in, which is the tracepoint
3522 number and trace frame size. */
3524 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3526 tf_size
= (uint32_t)
3527 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3529 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3538 for (block
= 0; block
< tf_size
; )
3540 gdb_byte block_type
;
3542 /* We'll fetch one block each time, in order to
3543 handle the extremely large 'M' block. We first
3544 fetch one byte to get the type of the block. */
3545 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3547 error (_("Failure to get requested trace buffer data"));
3553 block_type
= buf
[0];
3558 = target_get_raw_trace_data (buf
, offset
,
3559 trace_regblock_size
);
3560 if (gotten
< trace_regblock_size
)
3561 error (_("Failure to get requested trace"
3564 TRACE_WRITE_R_BLOCK (writer
, buf
,
3565 trace_regblock_size
);
3569 unsigned short mlen
;
3574 t
= target_get_raw_trace_data (buf
,offset
, 10);
3576 error (_("Failure to get requested trace"
3584 extract_unsigned_integer (buf
, 8,
3586 mlen
= (unsigned short)
3587 extract_unsigned_integer (&buf
[8], 2,
3590 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3593 /* The memory contents in 'M' block may be
3594 very large. Fetch the data from the target
3595 and write them into file one by one. */
3596 for (j
= 0; j
< mlen
; )
3598 unsigned int read_length
;
3600 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3601 read_length
= MAX_TRACE_UPLOAD
;
3603 read_length
= mlen
- j
;
3605 t
= target_get_raw_trace_data (buf
,
3608 if (t
< read_length
)
3609 error (_("Failure to get requested"
3610 " trace buffer data"));
3612 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3616 gotten
+= read_length
;
3627 = target_get_raw_trace_data (buf
, offset
,
3630 error (_("Failure to get requested"
3631 " trace buffer data"));
3633 vnum
= (int) extract_signed_integer (buf
,
3637 = extract_signed_integer (&buf
[4], 8,
3640 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3644 error (_("Unknown block type '%c' (0x%x) in"
3646 block_type
, block_type
);
3656 writer
->ops
->frame_ops
->end (writer
);
3660 writer
->ops
->end (writer
);
3663 /* Return a trace writer for TFILE format. */
3665 static struct trace_file_writer
*
3666 tfile_trace_file_writer_new (void)
3668 struct tfile_trace_file_writer
*writer
3669 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3671 writer
->base
.ops
= &tfile_write_ops
;
3673 writer
->pathname
= NULL
;
3675 return (struct trace_file_writer
*) writer
;
3679 trace_save_command (char *args
, int from_tty
)
3681 int target_does_save
= 0;
3683 char *filename
= NULL
;
3684 struct cleanup
*back_to
;
3685 int generate_ctf
= 0;
3686 struct trace_file_writer
*writer
= NULL
;
3689 error_no_arg (_("file in which to save trace data"));
3691 argv
= gdb_buildargv (args
);
3692 back_to
= make_cleanup_freeargv (argv
);
3694 for (; *argv
; ++argv
)
3696 if (strcmp (*argv
, "-r") == 0)
3697 target_does_save
= 1;
3698 if (strcmp (*argv
, "-ctf") == 0)
3700 else if (**argv
== '-')
3701 error (_("unknown option `%s'"), *argv
);
3707 error_no_arg (_("file in which to save trace data"));
3710 writer
= ctf_trace_file_writer_new ();
3712 writer
= tfile_trace_file_writer_new ();
3714 make_cleanup (trace_file_writer_xfree
, writer
);
3716 trace_save (filename
, writer
, target_does_save
);
3719 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3720 generate_ctf
? "directory" : "file", filename
);
3722 do_cleanups (back_to
);
3725 /* Save the trace data to file FILENAME of tfile format. */
3728 trace_save_tfile (const char *filename
, int target_does_save
)
3730 struct trace_file_writer
*writer
;
3731 struct cleanup
*back_to
;
3733 writer
= tfile_trace_file_writer_new ();
3734 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3735 trace_save (filename
, writer
, target_does_save
);
3736 do_cleanups (back_to
);
3739 /* Save the trace data to dir DIRNAME of ctf format. */
3742 trace_save_ctf (const char *dirname
, int target_does_save
)
3744 struct trace_file_writer
*writer
;
3745 struct cleanup
*back_to
;
3747 writer
= ctf_trace_file_writer_new ();
3748 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3750 trace_save (dirname
, writer
, target_does_save
);
3751 do_cleanups (back_to
);
3754 /* Tell the target what to do with an ongoing tracing run if GDB
3755 disconnects for some reason. */
3758 set_disconnected_tracing (char *args
, int from_tty
,
3759 struct cmd_list_element
*c
)
3761 target_set_disconnected_tracing (disconnected_tracing
);
3765 set_circular_trace_buffer (char *args
, int from_tty
,
3766 struct cmd_list_element
*c
)
3768 target_set_circular_trace_buffer (circular_trace_buffer
);
3772 set_trace_buffer_size (char *args
, int from_tty
,
3773 struct cmd_list_element
*c
)
3775 target_set_trace_buffer_size (trace_buffer_size
);
3779 set_trace_user (char *args
, int from_tty
,
3780 struct cmd_list_element
*c
)
3784 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3787 warning (_("Target does not support trace notes, user ignored"));
3791 set_trace_notes (char *args
, int from_tty
,
3792 struct cmd_list_element
*c
)
3796 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3799 warning (_("Target does not support trace notes, note ignored"));
3803 set_trace_stop_notes (char *args
, int from_tty
,
3804 struct cmd_list_element
*c
)
3808 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3811 warning (_("Target does not support trace notes, stop note ignored"));
3814 /* Convert the memory pointed to by mem into hex, placing result in buf.
3815 * Return a pointer to the last char put in buf (null)
3816 * "stolen" from sparc-stub.c
3819 static const char hexchars
[] = "0123456789abcdef";
3822 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3830 *buf
++ = hexchars
[ch
>> 4];
3831 *buf
++ = hexchars
[ch
& 0xf];
3840 get_traceframe_number (void)
3842 return traceframe_number
;
3846 get_tracepoint_number (void)
3848 return tracepoint_number
;
3851 /* Make the traceframe NUM be the current trace frame. Does nothing
3852 if NUM is already current. */
3855 set_current_traceframe (int num
)
3859 if (traceframe_number
== num
)
3861 /* Nothing to do. */
3865 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3868 warning (_("could not change traceframe"));
3870 set_traceframe_num (newnum
);
3872 /* Changing the traceframe changes our view of registers and of the
3874 registers_changed ();
3876 clear_traceframe_info ();
3879 /* Make the traceframe NUM be the current trace frame, and do nothing
3883 set_traceframe_number (int num
)
3885 traceframe_number
= num
;
3888 /* A cleanup used when switching away and back from tfind mode. */
3890 struct current_traceframe_cleanup
3892 /* The traceframe we were inspecting. */
3893 int traceframe_number
;
3897 do_restore_current_traceframe_cleanup (void *arg
)
3899 struct current_traceframe_cleanup
*old
= arg
;
3901 set_current_traceframe (old
->traceframe_number
);
3905 restore_current_traceframe_cleanup_dtor (void *arg
)
3907 struct current_traceframe_cleanup
*old
= arg
;
3913 make_cleanup_restore_current_traceframe (void)
3915 struct current_traceframe_cleanup
*old
;
3917 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3918 old
->traceframe_number
= traceframe_number
;
3920 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3921 restore_current_traceframe_cleanup_dtor
);
3925 make_cleanup_restore_traceframe_number (void)
3927 return make_cleanup_restore_integer (&traceframe_number
);
3930 /* Given a number and address, return an uploaded tracepoint with that
3931 number, creating if necessary. */
3933 struct uploaded_tp
*
3934 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3936 struct uploaded_tp
*utp
;
3938 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3939 if (utp
->number
== num
&& utp
->addr
== addr
)
3941 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3942 memset (utp
, 0, sizeof (struct uploaded_tp
));
3945 utp
->actions
= NULL
;
3946 utp
->step_actions
= NULL
;
3947 utp
->cmd_strings
= NULL
;
3954 free_uploaded_tps (struct uploaded_tp
**utpp
)
3956 struct uploaded_tp
*next_one
;
3960 next_one
= (*utpp
)->next
;
3966 /* Given a number and address, return an uploaded tracepoint with that
3967 number, creating if necessary. */
3969 struct uploaded_tsv
*
3970 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3972 struct uploaded_tsv
*utsv
;
3974 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3975 if (utsv
->number
== num
)
3977 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3978 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3980 utsv
->next
= *utsvp
;
3986 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3988 struct uploaded_tsv
*next_one
;
3992 next_one
= (*utsvp
)->next
;
3998 /* FIXME this function is heuristic and will miss the cases where the
3999 conditional is semantically identical but differs in whitespace,
4000 such as "x == 0" vs "x==0". */
4003 cond_string_is_same (char *str1
, char *str2
)
4005 if (str1
== NULL
|| str2
== NULL
)
4006 return (str1
== str2
);
4008 return (strcmp (str1
, str2
) == 0);
4011 /* Look for an existing tracepoint that seems similar enough to the
4012 uploaded one. Enablement isn't compared, because the user can
4013 toggle that freely, and may have done so in anticipation of the
4014 next trace run. Return the location of matched tracepoint. */
4016 static struct bp_location
*
4017 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
4019 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
4021 struct breakpoint
*b
;
4022 struct bp_location
*loc
;
4024 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
4026 struct tracepoint
*t
= (struct tracepoint
*) b
;
4028 if (b
->type
== utp
->type
4029 && t
->step_count
== utp
->step
4030 && t
->pass_count
== utp
->pass
4031 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
4032 /* FIXME also test actions. */
4035 /* Scan the locations for an address match. */
4036 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4038 if (loc
->address
== utp
->addr
)
4046 /* Given a list of tracepoints uploaded from a target, attempt to
4047 match them up with existing tracepoints, and create new ones if not
4051 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
4053 struct uploaded_tp
*utp
;
4054 /* A set of tracepoints which are modified. */
4055 VEC(breakpoint_p
) *modified_tp
= NULL
;
4057 struct breakpoint
*b
;
4059 /* Look for GDB tracepoints that match up with our uploaded versions. */
4060 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
4062 struct bp_location
*loc
;
4063 struct tracepoint
*t
;
4065 loc
= find_matching_tracepoint_location (utp
);
4070 /* Mark this location as already inserted. */
4072 t
= (struct tracepoint
*) loc
->owner
;
4073 printf_filtered (_("Assuming tracepoint %d is same "
4074 "as target's tracepoint %d at %s.\n"),
4075 loc
->owner
->number
, utp
->number
,
4076 paddress (loc
->gdbarch
, utp
->addr
));
4078 /* The tracepoint LOC->owner was modified (the location LOC
4079 was marked as inserted in the target). Save it in
4080 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4081 observers will be notified later once for each tracepoint
4082 saved in MODIFIED_TP. */
4084 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
4086 if (b
== loc
->owner
)
4092 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
4096 t
= create_tracepoint_from_upload (utp
);
4098 printf_filtered (_("Created tracepoint %d for "
4099 "target's tracepoint %d at %s.\n"),
4100 t
->base
.number
, utp
->number
,
4101 paddress (get_current_arch (), utp
->addr
));
4103 printf_filtered (_("Failed to create tracepoint for target's "
4104 "tracepoint %d at %s, skipping it.\n"),
4106 paddress (get_current_arch (), utp
->addr
));
4108 /* Whether found or created, record the number used by the
4109 target, to help with mapping target tracepoints back to their
4110 counterparts here. */
4112 t
->number_on_target
= utp
->number
;
4115 /* Notify 'breakpoint-modified' observer that at least one of B's
4116 locations was changed. */
4117 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4118 observer_notify_breakpoint_modified (b
);
4120 VEC_free (breakpoint_p
, modified_tp
);
4121 free_uploaded_tps (uploaded_tps
);
4124 /* Trace state variables don't have much to identify them beyond their
4125 name, so just use that to detect matches. */
4127 static struct trace_state_variable
*
4128 find_matching_tsv (struct uploaded_tsv
*utsv
)
4133 return find_trace_state_variable (utsv
->name
);
4136 static struct trace_state_variable
*
4137 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4139 const char *namebase
;
4142 struct trace_state_variable
*tsv
;
4143 struct cleanup
*old_chain
;
4147 namebase
= utsv
->name
;
4148 buf
= xstrprintf ("%s", namebase
);
4153 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4156 /* Fish for a name that is not in use. */
4157 /* (should check against all internal vars?) */
4158 while (find_trace_state_variable (buf
))
4161 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4164 old_chain
= make_cleanup (xfree
, buf
);
4166 /* We have an available name, create the variable. */
4167 tsv
= create_trace_state_variable (buf
);
4168 tsv
->initial_value
= utsv
->initial_value
;
4169 tsv
->builtin
= utsv
->builtin
;
4171 observer_notify_tsv_created (tsv
);
4173 do_cleanups (old_chain
);
4178 /* Given a list of uploaded trace state variables, try to match them
4179 up with existing variables, or create additional ones. */
4182 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4185 struct uploaded_tsv
*utsv
;
4186 struct trace_state_variable
*tsv
;
4189 /* Most likely some numbers will have to be reassigned as part of
4190 the merge, so clear them all in anticipation. */
4191 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4194 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4196 tsv
= find_matching_tsv (utsv
);
4200 printf_filtered (_("Assuming trace state variable $%s "
4201 "is same as target's variable %d.\n"),
4202 tsv
->name
, utsv
->number
);
4206 tsv
= create_tsv_from_upload (utsv
);
4208 printf_filtered (_("Created trace state variable "
4209 "$%s for target's variable %d.\n"),
4210 tsv
->name
, utsv
->number
);
4212 /* Give precedence to numberings that come from the target. */
4214 tsv
->number
= utsv
->number
;
4217 /* Renumber everything that didn't get a target-assigned number. */
4219 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4220 if (tsv
->number
> highest
)
4221 highest
= tsv
->number
;
4224 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4225 if (tsv
->number
== 0)
4226 tsv
->number
= highest
++;
4228 free_uploaded_tsvs (uploaded_tsvs
);
4231 /* target tfile command */
4233 static struct target_ops tfile_ops
;
4235 /* Fill in tfile_ops with its defined operations and properties. */
4237 #define TRACE_HEADER_SIZE 8
4239 static char *trace_filename
;
4240 static int trace_fd
= -1;
4241 static off_t trace_frames_offset
;
4242 static off_t cur_offset
;
4243 static int cur_data_size
;
4244 int trace_regblock_size
;
4246 static void tfile_interp_line (char *line
,
4247 struct uploaded_tp
**utpp
,
4248 struct uploaded_tsv
**utsvp
);
4250 /* Read SIZE bytes into READBUF from the trace frame, starting at
4251 TRACE_FD's current position. Note that this call `read'
4252 underneath, hence it advances the file's seek position. Throws an
4253 error if the `read' syscall fails, or less than SIZE bytes are
4257 tfile_read (gdb_byte
*readbuf
, int size
)
4261 gotten
= read (trace_fd
, readbuf
, size
);
4263 perror_with_name (trace_filename
);
4264 else if (gotten
< size
)
4265 error (_("Premature end of file while reading trace file"));
4269 tfile_open (char *filename
, int from_tty
)
4271 volatile struct gdb_exception ex
;
4273 struct cleanup
*old_chain
;
4276 char header
[TRACE_HEADER_SIZE
];
4277 char linebuf
[1000]; /* Should be max remote packet size or so. */
4280 struct trace_status
*ts
;
4281 struct uploaded_tp
*uploaded_tps
= NULL
;
4282 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4284 target_preopen (from_tty
);
4286 error (_("No trace file specified."));
4288 filename
= tilde_expand (filename
);
4289 if (!IS_ABSOLUTE_PATH(filename
))
4291 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4296 old_chain
= make_cleanup (xfree
, filename
);
4298 flags
= O_BINARY
| O_LARGEFILE
;
4300 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4301 if (scratch_chan
< 0)
4302 perror_with_name (filename
);
4304 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4306 discard_cleanups (old_chain
); /* Don't free filename any more. */
4307 unpush_target (&tfile_ops
);
4309 trace_filename
= xstrdup (filename
);
4310 trace_fd
= scratch_chan
;
4313 /* Read the file header and test for validity. */
4314 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4316 bytes
+= TRACE_HEADER_SIZE
;
4317 if (!(header
[0] == 0x7f
4318 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4319 error (_("File is not a valid trace file."));
4321 push_target (&tfile_ops
);
4323 trace_regblock_size
= 0;
4324 ts
= current_trace_status ();
4325 /* We know we're working with a file. Record its name. */
4326 ts
->filename
= trace_filename
;
4327 /* Set defaults in case there is no status line. */
4328 ts
->running_known
= 0;
4329 ts
->stop_reason
= trace_stop_reason_unknown
;
4330 ts
->traceframe_count
= -1;
4331 ts
->buffer_free
= 0;
4332 ts
->disconnected_tracing
= 0;
4333 ts
->circular_buffer
= 0;
4335 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4337 /* Read through a section of newline-terminated lines that
4338 define things like tracepoints. */
4342 tfile_read (&byte
, 1);
4347 /* Empty line marks end of the definition section. */
4352 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4355 linebuf
[i
++] = byte
;
4357 error (_("Excessively long lines in trace file"));
4360 /* Record the starting offset of the binary trace data. */
4361 trace_frames_offset
= bytes
;
4363 /* If we don't have a blocksize, we can't interpret the
4365 if (trace_regblock_size
== 0)
4366 error (_("No register block size recorded in trace file"));
4370 /* Remove the partially set up target. */
4371 unpush_target (&tfile_ops
);
4372 throw_exception (ex
);
4375 if (ts
->traceframe_count
<= 0)
4376 warning (_("No traceframes present in this file."));
4378 /* Add the file's tracepoints and variables into the current mix. */
4380 /* Get trace state variables first, they may be checked when parsing
4381 uploaded commands. */
4382 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4384 merge_uploaded_tracepoints (&uploaded_tps
);
4387 /* Interpret the given line from the definitions part of the trace
4391 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4392 struct uploaded_tsv
**utsvp
)
4396 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4399 trace_regblock_size
= strtol (p
, &p
, 16);
4401 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4403 p
+= strlen ("status ");
4404 parse_trace_status (p
, current_trace_status ());
4406 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4408 p
+= strlen ("tp ");
4409 parse_tracepoint_definition (p
, utpp
);
4411 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4413 p
+= strlen ("tsv ");
4414 parse_tsv_definition (p
, utsvp
);
4417 warning (_("Ignoring trace file definition \"%s\""), line
);
4420 /* Parse the part of trace status syntax that is shared between
4421 the remote protocol and the trace file reader. */
4424 parse_trace_status (char *line
, struct trace_status
*ts
)
4426 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4430 ts
->running_known
= 1;
4431 ts
->running
= (*p
++ == '1');
4432 ts
->stop_reason
= trace_stop_reason_unknown
;
4433 xfree (ts
->stop_desc
);
4434 ts
->stop_desc
= NULL
;
4435 ts
->traceframe_count
= -1;
4436 ts
->traceframes_created
= -1;
4437 ts
->buffer_free
= -1;
4438 ts
->buffer_size
= -1;
4439 ts
->disconnected_tracing
= 0;
4440 ts
->circular_buffer
= 0;
4441 xfree (ts
->user_name
);
4442 ts
->user_name
= NULL
;
4445 ts
->start_time
= ts
->stop_time
= 0;
4449 p1
= strchr (p
, ':');
4451 error (_("Malformed trace status, at %s\n\
4452 Status line: '%s'\n"), p
, line
);
4453 p3
= strchr (p
, ';');
4455 p3
= p
+ strlen (p
);
4456 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4458 p
= unpack_varlen_hex (++p1
, &val
);
4459 ts
->stop_reason
= trace_buffer_full
;
4461 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4463 p
= unpack_varlen_hex (++p1
, &val
);
4464 ts
->stop_reason
= trace_never_run
;
4466 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4469 p
= unpack_varlen_hex (++p1
, &val
);
4470 ts
->stop_reason
= tracepoint_passcount
;
4471 ts
->stopping_tracepoint
= val
;
4473 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4475 p2
= strchr (++p1
, ':');
4483 ts
->stop_desc
= xmalloc (strlen (line
));
4484 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4485 ts
->stop_desc
[end
] = '\0';
4488 ts
->stop_desc
= xstrdup ("");
4490 p
= unpack_varlen_hex (++p2
, &val
);
4491 ts
->stop_reason
= tstop_command
;
4493 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4495 p
= unpack_varlen_hex (++p1
, &val
);
4496 ts
->stop_reason
= trace_disconnected
;
4498 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4500 p2
= strchr (++p1
, ':');
4503 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4504 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4505 ts
->stop_desc
[end
] = '\0';
4508 ts
->stop_desc
= xstrdup ("");
4510 p
= unpack_varlen_hex (++p2
, &val
);
4511 ts
->stopping_tracepoint
= val
;
4512 ts
->stop_reason
= tracepoint_error
;
4514 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4516 p
= unpack_varlen_hex (++p1
, &val
);
4517 ts
->traceframe_count
= val
;
4519 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4521 p
= unpack_varlen_hex (++p1
, &val
);
4522 ts
->traceframes_created
= val
;
4524 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4526 p
= unpack_varlen_hex (++p1
, &val
);
4527 ts
->buffer_free
= val
;
4529 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4531 p
= unpack_varlen_hex (++p1
, &val
);
4532 ts
->buffer_size
= val
;
4534 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4536 p
= unpack_varlen_hex (++p1
, &val
);
4537 ts
->disconnected_tracing
= val
;
4539 else if (strncmp (p
, "circular", p1
- p
) == 0)
4541 p
= unpack_varlen_hex (++p1
, &val
);
4542 ts
->circular_buffer
= val
;
4544 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4546 p
= unpack_varlen_hex (++p1
, &val
);
4547 ts
->start_time
= val
;
4549 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4551 p
= unpack_varlen_hex (++p1
, &val
);
4552 ts
->stop_time
= val
;
4554 else if (strncmp (p
, "username", p1
- p
) == 0)
4557 ts
->user_name
= xmalloc (strlen (p
) / 2);
4558 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4559 ts
->user_name
[end
] = '\0';
4562 else if (strncmp (p
, "notes", p1
- p
) == 0)
4565 ts
->notes
= xmalloc (strlen (p
) / 2);
4566 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4567 ts
->notes
[end
] = '\0';
4572 /* Silently skip unknown optional info. */
4573 p_temp
= strchr (p1
+ 1, ';');
4577 /* Must be at the end. */
4584 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4585 struct uploaded_tp
*utp
)
4588 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4590 p
= unpack_varlen_hex (p
, &uval
);
4592 tp
->base
.hit_count
+= uval
;
4594 utp
->hit_count
+= uval
;
4595 p
= unpack_varlen_hex (p
+ 1, &uval
);
4597 tp
->traceframe_usage
+= uval
;
4599 utp
->traceframe_usage
+= uval
;
4600 /* Ignore any extra, allowing for future extensions. */
4603 /* Given a line of text defining a part of a tracepoint, parse it into
4604 an "uploaded tracepoint". */
4607 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4611 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4614 char *cond
, *srctype
, *buf
;
4615 struct uploaded_tp
*utp
= NULL
;
4618 /* Both tracepoint and action definitions start with the same number
4619 and address sequence. */
4621 p
= unpack_varlen_hex (p
, &num
);
4622 p
++; /* skip a colon */
4623 p
= unpack_varlen_hex (p
, &addr
);
4624 p
++; /* skip a colon */
4627 enabled
= (*p
++ == 'E');
4628 p
++; /* skip a colon */
4629 p
= unpack_varlen_hex (p
, &step
);
4630 p
++; /* skip a colon */
4631 p
= unpack_varlen_hex (p
, &pass
);
4632 type
= bp_tracepoint
;
4634 /* Thumb through optional fields. */
4637 p
++; /* skip a colon */
4640 type
= bp_fast_tracepoint
;
4642 p
= unpack_varlen_hex (p
, &orig_size
);
4646 type
= bp_static_tracepoint
;
4652 p
= unpack_varlen_hex (p
, &xlen
);
4653 p
++; /* skip a comma */
4654 cond
= (char *) xmalloc (2 * xlen
+ 1);
4655 strncpy (cond
, p
, 2 * xlen
);
4656 cond
[2 * xlen
] = '\0';
4660 warning (_("Unrecognized char '%c' in tracepoint "
4661 "definition, skipping rest"), *p
);
4663 utp
= get_uploaded_tp (num
, addr
, utpp
);
4665 utp
->enabled
= enabled
;
4670 else if (piece
== 'A')
4672 utp
= get_uploaded_tp (num
, addr
, utpp
);
4673 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4675 else if (piece
== 'S')
4677 utp
= get_uploaded_tp (num
, addr
, utpp
);
4678 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4680 else if (piece
== 'Z')
4682 /* Parse a chunk of source form definition. */
4683 utp
= get_uploaded_tp (num
, addr
, utpp
);
4685 p
= strchr (p
, ':');
4686 p
++; /* skip a colon */
4687 p
= unpack_varlen_hex (p
, &start
);
4688 p
++; /* skip a colon */
4689 p
= unpack_varlen_hex (p
, &xlen
);
4690 p
++; /* skip a colon */
4692 buf
= alloca (strlen (line
));
4694 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4697 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4698 utp
->at_string
= xstrdup (buf
);
4699 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4700 utp
->cond_string
= xstrdup (buf
);
4701 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4702 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4704 else if (piece
== 'V')
4706 utp
= get_uploaded_tp (num
, addr
, utpp
);
4708 parse_tracepoint_status (p
, NULL
, utp
);
4712 /* Don't error out, the target might be sending us optional
4713 info that we don't care about. */
4714 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4718 /* Convert a textual description of a trace state variable into an
4722 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4725 ULONGEST num
, initval
, builtin
;
4727 struct uploaded_tsv
*utsv
= NULL
;
4729 buf
= alloca (strlen (line
));
4732 p
= unpack_varlen_hex (p
, &num
);
4733 p
++; /* skip a colon */
4734 p
= unpack_varlen_hex (p
, &initval
);
4735 p
++; /* skip a colon */
4736 p
= unpack_varlen_hex (p
, &builtin
);
4737 p
++; /* skip a colon */
4738 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4741 utsv
= get_uploaded_tsv (num
, utsvp
);
4742 utsv
->initial_value
= initval
;
4743 utsv
->builtin
= builtin
;
4744 utsv
->name
= xstrdup (buf
);
4747 /* Close the trace file and generally clean up. */
4759 xfree (trace_filename
);
4760 trace_filename
= NULL
;
4762 trace_reset_local_state ();
4766 tfile_files_info (struct target_ops
*t
)
4768 printf_filtered ("\t`%s'\n", trace_filename
);
4771 /* The trace status for a file is that tracing can never be run. */
4774 tfile_get_trace_status (struct trace_status
*ts
)
4776 /* Other bits of trace status were collected as part of opening the
4777 trace files, so nothing to do here. */
4783 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4785 /* Other bits of trace status were collected as part of opening the
4786 trace files, so nothing to do here. */
4789 /* Given the position of a traceframe in the file, figure out what
4790 address the frame was collected at. This would normally be the
4791 value of a collected PC register, but if not available, we
4795 tfile_get_traceframe_address (off_t tframe_offset
)
4799 struct tracepoint
*tp
;
4800 off_t saved_offset
= cur_offset
;
4802 /* FIXME dig pc out of collected registers. */
4804 /* Fall back to using tracepoint address. */
4805 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4806 tfile_read ((gdb_byte
*) &tpnum
, 2);
4807 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4809 (target_gdbarch ()));
4811 tp
= get_tracepoint_by_number_on_target (tpnum
);
4812 /* FIXME this is a poor heuristic if multiple locations. */
4813 if (tp
&& tp
->base
.loc
)
4814 addr
= tp
->base
.loc
->address
;
4816 /* Restore our seek position. */
4817 cur_offset
= saved_offset
;
4818 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4822 /* Given a type of search and some parameters, scan the collection of
4823 traceframes in the file looking for a match. When found, return
4824 both the traceframe and tracepoint number, otherwise -1 for
4828 tfile_trace_find (enum trace_find_type type
, int num
,
4829 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4832 int tfnum
= 0, found
= 0;
4833 unsigned int data_size
;
4834 struct tracepoint
*tp
;
4835 off_t offset
, tframe_offset
;
4845 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4846 offset
= trace_frames_offset
;
4849 tframe_offset
= offset
;
4850 tfile_read ((gdb_byte
*) &tpnum
, 2);
4851 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4853 (target_gdbarch ()));
4857 tfile_read ((gdb_byte
*) &data_size
, 4);
4858 data_size
= (unsigned int) extract_unsigned_integer
4859 ((gdb_byte
*) &data_size
, 4,
4860 gdbarch_byte_order (target_gdbarch ()));
4863 if (type
== tfind_number
)
4865 /* Looking for a specific trace frame. */
4871 /* Start from the _next_ trace frame. */
4872 if (tfnum
> traceframe_number
)
4877 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4878 if (tfaddr
== addr1
)
4882 tp
= get_tracepoint (num
);
4883 if (tp
&& tpnum
== tp
->number_on_target
)
4887 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4888 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4892 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4893 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4897 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4906 cur_offset
= offset
;
4907 cur_data_size
= data_size
;
4911 /* Skip past the traceframe's data. */
4912 lseek (trace_fd
, data_size
, SEEK_CUR
);
4913 offset
+= data_size
;
4914 /* Update our own count of traceframes. */
4917 /* Did not find what we were looking for. */
4923 /* Prototype of the callback passed to tframe_walk_blocks. */
4924 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4926 /* Callback for traceframe_walk_blocks, used to find a given block
4927 type in a traceframe. */
4930 match_blocktype (char blocktype
, void *data
)
4932 char *wantedp
= data
;
4934 if (*wantedp
== blocktype
)
4940 /* Walk over all traceframe block starting at POS offset from
4941 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4942 unmodified. If CALLBACK returns true, this returns the position in
4943 the traceframe where the block is found, relative to the start of
4944 the traceframe (cur_offset). Returns -1 if no callback call
4945 returned true, indicating that all blocks have been walked. */
4948 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4949 int pos
, void *data
)
4951 /* Iterate through a traceframe's blocks, looking for a block of the
4954 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4955 while (pos
< cur_data_size
)
4957 unsigned short mlen
;
4960 tfile_read ((gdb_byte
*) &block_type
, 1);
4964 if ((*callback
) (block_type
, data
))
4970 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4971 pos
+= trace_regblock_size
;
4974 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4975 tfile_read ((gdb_byte
*) &mlen
, 2);
4976 mlen
= (unsigned short)
4977 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4979 (target_gdbarch ()));
4980 lseek (trace_fd
, mlen
, SEEK_CUR
);
4981 pos
+= (8 + 2 + mlen
);
4984 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4988 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4989 block_type
, block_type
);
4997 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4998 position offset of a block of type TYPE_WANTED in the current trace
4999 frame, starting at POS. Returns -1 if no such block was found. */
5002 traceframe_find_block_type (char type_wanted
, int pos
)
5004 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
5007 /* Look for a block of saved registers in the traceframe, and get the
5008 requested register from it. */
5011 tfile_fetch_registers (struct target_ops
*ops
,
5012 struct regcache
*regcache
, int regno
)
5014 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5015 int offset
, regn
, regsize
, pc_regno
;
5018 /* An uninitialized reg size says we're not going to be
5019 successful at getting register blocks. */
5020 if (!trace_regblock_size
)
5023 regs
= alloca (trace_regblock_size
);
5025 if (traceframe_find_block_type ('R', 0) >= 0)
5027 tfile_read (regs
, trace_regblock_size
);
5029 /* Assume the block is laid out in GDB register number order,
5030 each register with the size that it has in GDB. */
5032 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5034 regsize
= register_size (gdbarch
, regn
);
5035 /* Make sure we stay within block bounds. */
5036 if (offset
+ regsize
>= trace_regblock_size
)
5038 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
5042 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
5045 else if (regno
== -1)
5047 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
5055 /* We get here if no register data has been found. Mark registers
5057 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5058 regcache_raw_supply (regcache
, regn
, NULL
);
5060 /* We can often usefully guess that the PC is going to be the same
5061 as the address of the tracepoint. */
5062 pc_regno
= gdbarch_pc_regnum (gdbarch
);
5063 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
5065 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
5067 if (tp
&& tp
->base
.loc
)
5069 /* But don't try to guess if tracepoint is multi-location... */
5070 if (tp
->base
.loc
->next
)
5072 warning (_("Tracepoint %d has multiple "
5073 "locations, cannot infer $pc"),
5077 /* ... or does while-stepping. */
5078 if (tp
->step_count
> 0)
5080 warning (_("Tracepoint %d does while-stepping, "
5081 "cannot infer $pc"),
5086 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
5087 gdbarch_byte_order (gdbarch
),
5088 tp
->base
.loc
->address
);
5089 regcache_raw_supply (regcache
, pc_regno
, regs
);
5095 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5096 const char *annex
, gdb_byte
*readbuf
,
5097 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5099 /* We're only doing regular memory for now. */
5100 if (object
!= TARGET_OBJECT_MEMORY
)
5103 if (readbuf
== NULL
)
5104 error (_("tfile_xfer_partial: trace file is read-only"));
5106 if (traceframe_number
!= -1)
5110 /* Iterate through the traceframe's blocks, looking for
5112 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5114 ULONGEST maddr
, amt
;
5115 unsigned short mlen
;
5116 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5118 tfile_read ((gdb_byte
*) &maddr
, 8);
5119 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5121 tfile_read ((gdb_byte
*) &mlen
, 2);
5122 mlen
= (unsigned short)
5123 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5125 /* If the block includes the first part of the desired
5126 range, return as much it has; GDB will re-request the
5127 remainder, which might be in a different block of this
5129 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5131 amt
= (maddr
+ mlen
) - offset
;
5135 if (maddr
!= offset
)
5136 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5137 tfile_read (readbuf
, amt
);
5141 /* Skip over this block. */
5142 pos
+= (8 + 2 + mlen
);
5146 /* It's unduly pedantic to refuse to look at the executable for
5147 read-only pieces; so do the equivalent of readonly regions aka
5149 /* FIXME account for relocation at some point. */
5156 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5158 if ((s
->flags
& SEC_LOAD
) == 0
5159 || (s
->flags
& SEC_READONLY
) == 0)
5163 size
= bfd_get_section_size (s
);
5164 if (vma
<= offset
&& offset
< (vma
+ size
))
5168 amt
= (vma
+ size
) - offset
;
5172 amt
= bfd_get_section_contents (exec_bfd
, s
,
5173 readbuf
, offset
- vma
, amt
);
5179 /* Indicate failure to find the requested memory block. */
5183 /* Iterate through the blocks of a trace frame, looking for a 'V'
5184 block with a matching tsv number. */
5187 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5192 /* Iterate over blocks in current frame and find the last 'V'
5193 block in which tsv number is TSVNUM. In one trace frame, there
5194 may be multiple 'V' blocks created for a given trace variable,
5195 and the last matched 'V' block contains the updated value. */
5197 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5201 tfile_read ((gdb_byte
*) &vnum
, 4);
5202 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5204 (target_gdbarch ()));
5207 tfile_read ((gdb_byte
*) val
, 8);
5208 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5210 (target_gdbarch ()));
5220 tfile_has_all_memory (struct target_ops
*ops
)
5226 tfile_has_memory (struct target_ops
*ops
)
5232 tfile_has_stack (struct target_ops
*ops
)
5234 return traceframe_number
!= -1;
5238 tfile_has_registers (struct target_ops
*ops
)
5240 return traceframe_number
!= -1;
5243 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5244 object for the tfile target's current traceframe. */
5247 build_traceframe_info (char blocktype
, void *data
)
5249 struct traceframe_info
*info
= data
;
5255 struct mem_range
*r
;
5257 unsigned short mlen
;
5259 tfile_read ((gdb_byte
*) &maddr
, 8);
5260 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5262 (target_gdbarch ()));
5263 tfile_read ((gdb_byte
*) &mlen
, 2);
5264 mlen
= (unsigned short)
5265 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5266 2, gdbarch_byte_order
5267 (target_gdbarch ()));
5269 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5279 tfile_read ((gdb_byte
*) &vnum
, 4);
5280 VEC_safe_push (int, info
->tvars
, vnum
);
5288 warning (_("Unhandled trace block type (%d) '%c ' "
5289 "while building trace frame info."),
5290 blocktype
, blocktype
);
5297 static struct traceframe_info
*
5298 tfile_traceframe_info (void)
5300 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5302 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5307 init_tfile_ops (void)
5309 tfile_ops
.to_shortname
= "tfile";
5310 tfile_ops
.to_longname
= "Local trace dump file";
5312 = "Use a trace file as a target. Specify the filename of the trace file.";
5313 tfile_ops
.to_open
= tfile_open
;
5314 tfile_ops
.to_close
= tfile_close
;
5315 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5316 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5317 tfile_ops
.to_files_info
= tfile_files_info
;
5318 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5319 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5320 tfile_ops
.to_trace_find
= tfile_trace_find
;
5321 tfile_ops
.to_get_trace_state_variable_value
5322 = tfile_get_trace_state_variable_value
;
5323 tfile_ops
.to_stratum
= process_stratum
;
5324 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5325 tfile_ops
.to_has_memory
= tfile_has_memory
;
5326 tfile_ops
.to_has_stack
= tfile_has_stack
;
5327 tfile_ops
.to_has_registers
= tfile_has_registers
;
5328 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5329 tfile_ops
.to_magic
= OPS_MAGIC
;
5333 free_current_marker (void *arg
)
5335 struct static_tracepoint_marker
**marker_p
= arg
;
5337 if (*marker_p
!= NULL
)
5339 release_static_tracepoint_marker (*marker_p
);
5346 /* Given a line of text defining a static tracepoint marker, parse it
5347 into a "static tracepoint marker" object. Throws an error is
5348 parsing fails. If PP is non-null, it points to one past the end of
5349 the parsed marker definition. */
5352 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5353 struct static_tracepoint_marker
*marker
)
5360 p
= unpack_varlen_hex (p
, &addr
);
5361 p
++; /* skip a colon */
5363 marker
->gdbarch
= target_gdbarch ();
5364 marker
->address
= (CORE_ADDR
) addr
;
5366 endp
= strchr (p
, ':');
5368 error (_("bad marker definition: %s"), line
);
5370 marker
->str_id
= xmalloc (endp
- p
+ 1);
5371 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5372 marker
->str_id
[end
] = '\0';
5375 p
++; /* skip a colon */
5377 marker
->extra
= xmalloc (strlen (p
) + 1);
5378 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5379 marker
->extra
[end
] = '\0';
5385 /* Release a static tracepoint marker's contents. Note that the
5386 object itself isn't released here. There objects are usually on
5390 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5392 xfree (marker
->str_id
);
5393 marker
->str_id
= NULL
;
5396 /* Print MARKER to gdb_stdout. */
5399 print_one_static_tracepoint_marker (int count
,
5400 struct static_tracepoint_marker
*marker
)
5402 struct command_line
*l
;
5405 char wrap_indent
[80];
5406 char extra_field_indent
[80];
5407 struct ui_out
*uiout
= current_uiout
;
5408 struct cleanup
*bkpt_chain
;
5409 VEC(breakpoint_p
) *tracepoints
;
5411 struct symtab_and_line sal
;
5415 sal
.pc
= marker
->address
;
5417 tracepoints
= static_tracepoints_here (marker
->address
);
5419 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5421 /* A counter field to help readability. This is not a stable
5423 ui_out_field_int (uiout
, "count", count
);
5425 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5427 ui_out_field_fmt (uiout
, "enabled", "%c",
5428 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5429 ui_out_spaces (uiout
, 2);
5431 strcpy (wrap_indent
, " ");
5433 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5434 strcat (wrap_indent
, " ");
5436 strcat (wrap_indent
, " ");
5438 strcpy (extra_field_indent
, " ");
5440 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5442 sal
= find_pc_line (marker
->address
, 0);
5443 sym
= find_pc_sect_function (marker
->address
, NULL
);
5446 ui_out_text (uiout
, "in ");
5447 ui_out_field_string (uiout
, "func",
5448 SYMBOL_PRINT_NAME (sym
));
5449 ui_out_wrap_hint (uiout
, wrap_indent
);
5450 ui_out_text (uiout
, " at ");
5453 ui_out_field_skip (uiout
, "func");
5455 if (sal
.symtab
!= NULL
)
5457 ui_out_field_string (uiout
, "file",
5458 symtab_to_filename_for_display (sal
.symtab
));
5459 ui_out_text (uiout
, ":");
5461 if (ui_out_is_mi_like_p (uiout
))
5463 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5465 ui_out_field_string (uiout
, "fullname", fullname
);
5468 ui_out_field_skip (uiout
, "fullname");
5470 ui_out_field_int (uiout
, "line", sal
.line
);
5474 ui_out_field_skip (uiout
, "fullname");
5475 ui_out_field_skip (uiout
, "line");
5478 ui_out_text (uiout
, "\n");
5479 ui_out_text (uiout
, extra_field_indent
);
5480 ui_out_text (uiout
, _("Data: \""));
5481 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5482 ui_out_text (uiout
, "\"\n");
5484 if (!VEC_empty (breakpoint_p
, tracepoints
))
5486 struct cleanup
*cleanup_chain
;
5488 struct breakpoint
*b
;
5490 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5493 ui_out_text (uiout
, extra_field_indent
);
5494 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5495 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5498 ui_out_text (uiout
, ", ");
5499 ui_out_text (uiout
, "#");
5500 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5503 do_cleanups (cleanup_chain
);
5505 if (ui_out_is_mi_like_p (uiout
))
5506 ui_out_field_int (uiout
, "number-of-tracepoints",
5507 VEC_length(breakpoint_p
, tracepoints
));
5509 ui_out_text (uiout
, "\n");
5511 VEC_free (breakpoint_p
, tracepoints
);
5513 do_cleanups (bkpt_chain
);
5517 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5519 VEC(static_tracepoint_marker_p
) *markers
;
5520 struct cleanup
*old_chain
;
5521 struct static_tracepoint_marker
*marker
;
5522 struct ui_out
*uiout
= current_uiout
;
5525 /* We don't have to check target_can_use_agent and agent's capability on
5526 static tracepoint here, in order to be compatible with older GDBserver.
5527 We don't check USE_AGENT is true or not, because static tracepoints
5528 don't work without in-process agent, so we don't bother users to type
5529 `set agent on' when to use static tracepoint. */
5532 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5533 "StaticTracepointMarkersTable");
5535 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5537 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5539 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5540 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5541 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5543 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5544 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5546 ui_out_table_body (uiout
);
5548 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5549 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5552 VEC_iterate (static_tracepoint_marker_p
,
5553 markers
, i
, marker
);
5556 print_one_static_tracepoint_marker (i
+ 1, marker
);
5557 release_static_tracepoint_marker (marker
);
5560 do_cleanups (old_chain
);
5563 /* The $_sdata convenience variable is a bit special. We don't know
5564 for sure type of the value until we actually have a chance to fetch
5565 the data --- the size of the object depends on what has been
5566 collected. We solve this by making $_sdata be an internalvar that
5567 creates a new value on access. */
5569 /* Return a new value with the correct type for the sdata object of
5570 the current trace frame. Return a void value if there's no object
5573 static struct value
*
5574 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5580 /* We need to read the whole object before we know its size. */
5581 size
= target_read_alloc (¤t_target
,
5582 TARGET_OBJECT_STATIC_TRACE_DATA
,
5589 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5591 v
= allocate_value (type
);
5592 memcpy (value_contents_raw (v
), buf
, size
);
5597 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5600 #if !defined(HAVE_LIBEXPAT)
5602 struct traceframe_info
*
5603 parse_traceframe_info (const char *tframe_info
)
5605 static int have_warned
;
5610 warning (_("Can not parse XML trace frame info; XML support "
5611 "was disabled at compile time"));
5617 #else /* HAVE_LIBEXPAT */
5619 #include "xml-support.h"
5621 /* Handle the start of a <memory> element. */
5624 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5625 const struct gdb_xml_element
*element
,
5626 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5628 struct traceframe_info
*info
= user_data
;
5629 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5630 ULONGEST
*start_p
, *length_p
;
5632 start_p
= xml_find_attribute (attributes
, "start")->value
;
5633 length_p
= xml_find_attribute (attributes
, "length")->value
;
5635 r
->start
= *start_p
;
5636 r
->length
= *length_p
;
5639 /* Handle the start of a <tvar> element. */
5642 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
5643 const struct gdb_xml_element
*element
,
5645 VEC(gdb_xml_value_s
) *attributes
)
5647 struct traceframe_info
*info
= user_data
;
5648 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
5649 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
5651 VEC_safe_push (int, info
->tvars
, id
);
5654 /* Discard the constructed trace frame info (if an error occurs). */
5657 free_result (void *p
)
5659 struct traceframe_info
*result
= p
;
5661 free_traceframe_info (result
);
5664 /* The allowed elements and attributes for an XML memory map. */
5666 static const struct gdb_xml_attribute memory_attributes
[] = {
5667 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5668 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5669 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5672 static const struct gdb_xml_attribute tvar_attributes
[] = {
5673 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
5674 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5677 static const struct gdb_xml_element traceframe_info_children
[] = {
5678 { "memory", memory_attributes
, NULL
,
5679 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5680 traceframe_info_start_memory
, NULL
},
5681 { "tvar", tvar_attributes
, NULL
,
5682 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5683 traceframe_info_start_tvar
, NULL
},
5684 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5687 static const struct gdb_xml_element traceframe_info_elements
[] = {
5688 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5690 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5693 /* Parse a traceframe-info XML document. */
5695 struct traceframe_info
*
5696 parse_traceframe_info (const char *tframe_info
)
5698 struct traceframe_info
*result
;
5699 struct cleanup
*back_to
;
5701 result
= XCNEW (struct traceframe_info
);
5702 back_to
= make_cleanup (free_result
, result
);
5704 if (gdb_xml_parse_quick (_("trace frame info"),
5705 "traceframe-info.dtd", traceframe_info_elements
,
5706 tframe_info
, result
) == 0)
5708 /* Parsed successfully, keep the result. */
5709 discard_cleanups (back_to
);
5714 do_cleanups (back_to
);
5718 #endif /* HAVE_LIBEXPAT */
5720 /* Returns the traceframe_info object for the current traceframe.
5721 This is where we avoid re-fetching the object from the target if we
5722 already have it cached. */
5724 struct traceframe_info
*
5725 get_traceframe_info (void)
5727 if (traceframe_info
== NULL
)
5728 traceframe_info
= target_traceframe_info ();
5730 return traceframe_info
;
5733 /* If the target supports the query, return in RESULT the set of
5734 collected memory in the current traceframe, found within the LEN
5735 bytes range starting at MEMADDR. Returns true if the target
5736 supports the query, otherwise returns false, and RESULT is left
5740 traceframe_available_memory (VEC(mem_range_s
) **result
,
5741 CORE_ADDR memaddr
, ULONGEST len
)
5743 struct traceframe_info
*info
= get_traceframe_info ();
5747 struct mem_range
*r
;
5752 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5753 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5755 ULONGEST lo1
, hi1
, lo2
, hi2
;
5756 struct mem_range
*nr
;
5759 hi1
= memaddr
+ len
;
5762 hi2
= r
->start
+ r
->length
;
5764 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5766 nr
->start
= max (lo1
, lo2
);
5767 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5770 normalize_mem_ranges (*result
);
5777 /* Implementation of `sdata' variable. */
5779 static const struct internalvar_funcs sdata_funcs
=
5786 /* module initialization */
5788 _initialize_tracepoint (void)
5790 struct cmd_list_element
*c
;
5792 /* Explicitly create without lookup, since that tries to create a
5793 value with a void typed value, and when we get here, gdbarch
5794 isn't initialized yet. At this point, we're quite sure there
5795 isn't another convenience variable of the same name. */
5796 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5798 traceframe_number
= -1;
5799 tracepoint_number
= -1;
5801 add_info ("scope", scope_info
,
5802 _("List the variables local to a scope"));
5804 add_cmd ("tracepoints", class_trace
, NULL
,
5805 _("Tracing of program execution without stopping the program."),
5808 add_com ("tdump", class_trace
, trace_dump_command
,
5809 _("Print everything collected at the current tracepoint."));
5811 add_com ("tsave", class_trace
, trace_save_command
, _("\
5812 Save the trace data to a file.\n\
5813 Use the '-ctf' option to save the data to CTF format.\n\
5814 Use the '-r' option to direct the target to save directly to the file,\n\
5815 using its own filesystem."));
5817 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5818 Define a trace state variable.\n\
5819 Argument is a $-prefixed name, optionally followed\n\
5820 by '=' and an expression that sets the initial value\n\
5821 at the start of tracing."));
5822 set_cmd_completer (c
, expression_completer
);
5824 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5825 Delete one or more trace state variables.\n\
5826 Arguments are the names of the variables to delete.\n\
5827 If no arguments are supplied, delete all variables."), &deletelist
);
5828 /* FIXME add a trace variable completer. */
5830 add_info ("tvariables", tvariables_info
, _("\
5831 Status of trace state variables and their values.\n\
5834 add_info ("static-tracepoint-markers",
5835 info_static_tracepoint_markers_command
, _("\
5836 List target static tracepoints markers.\n\
5839 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5840 Select a trace frame;\n\
5841 No argument means forward by one frame; '-' means backward by one frame."),
5842 &tfindlist
, "tfind ", 1, &cmdlist
);
5844 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5845 Select a trace frame whose PC is outside the given range (exclusive).\n\
5846 Usage: tfind outside addr1, addr2"),
5849 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5850 Select a trace frame whose PC is in the given range (inclusive).\n\
5851 Usage: tfind range addr1,addr2"),
5854 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5855 Select a trace frame by source line.\n\
5856 Argument can be a line number (with optional source file),\n\
5857 a function name, or '*' followed by an address.\n\
5858 Default argument is 'the next source line that was traced'."),
5861 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5862 Select a trace frame by tracepoint number.\n\
5863 Default is the tracepoint for the current trace frame."),
5866 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5867 Select a trace frame by PC.\n\
5868 Default is the current PC, or the PC of the current trace frame."),
5871 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5872 De-select any trace frame and resume 'live' debugging."),
5875 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5877 add_cmd ("start", class_trace
, trace_find_start_command
,
5878 _("Select the first trace frame in the trace buffer."),
5881 add_com ("tstatus", class_trace
, trace_status_command
,
5882 _("Display the status of the current trace data collection."));
5884 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5885 Stop trace data collection.\n\
5886 Usage: tstop [ <notes> ... ]\n\
5887 Any arguments supplied are recorded with the trace as a stop reason and\n\
5888 reported by tstatus (if the target supports trace notes)."));
5890 add_com ("tstart", class_trace
, trace_start_command
, _("\
5891 Start trace data collection.\n\
5892 Usage: tstart [ <notes> ... ]\n\
5893 Any arguments supplied are recorded with the trace as a note and\n\
5894 reported by tstatus (if the target supports trace notes)."));
5896 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5897 Ends a list of commands or actions.\n\
5898 Several GDB commands allow you to enter a list of commands or actions.\n\
5899 Entering \"end\" on a line by itself is the normal way to terminate\n\
5901 Note: the \"end\" command cannot be used at the gdb prompt."));
5903 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5904 Specify single-stepping behavior at a tracepoint.\n\
5905 Argument is number of instructions to trace in single-step mode\n\
5906 following the tracepoint. This command is normally followed by\n\
5907 one or more \"collect\" commands, to specify what to collect\n\
5908 while single-stepping.\n\n\
5909 Note: this command can only be used in a tracepoint \"actions\" list."));
5911 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5912 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5914 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5915 Specify one or more data items to be collected at a tracepoint.\n\
5916 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5917 collect all data (variables, registers) referenced by that expression.\n\
5918 Also accepts the following special arguments:\n\
5919 $regs -- all registers.\n\
5920 $args -- all function arguments.\n\
5921 $locals -- all variables local to the block/function scope.\n\
5922 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5923 Note: this command can only be used in a tracepoint \"actions\" list."));
5925 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5926 Specify one or more expressions to be evaluated at a tracepoint.\n\
5927 Accepts a comma-separated list of (one or more) expressions.\n\
5928 The result of each evaluation will be discarded.\n\
5929 Note: this command can only be used in a tracepoint \"actions\" list."));
5931 add_com ("actions", class_trace
, trace_actions_command
, _("\
5932 Specify the actions to be taken at a tracepoint.\n\
5933 Tracepoint actions may include collecting of specified data,\n\
5934 single-stepping, or enabling/disabling other tracepoints,\n\
5935 depending on target's capabilities."));
5937 default_collect
= xstrdup ("");
5938 add_setshow_string_cmd ("default-collect", class_trace
,
5939 &default_collect
, _("\
5940 Set the list of expressions to collect by default"), _("\
5941 Show the list of expressions to collect by default"), NULL
,
5943 &setlist
, &showlist
);
5945 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5946 &disconnected_tracing
, _("\
5947 Set whether tracing continues after GDB disconnects."), _("\
5948 Show whether tracing continues after GDB disconnects."), _("\
5949 Use this to continue a tracing run even if GDB disconnects\n\
5950 or detaches from the target. You can reconnect later and look at\n\
5951 trace data collected in the meantime."),
5952 set_disconnected_tracing
,
5957 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5958 &circular_trace_buffer
, _("\
5959 Set target's use of circular trace buffer."), _("\
5960 Show target's use of circular trace buffer."), _("\
5961 Use this to make the trace buffer into a circular buffer,\n\
5962 which will discard traceframes (oldest first) instead of filling\n\
5963 up and stopping the trace run."),
5964 set_circular_trace_buffer
,
5969 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5970 &trace_buffer_size
, _("\
5971 Set requested size of trace buffer."), _("\
5972 Show requested size of trace buffer."), _("\
5973 Use this to choose a size for the trace buffer. Some targets\n\
5974 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5975 disables any attempt to set the buffer size and lets the target choose."),
5976 set_trace_buffer_size
, NULL
,
5977 &setlist
, &showlist
);
5979 add_setshow_string_cmd ("trace-user", class_trace
,
5981 Set the user name to use for current and future trace runs"), _("\
5982 Show the user name to use for current and future trace runs"), NULL
,
5983 set_trace_user
, NULL
,
5984 &setlist
, &showlist
);
5986 add_setshow_string_cmd ("trace-notes", class_trace
,
5988 Set notes string to use for current and future trace runs"), _("\
5989 Show the notes string to use for current and future trace runs"), NULL
,
5990 set_trace_notes
, NULL
,
5991 &setlist
, &showlist
);
5993 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5994 &trace_stop_notes
, _("\
5995 Set notes string to use for future tstop commands"), _("\
5996 Show the notes string to use for future tstop commands"), NULL
,
5997 set_trace_stop_notes
, NULL
,
5998 &setlist
, &showlist
);
6002 add_target_with_completer (&tfile_ops
, filename_completer
);