1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 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"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
83 /* A hook used to notify the UI of tracepoint operations. */
85 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
86 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
91 This module defines the following debugger commands:
92 trace : set a tracepoint on a function, line, or address.
93 info trace : list all debugger-defined tracepoints.
94 delete trace : delete one or more tracepoints.
95 enable trace : enable one or more tracepoints.
96 disable trace : disable one or more tracepoints.
97 actions : specify actions to be taken at a tracepoint.
98 passcount : specify a pass count for a tracepoint.
99 tstart : start a trace experiment.
100 tstop : stop a trace experiment.
101 tstatus : query the status of a trace experiment.
102 tfind : find a trace frame in the trace buffer.
103 tdump : print everything collected at the current tracepoint.
104 save-tracepoints : write tracepoint setup into a file.
106 This module defines the following user-visible debugger variables:
107 $trace_frame : sequence number of trace frame currently being debugged.
108 $trace_line : source line of trace frame currently being debugged.
109 $trace_file : source file of trace frame currently being debugged.
110 $tracepoint : tracepoint number of trace frame currently being debugged.
114 /* ======= Important global variables: ======= */
116 /* The list of all trace state variables. We don't retain pointers to
117 any of these for any reason - API is by name or number only - so it
118 works to have a vector of objects. */
120 typedef struct trace_state_variable tsv_s
;
123 static VEC(tsv_s
) *tvariables
;
125 /* The next integer to assign to a variable. */
127 static int next_tsv_number
= 1;
129 /* Number of last traceframe collected. */
130 static int traceframe_number
;
132 /* Tracepoint for last traceframe collected. */
133 static int tracepoint_number
;
135 /* Symbol for function for last traceframe collected. */
136 static struct symbol
*traceframe_fun
;
138 /* Symtab and line for last traceframe collected. */
139 static struct symtab_and_line traceframe_sal
;
141 /* The traceframe info of the current traceframe. NULL if we haven't
142 yet attempted to fetch it, or if the target does not support
143 fetching this object, or if we're not inspecting a traceframe
145 static struct traceframe_info
*traceframe_info
;
147 /* Tracing command lists. */
148 static struct cmd_list_element
*tfindlist
;
150 /* List of expressions to collect by default at each tracepoint hit. */
151 char *default_collect
= "";
153 static int disconnected_tracing
;
155 /* This variable controls whether we ask the target for a linear or
156 circular trace buffer. */
158 static int circular_trace_buffer
;
160 /* This variable is the requested trace buffer size, or -1 to indicate
161 that we don't care and leave it up to the target to set a size. */
163 static int trace_buffer_size
= -1;
165 /* Textual notes applying to the current and/or future trace runs. */
167 char *trace_user
= NULL
;
169 /* Textual notes applying to the current and/or future trace runs. */
171 char *trace_notes
= NULL
;
173 /* Textual notes applying to the stopping of a trace. */
175 char *trace_stop_notes
= NULL
;
177 /* ======= Important command functions: ======= */
178 static void trace_actions_command (char *, int);
179 static void trace_start_command (char *, int);
180 static void trace_stop_command (char *, int);
181 static void trace_status_command (char *, int);
182 static void trace_find_command (char *, int);
183 static void trace_find_pc_command (char *, int);
184 static void trace_find_tracepoint_command (char *, int);
185 static void trace_find_line_command (char *, int);
186 static void trace_find_range_command (char *, int);
187 static void trace_find_outside_command (char *, int);
188 static void trace_dump_command (char *, int);
190 /* support routines */
192 struct collection_list
;
193 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
194 static char *mem2hex (gdb_byte
*, char *, int);
195 static void add_register (struct collection_list
*collection
,
198 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
199 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
201 static struct command_line
*
202 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
204 extern void _initialize_tracepoint (void);
206 static struct trace_status trace_status
;
208 char *stop_reason_names
[] = {
218 struct trace_status
*
219 current_trace_status (void)
221 return &trace_status
;
227 free_traceframe_info (struct traceframe_info
*info
)
231 VEC_free (mem_range_s
, info
->memory
);
232 VEC_free (int, info
->tvars
);
238 /* Free and clear the traceframe info cache of the current
242 clear_traceframe_info (void)
244 free_traceframe_info (traceframe_info
);
245 traceframe_info
= NULL
;
248 /* Set traceframe number to NUM. */
250 set_traceframe_num (int num
)
252 traceframe_number
= num
;
253 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
256 /* Set tracepoint number to NUM. */
258 set_tracepoint_num (int num
)
260 tracepoint_number
= num
;
261 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
264 /* Set externally visible debug variables for querying/printing
265 the traceframe context (line, function, file). */
268 set_traceframe_context (struct frame_info
*trace_frame
)
272 /* Save as globals for internal use. */
273 if (trace_frame
!= NULL
274 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
276 traceframe_sal
= find_pc_line (trace_pc
, 0);
277 traceframe_fun
= find_pc_function (trace_pc
);
279 /* Save linenumber as "$trace_line", a debugger variable visible to
281 set_internalvar_integer (lookup_internalvar ("trace_line"),
282 traceframe_sal
.line
);
286 init_sal (&traceframe_sal
);
287 traceframe_fun
= NULL
;
288 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
291 /* Save func name as "$trace_func", a debugger variable visible to
293 if (traceframe_fun
== NULL
294 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
295 clear_internalvar (lookup_internalvar ("trace_func"));
297 set_internalvar_string (lookup_internalvar ("trace_func"),
298 SYMBOL_LINKAGE_NAME (traceframe_fun
));
300 /* Save file name as "$trace_file", a debugger variable visible to
302 if (traceframe_sal
.symtab
== NULL
)
303 clear_internalvar (lookup_internalvar ("trace_file"));
305 set_internalvar_string (lookup_internalvar ("trace_file"),
306 symtab_to_filename_for_display (traceframe_sal
.symtab
));
309 /* Create a new trace state variable with the given name. */
311 struct trace_state_variable
*
312 create_trace_state_variable (const char *name
)
314 struct trace_state_variable tsv
;
316 memset (&tsv
, 0, sizeof (tsv
));
317 tsv
.name
= xstrdup (name
);
318 tsv
.number
= next_tsv_number
++;
319 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
322 /* Look for a trace state variable of the given name. */
324 struct trace_state_variable
*
325 find_trace_state_variable (const char *name
)
327 struct trace_state_variable
*tsv
;
330 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
331 if (strcmp (name
, tsv
->name
) == 0)
337 /* Look for a trace state variable of the given number. Return NULL if
340 struct trace_state_variable
*
341 find_trace_state_variable_by_number (int number
)
343 struct trace_state_variable
*tsv
;
346 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
347 if (tsv
->number
== number
)
354 delete_trace_state_variable (const char *name
)
356 struct trace_state_variable
*tsv
;
359 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
360 if (strcmp (name
, tsv
->name
) == 0)
362 observer_notify_tsv_deleted (tsv
);
364 xfree ((void *)tsv
->name
);
365 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
370 warning (_("No trace variable named \"$%s\", not deleting"), name
);
373 /* Throws an error if NAME is not valid syntax for a trace state
377 validate_trace_state_variable_name (const char *name
)
382 error (_("Must supply a non-empty variable name"));
384 /* All digits in the name is reserved for value history
386 for (p
= name
; isdigit (*p
); p
++)
389 error (_("$%s is not a valid trace state variable name"), name
);
391 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
394 error (_("$%s is not a valid trace state variable name"), name
);
397 /* The 'tvariable' command collects a name and optional expression to
398 evaluate into an initial value. */
401 trace_variable_command (char *args
, int from_tty
)
403 struct cleanup
*old_chain
;
405 struct trace_state_variable
*tsv
;
409 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
411 /* Only allow two syntaxes; "$name" and "$name=value". */
412 p
= skip_spaces (args
);
415 error (_("Name of trace variable should start with '$'"));
418 while (isalnum (*p
) || *p
== '_')
420 name
= savestring (name
, p
- name
);
421 old_chain
= make_cleanup (xfree
, name
);
424 if (*p
!= '=' && *p
!= '\0')
425 error (_("Syntax must be $NAME [ = EXPR ]"));
427 validate_trace_state_variable_name (name
);
430 initval
= value_as_long (parse_and_eval (++p
));
432 /* If the variable already exists, just change its initial value. */
433 tsv
= find_trace_state_variable (name
);
436 if (tsv
->initial_value
!= initval
)
438 tsv
->initial_value
= initval
;
439 observer_notify_tsv_modified (tsv
);
441 printf_filtered (_("Trace state variable $%s "
442 "now has initial value %s.\n"),
443 tsv
->name
, plongest (tsv
->initial_value
));
444 do_cleanups (old_chain
);
448 /* Create a new variable. */
449 tsv
= create_trace_state_variable (name
);
450 tsv
->initial_value
= initval
;
452 observer_notify_tsv_created (tsv
);
454 printf_filtered (_("Trace state variable $%s "
455 "created, with initial value %s.\n"),
456 tsv
->name
, plongest (tsv
->initial_value
));
458 do_cleanups (old_chain
);
462 delete_trace_variable_command (char *args
, int from_tty
)
466 struct cleanup
*back_to
;
470 if (query (_("Delete all trace state variables? ")))
471 VEC_free (tsv_s
, tvariables
);
473 observer_notify_tsv_deleted (NULL
);
477 argv
= gdb_buildargv (args
);
478 back_to
= make_cleanup_freeargv (argv
);
480 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
482 if (*argv
[ix
] == '$')
483 delete_trace_state_variable (argv
[ix
] + 1);
485 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
488 do_cleanups (back_to
);
494 tvariables_info_1 (void)
496 struct trace_state_variable
*tsv
;
499 struct cleanup
*back_to
;
500 struct ui_out
*uiout
= current_uiout
;
502 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
504 printf_filtered (_("No trace state variables.\n"));
508 /* Try to acquire values from the target. */
509 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
510 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
513 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
514 count
, "trace-variables");
515 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
516 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
517 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
519 ui_out_table_body (uiout
);
521 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
523 struct cleanup
*back_to2
;
527 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
529 name
= concat ("$", tsv
->name
, (char *) NULL
);
530 make_cleanup (xfree
, name
);
531 ui_out_field_string (uiout
, "name", name
);
532 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
534 if (tsv
->value_known
)
535 c
= plongest (tsv
->value
);
536 else if (ui_out_is_mi_like_p (uiout
))
537 /* For MI, we prefer not to use magic string constants, but rather
538 omit the field completely. The difference between unknown and
539 undefined does not seem important enough to represent. */
541 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
542 /* The value is/was defined, but we don't have it. */
545 /* It is not meaningful to ask about the value. */
548 ui_out_field_string (uiout
, "current", c
);
549 ui_out_text (uiout
, "\n");
551 do_cleanups (back_to2
);
554 do_cleanups (back_to
);
557 /* List all the trace state variables. */
560 tvariables_info (char *args
, int from_tty
)
562 tvariables_info_1 ();
565 /* Stash definitions of tsvs into the given file. */
568 save_trace_state_variables (struct ui_file
*fp
)
570 struct trace_state_variable
*tsv
;
573 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
575 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
576 if (tsv
->initial_value
)
577 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
578 fprintf_unfiltered (fp
, "\n");
582 /* ACTIONS functions: */
584 /* The three functions:
585 collect_pseudocommand,
586 while_stepping_pseudocommand, and
587 end_actions_pseudocommand
588 are placeholders for "commands" that are actually ONLY to be used
589 within a tracepoint action list. If the actual function is ever called,
590 it means that somebody issued the "command" at the top level,
591 which is always an error. */
594 end_actions_pseudocommand (char *args
, int from_tty
)
596 error (_("This command cannot be used at the top level."));
600 while_stepping_pseudocommand (char *args
, int from_tty
)
602 error (_("This command can only be used in a tracepoint actions list."));
606 collect_pseudocommand (char *args
, int from_tty
)
608 error (_("This command can only be used in a tracepoint actions list."));
612 teval_pseudocommand (char *args
, int from_tty
)
614 error (_("This command can only be used in a tracepoint actions list."));
617 /* Parse any collection options, such as /s for strings. */
620 decode_agent_options (const char *exp
, int *trace_string
)
622 struct value_print_options opts
;
629 /* Call this to borrow the print elements default for collection
631 get_user_print_options (&opts
);
636 if (target_supports_string_tracing ())
638 /* Allow an optional decimal number giving an explicit maximum
639 string length, defaulting it to the "print elements" value;
640 so "collect/s80 mystr" gets at most 80 bytes of string. */
641 *trace_string
= opts
.print_max
;
643 if (*exp
>= '0' && *exp
<= '9')
644 *trace_string
= atoi (exp
);
645 while (*exp
>= '0' && *exp
<= '9')
649 error (_("Target does not support \"/s\" option for string tracing."));
652 error (_("Undefined collection format \"%c\"."), *exp
);
654 exp
= skip_spaces_const (exp
);
659 /* Enter a list of actions for a tracepoint. */
661 trace_actions_command (char *args
, int from_tty
)
663 struct tracepoint
*t
;
664 struct command_line
*l
;
666 t
= get_tracepoint_by_number (&args
, NULL
, 1);
670 xstrprintf ("Enter actions for tracepoint %d, one per line.",
672 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
674 l
= read_command_lines (tmpbuf
, from_tty
, 1,
675 check_tracepoint_command
, t
);
676 do_cleanups (cleanups
);
677 breakpoint_set_commands (&t
->base
, l
);
679 /* else just return */
682 /* Report the results of checking the agent expression, as errors or
686 report_agent_reqs_errors (struct agent_expr
*aexpr
)
688 /* All of the "flaws" are serious bytecode generation issues that
689 should never occur. */
690 if (aexpr
->flaw
!= agent_flaw_none
)
691 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
693 /* If analysis shows a stack underflow, GDB must have done something
694 badly wrong in its bytecode generation. */
695 if (aexpr
->min_height
< 0)
696 internal_error (__FILE__
, __LINE__
,
697 _("expression has min height < 0"));
699 /* Issue this error if the stack is predicted to get too deep. The
700 limit is rather arbitrary; a better scheme might be for the
701 target to report how much stack it will have available. The
702 depth roughly corresponds to parenthesization, so a limit of 20
703 amounts to 20 levels of expression nesting, which is actually
704 a pretty big hairy expression. */
705 if (aexpr
->max_height
> 20)
706 error (_("Expression is too complicated."));
709 /* worker function */
711 validate_actionline (const char *line
, struct breakpoint
*b
)
713 struct cmd_list_element
*c
;
714 struct expression
*exp
= NULL
;
715 struct cleanup
*old_chain
= NULL
;
718 struct bp_location
*loc
;
719 struct agent_expr
*aexpr
;
720 struct tracepoint
*t
= (struct tracepoint
*) b
;
722 /* If EOF is typed, *line is NULL. */
726 p
= skip_spaces_const (line
);
728 /* Symbol lookup etc. */
729 if (*p
== '\0') /* empty line: just prompt for another line. */
732 if (*p
== '#') /* comment line */
735 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
737 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
739 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
741 int trace_string
= 0;
744 p
= decode_agent_options (p
, &trace_string
);
747 { /* Repeat over a comma-separated list. */
748 QUIT
; /* Allow user to bail out with ^C. */
749 p
= skip_spaces_const (p
);
751 if (*p
== '$') /* Look for special pseudo-symbols. */
753 if (0 == strncasecmp ("reg", p
+ 1, 3)
754 || 0 == strncasecmp ("arg", p
+ 1, 3)
755 || 0 == strncasecmp ("loc", p
+ 1, 3)
756 || 0 == strncasecmp ("_ret", p
+ 1, 4)
757 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
762 /* else fall thru, treat p as an expression and parse it! */
765 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
768 exp
= parse_exp_1 (&p
, loc
->address
,
769 block_for_pc (loc
->address
), 1);
770 old_chain
= make_cleanup (free_current_contents
, &exp
);
772 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
774 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
776 error (_("constant `%s' (value %s) "
777 "will not be collected."),
778 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
779 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
781 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
782 == LOC_OPTIMIZED_OUT
)
784 error (_("`%s' is optimized away "
785 "and cannot be collected."),
786 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
790 /* We have something to collect, make sure that the expr to
791 bytecode translator can handle it and that it's not too
793 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
794 make_cleanup_free_agent_expr (aexpr
);
796 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
797 error (_("Expression is too complicated."));
801 report_agent_reqs_errors (aexpr
);
803 do_cleanups (old_chain
);
806 while (p
&& *p
++ == ',');
809 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
812 { /* Repeat over a comma-separated list. */
813 QUIT
; /* Allow user to bail out with ^C. */
814 p
= skip_spaces_const (p
);
817 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
821 /* Only expressions are allowed for this action. */
822 exp
= parse_exp_1 (&p
, loc
->address
,
823 block_for_pc (loc
->address
), 1);
824 old_chain
= make_cleanup (free_current_contents
, &exp
);
826 /* We have something to evaluate, make sure that the expr to
827 bytecode translator can handle it and that it's not too
829 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
830 make_cleanup_free_agent_expr (aexpr
);
832 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
833 error (_("Expression is too complicated."));
836 report_agent_reqs_errors (aexpr
);
838 do_cleanups (old_chain
);
841 while (p
&& *p
++ == ',');
844 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
848 p
= skip_spaces_const (p
);
849 t
->step_count
= strtol (p
, &endp
, 0);
850 if (endp
== p
|| t
->step_count
== 0)
851 error (_("while-stepping step count `%s' is malformed."), line
);
855 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
859 error (_("`%s' is not a supported tracepoint action."), line
);
863 memrange_absolute
= -1
866 /* MEMRANGE functions: */
868 static int memrange_cmp (const void *, const void *);
870 /* Compare memranges for qsort. */
872 memrange_cmp (const void *va
, const void *vb
)
874 const struct memrange
*a
= va
, *b
= vb
;
876 if (a
->type
< b
->type
)
878 if (a
->type
> b
->type
)
880 if (a
->type
== memrange_absolute
)
882 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
884 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
889 if (a
->start
< b
->start
)
891 if (a
->start
> b
->start
)
897 /* Sort the memrange list using qsort, and merge adjacent memranges. */
899 memrange_sortmerge (struct collection_list
*memranges
)
903 qsort (memranges
->list
, memranges
->next_memrange
,
904 sizeof (struct memrange
), memrange_cmp
);
905 if (memranges
->next_memrange
> 0)
907 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
909 /* If memrange b overlaps or is adjacent to memrange a,
911 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
912 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
914 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
915 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
916 continue; /* next b, same a */
920 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
921 sizeof (struct memrange
));
923 memranges
->next_memrange
= a
+ 1;
927 /* Add a register to a collection list. */
929 add_register (struct collection_list
*collection
, unsigned int regno
)
932 printf_filtered ("collect register %d\n", regno
);
933 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
934 error (_("Internal: register number %d too large for tracepoint"),
936 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
939 /* Add a memrange to a collection list. */
941 add_memrange (struct collection_list
*memranges
,
942 int type
, bfd_signed_vma base
,
947 printf_filtered ("(%d,", type
);
949 printf_filtered (",%ld)\n", len
);
952 /* type: memrange_absolute == memory, other n == basereg */
953 memranges
->list
[memranges
->next_memrange
].type
= type
;
954 /* base: addr if memory, offset if reg relative. */
955 memranges
->list
[memranges
->next_memrange
].start
= base
;
956 /* len: we actually save end (base + len) for convenience */
957 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
958 memranges
->next_memrange
++;
959 if (memranges
->next_memrange
>= memranges
->listsize
)
961 memranges
->listsize
*= 2;
962 memranges
->list
= xrealloc (memranges
->list
,
963 memranges
->listsize
);
966 if (type
!= memrange_absolute
) /* Better collect the base register! */
967 add_register (memranges
, type
);
970 /* Add a symbol to a collection list. */
972 collect_symbol (struct collection_list
*collect
,
974 struct gdbarch
*gdbarch
,
975 long frame_regno
, long frame_offset
,
981 bfd_signed_vma offset
;
982 int treat_as_expr
= 0;
984 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
985 switch (SYMBOL_CLASS (sym
))
988 printf_filtered ("%s: don't know symbol class %d\n",
989 SYMBOL_PRINT_NAME (sym
),
993 printf_filtered ("constant %s (value %s) will not be collected.\n",
994 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
997 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1002 sprintf_vma (tmp
, offset
);
1003 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1004 SYMBOL_PRINT_NAME (sym
), len
,
1007 /* A struct may be a C++ class with static fields, go to general
1008 expression handling. */
1009 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1012 add_memrange (collect
, memrange_absolute
, offset
, len
);
1015 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1017 printf_filtered ("LOC_REG[parm] %s: ",
1018 SYMBOL_PRINT_NAME (sym
));
1019 add_register (collect
, reg
);
1020 /* Check for doubles stored in two registers. */
1021 /* FIXME: how about larger types stored in 3 or more regs? */
1022 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1023 len
> register_size (gdbarch
, reg
))
1024 add_register (collect
, reg
+ 1);
1027 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1028 printf_filtered (" (will not collect %s)\n",
1029 SYMBOL_PRINT_NAME (sym
));
1033 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1036 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1037 SYMBOL_PRINT_NAME (sym
), len
);
1038 printf_vma (offset
);
1039 printf_filtered (" from frame ptr reg %d\n", reg
);
1041 add_memrange (collect
, reg
, offset
, len
);
1043 case LOC_REGPARM_ADDR
:
1044 reg
= SYMBOL_VALUE (sym
);
1048 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1049 SYMBOL_PRINT_NAME (sym
), len
);
1050 printf_vma (offset
);
1051 printf_filtered (" from reg %d\n", reg
);
1053 add_memrange (collect
, reg
, offset
, len
);
1057 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1060 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1061 SYMBOL_PRINT_NAME (sym
), len
);
1062 printf_vma (offset
);
1063 printf_filtered (" from frame ptr reg %d\n", reg
);
1065 add_memrange (collect
, reg
, offset
, len
);
1068 case LOC_UNRESOLVED
:
1072 case LOC_OPTIMIZED_OUT
:
1073 printf_filtered ("%s has been optimized out of existence.\n",
1074 SYMBOL_PRINT_NAME (sym
));
1082 /* Expressions are the most general case. */
1085 struct agent_expr
*aexpr
;
1086 struct cleanup
*old_chain1
= NULL
;
1088 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1090 /* It can happen that the symbol is recorded as a computed
1091 location, but it's been optimized away and doesn't actually
1092 have a location expression. */
1095 printf_filtered ("%s has been optimized out of existence.\n",
1096 SYMBOL_PRINT_NAME (sym
));
1100 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1104 report_agent_reqs_errors (aexpr
);
1106 discard_cleanups (old_chain1
);
1107 add_aexpr (collect
, aexpr
);
1109 /* Take care of the registers. */
1110 if (aexpr
->reg_mask_len
> 0)
1114 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1116 QUIT
; /* Allow user to bail out with ^C. */
1117 if (aexpr
->reg_mask
[ndx1
] != 0)
1119 /* Assume chars have 8 bits. */
1120 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1121 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1122 /* It's used -- record it. */
1123 add_register (collect
, ndx1
* 8 + ndx2
);
1130 /* Data to be passed around in the calls to the locals and args
1133 struct add_local_symbols_data
1135 struct collection_list
*collect
;
1136 struct gdbarch
*gdbarch
;
1144 /* The callback for the locals and args iterators. */
1147 do_collect_symbol (const char *print_name
,
1151 struct add_local_symbols_data
*p
= cb_data
;
1153 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1154 p
->frame_offset
, p
->pc
, p
->trace_string
);
1157 VEC_safe_push (char_ptr
, p
->collect
->wholly_collected
,
1158 xstrdup (print_name
));
1161 /* Add all locals (or args) symbols to collection list. */
1163 add_local_symbols (struct collection_list
*collect
,
1164 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1165 long frame_regno
, long frame_offset
, int type
,
1168 struct block
*block
;
1169 struct add_local_symbols_data cb_data
;
1171 cb_data
.collect
= collect
;
1172 cb_data
.gdbarch
= gdbarch
;
1174 cb_data
.frame_regno
= frame_regno
;
1175 cb_data
.frame_offset
= frame_offset
;
1177 cb_data
.trace_string
= trace_string
;
1181 block
= block_for_pc (pc
);
1184 warning (_("Can't collect locals; "
1185 "no symbol table info available.\n"));
1189 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1190 if (cb_data
.count
== 0)
1191 warning (_("No locals found in scope."));
1195 pc
= get_pc_function_start (pc
);
1196 block
= block_for_pc (pc
);
1199 warning (_("Can't collect args; no symbol table info available."));
1203 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1204 if (cb_data
.count
== 0)
1205 warning (_("No args found in scope."));
1210 add_static_trace_data (struct collection_list
*collection
)
1213 printf_filtered ("collect static trace data\n");
1214 collection
->strace_data
= 1;
1217 /* worker function */
1219 clear_collection_list (struct collection_list
*list
)
1223 list
->next_memrange
= 0;
1224 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1226 free_agent_expr (list
->aexpr_list
[ndx
]);
1227 list
->aexpr_list
[ndx
] = NULL
;
1229 list
->next_aexpr_elt
= 0;
1230 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1231 list
->strace_data
= 0;
1233 xfree (list
->aexpr_list
);
1236 VEC_free (char_ptr
, list
->wholly_collected
);
1237 VEC_free (char_ptr
, list
->computed
);
1240 /* A cleanup wrapper for function clear_collection_list. */
1243 do_clear_collection_list (void *list
)
1245 struct collection_list
*l
= list
;
1247 clear_collection_list (l
);
1250 /* Initialize collection_list CLIST. */
1253 init_collection_list (struct collection_list
*clist
)
1255 memset (clist
, 0, sizeof *clist
);
1257 clist
->listsize
= 128;
1258 clist
->list
= xcalloc (clist
->listsize
,
1259 sizeof (struct memrange
));
1261 clist
->aexpr_listsize
= 128;
1262 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1263 sizeof (struct agent_expr
*));
1266 /* Reduce a collection list to string form (for gdb protocol). */
1268 stringify_collection_list (struct collection_list
*list
)
1270 char temp_buf
[2048];
1274 char *(*str_list
)[];
1278 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1279 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1281 if (list
->strace_data
)
1284 printf_filtered ("\nCollecting static trace data\n");
1287 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1291 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1292 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1294 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1297 printf_filtered ("\nCollecting registers (mask): 0x");
1302 QUIT
; /* Allow user to bail out with ^C. */
1304 printf_filtered ("%02X", list
->regs_mask
[i
]);
1305 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1308 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1312 printf_filtered ("\n");
1313 if (list
->next_memrange
> 0 && info_verbose
)
1314 printf_filtered ("Collecting memranges: \n");
1315 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1317 QUIT
; /* Allow user to bail out with ^C. */
1318 sprintf_vma (tmp2
, list
->list
[i
].start
);
1321 printf_filtered ("(%d, %s, %ld)\n",
1324 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1326 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1328 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1335 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1337 /* The "%X" conversion specifier expects an unsigned argument,
1338 so passing -1 (memrange_absolute) to it directly gives you
1339 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1341 if (list
->list
[i
].type
== memrange_absolute
)
1342 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1344 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1347 count
+= strlen (end
);
1348 end
= temp_buf
+ count
;
1351 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1353 QUIT
; /* Allow user to bail out with ^C. */
1354 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1356 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1361 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1362 end
+= 10; /* 'X' + 8 hex digits + ',' */
1365 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1366 end
, list
->aexpr_list
[i
]->len
);
1367 count
+= 2 * list
->aexpr_list
[i
]->len
;
1372 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1377 (*str_list
)[ndx
] = NULL
;
1388 /* Add the printed expression EXP to *LIST. */
1391 append_exp (struct expression
*exp
, VEC(char_ptr
) **list
)
1393 struct ui_file
*tmp_stream
= mem_fileopen ();
1396 print_expression (exp
, tmp_stream
);
1398 text
= ui_file_xstrdup (tmp_stream
, NULL
);
1400 VEC_safe_push (char_ptr
, *list
, text
);
1401 ui_file_delete (tmp_stream
);
1405 encode_actions_1 (struct command_line
*action
,
1406 struct bp_location
*tloc
,
1408 LONGEST frame_offset
,
1409 struct collection_list
*collect
,
1410 struct collection_list
*stepping_list
)
1412 const char *action_exp
;
1413 struct expression
*exp
= NULL
;
1415 struct value
*tempval
;
1416 struct cmd_list_element
*cmd
;
1417 struct agent_expr
*aexpr
;
1419 for (; action
; action
= action
->next
)
1421 QUIT
; /* Allow user to bail out with ^C. */
1422 action_exp
= action
->line
;
1423 action_exp
= skip_spaces_const (action_exp
);
1425 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1427 error (_("Bad action list item: %s"), action_exp
);
1429 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1431 int trace_string
= 0;
1433 if (*action_exp
== '/')
1434 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1437 { /* Repeat over a comma-separated list. */
1438 QUIT
; /* Allow user to bail out with ^C. */
1439 action_exp
= skip_spaces_const (action_exp
);
1441 if (0 == strncasecmp ("$reg", action_exp
, 4))
1443 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1444 add_register (collect
, i
);
1445 action_exp
= strchr (action_exp
, ','); /* more? */
1447 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1449 add_local_symbols (collect
,
1456 action_exp
= strchr (action_exp
, ','); /* more? */
1458 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1460 add_local_symbols (collect
,
1467 action_exp
= strchr (action_exp
, ','); /* more? */
1469 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1471 struct cleanup
*old_chain1
= NULL
;
1473 aexpr
= gen_trace_for_return_address (tloc
->address
,
1477 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1480 report_agent_reqs_errors (aexpr
);
1482 discard_cleanups (old_chain1
);
1483 add_aexpr (collect
, aexpr
);
1485 /* take care of the registers */
1486 if (aexpr
->reg_mask_len
> 0)
1490 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1492 QUIT
; /* allow user to bail out with ^C */
1493 if (aexpr
->reg_mask
[ndx1
] != 0)
1495 /* assume chars have 8 bits */
1496 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1497 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1498 /* it's used -- record it */
1499 add_register (collect
,
1505 action_exp
= strchr (action_exp
, ','); /* more? */
1507 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1509 add_static_trace_data (collect
);
1510 action_exp
= strchr (action_exp
, ','); /* more? */
1515 struct cleanup
*old_chain
= NULL
;
1516 struct cleanup
*old_chain1
= NULL
;
1518 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1519 block_for_pc (tloc
->address
), 1);
1520 old_chain
= make_cleanup (free_current_contents
, &exp
);
1522 switch (exp
->elts
[0].opcode
)
1526 const char *name
= &exp
->elts
[2].string
;
1528 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1529 name
, strlen (name
));
1531 internal_error (__FILE__
, __LINE__
,
1532 _("Register $%s not available"),
1535 printf_filtered ("OP_REGISTER: ");
1536 add_register (collect
, i
);
1541 /* Safe because we know it's a simple expression. */
1542 tempval
= evaluate_expression (exp
);
1543 addr
= value_address (tempval
);
1544 /* Initialize the TYPE_LENGTH if it is a typedef. */
1545 check_typedef (exp
->elts
[1].type
);
1546 add_memrange (collect
, memrange_absolute
, addr
,
1547 TYPE_LENGTH (exp
->elts
[1].type
));
1548 append_exp (exp
, &collect
->computed
);
1553 struct symbol
*sym
= exp
->elts
[2].symbol
;
1554 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1556 collect_symbol (collect
,
1557 exp
->elts
[2].symbol
,
1563 VEC_safe_push (char_ptr
,
1564 collect
->wholly_collected
,
1569 default: /* Full-fledged expression. */
1570 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1573 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1577 report_agent_reqs_errors (aexpr
);
1579 discard_cleanups (old_chain1
);
1580 add_aexpr (collect
, aexpr
);
1582 /* Take care of the registers. */
1583 if (aexpr
->reg_mask_len
> 0)
1588 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1590 QUIT
; /* Allow user to bail out with ^C. */
1591 if (aexpr
->reg_mask
[ndx1
] != 0)
1593 /* Assume chars have 8 bits. */
1594 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1595 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1596 /* It's used -- record it. */
1597 add_register (collect
,
1603 append_exp (exp
, &collect
->computed
);
1606 do_cleanups (old_chain
);
1609 while (action_exp
&& *action_exp
++ == ',');
1611 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1614 { /* Repeat over a comma-separated list. */
1615 QUIT
; /* Allow user to bail out with ^C. */
1616 action_exp
= skip_spaces_const (action_exp
);
1619 struct cleanup
*old_chain
= NULL
;
1620 struct cleanup
*old_chain1
= NULL
;
1622 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1623 block_for_pc (tloc
->address
), 1);
1624 old_chain
= make_cleanup (free_current_contents
, &exp
);
1626 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1627 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1630 report_agent_reqs_errors (aexpr
);
1632 discard_cleanups (old_chain1
);
1633 /* Even though we're not officially collecting, add
1634 to the collect list anyway. */
1635 add_aexpr (collect
, aexpr
);
1637 do_cleanups (old_chain
);
1640 while (action_exp
&& *action_exp
++ == ',');
1642 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1644 /* We check against nested while-stepping when setting
1645 breakpoint action, so no way to run into nested
1647 gdb_assert (stepping_list
);
1649 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1650 frame_offset
, stepping_list
, NULL
);
1653 error (_("Invalid tracepoint command '%s'"), action
->line
);
1657 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1658 and STEPPING_LIST. Return a cleanup pointer to clean up both
1659 TRACEPOINT_LIST and STEPPING_LIST. */
1662 encode_actions_and_make_cleanup (struct bp_location
*tloc
,
1663 struct collection_list
*tracepoint_list
,
1664 struct collection_list
*stepping_list
)
1666 char *default_collect_line
= NULL
;
1667 struct command_line
*actions
;
1668 struct command_line
*default_collect_action
= NULL
;
1670 LONGEST frame_offset
;
1671 struct cleanup
*back_to
, *return_chain
;
1673 return_chain
= make_cleanup (null_cleanup
, NULL
);
1674 init_collection_list (tracepoint_list
);
1675 init_collection_list (stepping_list
);
1677 make_cleanup (do_clear_collection_list
, tracepoint_list
);
1678 make_cleanup (do_clear_collection_list
, stepping_list
);
1680 back_to
= make_cleanup (null_cleanup
, NULL
);
1681 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1682 tloc
->address
, &frame_reg
, &frame_offset
);
1684 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1686 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1687 tracepoint_list
, stepping_list
);
1689 memrange_sortmerge (tracepoint_list
);
1690 memrange_sortmerge (stepping_list
);
1692 do_cleanups (back_to
);
1693 return return_chain
;
1696 /* Render all actions into gdb protocol. */
1699 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1700 char ***stepping_actions
)
1702 struct collection_list tracepoint_list
, stepping_list
;
1703 struct cleanup
*cleanup
;
1705 *tdp_actions
= NULL
;
1706 *stepping_actions
= NULL
;
1708 cleanup
= encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
1711 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1712 *stepping_actions
= stringify_collection_list (&stepping_list
);
1714 do_cleanups (cleanup
);
1718 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1720 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1722 collect
->aexpr_list
=
1723 xrealloc (collect
->aexpr_list
,
1724 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1725 collect
->aexpr_listsize
*= 2;
1727 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1728 collect
->next_aexpr_elt
++;
1732 process_tracepoint_on_disconnect (void)
1734 VEC(breakpoint_p
) *tp_vec
= NULL
;
1736 struct breakpoint
*b
;
1737 int has_pending_p
= 0;
1739 /* Check whether we still have pending tracepoint. If we have, warn the
1740 user that pending tracepoint will no longer work. */
1741 tp_vec
= all_tracepoints ();
1742 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1751 struct bp_location
*loc1
;
1753 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1755 if (loc1
->shlib_disabled
)
1766 VEC_free (breakpoint_p
, tp_vec
);
1769 warning (_("Pending tracepoints will not be resolved while"
1770 " GDB is disconnected\n"));
1773 /* Reset local state of tracing. */
1776 trace_reset_local_state (void)
1778 set_traceframe_num (-1);
1779 set_tracepoint_num (-1);
1780 set_traceframe_context (NULL
);
1781 clear_traceframe_info ();
1785 start_tracing (char *notes
)
1787 VEC(breakpoint_p
) *tp_vec
= NULL
;
1789 struct breakpoint
*b
;
1790 struct trace_state_variable
*tsv
;
1791 int any_enabled
= 0, num_to_download
= 0;
1794 tp_vec
= all_tracepoints ();
1796 /* No point in tracing without any tracepoints... */
1797 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1799 VEC_free (breakpoint_p
, tp_vec
);
1800 error (_("No tracepoints defined, not starting trace"));
1803 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1805 struct tracepoint
*t
= (struct tracepoint
*) b
;
1806 struct bp_location
*loc
;
1808 if (b
->enable_state
== bp_enabled
)
1811 if ((b
->type
== bp_fast_tracepoint
1812 ? may_insert_fast_tracepoints
1813 : may_insert_tracepoints
))
1816 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1817 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1822 if (target_supports_enable_disable_tracepoint ())
1823 warning (_("No tracepoints enabled"));
1826 /* No point in tracing with only disabled tracepoints that
1827 cannot be re-enabled. */
1828 VEC_free (breakpoint_p
, tp_vec
);
1829 error (_("No tracepoints enabled, not starting trace"));
1833 if (num_to_download
<= 0)
1835 VEC_free (breakpoint_p
, tp_vec
);
1836 error (_("No tracepoints that may be downloaded, not starting trace"));
1839 target_trace_init ();
1841 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1843 struct tracepoint
*t
= (struct tracepoint
*) b
;
1844 struct bp_location
*loc
;
1845 int bp_location_downloaded
= 0;
1847 /* Clear `inserted' flag. */
1848 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1851 if ((b
->type
== bp_fast_tracepoint
1852 ? !may_insert_fast_tracepoints
1853 : !may_insert_tracepoints
))
1856 t
->number_on_target
= 0;
1858 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1860 /* Since tracepoint locations are never duplicated, `inserted'
1861 flag should be zero. */
1862 gdb_assert (!loc
->inserted
);
1864 target_download_tracepoint (loc
);
1867 bp_location_downloaded
= 1;
1870 t
->number_on_target
= b
->number
;
1872 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1873 if (loc
->probe
!= NULL
)
1874 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1876 if (bp_location_downloaded
)
1877 observer_notify_breakpoint_modified (b
);
1879 VEC_free (breakpoint_p
, tp_vec
);
1881 /* Send down all the trace state variables too. */
1882 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1884 target_download_trace_state_variable (tsv
);
1887 /* Tell target to treat text-like sections as transparent. */
1888 target_trace_set_readonly_regions ();
1889 /* Set some mode flags. */
1890 target_set_disconnected_tracing (disconnected_tracing
);
1891 target_set_circular_trace_buffer (circular_trace_buffer
);
1892 target_set_trace_buffer_size (trace_buffer_size
);
1895 notes
= trace_notes
;
1896 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1898 if (!ret
&& (trace_user
|| notes
))
1899 warning (_("Target does not support trace user/notes, info ignored"));
1901 /* Now insert traps and begin collecting data. */
1902 target_trace_start ();
1904 /* Reset our local state. */
1905 trace_reset_local_state ();
1906 current_trace_status()->running
= 1;
1909 /* The tstart command requests the target to start a new trace run.
1910 The command passes any arguments it has to the target verbatim, as
1911 an optional "trace note". This is useful as for instance a warning
1912 to other users if the trace runs disconnected, and you don't want
1913 anybody else messing with the target. */
1916 trace_start_command (char *args
, int from_tty
)
1918 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1920 if (current_trace_status ()->running
)
1923 && !query (_("A trace is running already. Start a new run? ")))
1924 error (_("New trace run not started."));
1927 start_tracing (args
);
1930 /* The tstop command stops the tracing run. The command passes any
1931 supplied arguments to the target verbatim as a "stop note"; if the
1932 target supports trace notes, then it will be reported back as part
1933 of the trace run's status. */
1936 trace_stop_command (char *args
, int from_tty
)
1938 if (!current_trace_status ()->running
)
1939 error (_("Trace is not running."));
1941 stop_tracing (args
);
1945 stop_tracing (char *note
)
1948 VEC(breakpoint_p
) *tp_vec
= NULL
;
1950 struct breakpoint
*t
;
1952 target_trace_stop ();
1954 tp_vec
= all_tracepoints ();
1955 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1957 struct bp_location
*loc
;
1959 if ((t
->type
== bp_fast_tracepoint
1960 ? !may_insert_fast_tracepoints
1961 : !may_insert_tracepoints
))
1964 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1966 /* GDB can be totally absent in some disconnected trace scenarios,
1967 but we don't really care if this semaphore goes out of sync.
1968 That's why we are decrementing it here, but not taking care
1970 if (loc
->probe
!= NULL
)
1971 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1975 VEC_free (breakpoint_p
, tp_vec
);
1978 note
= trace_stop_notes
;
1979 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1982 warning (_("Target does not support trace notes, note ignored"));
1984 /* Should change in response to reply? */
1985 current_trace_status ()->running
= 0;
1988 /* tstatus command */
1990 trace_status_command (char *args
, int from_tty
)
1992 struct trace_status
*ts
= current_trace_status ();
1994 VEC(breakpoint_p
) *tp_vec
= NULL
;
1995 struct breakpoint
*t
;
1997 status
= target_get_trace_status (ts
);
2001 if (ts
->filename
!= NULL
)
2002 printf_filtered (_("Using a trace file.\n"));
2005 printf_filtered (_("Trace can not be run on this target.\n"));
2010 if (!ts
->running_known
)
2012 printf_filtered (_("Run/stop status is unknown.\n"));
2014 else if (ts
->running
)
2016 printf_filtered (_("Trace is running on the target.\n"));
2020 switch (ts
->stop_reason
)
2022 case trace_never_run
:
2023 printf_filtered (_("No trace has been run on the target.\n"));
2027 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2030 printf_filtered (_("Trace stopped by a tstop command.\n"));
2032 case trace_buffer_full
:
2033 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2035 case trace_disconnected
:
2036 printf_filtered (_("Trace stopped because of disconnection.\n"));
2038 case tracepoint_passcount
:
2039 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2040 ts
->stopping_tracepoint
);
2042 case tracepoint_error
:
2043 if (ts
->stopping_tracepoint
)
2044 printf_filtered (_("Trace stopped by an "
2045 "error (%s, tracepoint %d).\n"),
2046 ts
->stop_desc
, ts
->stopping_tracepoint
);
2048 printf_filtered (_("Trace stopped by an error (%s).\n"),
2051 case trace_stop_reason_unknown
:
2052 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2055 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2061 if (ts
->traceframes_created
>= 0
2062 && ts
->traceframe_count
!= ts
->traceframes_created
)
2064 printf_filtered (_("Buffer contains %d trace "
2065 "frames (of %d created total).\n"),
2066 ts
->traceframe_count
, ts
->traceframes_created
);
2068 else if (ts
->traceframe_count
>= 0)
2070 printf_filtered (_("Collected %d trace frames.\n"),
2071 ts
->traceframe_count
);
2074 if (ts
->buffer_free
>= 0)
2076 if (ts
->buffer_size
>= 0)
2078 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2079 ts
->buffer_free
, ts
->buffer_size
);
2080 if (ts
->buffer_size
> 0)
2081 printf_filtered (_(" (%d%% full)"),
2082 ((int) ((((long long) (ts
->buffer_size
2083 - ts
->buffer_free
)) * 100)
2084 / ts
->buffer_size
)));
2085 printf_filtered (_(".\n"));
2088 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2092 if (ts
->disconnected_tracing
)
2093 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2095 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2097 if (ts
->circular_buffer
)
2098 printf_filtered (_("Trace buffer is circular.\n"));
2100 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2101 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2103 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2104 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2106 /* Now report on what we're doing with tfind. */
2107 if (traceframe_number
>= 0)
2108 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2109 traceframe_number
, tracepoint_number
);
2111 printf_filtered (_("Not looking at any trace frame.\n"));
2113 /* Report start/stop times if supplied. */
2118 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2120 /* Reporting a run time is more readable than two long numbers. */
2121 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2122 (long int) (ts
->start_time
/ 1000000),
2123 (long int) (ts
->start_time
% 1000000),
2124 (long int) (run_time
/ 1000000),
2125 (long int) (run_time
% 1000000));
2128 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2129 (long int) (ts
->start_time
/ 1000000),
2130 (long int) (ts
->start_time
% 1000000));
2132 else if (ts
->stop_time
)
2133 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2134 (long int) (ts
->stop_time
/ 1000000),
2135 (long int) (ts
->stop_time
% 1000000));
2137 /* Now report any per-tracepoint status available. */
2138 tp_vec
= all_tracepoints ();
2140 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2141 target_get_tracepoint_status (t
, NULL
);
2143 VEC_free (breakpoint_p
, tp_vec
);
2146 /* Report the trace status to uiout, in a way suitable for MI, and not
2147 suitable for CLI. If ON_STOP is true, suppress a few fields that
2148 are not meaningful in the -trace-stop response.
2150 The implementation is essentially parallel to trace_status_command, but
2151 merging them will result in unreadable code. */
2153 trace_status_mi (int on_stop
)
2155 struct ui_out
*uiout
= current_uiout
;
2156 struct trace_status
*ts
= current_trace_status ();
2159 status
= target_get_trace_status (ts
);
2161 if (status
== -1 && ts
->filename
== NULL
)
2163 ui_out_field_string (uiout
, "supported", "0");
2167 if (ts
->filename
!= NULL
)
2168 ui_out_field_string (uiout
, "supported", "file");
2170 ui_out_field_string (uiout
, "supported", "1");
2172 if (ts
->filename
!= NULL
)
2173 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2175 gdb_assert (ts
->running_known
);
2179 ui_out_field_string (uiout
, "running", "1");
2181 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2182 Given that the frontend gets the status either on -trace-stop, or from
2183 -trace-status after re-connection, it does not seem like this
2184 information is necessary for anything. It is not necessary for either
2185 figuring the vital state of the target nor for navigation of trace
2186 frames. If the frontend wants to show the current state is some
2187 configure dialog, it can request the value when such dialog is
2188 invoked by the user. */
2192 char *stop_reason
= NULL
;
2193 int stopping_tracepoint
= -1;
2196 ui_out_field_string (uiout
, "running", "0");
2198 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2200 switch (ts
->stop_reason
)
2203 stop_reason
= "request";
2205 case trace_buffer_full
:
2206 stop_reason
= "overflow";
2208 case trace_disconnected
:
2209 stop_reason
= "disconnection";
2211 case tracepoint_passcount
:
2212 stop_reason
= "passcount";
2213 stopping_tracepoint
= ts
->stopping_tracepoint
;
2215 case tracepoint_error
:
2216 stop_reason
= "error";
2217 stopping_tracepoint
= ts
->stopping_tracepoint
;
2223 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2224 if (stopping_tracepoint
!= -1)
2225 ui_out_field_int (uiout
, "stopping-tracepoint",
2226 stopping_tracepoint
);
2227 if (ts
->stop_reason
== tracepoint_error
)
2228 ui_out_field_string (uiout
, "error-description",
2234 if (ts
->traceframe_count
!= -1)
2235 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2236 if (ts
->traceframes_created
!= -1)
2237 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2238 if (ts
->buffer_size
!= -1)
2239 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2240 if (ts
->buffer_free
!= -1)
2241 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2243 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2244 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2246 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2247 ui_out_field_string (uiout
, "notes", ts
->notes
);
2252 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2253 (long int) (ts
->start_time
/ 1000000),
2254 (long int) (ts
->start_time
% 1000000));
2255 ui_out_field_string (uiout
, "start-time", buf
);
2256 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2257 (long int) (ts
->stop_time
/ 1000000),
2258 (long int) (ts
->stop_time
% 1000000));
2259 ui_out_field_string (uiout
, "stop-time", buf
);
2263 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2264 user if she really wants to detach. */
2267 query_if_trace_running (int from_tty
)
2272 /* It can happen that the target that was tracing went away on its
2273 own, and we didn't notice. Get a status update, and if the
2274 current target doesn't even do tracing, then assume it's not
2276 if (target_get_trace_status (current_trace_status ()) < 0)
2277 current_trace_status ()->running
= 0;
2279 /* If running interactively, give the user the option to cancel and
2280 then decide what to do differently with the run. Scripts are
2281 just going to disconnect and let the target deal with it,
2282 according to how it's been instructed previously via
2283 disconnected-tracing. */
2284 if (current_trace_status ()->running
)
2286 process_tracepoint_on_disconnect ();
2288 if (current_trace_status ()->disconnected_tracing
)
2290 if (!query (_("Trace is running and will "
2291 "continue after detach; detach anyway? ")))
2292 error (_("Not confirmed."));
2296 if (!query (_("Trace is running but will "
2297 "stop on detach; detach anyway? ")))
2298 error (_("Not confirmed."));
2303 /* This function handles the details of what to do about an ongoing
2304 tracing run if the user has asked to detach or otherwise disconnect
2308 disconnect_tracing (void)
2310 /* Also we want to be out of tfind mode, otherwise things can get
2311 confusing upon reconnection. Just use these calls instead of
2312 full tfind_1 behavior because we're in the middle of detaching,
2313 and there's no point to updating current stack frame etc. */
2314 trace_reset_local_state ();
2317 /* Worker function for the various flavors of the tfind command. */
2319 tfind_1 (enum trace_find_type type
, int num
,
2320 CORE_ADDR addr1
, CORE_ADDR addr2
,
2323 int target_frameno
= -1, target_tracept
= -1;
2324 struct frame_id old_frame_id
= null_frame_id
;
2325 struct tracepoint
*tp
;
2326 struct ui_out
*uiout
= current_uiout
;
2328 /* Only try to get the current stack frame if we have a chance of
2329 succeeding. In particular, if we're trying to get a first trace
2330 frame while all threads are running, it's not going to succeed,
2331 so leave it with a default value and let the frame comparison
2332 below (correctly) decide to print out the source location of the
2334 if (!(type
== tfind_number
&& num
== -1)
2335 && (has_stack_frames () || traceframe_number
>= 0))
2336 old_frame_id
= get_frame_id (get_current_frame ());
2338 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2341 if (type
== tfind_number
2343 && target_frameno
== -1)
2345 /* We told the target to get out of tfind mode, and it did. */
2347 else if (target_frameno
== -1)
2349 /* A request for a non-existent trace frame has failed.
2350 Our response will be different, depending on FROM_TTY:
2352 If FROM_TTY is true, meaning that this command was
2353 typed interactively by the user, then give an error
2354 and DO NOT change the state of traceframe_number etc.
2356 However if FROM_TTY is false, meaning that we're either
2357 in a script, a loop, or a user-defined command, then
2358 DON'T give an error, but DO change the state of
2359 traceframe_number etc. to invalid.
2361 The rationalle is that if you typed the command, you
2362 might just have committed a typo or something, and you'd
2363 like to NOT lose your current debugging state. However
2364 if you're in a user-defined command or especially in a
2365 loop, then you need a way to detect that the command
2366 failed WITHOUT aborting. This allows you to write
2367 scripts that search thru the trace buffer until the end,
2368 and then continue on to do something else. */
2371 error (_("Target failed to find requested trace frame."));
2375 printf_filtered ("End of trace buffer.\n");
2376 #if 0 /* dubious now? */
2377 /* The following will not recurse, since it's
2379 trace_find_command ("-1", from_tty
);
2384 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2386 reinit_frame_cache ();
2387 target_dcache_invalidate ();
2389 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2391 if (target_frameno
!= get_traceframe_number ())
2392 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2394 set_current_traceframe (target_frameno
);
2396 if (target_frameno
== -1)
2397 set_traceframe_context (NULL
);
2399 set_traceframe_context (get_current_frame ());
2401 if (traceframe_number
>= 0)
2403 /* Use different branches for MI and CLI to make CLI messages
2405 if (ui_out_is_mi_like_p (uiout
))
2407 ui_out_field_string (uiout
, "found", "1");
2408 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2409 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2413 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2414 traceframe_number
, tracepoint_number
);
2419 if (ui_out_is_mi_like_p (uiout
))
2420 ui_out_field_string (uiout
, "found", "0");
2421 else if (type
== tfind_number
&& num
== -1)
2422 printf_unfiltered (_("No longer looking at any trace frame\n"));
2423 else /* This case may never occur, check. */
2424 printf_unfiltered (_("No trace frame found\n"));
2427 /* If we're in nonstop mode and getting out of looking at trace
2428 frames, there won't be any current frame to go back to and
2431 && (has_stack_frames () || traceframe_number
>= 0))
2433 enum print_what print_what
;
2435 /* NOTE: in imitation of the step command, try to determine
2436 whether we have made a transition from one function to
2437 another. If so, we'll print the "stack frame" (ie. the new
2438 function and it's arguments) -- otherwise we'll just show the
2441 if (frame_id_eq (old_frame_id
,
2442 get_frame_id (get_current_frame ())))
2443 print_what
= SRC_LINE
;
2445 print_what
= SRC_AND_LOC
;
2447 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2452 /* trace_find_command takes a trace frame number n,
2453 sends "QTFrame:<n>" to the target,
2454 and accepts a reply that may contain several optional pieces
2455 of information: a frame number, a tracepoint number, and an
2456 indication of whether this is a trap frame or a stepping frame.
2458 The minimal response is just "OK" (which indicates that the
2459 target does not give us a frame number or a tracepoint number).
2460 Instead of that, the target may send us a string containing
2462 F<hexnum> (gives the selected frame number)
2463 T<hexnum> (gives the selected tracepoint number)
2468 trace_find_command (char *args
, int from_tty
)
2469 { /* This should only be called with a numeric argument. */
2472 if (current_trace_status ()->running
2473 && current_trace_status ()->filename
== NULL
)
2474 error (_("May not look at trace frames while trace is running."));
2476 if (args
== 0 || *args
== 0)
2477 { /* TFIND with no args means find NEXT trace frame. */
2478 if (traceframe_number
== -1)
2479 frameno
= 0; /* "next" is first one. */
2481 frameno
= traceframe_number
+ 1;
2483 else if (0 == strcmp (args
, "-"))
2485 if (traceframe_number
== -1)
2486 error (_("not debugging trace buffer"));
2487 else if (from_tty
&& traceframe_number
== 0)
2488 error (_("already at start of trace buffer"));
2490 frameno
= traceframe_number
- 1;
2492 /* A hack to work around eval's need for fp to have been collected. */
2493 else if (0 == strcmp (args
, "-1"))
2496 frameno
= parse_and_eval_long (args
);
2499 error (_("invalid input (%d is less than zero)"), frameno
);
2501 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2506 trace_find_end_command (char *args
, int from_tty
)
2508 trace_find_command ("-1", from_tty
);
2513 trace_find_start_command (char *args
, int from_tty
)
2515 trace_find_command ("0", from_tty
);
2518 /* tfind pc command */
2520 trace_find_pc_command (char *args
, int from_tty
)
2524 if (current_trace_status ()->running
2525 && current_trace_status ()->filename
== NULL
)
2526 error (_("May not look at trace frames while trace is running."));
2528 if (args
== 0 || *args
== 0)
2529 pc
= regcache_read_pc (get_current_regcache ());
2531 pc
= parse_and_eval_address (args
);
2533 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2536 /* tfind tracepoint command */
2538 trace_find_tracepoint_command (char *args
, int from_tty
)
2541 struct tracepoint
*tp
;
2543 if (current_trace_status ()->running
2544 && current_trace_status ()->filename
== NULL
)
2545 error (_("May not look at trace frames while trace is running."));
2547 if (args
== 0 || *args
== 0)
2549 if (tracepoint_number
== -1)
2550 error (_("No current tracepoint -- please supply an argument."));
2552 tdp
= tracepoint_number
; /* Default is current TDP. */
2555 tdp
= parse_and_eval_long (args
);
2557 /* If we have the tracepoint on hand, use the number that the
2558 target knows about (which may be different if we disconnected
2559 and reconnected). */
2560 tp
= get_tracepoint (tdp
);
2562 tdp
= tp
->number_on_target
;
2564 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2567 /* TFIND LINE command:
2569 This command will take a sourceline for argument, just like BREAK
2570 or TRACE (ie. anything that "decode_line_1" can handle).
2572 With no argument, this command will find the next trace frame
2573 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2576 trace_find_line_command (char *args
, int from_tty
)
2578 static CORE_ADDR start_pc
, end_pc
;
2579 struct symtabs_and_lines sals
;
2580 struct symtab_and_line sal
;
2581 struct cleanup
*old_chain
;
2583 if (current_trace_status ()->running
2584 && current_trace_status ()->filename
== NULL
)
2585 error (_("May not look at trace frames while trace is running."));
2587 if (args
== 0 || *args
== 0)
2589 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2591 sals
.sals
= (struct symtab_and_line
*)
2592 xmalloc (sizeof (struct symtab_and_line
));
2597 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2601 old_chain
= make_cleanup (xfree
, sals
.sals
);
2602 if (sal
.symtab
== 0)
2603 error (_("No line number information available."));
2605 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2607 if (start_pc
== end_pc
)
2609 printf_filtered ("Line %d of \"%s\"",
2611 symtab_to_filename_for_display (sal
.symtab
));
2613 printf_filtered (" is at address ");
2614 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2616 printf_filtered (" but contains no code.\n");
2617 sal
= find_pc_line (start_pc
, 0);
2619 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2620 && start_pc
!= end_pc
)
2621 printf_filtered ("Attempting to find line %d instead.\n",
2624 error (_("Cannot find a good line."));
2628 /* Is there any case in which we get here, and have an address
2629 which the user would want to see? If we have debugging
2630 symbols and no line numbers? */
2631 error (_("Line number %d is out of range for \"%s\"."),
2632 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2634 /* Find within range of stated line. */
2636 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2638 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2639 do_cleanups (old_chain
);
2642 /* tfind range command */
2644 trace_find_range_command (char *args
, int from_tty
)
2646 static CORE_ADDR start
, stop
;
2649 if (current_trace_status ()->running
2650 && current_trace_status ()->filename
== NULL
)
2651 error (_("May not look at trace frames while trace is running."));
2653 if (args
== 0 || *args
== 0)
2654 { /* XXX FIXME: what should default behavior be? */
2655 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2659 if (0 != (tmp
= strchr (args
, ',')))
2661 *tmp
++ = '\0'; /* Terminate start address. */
2662 tmp
= skip_spaces (tmp
);
2663 start
= parse_and_eval_address (args
);
2664 stop
= parse_and_eval_address (tmp
);
2667 { /* No explicit end address? */
2668 start
= parse_and_eval_address (args
);
2669 stop
= start
+ 1; /* ??? */
2672 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2675 /* tfind outside command */
2677 trace_find_outside_command (char *args
, int from_tty
)
2679 CORE_ADDR start
, stop
;
2682 if (current_trace_status ()->running
2683 && current_trace_status ()->filename
== NULL
)
2684 error (_("May not look at trace frames while trace is running."));
2686 if (args
== 0 || *args
== 0)
2687 { /* XXX FIXME: what should default behavior be? */
2688 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2692 if (0 != (tmp
= strchr (args
, ',')))
2694 *tmp
++ = '\0'; /* Terminate start address. */
2695 tmp
= skip_spaces (tmp
);
2696 start
= parse_and_eval_address (args
);
2697 stop
= parse_and_eval_address (tmp
);
2700 { /* No explicit end address? */
2701 start
= parse_and_eval_address (args
);
2702 stop
= start
+ 1; /* ??? */
2705 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2708 /* info scope command: list the locals for a scope. */
2710 scope_info (char *args
, int from_tty
)
2712 struct symtabs_and_lines sals
;
2714 struct minimal_symbol
*msym
;
2715 struct block
*block
;
2716 const char *symname
;
2717 char *save_args
= args
;
2718 struct block_iterator iter
;
2720 struct gdbarch
*gdbarch
;
2723 if (args
== 0 || *args
== 0)
2724 error (_("requires an argument (function, "
2725 "line or *addr) to define a scope"));
2727 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2728 if (sals
.nelts
== 0)
2729 return; /* Presumably decode_line_1 has already warned. */
2731 /* Resolve line numbers to PC. */
2732 resolve_sal_pc (&sals
.sals
[0]);
2733 block
= block_for_pc (sals
.sals
[0].pc
);
2737 QUIT
; /* Allow user to bail out with ^C. */
2738 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2740 QUIT
; /* Allow user to bail out with ^C. */
2742 printf_filtered ("Scope for %s:\n", save_args
);
2745 symname
= SYMBOL_PRINT_NAME (sym
);
2746 if (symname
== NULL
|| *symname
== '\0')
2747 continue; /* Probably botched, certainly useless. */
2749 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2751 printf_filtered ("Symbol %s is ", symname
);
2753 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2754 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2755 BLOCK_START (block
),
2759 switch (SYMBOL_CLASS (sym
))
2762 case LOC_UNDEF
: /* Messed up symbol? */
2763 printf_filtered ("a bogus symbol, class %d.\n",
2764 SYMBOL_CLASS (sym
));
2765 count
--; /* Don't count this one. */
2768 printf_filtered ("a constant with value %s (%s)",
2769 plongest (SYMBOL_VALUE (sym
)),
2770 hex_string (SYMBOL_VALUE (sym
)));
2772 case LOC_CONST_BYTES
:
2773 printf_filtered ("constant bytes: ");
2774 if (SYMBOL_TYPE (sym
))
2775 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2776 fprintf_filtered (gdb_stdout
, " %02x",
2777 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2780 printf_filtered ("in static storage at address ");
2781 printf_filtered ("%s", paddress (gdbarch
,
2782 SYMBOL_VALUE_ADDRESS (sym
)));
2785 /* GDBARCH is the architecture associated with the objfile
2786 the symbol is defined in; the target architecture may be
2787 different, and may provide additional registers. However,
2788 we do not know the target architecture at this point.
2789 We assume the objfile architecture will contain all the
2790 standard registers that occur in debug info in that
2792 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2795 if (SYMBOL_IS_ARGUMENT (sym
))
2796 printf_filtered ("an argument in register $%s",
2797 gdbarch_register_name (gdbarch
, regno
));
2799 printf_filtered ("a local variable in register $%s",
2800 gdbarch_register_name (gdbarch
, regno
));
2803 printf_filtered ("an argument at stack/frame offset %s",
2804 plongest (SYMBOL_VALUE (sym
)));
2807 printf_filtered ("a local variable at frame offset %s",
2808 plongest (SYMBOL_VALUE (sym
)));
2811 printf_filtered ("a reference argument at offset %s",
2812 plongest (SYMBOL_VALUE (sym
)));
2814 case LOC_REGPARM_ADDR
:
2815 /* Note comment at LOC_REGISTER. */
2816 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2818 printf_filtered ("the address of an argument, in register $%s",
2819 gdbarch_register_name (gdbarch
, regno
));
2822 printf_filtered ("a typedef.\n");
2825 printf_filtered ("a label at address ");
2826 printf_filtered ("%s", paddress (gdbarch
,
2827 SYMBOL_VALUE_ADDRESS (sym
)));
2830 printf_filtered ("a function at address ");
2831 printf_filtered ("%s",
2832 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2834 case LOC_UNRESOLVED
:
2835 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2838 printf_filtered ("Unresolved Static");
2841 printf_filtered ("static storage at address ");
2842 printf_filtered ("%s",
2844 SYMBOL_VALUE_ADDRESS (msym
)));
2847 case LOC_OPTIMIZED_OUT
:
2848 printf_filtered ("optimized out.\n");
2851 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2854 if (SYMBOL_TYPE (sym
))
2855 printf_filtered (", length %d.\n",
2856 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2858 if (BLOCK_FUNCTION (block
))
2861 block
= BLOCK_SUPERBLOCK (block
);
2864 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2868 /* Helper for trace_dump_command. Dump the action list starting at
2869 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2870 actions of the body of a while-stepping action. STEPPING_FRAME is
2871 set if the current traceframe was determined to be a while-stepping
2875 trace_dump_actions (struct command_line
*action
,
2876 int stepping_actions
, int stepping_frame
,
2879 const char *action_exp
, *next_comma
;
2881 for (; action
!= NULL
; action
= action
->next
)
2883 struct cmd_list_element
*cmd
;
2885 QUIT
; /* Allow user to bail out with ^C. */
2886 action_exp
= action
->line
;
2887 action_exp
= skip_spaces_const (action_exp
);
2889 /* The collection actions to be done while stepping are
2890 bracketed by the commands "while-stepping" and "end". */
2892 if (*action_exp
== '#') /* comment line */
2895 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2897 error (_("Bad action list item: %s"), action_exp
);
2899 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2903 for (i
= 0; i
< action
->body_count
; ++i
)
2904 trace_dump_actions (action
->body_list
[i
],
2905 1, stepping_frame
, from_tty
);
2907 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2909 /* Display the collected data.
2910 For the trap frame, display only what was collected at
2911 the trap. Likewise for stepping frames, display only
2912 what was collected while stepping. This means that the
2913 two boolean variables, STEPPING_FRAME and
2914 STEPPING_ACTIONS should be equal. */
2915 if (stepping_frame
== stepping_actions
)
2918 struct cleanup
*old_chain
2919 = make_cleanup (free_current_contents
, &cmd
);
2920 int trace_string
= 0;
2922 if (*action_exp
== '/')
2923 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2926 { /* Repeat over a comma-separated list. */
2927 QUIT
; /* Allow user to bail out with ^C. */
2928 if (*action_exp
== ',')
2930 action_exp
= skip_spaces_const (action_exp
);
2932 next_comma
= strchr (action_exp
, ',');
2934 if (0 == strncasecmp (action_exp
, "$reg", 4))
2935 registers_info (NULL
, from_tty
);
2936 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2938 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2939 locals_info (NULL
, from_tty
);
2940 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2941 args_info (NULL
, from_tty
);
2944 if (next_comma
!= NULL
)
2946 size_t len
= next_comma
- action_exp
;
2948 cmd
= xrealloc (cmd
, len
+ 1);
2949 memcpy (cmd
, action_exp
, len
);
2954 size_t len
= strlen (action_exp
);
2956 cmd
= xrealloc (cmd
, len
+ 1);
2957 memcpy (cmd
, action_exp
, len
+ 1);
2960 printf_filtered ("%s = ", cmd
);
2961 output_command_const (cmd
, from_tty
);
2962 printf_filtered ("\n");
2964 action_exp
= next_comma
;
2966 while (action_exp
&& *action_exp
== ',');
2968 do_cleanups (old_chain
);
2974 /* Return bp_location of the tracepoint associated with the current
2975 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2976 is a stepping traceframe. */
2978 struct bp_location
*
2979 get_traceframe_location (int *stepping_frame_p
)
2981 struct tracepoint
*t
;
2982 struct bp_location
*tloc
;
2983 struct regcache
*regcache
;
2985 if (tracepoint_number
== -1)
2986 error (_("No current trace frame."));
2988 t
= get_tracepoint (tracepoint_number
);
2991 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2994 /* The current frame is a trap frame if the frame PC is equal to the
2995 tracepoint PC. If not, then the current frame was collected
2996 during single-stepping. */
2997 regcache
= get_current_regcache ();
2999 /* If the traceframe's address matches any of the tracepoint's
3000 locations, assume it is a direct hit rather than a while-stepping
3001 frame. (FIXME this is not reliable, should record each frame's
3003 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
3004 if (tloc
->address
== regcache_read_pc (regcache
))
3006 *stepping_frame_p
= 0;
3010 /* If this is a stepping frame, we don't know which location
3011 triggered. The first is as good (or bad) a guess as any... */
3012 *stepping_frame_p
= 1;
3016 /* Return all the actions, including default collect, of a tracepoint
3017 T. It constructs cleanups into the chain, and leaves the caller to
3018 handle them (call do_cleanups). */
3020 static struct command_line
*
3021 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3023 struct command_line
*actions
;
3025 actions
= breakpoint_commands (t
);
3027 /* If there are default expressions to collect, make up a collect
3028 action and prepend to the action list to encode. Note that since
3029 validation is per-tracepoint (local var "xyz" might be valid for
3030 one tracepoint and not another, etc), we make up the action on
3031 the fly, and don't cache it. */
3032 if (*default_collect
)
3034 struct command_line
*default_collect_action
;
3035 char *default_collect_line
;
3037 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3038 make_cleanup (xfree
, default_collect_line
);
3040 validate_actionline (default_collect_line
, t
);
3041 default_collect_action
= xmalloc (sizeof (struct command_line
));
3042 make_cleanup (xfree
, default_collect_action
);
3043 default_collect_action
->next
= actions
;
3044 default_collect_action
->line
= default_collect_line
;
3045 actions
= default_collect_action
;
3051 /* The tdump command. */
3054 trace_dump_command (char *args
, int from_tty
)
3056 int stepping_frame
= 0;
3057 struct bp_location
*loc
;
3058 struct cleanup
*old_chain
;
3059 struct command_line
*actions
;
3061 /* This throws an error is not inspecting a trace frame. */
3062 loc
= get_traceframe_location (&stepping_frame
);
3064 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3065 tracepoint_number
, traceframe_number
);
3067 old_chain
= make_cleanup (null_cleanup
, NULL
);
3068 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3070 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3072 do_cleanups (old_chain
);
3075 /* Encode a piece of a tracepoint's source-level definition in a form
3076 that is suitable for both protocol and saving in files. */
3077 /* This version does not do multiple encodes for long strings; it should
3078 return an offset to the next piece to encode. FIXME */
3081 encode_source_string (int tpnum
, ULONGEST addr
,
3082 char *srctype
, char *src
, char *buf
, int buf_size
)
3084 if (80 + strlen (srctype
) > buf_size
)
3085 error (_("Buffer too small for source encoding"));
3086 sprintf (buf
, "%x:%s:%s:%x:%x:",
3087 tpnum
, phex_nz (addr
, sizeof (addr
)),
3088 srctype
, 0, (int) strlen (src
));
3089 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3090 error (_("Source string too long for buffer"));
3091 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3095 /* Free trace file writer. */
3098 trace_file_writer_xfree (void *arg
)
3100 struct trace_file_writer
*writer
= arg
;
3102 writer
->ops
->dtor (writer
);
3106 /* TFILE trace writer. */
3108 struct tfile_trace_file_writer
3110 struct trace_file_writer base
;
3112 /* File pointer to tfile trace file. */
3114 /* Path name of the tfile trace file. */
3118 /* This is the implementation of trace_file_write_ops method
3119 target_save. We just call the generic target
3120 target_save_trace_data to do target-side saving. */
3123 tfile_target_save (struct trace_file_writer
*self
,
3124 const char *filename
)
3126 int err
= target_save_trace_data (filename
);
3131 /* This is the implementation of trace_file_write_ops method
3135 tfile_dtor (struct trace_file_writer
*self
)
3137 struct tfile_trace_file_writer
*writer
3138 = (struct tfile_trace_file_writer
*) self
;
3140 xfree (writer
->pathname
);
3142 if (writer
->fp
!= NULL
)
3143 fclose (writer
->fp
);
3146 /* This is the implementation of trace_file_write_ops method
3147 start. It creates the trace file FILENAME and registers some
3151 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3153 struct tfile_trace_file_writer
*writer
3154 = (struct tfile_trace_file_writer
*) self
;
3156 writer
->pathname
= tilde_expand (filename
);
3157 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3158 if (writer
->fp
== NULL
)
3159 error (_("Unable to open file '%s' for saving trace data (%s)"),
3160 filename
, safe_strerror (errno
));
3163 /* This is the implementation of trace_file_write_ops method
3164 write_header. Write the TFILE header. */
3167 tfile_write_header (struct trace_file_writer
*self
)
3169 struct tfile_trace_file_writer
*writer
3170 = (struct tfile_trace_file_writer
*) self
;
3173 /* Write a file header, with a high-bit-set char to indicate a
3174 binary file, plus a hint as what this file is, and a version
3175 number in case of future needs. */
3176 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3178 perror_with_name (writer
->pathname
);
3181 /* This is the implementation of trace_file_write_ops method
3182 write_regblock_type. Write the size of register block. */
3185 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3187 struct tfile_trace_file_writer
*writer
3188 = (struct tfile_trace_file_writer
*) self
;
3190 fprintf (writer
->fp
, "R %x\n", size
);
3193 /* This is the implementation of trace_file_write_ops method
3197 tfile_write_status (struct trace_file_writer
*self
,
3198 struct trace_status
*ts
)
3200 struct tfile_trace_file_writer
*writer
3201 = (struct tfile_trace_file_writer
*) self
;
3203 fprintf (writer
->fp
, "status %c;%s",
3204 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3205 if (ts
->stop_reason
== tracepoint_error
3206 || ts
->stop_reason
== tstop_command
)
3208 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3210 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3211 fprintf (writer
->fp
, ":%s", buf
);
3213 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3214 if (ts
->traceframe_count
>= 0)
3215 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3216 if (ts
->traceframes_created
>= 0)
3217 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3218 if (ts
->buffer_free
>= 0)
3219 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3220 if (ts
->buffer_size
>= 0)
3221 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3222 if (ts
->disconnected_tracing
)
3223 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3224 if (ts
->circular_buffer
)
3225 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3228 fprintf (writer
->fp
, ";starttime:%s",
3229 phex_nz (ts
->start_time
, sizeof (ts
->start_time
)));
3233 fprintf (writer
->fp
, ";stoptime:%s",
3234 phex_nz (ts
->stop_time
, sizeof (ts
->stop_time
)));
3236 if (ts
->notes
!= NULL
)
3238 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3240 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3241 fprintf (writer
->fp
, ";notes:%s", buf
);
3243 if (ts
->user_name
!= NULL
)
3245 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3247 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3248 fprintf (writer
->fp
, ";username:%s", buf
);
3250 fprintf (writer
->fp
, "\n");
3253 /* This is the implementation of trace_file_write_ops method
3254 write_uploaded_tsv. */
3257 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3258 struct uploaded_tsv
*utsv
)
3261 struct tfile_trace_file_writer
*writer
3262 = (struct tfile_trace_file_writer
*) self
;
3266 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3267 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3270 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3271 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3272 utsv
->builtin
, buf
);
3278 #define MAX_TRACE_UPLOAD 2000
3280 /* This is the implementation of trace_file_write_ops method
3281 write_uploaded_tp. */
3284 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3285 struct uploaded_tp
*utp
)
3287 struct tfile_trace_file_writer
*writer
3288 = (struct tfile_trace_file_writer
*) self
;
3291 char buf
[MAX_TRACE_UPLOAD
];
3293 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3294 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3295 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3296 if (utp
->type
== bp_fast_tracepoint
)
3297 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3299 fprintf (writer
->fp
,
3300 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3302 fprintf (writer
->fp
, "\n");
3303 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3304 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3305 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3306 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3307 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3308 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3311 encode_source_string (utp
->number
, utp
->addr
,
3312 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3313 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3315 if (utp
->cond_string
)
3317 encode_source_string (utp
->number
, utp
->addr
,
3318 "cond", utp
->cond_string
,
3319 buf
, MAX_TRACE_UPLOAD
);
3320 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3322 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3324 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3325 buf
, MAX_TRACE_UPLOAD
);
3326 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3328 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3329 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3331 phex_nz (utp
->traceframe_usage
,
3332 sizeof (utp
->traceframe_usage
)));
3335 /* This is the implementation of trace_file_write_ops method
3336 write_definition_end. */
3339 tfile_write_definition_end (struct trace_file_writer
*self
)
3341 struct tfile_trace_file_writer
*writer
3342 = (struct tfile_trace_file_writer
*) self
;
3344 fprintf (writer
->fp
, "\n");
3347 /* This is the implementation of trace_file_write_ops method
3351 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3354 struct tfile_trace_file_writer
*writer
3355 = (struct tfile_trace_file_writer
*) self
;
3357 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3358 perror_with_name (writer
->pathname
);
3361 /* This is the implementation of trace_file_write_ops method
3365 tfile_end (struct trace_file_writer
*self
)
3367 struct tfile_trace_file_writer
*writer
3368 = (struct tfile_trace_file_writer
*) self
;
3369 uint32_t gotten
= 0;
3371 /* Mark the end of trace data. */
3372 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3373 perror_with_name (writer
->pathname
);
3376 /* Operations to write trace buffers into TFILE format. */
3378 static const struct trace_file_write_ops tfile_write_ops
=
3384 tfile_write_regblock_type
,
3386 tfile_write_uploaded_tsv
,
3387 tfile_write_uploaded_tp
,
3388 tfile_write_definition_end
,
3389 tfile_write_raw_data
,
3394 /* Helper macros. */
3396 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3397 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3398 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3399 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3401 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3402 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3404 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3405 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3407 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3408 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3409 the save is performed on the target, otherwise GDB obtains all trace
3410 data and saves it locally. */
3413 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3414 int target_does_save
)
3416 struct trace_status
*ts
= current_trace_status ();
3418 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3419 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3421 ULONGEST offset
= 0;
3422 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3423 #define MAX_TRACE_UPLOAD 2000
3425 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3427 /* If the target is to save the data to a file on its own, then just
3428 send the command and be done with it. */
3429 if (target_does_save
)
3431 if (!writer
->ops
->target_save (writer
, filename
))
3432 error (_("Target failed to save trace data to '%s'."),
3437 /* Get the trace status first before opening the file, so if the
3438 target is losing, we can get out without touching files. */
3439 status
= target_get_trace_status (ts
);
3441 writer
->ops
->start (writer
, filename
);
3443 writer
->ops
->write_header (writer
);
3445 /* Write descriptive info. */
3447 /* Write out the size of a register block. */
3448 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3450 /* Write out status of the tracing run (aka "tstatus" info). */
3451 writer
->ops
->write_status (writer
, ts
);
3453 /* Note that we want to upload tracepoints and save those, rather
3454 than simply writing out the local ones, because the user may have
3455 changed tracepoints in GDB in preparation for a future tracing
3456 run, or maybe just mass-deleted all types of breakpoints as part
3457 of cleaning up. So as not to contaminate the session, leave the
3458 data in its uploaded form, don't make into real tracepoints. */
3460 /* Get trace state variables first, they may be checked when parsing
3461 uploaded commands. */
3463 target_upload_trace_state_variables (&uploaded_tsvs
);
3465 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3466 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3468 free_uploaded_tsvs (&uploaded_tsvs
);
3470 target_upload_tracepoints (&uploaded_tps
);
3472 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3473 target_get_tracepoint_status (NULL
, utp
);
3475 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3476 writer
->ops
->write_uploaded_tp (writer
, utp
);
3478 free_uploaded_tps (&uploaded_tps
);
3480 /* Mark the end of the definition section. */
3481 writer
->ops
->write_definition_end (writer
);
3483 /* Get and write the trace data proper. */
3488 /* The writer supports writing the contents of trace buffer
3489 directly to trace file. Don't parse the contents of trace
3491 if (writer
->ops
->write_trace_buffer
!= NULL
)
3493 /* We ask for big blocks, in the hopes of efficiency, but
3494 will take less if the target has packet size limitations
3496 gotten
= target_get_raw_trace_data (buf
, offset
,
3499 error (_("Failure to get requested trace buffer data"));
3500 /* No more data is forthcoming, we're done. */
3504 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3512 /* Parse the trace buffers according to how data are stored
3513 in trace buffer in GDBserver. */
3515 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3520 /* Read the first six bytes in, which is the tracepoint
3521 number and trace frame size. */
3523 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3525 tf_size
= (uint32_t)
3526 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3528 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3537 for (block
= 0; block
< tf_size
; )
3539 gdb_byte block_type
;
3541 /* We'll fetch one block each time, in order to
3542 handle the extremely large 'M' block. We first
3543 fetch one byte to get the type of the block. */
3544 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3546 error (_("Failure to get requested trace buffer data"));
3552 block_type
= buf
[0];
3557 = target_get_raw_trace_data (buf
, offset
,
3558 trace_regblock_size
);
3559 if (gotten
< trace_regblock_size
)
3560 error (_("Failure to get requested trace"
3563 TRACE_WRITE_R_BLOCK (writer
, buf
,
3564 trace_regblock_size
);
3568 unsigned short mlen
;
3573 t
= target_get_raw_trace_data (buf
,offset
, 10);
3575 error (_("Failure to get requested trace"
3583 extract_unsigned_integer (buf
, 8,
3585 mlen
= (unsigned short)
3586 extract_unsigned_integer (&buf
[8], 2,
3589 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3592 /* The memory contents in 'M' block may be
3593 very large. Fetch the data from the target
3594 and write them into file one by one. */
3595 for (j
= 0; j
< mlen
; )
3597 unsigned int read_length
;
3599 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3600 read_length
= MAX_TRACE_UPLOAD
;
3602 read_length
= mlen
- j
;
3604 t
= target_get_raw_trace_data (buf
,
3607 if (t
< read_length
)
3608 error (_("Failure to get requested"
3609 " trace buffer data"));
3611 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3615 gotten
+= read_length
;
3626 = target_get_raw_trace_data (buf
, offset
,
3629 error (_("Failure to get requested"
3630 " trace buffer data"));
3632 vnum
= (int) extract_signed_integer (buf
,
3636 = extract_signed_integer (&buf
[4], 8,
3639 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3643 error (_("Unknown block type '%c' (0x%x) in"
3645 block_type
, block_type
);
3655 writer
->ops
->frame_ops
->end (writer
);
3659 writer
->ops
->end (writer
);
3662 /* Return a trace writer for TFILE format. */
3664 static struct trace_file_writer
*
3665 tfile_trace_file_writer_new (void)
3667 struct tfile_trace_file_writer
*writer
3668 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3670 writer
->base
.ops
= &tfile_write_ops
;
3672 writer
->pathname
= NULL
;
3674 return (struct trace_file_writer
*) writer
;
3678 trace_save_command (char *args
, int from_tty
)
3680 int target_does_save
= 0;
3682 char *filename
= NULL
;
3683 struct cleanup
*back_to
;
3684 int generate_ctf
= 0;
3685 struct trace_file_writer
*writer
= NULL
;
3688 error_no_arg (_("file in which to save trace data"));
3690 argv
= gdb_buildargv (args
);
3691 back_to
= make_cleanup_freeargv (argv
);
3693 for (; *argv
; ++argv
)
3695 if (strcmp (*argv
, "-r") == 0)
3696 target_does_save
= 1;
3697 if (strcmp (*argv
, "-ctf") == 0)
3699 else if (**argv
== '-')
3700 error (_("unknown option `%s'"), *argv
);
3706 error_no_arg (_("file in which to save trace data"));
3709 writer
= ctf_trace_file_writer_new ();
3711 writer
= tfile_trace_file_writer_new ();
3713 make_cleanup (trace_file_writer_xfree
, writer
);
3715 trace_save (filename
, writer
, target_does_save
);
3718 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3719 generate_ctf
? "directory" : "file", filename
);
3721 do_cleanups (back_to
);
3724 /* Save the trace data to file FILENAME of tfile format. */
3727 trace_save_tfile (const char *filename
, int target_does_save
)
3729 struct trace_file_writer
*writer
;
3730 struct cleanup
*back_to
;
3732 writer
= tfile_trace_file_writer_new ();
3733 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3734 trace_save (filename
, writer
, target_does_save
);
3735 do_cleanups (back_to
);
3738 /* Save the trace data to dir DIRNAME of ctf format. */
3741 trace_save_ctf (const char *dirname
, int target_does_save
)
3743 struct trace_file_writer
*writer
;
3744 struct cleanup
*back_to
;
3746 writer
= ctf_trace_file_writer_new ();
3747 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3749 trace_save (dirname
, writer
, target_does_save
);
3750 do_cleanups (back_to
);
3753 /* Tell the target what to do with an ongoing tracing run if GDB
3754 disconnects for some reason. */
3757 set_disconnected_tracing (char *args
, int from_tty
,
3758 struct cmd_list_element
*c
)
3760 target_set_disconnected_tracing (disconnected_tracing
);
3764 set_circular_trace_buffer (char *args
, int from_tty
,
3765 struct cmd_list_element
*c
)
3767 target_set_circular_trace_buffer (circular_trace_buffer
);
3771 set_trace_buffer_size (char *args
, int from_tty
,
3772 struct cmd_list_element
*c
)
3774 target_set_trace_buffer_size (trace_buffer_size
);
3778 set_trace_user (char *args
, int from_tty
,
3779 struct cmd_list_element
*c
)
3783 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3786 warning (_("Target does not support trace notes, user ignored"));
3790 set_trace_notes (char *args
, int from_tty
,
3791 struct cmd_list_element
*c
)
3795 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3798 warning (_("Target does not support trace notes, note ignored"));
3802 set_trace_stop_notes (char *args
, int from_tty
,
3803 struct cmd_list_element
*c
)
3807 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3810 warning (_("Target does not support trace notes, stop note ignored"));
3813 /* Convert the memory pointed to by mem into hex, placing result in buf.
3814 * Return a pointer to the last char put in buf (null)
3815 * "stolen" from sparc-stub.c
3818 static const char hexchars
[] = "0123456789abcdef";
3821 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3829 *buf
++ = hexchars
[ch
>> 4];
3830 *buf
++ = hexchars
[ch
& 0xf];
3839 get_traceframe_number (void)
3841 return traceframe_number
;
3845 get_tracepoint_number (void)
3847 return tracepoint_number
;
3850 /* Make the traceframe NUM be the current trace frame. Does nothing
3851 if NUM is already current. */
3854 set_current_traceframe (int num
)
3858 if (traceframe_number
== num
)
3860 /* Nothing to do. */
3864 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3867 warning (_("could not change traceframe"));
3869 set_traceframe_num (newnum
);
3871 /* Changing the traceframe changes our view of registers and of the
3873 registers_changed ();
3875 clear_traceframe_info ();
3878 /* Make the traceframe NUM be the current trace frame, and do nothing
3882 set_traceframe_number (int num
)
3884 traceframe_number
= num
;
3887 /* A cleanup used when switching away and back from tfind mode. */
3889 struct current_traceframe_cleanup
3891 /* The traceframe we were inspecting. */
3892 int traceframe_number
;
3896 do_restore_current_traceframe_cleanup (void *arg
)
3898 struct current_traceframe_cleanup
*old
= arg
;
3900 set_current_traceframe (old
->traceframe_number
);
3904 restore_current_traceframe_cleanup_dtor (void *arg
)
3906 struct current_traceframe_cleanup
*old
= arg
;
3912 make_cleanup_restore_current_traceframe (void)
3914 struct current_traceframe_cleanup
*old
;
3916 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3917 old
->traceframe_number
= traceframe_number
;
3919 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3920 restore_current_traceframe_cleanup_dtor
);
3924 make_cleanup_restore_traceframe_number (void)
3926 return make_cleanup_restore_integer (&traceframe_number
);
3929 /* Given a number and address, return an uploaded tracepoint with that
3930 number, creating if necessary. */
3932 struct uploaded_tp
*
3933 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3935 struct uploaded_tp
*utp
;
3937 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3938 if (utp
->number
== num
&& utp
->addr
== addr
)
3940 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3941 memset (utp
, 0, sizeof (struct uploaded_tp
));
3944 utp
->actions
= NULL
;
3945 utp
->step_actions
= NULL
;
3946 utp
->cmd_strings
= NULL
;
3953 free_uploaded_tps (struct uploaded_tp
**utpp
)
3955 struct uploaded_tp
*next_one
;
3959 next_one
= (*utpp
)->next
;
3965 /* Given a number and address, return an uploaded tracepoint with that
3966 number, creating if necessary. */
3968 struct uploaded_tsv
*
3969 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3971 struct uploaded_tsv
*utsv
;
3973 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3974 if (utsv
->number
== num
)
3976 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3977 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3979 utsv
->next
= *utsvp
;
3985 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3987 struct uploaded_tsv
*next_one
;
3991 next_one
= (*utsvp
)->next
;
3997 /* FIXME this function is heuristic and will miss the cases where the
3998 conditional is semantically identical but differs in whitespace,
3999 such as "x == 0" vs "x==0". */
4002 cond_string_is_same (char *str1
, char *str2
)
4004 if (str1
== NULL
|| str2
== NULL
)
4005 return (str1
== str2
);
4007 return (strcmp (str1
, str2
) == 0);
4010 /* Look for an existing tracepoint that seems similar enough to the
4011 uploaded one. Enablement isn't compared, because the user can
4012 toggle that freely, and may have done so in anticipation of the
4013 next trace run. Return the location of matched tracepoint. */
4015 static struct bp_location
*
4016 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
4018 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
4020 struct breakpoint
*b
;
4021 struct bp_location
*loc
;
4023 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
4025 struct tracepoint
*t
= (struct tracepoint
*) b
;
4027 if (b
->type
== utp
->type
4028 && t
->step_count
== utp
->step
4029 && t
->pass_count
== utp
->pass
4030 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
4031 /* FIXME also test actions. */
4034 /* Scan the locations for an address match. */
4035 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4037 if (loc
->address
== utp
->addr
)
4045 /* Given a list of tracepoints uploaded from a target, attempt to
4046 match them up with existing tracepoints, and create new ones if not
4050 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
4052 struct uploaded_tp
*utp
;
4053 /* A set of tracepoints which are modified. */
4054 VEC(breakpoint_p
) *modified_tp
= NULL
;
4056 struct breakpoint
*b
;
4058 /* Look for GDB tracepoints that match up with our uploaded versions. */
4059 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
4061 struct bp_location
*loc
;
4062 struct tracepoint
*t
;
4064 loc
= find_matching_tracepoint_location (utp
);
4069 /* Mark this location as already inserted. */
4071 t
= (struct tracepoint
*) loc
->owner
;
4072 printf_filtered (_("Assuming tracepoint %d is same "
4073 "as target's tracepoint %d at %s.\n"),
4074 loc
->owner
->number
, utp
->number
,
4075 paddress (loc
->gdbarch
, utp
->addr
));
4077 /* The tracepoint LOC->owner was modified (the location LOC
4078 was marked as inserted in the target). Save it in
4079 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4080 observers will be notified later once for each tracepoint
4081 saved in MODIFIED_TP. */
4083 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
4085 if (b
== loc
->owner
)
4091 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
4095 t
= create_tracepoint_from_upload (utp
);
4097 printf_filtered (_("Created tracepoint %d for "
4098 "target's tracepoint %d at %s.\n"),
4099 t
->base
.number
, utp
->number
,
4100 paddress (get_current_arch (), utp
->addr
));
4102 printf_filtered (_("Failed to create tracepoint for target's "
4103 "tracepoint %d at %s, skipping it.\n"),
4105 paddress (get_current_arch (), utp
->addr
));
4107 /* Whether found or created, record the number used by the
4108 target, to help with mapping target tracepoints back to their
4109 counterparts here. */
4111 t
->number_on_target
= utp
->number
;
4114 /* Notify 'breakpoint-modified' observer that at least one of B's
4115 locations was changed. */
4116 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4117 observer_notify_breakpoint_modified (b
);
4119 VEC_free (breakpoint_p
, modified_tp
);
4120 free_uploaded_tps (uploaded_tps
);
4123 /* Trace state variables don't have much to identify them beyond their
4124 name, so just use that to detect matches. */
4126 static struct trace_state_variable
*
4127 find_matching_tsv (struct uploaded_tsv
*utsv
)
4132 return find_trace_state_variable (utsv
->name
);
4135 static struct trace_state_variable
*
4136 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4138 const char *namebase
;
4141 struct trace_state_variable
*tsv
;
4142 struct cleanup
*old_chain
;
4146 namebase
= utsv
->name
;
4147 buf
= xstrprintf ("%s", namebase
);
4152 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4155 /* Fish for a name that is not in use. */
4156 /* (should check against all internal vars?) */
4157 while (find_trace_state_variable (buf
))
4160 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4163 old_chain
= make_cleanup (xfree
, buf
);
4165 /* We have an available name, create the variable. */
4166 tsv
= create_trace_state_variable (buf
);
4167 tsv
->initial_value
= utsv
->initial_value
;
4168 tsv
->builtin
= utsv
->builtin
;
4170 observer_notify_tsv_created (tsv
);
4172 do_cleanups (old_chain
);
4177 /* Given a list of uploaded trace state variables, try to match them
4178 up with existing variables, or create additional ones. */
4181 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4184 struct uploaded_tsv
*utsv
;
4185 struct trace_state_variable
*tsv
;
4188 /* Most likely some numbers will have to be reassigned as part of
4189 the merge, so clear them all in anticipation. */
4190 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4193 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4195 tsv
= find_matching_tsv (utsv
);
4199 printf_filtered (_("Assuming trace state variable $%s "
4200 "is same as target's variable %d.\n"),
4201 tsv
->name
, utsv
->number
);
4205 tsv
= create_tsv_from_upload (utsv
);
4207 printf_filtered (_("Created trace state variable "
4208 "$%s for target's variable %d.\n"),
4209 tsv
->name
, utsv
->number
);
4211 /* Give precedence to numberings that come from the target. */
4213 tsv
->number
= utsv
->number
;
4216 /* Renumber everything that didn't get a target-assigned number. */
4218 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4219 if (tsv
->number
> highest
)
4220 highest
= tsv
->number
;
4223 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4224 if (tsv
->number
== 0)
4225 tsv
->number
= highest
++;
4227 free_uploaded_tsvs (uploaded_tsvs
);
4230 /* target tfile command */
4232 static struct target_ops tfile_ops
;
4234 /* Fill in tfile_ops with its defined operations and properties. */
4236 #define TRACE_HEADER_SIZE 8
4238 static char *trace_filename
;
4239 static int trace_fd
= -1;
4240 static off_t trace_frames_offset
;
4241 static off_t cur_offset
;
4242 static int cur_data_size
;
4243 int trace_regblock_size
;
4245 static void tfile_interp_line (char *line
,
4246 struct uploaded_tp
**utpp
,
4247 struct uploaded_tsv
**utsvp
);
4249 /* Read SIZE bytes into READBUF from the trace frame, starting at
4250 TRACE_FD's current position. Note that this call `read'
4251 underneath, hence it advances the file's seek position. Throws an
4252 error if the `read' syscall fails, or less than SIZE bytes are
4256 tfile_read (gdb_byte
*readbuf
, int size
)
4260 gotten
= read (trace_fd
, readbuf
, size
);
4262 perror_with_name (trace_filename
);
4263 else if (gotten
< size
)
4264 error (_("Premature end of file while reading trace file"));
4268 tfile_open (char *filename
, int from_tty
)
4270 volatile struct gdb_exception ex
;
4272 struct cleanup
*old_chain
;
4275 char header
[TRACE_HEADER_SIZE
];
4276 char linebuf
[1000]; /* Should be max remote packet size or so. */
4279 struct trace_status
*ts
;
4280 struct uploaded_tp
*uploaded_tps
= NULL
;
4281 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4283 target_preopen (from_tty
);
4285 error (_("No trace file specified."));
4287 filename
= tilde_expand (filename
);
4288 if (!IS_ABSOLUTE_PATH(filename
))
4290 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4295 old_chain
= make_cleanup (xfree
, filename
);
4297 flags
= O_BINARY
| O_LARGEFILE
;
4299 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4300 if (scratch_chan
< 0)
4301 perror_with_name (filename
);
4303 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4305 discard_cleanups (old_chain
); /* Don't free filename any more. */
4306 unpush_target (&tfile_ops
);
4308 trace_filename
= xstrdup (filename
);
4309 trace_fd
= scratch_chan
;
4312 /* Read the file header and test for validity. */
4313 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4315 bytes
+= TRACE_HEADER_SIZE
;
4316 if (!(header
[0] == 0x7f
4317 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4318 error (_("File is not a valid trace file."));
4320 push_target (&tfile_ops
);
4322 trace_regblock_size
= 0;
4323 ts
= current_trace_status ();
4324 /* We know we're working with a file. Record its name. */
4325 ts
->filename
= trace_filename
;
4326 /* Set defaults in case there is no status line. */
4327 ts
->running_known
= 0;
4328 ts
->stop_reason
= trace_stop_reason_unknown
;
4329 ts
->traceframe_count
= -1;
4330 ts
->buffer_free
= 0;
4331 ts
->disconnected_tracing
= 0;
4332 ts
->circular_buffer
= 0;
4334 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4336 /* Read through a section of newline-terminated lines that
4337 define things like tracepoints. */
4341 tfile_read (&byte
, 1);
4346 /* Empty line marks end of the definition section. */
4351 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4354 linebuf
[i
++] = byte
;
4356 error (_("Excessively long lines in trace file"));
4359 /* Record the starting offset of the binary trace data. */
4360 trace_frames_offset
= bytes
;
4362 /* If we don't have a blocksize, we can't interpret the
4364 if (trace_regblock_size
== 0)
4365 error (_("No register block size recorded in trace file"));
4369 /* Pop the partially set up target. */
4371 throw_exception (ex
);
4374 if (ts
->traceframe_count
<= 0)
4375 warning (_("No traceframes present in this file."));
4377 /* Add the file's tracepoints and variables into the current mix. */
4379 /* Get trace state variables first, they may be checked when parsing
4380 uploaded commands. */
4381 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4383 merge_uploaded_tracepoints (&uploaded_tps
);
4386 /* Interpret the given line from the definitions part of the trace
4390 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4391 struct uploaded_tsv
**utsvp
)
4395 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4398 trace_regblock_size
= strtol (p
, &p
, 16);
4400 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4402 p
+= strlen ("status ");
4403 parse_trace_status (p
, current_trace_status ());
4405 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4407 p
+= strlen ("tp ");
4408 parse_tracepoint_definition (p
, utpp
);
4410 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4412 p
+= strlen ("tsv ");
4413 parse_tsv_definition (p
, utsvp
);
4416 warning (_("Ignoring trace file definition \"%s\""), line
);
4419 /* Parse the part of trace status syntax that is shared between
4420 the remote protocol and the trace file reader. */
4423 parse_trace_status (char *line
, struct trace_status
*ts
)
4425 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4429 ts
->running_known
= 1;
4430 ts
->running
= (*p
++ == '1');
4431 ts
->stop_reason
= trace_stop_reason_unknown
;
4432 xfree (ts
->stop_desc
);
4433 ts
->stop_desc
= NULL
;
4434 ts
->traceframe_count
= -1;
4435 ts
->traceframes_created
= -1;
4436 ts
->buffer_free
= -1;
4437 ts
->buffer_size
= -1;
4438 ts
->disconnected_tracing
= 0;
4439 ts
->circular_buffer
= 0;
4440 xfree (ts
->user_name
);
4441 ts
->user_name
= NULL
;
4444 ts
->start_time
= ts
->stop_time
= 0;
4448 p1
= strchr (p
, ':');
4450 error (_("Malformed trace status, at %s\n\
4451 Status line: '%s'\n"), p
, line
);
4452 p3
= strchr (p
, ';');
4454 p3
= p
+ strlen (p
);
4455 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4457 p
= unpack_varlen_hex (++p1
, &val
);
4458 ts
->stop_reason
= trace_buffer_full
;
4460 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4462 p
= unpack_varlen_hex (++p1
, &val
);
4463 ts
->stop_reason
= trace_never_run
;
4465 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4468 p
= unpack_varlen_hex (++p1
, &val
);
4469 ts
->stop_reason
= tracepoint_passcount
;
4470 ts
->stopping_tracepoint
= val
;
4472 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4474 p2
= strchr (++p1
, ':');
4482 ts
->stop_desc
= xmalloc (strlen (line
));
4483 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4484 ts
->stop_desc
[end
] = '\0';
4487 ts
->stop_desc
= xstrdup ("");
4489 p
= unpack_varlen_hex (++p2
, &val
);
4490 ts
->stop_reason
= tstop_command
;
4492 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4494 p
= unpack_varlen_hex (++p1
, &val
);
4495 ts
->stop_reason
= trace_disconnected
;
4497 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4499 p2
= strchr (++p1
, ':');
4502 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4503 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4504 ts
->stop_desc
[end
] = '\0';
4507 ts
->stop_desc
= xstrdup ("");
4509 p
= unpack_varlen_hex (++p2
, &val
);
4510 ts
->stopping_tracepoint
= val
;
4511 ts
->stop_reason
= tracepoint_error
;
4513 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4515 p
= unpack_varlen_hex (++p1
, &val
);
4516 ts
->traceframe_count
= val
;
4518 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4520 p
= unpack_varlen_hex (++p1
, &val
);
4521 ts
->traceframes_created
= val
;
4523 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4525 p
= unpack_varlen_hex (++p1
, &val
);
4526 ts
->buffer_free
= val
;
4528 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4530 p
= unpack_varlen_hex (++p1
, &val
);
4531 ts
->buffer_size
= val
;
4533 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4535 p
= unpack_varlen_hex (++p1
, &val
);
4536 ts
->disconnected_tracing
= val
;
4538 else if (strncmp (p
, "circular", p1
- p
) == 0)
4540 p
= unpack_varlen_hex (++p1
, &val
);
4541 ts
->circular_buffer
= val
;
4543 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4545 p
= unpack_varlen_hex (++p1
, &val
);
4546 ts
->start_time
= val
;
4548 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4550 p
= unpack_varlen_hex (++p1
, &val
);
4551 ts
->stop_time
= val
;
4553 else if (strncmp (p
, "username", p1
- p
) == 0)
4556 ts
->user_name
= xmalloc (strlen (p
) / 2);
4557 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4558 ts
->user_name
[end
] = '\0';
4561 else if (strncmp (p
, "notes", p1
- p
) == 0)
4564 ts
->notes
= xmalloc (strlen (p
) / 2);
4565 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4566 ts
->notes
[end
] = '\0';
4571 /* Silently skip unknown optional info. */
4572 p_temp
= strchr (p1
+ 1, ';');
4576 /* Must be at the end. */
4583 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4584 struct uploaded_tp
*utp
)
4587 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4589 p
= unpack_varlen_hex (p
, &uval
);
4591 tp
->base
.hit_count
+= uval
;
4593 utp
->hit_count
+= uval
;
4594 p
= unpack_varlen_hex (p
+ 1, &uval
);
4596 tp
->traceframe_usage
+= uval
;
4598 utp
->traceframe_usage
+= uval
;
4599 /* Ignore any extra, allowing for future extensions. */
4602 /* Given a line of text defining a part of a tracepoint, parse it into
4603 an "uploaded tracepoint". */
4606 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4610 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4613 char *cond
, *srctype
, *buf
;
4614 struct uploaded_tp
*utp
= NULL
;
4617 /* Both tracepoint and action definitions start with the same number
4618 and address sequence. */
4620 p
= unpack_varlen_hex (p
, &num
);
4621 p
++; /* skip a colon */
4622 p
= unpack_varlen_hex (p
, &addr
);
4623 p
++; /* skip a colon */
4626 enabled
= (*p
++ == 'E');
4627 p
++; /* skip a colon */
4628 p
= unpack_varlen_hex (p
, &step
);
4629 p
++; /* skip a colon */
4630 p
= unpack_varlen_hex (p
, &pass
);
4631 type
= bp_tracepoint
;
4633 /* Thumb through optional fields. */
4636 p
++; /* skip a colon */
4639 type
= bp_fast_tracepoint
;
4641 p
= unpack_varlen_hex (p
, &orig_size
);
4645 type
= bp_static_tracepoint
;
4651 p
= unpack_varlen_hex (p
, &xlen
);
4652 p
++; /* skip a comma */
4653 cond
= (char *) xmalloc (2 * xlen
+ 1);
4654 strncpy (cond
, p
, 2 * xlen
);
4655 cond
[2 * xlen
] = '\0';
4659 warning (_("Unrecognized char '%c' in tracepoint "
4660 "definition, skipping rest"), *p
);
4662 utp
= get_uploaded_tp (num
, addr
, utpp
);
4664 utp
->enabled
= enabled
;
4669 else if (piece
== 'A')
4671 utp
= get_uploaded_tp (num
, addr
, utpp
);
4672 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4674 else if (piece
== 'S')
4676 utp
= get_uploaded_tp (num
, addr
, utpp
);
4677 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4679 else if (piece
== 'Z')
4681 /* Parse a chunk of source form definition. */
4682 utp
= get_uploaded_tp (num
, addr
, utpp
);
4684 p
= strchr (p
, ':');
4685 p
++; /* skip a colon */
4686 p
= unpack_varlen_hex (p
, &start
);
4687 p
++; /* skip a colon */
4688 p
= unpack_varlen_hex (p
, &xlen
);
4689 p
++; /* skip a colon */
4691 buf
= alloca (strlen (line
));
4693 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4696 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4697 utp
->at_string
= xstrdup (buf
);
4698 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4699 utp
->cond_string
= xstrdup (buf
);
4700 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4701 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4703 else if (piece
== 'V')
4705 utp
= get_uploaded_tp (num
, addr
, utpp
);
4707 parse_tracepoint_status (p
, NULL
, utp
);
4711 /* Don't error out, the target might be sending us optional
4712 info that we don't care about. */
4713 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4717 /* Convert a textual description of a trace state variable into an
4721 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4724 ULONGEST num
, initval
, builtin
;
4726 struct uploaded_tsv
*utsv
= NULL
;
4728 buf
= alloca (strlen (line
));
4731 p
= unpack_varlen_hex (p
, &num
);
4732 p
++; /* skip a colon */
4733 p
= unpack_varlen_hex (p
, &initval
);
4734 p
++; /* skip a colon */
4735 p
= unpack_varlen_hex (p
, &builtin
);
4736 p
++; /* skip a colon */
4737 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4740 utsv
= get_uploaded_tsv (num
, utsvp
);
4741 utsv
->initial_value
= initval
;
4742 utsv
->builtin
= builtin
;
4743 utsv
->name
= xstrdup (buf
);
4746 /* Close the trace file and generally clean up. */
4758 xfree (trace_filename
);
4759 trace_filename
= NULL
;
4761 trace_reset_local_state ();
4765 tfile_files_info (struct target_ops
*t
)
4767 printf_filtered ("\t`%s'\n", trace_filename
);
4770 /* The trace status for a file is that tracing can never be run. */
4773 tfile_get_trace_status (struct trace_status
*ts
)
4775 /* Other bits of trace status were collected as part of opening the
4776 trace files, so nothing to do here. */
4782 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4784 /* Other bits of trace status were collected as part of opening the
4785 trace files, so nothing to do here. */
4788 /* Given the position of a traceframe in the file, figure out what
4789 address the frame was collected at. This would normally be the
4790 value of a collected PC register, but if not available, we
4794 tfile_get_traceframe_address (off_t tframe_offset
)
4798 struct tracepoint
*tp
;
4799 off_t saved_offset
= cur_offset
;
4801 /* FIXME dig pc out of collected registers. */
4803 /* Fall back to using tracepoint address. */
4804 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4805 tfile_read ((gdb_byte
*) &tpnum
, 2);
4806 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4808 (target_gdbarch ()));
4810 tp
= get_tracepoint_by_number_on_target (tpnum
);
4811 /* FIXME this is a poor heuristic if multiple locations. */
4812 if (tp
&& tp
->base
.loc
)
4813 addr
= tp
->base
.loc
->address
;
4815 /* Restore our seek position. */
4816 cur_offset
= saved_offset
;
4817 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4821 /* Given a type of search and some parameters, scan the collection of
4822 traceframes in the file looking for a match. When found, return
4823 both the traceframe and tracepoint number, otherwise -1 for
4827 tfile_trace_find (enum trace_find_type type
, int num
,
4828 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4831 int tfnum
= 0, found
= 0;
4832 unsigned int data_size
;
4833 struct tracepoint
*tp
;
4834 off_t offset
, tframe_offset
;
4844 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4845 offset
= trace_frames_offset
;
4848 tframe_offset
= offset
;
4849 tfile_read ((gdb_byte
*) &tpnum
, 2);
4850 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4852 (target_gdbarch ()));
4856 tfile_read ((gdb_byte
*) &data_size
, 4);
4857 data_size
= (unsigned int) extract_unsigned_integer
4858 ((gdb_byte
*) &data_size
, 4,
4859 gdbarch_byte_order (target_gdbarch ()));
4862 if (type
== tfind_number
)
4864 /* Looking for a specific trace frame. */
4870 /* Start from the _next_ trace frame. */
4871 if (tfnum
> traceframe_number
)
4876 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4877 if (tfaddr
== addr1
)
4881 tp
= get_tracepoint (num
);
4882 if (tp
&& tpnum
== tp
->number_on_target
)
4886 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4887 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4891 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4892 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4896 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4905 cur_offset
= offset
;
4906 cur_data_size
= data_size
;
4910 /* Skip past the traceframe's data. */
4911 lseek (trace_fd
, data_size
, SEEK_CUR
);
4912 offset
+= data_size
;
4913 /* Update our own count of traceframes. */
4916 /* Did not find what we were looking for. */
4922 /* Prototype of the callback passed to tframe_walk_blocks. */
4923 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4925 /* Callback for traceframe_walk_blocks, used to find a given block
4926 type in a traceframe. */
4929 match_blocktype (char blocktype
, void *data
)
4931 char *wantedp
= data
;
4933 if (*wantedp
== blocktype
)
4939 /* Walk over all traceframe block starting at POS offset from
4940 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4941 unmodified. If CALLBACK returns true, this returns the position in
4942 the traceframe where the block is found, relative to the start of
4943 the traceframe (cur_offset). Returns -1 if no callback call
4944 returned true, indicating that all blocks have been walked. */
4947 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4948 int pos
, void *data
)
4950 /* Iterate through a traceframe's blocks, looking for a block of the
4953 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4954 while (pos
< cur_data_size
)
4956 unsigned short mlen
;
4959 tfile_read ((gdb_byte
*) &block_type
, 1);
4963 if ((*callback
) (block_type
, data
))
4969 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4970 pos
+= trace_regblock_size
;
4973 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4974 tfile_read ((gdb_byte
*) &mlen
, 2);
4975 mlen
= (unsigned short)
4976 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4978 (target_gdbarch ()));
4979 lseek (trace_fd
, mlen
, SEEK_CUR
);
4980 pos
+= (8 + 2 + mlen
);
4983 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4987 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4988 block_type
, block_type
);
4996 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4997 position offset of a block of type TYPE_WANTED in the current trace
4998 frame, starting at POS. Returns -1 if no such block was found. */
5001 traceframe_find_block_type (char type_wanted
, int pos
)
5003 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
5006 /* Look for a block of saved registers in the traceframe, and get the
5007 requested register from it. */
5010 tfile_fetch_registers (struct target_ops
*ops
,
5011 struct regcache
*regcache
, int regno
)
5013 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5014 int offset
, regn
, regsize
, pc_regno
;
5017 /* An uninitialized reg size says we're not going to be
5018 successful at getting register blocks. */
5019 if (!trace_regblock_size
)
5022 regs
= alloca (trace_regblock_size
);
5024 if (traceframe_find_block_type ('R', 0) >= 0)
5026 tfile_read (regs
, trace_regblock_size
);
5028 /* Assume the block is laid out in GDB register number order,
5029 each register with the size that it has in GDB. */
5031 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5033 regsize
= register_size (gdbarch
, regn
);
5034 /* Make sure we stay within block bounds. */
5035 if (offset
+ regsize
>= trace_regblock_size
)
5037 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
5041 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
5044 else if (regno
== -1)
5046 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
5054 /* We get here if no register data has been found. Mark registers
5056 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5057 regcache_raw_supply (regcache
, regn
, NULL
);
5059 /* We can often usefully guess that the PC is going to be the same
5060 as the address of the tracepoint. */
5061 pc_regno
= gdbarch_pc_regnum (gdbarch
);
5062 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
5064 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
5066 if (tp
&& tp
->base
.loc
)
5068 /* But don't try to guess if tracepoint is multi-location... */
5069 if (tp
->base
.loc
->next
)
5071 warning (_("Tracepoint %d has multiple "
5072 "locations, cannot infer $pc"),
5076 /* ... or does while-stepping. */
5077 if (tp
->step_count
> 0)
5079 warning (_("Tracepoint %d does while-stepping, "
5080 "cannot infer $pc"),
5085 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
5086 gdbarch_byte_order (gdbarch
),
5087 tp
->base
.loc
->address
);
5088 regcache_raw_supply (regcache
, pc_regno
, regs
);
5094 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5095 const char *annex
, gdb_byte
*readbuf
,
5096 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5098 /* We're only doing regular memory for now. */
5099 if (object
!= TARGET_OBJECT_MEMORY
)
5102 if (readbuf
== NULL
)
5103 error (_("tfile_xfer_partial: trace file is read-only"));
5105 if (traceframe_number
!= -1)
5109 /* Iterate through the traceframe's blocks, looking for
5111 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5113 ULONGEST maddr
, amt
;
5114 unsigned short mlen
;
5115 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5117 tfile_read ((gdb_byte
*) &maddr
, 8);
5118 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5120 tfile_read ((gdb_byte
*) &mlen
, 2);
5121 mlen
= (unsigned short)
5122 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5124 /* If the block includes the first part of the desired
5125 range, return as much it has; GDB will re-request the
5126 remainder, which might be in a different block of this
5128 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5130 amt
= (maddr
+ mlen
) - offset
;
5134 if (maddr
!= offset
)
5135 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5136 tfile_read (readbuf
, amt
);
5140 /* Skip over this block. */
5141 pos
+= (8 + 2 + mlen
);
5145 /* It's unduly pedantic to refuse to look at the executable for
5146 read-only pieces; so do the equivalent of readonly regions aka
5148 /* FIXME account for relocation at some point. */
5155 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5157 if ((s
->flags
& SEC_LOAD
) == 0
5158 || (s
->flags
& SEC_READONLY
) == 0)
5162 size
= bfd_get_section_size (s
);
5163 if (vma
<= offset
&& offset
< (vma
+ size
))
5167 amt
= (vma
+ size
) - offset
;
5171 amt
= bfd_get_section_contents (exec_bfd
, s
,
5172 readbuf
, offset
- vma
, amt
);
5178 /* Indicate failure to find the requested memory block. */
5182 /* Iterate through the blocks of a trace frame, looking for a 'V'
5183 block with a matching tsv number. */
5186 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5191 /* Iterate over blocks in current frame and find the last 'V'
5192 block in which tsv number is TSVNUM. In one trace frame, there
5193 may be multiple 'V' blocks created for a given trace variable,
5194 and the last matched 'V' block contains the updated value. */
5196 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5200 tfile_read ((gdb_byte
*) &vnum
, 4);
5201 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5203 (target_gdbarch ()));
5206 tfile_read ((gdb_byte
*) val
, 8);
5207 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5209 (target_gdbarch ()));
5219 tfile_has_all_memory (struct target_ops
*ops
)
5225 tfile_has_memory (struct target_ops
*ops
)
5231 tfile_has_stack (struct target_ops
*ops
)
5233 return traceframe_number
!= -1;
5237 tfile_has_registers (struct target_ops
*ops
)
5239 return traceframe_number
!= -1;
5242 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5243 object for the tfile target's current traceframe. */
5246 build_traceframe_info (char blocktype
, void *data
)
5248 struct traceframe_info
*info
= data
;
5254 struct mem_range
*r
;
5256 unsigned short mlen
;
5258 tfile_read ((gdb_byte
*) &maddr
, 8);
5259 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5261 (target_gdbarch ()));
5262 tfile_read ((gdb_byte
*) &mlen
, 2);
5263 mlen
= (unsigned short)
5264 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5265 2, gdbarch_byte_order
5266 (target_gdbarch ()));
5268 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5278 tfile_read ((gdb_byte
*) &vnum
, 4);
5279 VEC_safe_push (int, info
->tvars
, vnum
);
5287 warning (_("Unhandled trace block type (%d) '%c ' "
5288 "while building trace frame info."),
5289 blocktype
, blocktype
);
5296 static struct traceframe_info
*
5297 tfile_traceframe_info (void)
5299 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5301 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5306 init_tfile_ops (void)
5308 tfile_ops
.to_shortname
= "tfile";
5309 tfile_ops
.to_longname
= "Local trace dump file";
5311 = "Use a trace file as a target. Specify the filename of the trace file.";
5312 tfile_ops
.to_open
= tfile_open
;
5313 tfile_ops
.to_close
= tfile_close
;
5314 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5315 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5316 tfile_ops
.to_files_info
= tfile_files_info
;
5317 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5318 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5319 tfile_ops
.to_trace_find
= tfile_trace_find
;
5320 tfile_ops
.to_get_trace_state_variable_value
5321 = tfile_get_trace_state_variable_value
;
5322 tfile_ops
.to_stratum
= process_stratum
;
5323 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5324 tfile_ops
.to_has_memory
= tfile_has_memory
;
5325 tfile_ops
.to_has_stack
= tfile_has_stack
;
5326 tfile_ops
.to_has_registers
= tfile_has_registers
;
5327 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5328 tfile_ops
.to_magic
= OPS_MAGIC
;
5332 free_current_marker (void *arg
)
5334 struct static_tracepoint_marker
**marker_p
= arg
;
5336 if (*marker_p
!= NULL
)
5338 release_static_tracepoint_marker (*marker_p
);
5345 /* Given a line of text defining a static tracepoint marker, parse it
5346 into a "static tracepoint marker" object. Throws an error is
5347 parsing fails. If PP is non-null, it points to one past the end of
5348 the parsed marker definition. */
5351 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5352 struct static_tracepoint_marker
*marker
)
5359 p
= unpack_varlen_hex (p
, &addr
);
5360 p
++; /* skip a colon */
5362 marker
->gdbarch
= target_gdbarch ();
5363 marker
->address
= (CORE_ADDR
) addr
;
5365 endp
= strchr (p
, ':');
5367 error (_("bad marker definition: %s"), line
);
5369 marker
->str_id
= xmalloc (endp
- p
+ 1);
5370 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5371 marker
->str_id
[end
] = '\0';
5374 p
++; /* skip a colon */
5376 marker
->extra
= xmalloc (strlen (p
) + 1);
5377 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5378 marker
->extra
[end
] = '\0';
5384 /* Release a static tracepoint marker's contents. Note that the
5385 object itself isn't released here. There objects are usually on
5389 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5391 xfree (marker
->str_id
);
5392 marker
->str_id
= NULL
;
5395 /* Print MARKER to gdb_stdout. */
5398 print_one_static_tracepoint_marker (int count
,
5399 struct static_tracepoint_marker
*marker
)
5401 struct command_line
*l
;
5404 char wrap_indent
[80];
5405 char extra_field_indent
[80];
5406 struct ui_out
*uiout
= current_uiout
;
5407 struct cleanup
*bkpt_chain
;
5408 VEC(breakpoint_p
) *tracepoints
;
5410 struct symtab_and_line sal
;
5414 sal
.pc
= marker
->address
;
5416 tracepoints
= static_tracepoints_here (marker
->address
);
5418 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5420 /* A counter field to help readability. This is not a stable
5422 ui_out_field_int (uiout
, "count", count
);
5424 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5426 ui_out_field_fmt (uiout
, "enabled", "%c",
5427 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5428 ui_out_spaces (uiout
, 2);
5430 strcpy (wrap_indent
, " ");
5432 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5433 strcat (wrap_indent
, " ");
5435 strcat (wrap_indent
, " ");
5437 strcpy (extra_field_indent
, " ");
5439 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5441 sal
= find_pc_line (marker
->address
, 0);
5442 sym
= find_pc_sect_function (marker
->address
, NULL
);
5445 ui_out_text (uiout
, "in ");
5446 ui_out_field_string (uiout
, "func",
5447 SYMBOL_PRINT_NAME (sym
));
5448 ui_out_wrap_hint (uiout
, wrap_indent
);
5449 ui_out_text (uiout
, " at ");
5452 ui_out_field_skip (uiout
, "func");
5454 if (sal
.symtab
!= NULL
)
5456 ui_out_field_string (uiout
, "file",
5457 symtab_to_filename_for_display (sal
.symtab
));
5458 ui_out_text (uiout
, ":");
5460 if (ui_out_is_mi_like_p (uiout
))
5462 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5464 ui_out_field_string (uiout
, "fullname", fullname
);
5467 ui_out_field_skip (uiout
, "fullname");
5469 ui_out_field_int (uiout
, "line", sal
.line
);
5473 ui_out_field_skip (uiout
, "fullname");
5474 ui_out_field_skip (uiout
, "line");
5477 ui_out_text (uiout
, "\n");
5478 ui_out_text (uiout
, extra_field_indent
);
5479 ui_out_text (uiout
, _("Data: \""));
5480 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5481 ui_out_text (uiout
, "\"\n");
5483 if (!VEC_empty (breakpoint_p
, tracepoints
))
5485 struct cleanup
*cleanup_chain
;
5487 struct breakpoint
*b
;
5489 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5492 ui_out_text (uiout
, extra_field_indent
);
5493 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5494 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5497 ui_out_text (uiout
, ", ");
5498 ui_out_text (uiout
, "#");
5499 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5502 do_cleanups (cleanup_chain
);
5504 if (ui_out_is_mi_like_p (uiout
))
5505 ui_out_field_int (uiout
, "number-of-tracepoints",
5506 VEC_length(breakpoint_p
, tracepoints
));
5508 ui_out_text (uiout
, "\n");
5510 VEC_free (breakpoint_p
, tracepoints
);
5512 do_cleanups (bkpt_chain
);
5516 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5518 VEC(static_tracepoint_marker_p
) *markers
;
5519 struct cleanup
*old_chain
;
5520 struct static_tracepoint_marker
*marker
;
5521 struct ui_out
*uiout
= current_uiout
;
5524 /* We don't have to check target_can_use_agent and agent's capability on
5525 static tracepoint here, in order to be compatible with older GDBserver.
5526 We don't check USE_AGENT is true or not, because static tracepoints
5527 don't work without in-process agent, so we don't bother users to type
5528 `set agent on' when to use static tracepoint. */
5531 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5532 "StaticTracepointMarkersTable");
5534 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5536 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5538 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5539 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5540 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5542 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5543 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5545 ui_out_table_body (uiout
);
5547 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5548 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5551 VEC_iterate (static_tracepoint_marker_p
,
5552 markers
, i
, marker
);
5555 print_one_static_tracepoint_marker (i
+ 1, marker
);
5556 release_static_tracepoint_marker (marker
);
5559 do_cleanups (old_chain
);
5562 /* The $_sdata convenience variable is a bit special. We don't know
5563 for sure type of the value until we actually have a chance to fetch
5564 the data --- the size of the object depends on what has been
5565 collected. We solve this by making $_sdata be an internalvar that
5566 creates a new value on access. */
5568 /* Return a new value with the correct type for the sdata object of
5569 the current trace frame. Return a void value if there's no object
5572 static struct value
*
5573 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5579 /* We need to read the whole object before we know its size. */
5580 size
= target_read_alloc (¤t_target
,
5581 TARGET_OBJECT_STATIC_TRACE_DATA
,
5588 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5590 v
= allocate_value (type
);
5591 memcpy (value_contents_raw (v
), buf
, size
);
5596 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5599 #if !defined(HAVE_LIBEXPAT)
5601 struct traceframe_info
*
5602 parse_traceframe_info (const char *tframe_info
)
5604 static int have_warned
;
5609 warning (_("Can not parse XML trace frame info; XML support "
5610 "was disabled at compile time"));
5616 #else /* HAVE_LIBEXPAT */
5618 #include "xml-support.h"
5620 /* Handle the start of a <memory> element. */
5623 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5624 const struct gdb_xml_element
*element
,
5625 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5627 struct traceframe_info
*info
= user_data
;
5628 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5629 ULONGEST
*start_p
, *length_p
;
5631 start_p
= xml_find_attribute (attributes
, "start")->value
;
5632 length_p
= xml_find_attribute (attributes
, "length")->value
;
5634 r
->start
= *start_p
;
5635 r
->length
= *length_p
;
5638 /* Handle the start of a <tvar> element. */
5641 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
5642 const struct gdb_xml_element
*element
,
5644 VEC(gdb_xml_value_s
) *attributes
)
5646 struct traceframe_info
*info
= user_data
;
5647 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
5648 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
5650 VEC_safe_push (int, info
->tvars
, id
);
5653 /* Discard the constructed trace frame info (if an error occurs). */
5656 free_result (void *p
)
5658 struct traceframe_info
*result
= p
;
5660 free_traceframe_info (result
);
5663 /* The allowed elements and attributes for an XML memory map. */
5665 static const struct gdb_xml_attribute memory_attributes
[] = {
5666 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5667 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5668 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5671 static const struct gdb_xml_attribute tvar_attributes
[] = {
5672 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
5673 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5676 static const struct gdb_xml_element traceframe_info_children
[] = {
5677 { "memory", memory_attributes
, NULL
,
5678 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5679 traceframe_info_start_memory
, NULL
},
5680 { "tvar", tvar_attributes
, NULL
,
5681 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5682 traceframe_info_start_tvar
, NULL
},
5683 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5686 static const struct gdb_xml_element traceframe_info_elements
[] = {
5687 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5689 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5692 /* Parse a traceframe-info XML document. */
5694 struct traceframe_info
*
5695 parse_traceframe_info (const char *tframe_info
)
5697 struct traceframe_info
*result
;
5698 struct cleanup
*back_to
;
5700 result
= XCNEW (struct traceframe_info
);
5701 back_to
= make_cleanup (free_result
, result
);
5703 if (gdb_xml_parse_quick (_("trace frame info"),
5704 "traceframe-info.dtd", traceframe_info_elements
,
5705 tframe_info
, result
) == 0)
5707 /* Parsed successfully, keep the result. */
5708 discard_cleanups (back_to
);
5713 do_cleanups (back_to
);
5717 #endif /* HAVE_LIBEXPAT */
5719 /* Returns the traceframe_info object for the current traceframe.
5720 This is where we avoid re-fetching the object from the target if we
5721 already have it cached. */
5723 struct traceframe_info
*
5724 get_traceframe_info (void)
5726 if (traceframe_info
== NULL
)
5727 traceframe_info
= target_traceframe_info ();
5729 return traceframe_info
;
5732 /* If the target supports the query, return in RESULT the set of
5733 collected memory in the current traceframe, found within the LEN
5734 bytes range starting at MEMADDR. Returns true if the target
5735 supports the query, otherwise returns false, and RESULT is left
5739 traceframe_available_memory (VEC(mem_range_s
) **result
,
5740 CORE_ADDR memaddr
, ULONGEST len
)
5742 struct traceframe_info
*info
= get_traceframe_info ();
5746 struct mem_range
*r
;
5751 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5752 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5754 ULONGEST lo1
, hi1
, lo2
, hi2
;
5755 struct mem_range
*nr
;
5758 hi1
= memaddr
+ len
;
5761 hi2
= r
->start
+ r
->length
;
5763 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5765 nr
->start
= max (lo1
, lo2
);
5766 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5769 normalize_mem_ranges (*result
);
5776 /* Implementation of `sdata' variable. */
5778 static const struct internalvar_funcs sdata_funcs
=
5785 /* module initialization */
5787 _initialize_tracepoint (void)
5789 struct cmd_list_element
*c
;
5791 /* Explicitly create without lookup, since that tries to create a
5792 value with a void typed value, and when we get here, gdbarch
5793 isn't initialized yet. At this point, we're quite sure there
5794 isn't another convenience variable of the same name. */
5795 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5797 traceframe_number
= -1;
5798 tracepoint_number
= -1;
5800 add_info ("scope", scope_info
,
5801 _("List the variables local to a scope"));
5803 add_cmd ("tracepoints", class_trace
, NULL
,
5804 _("Tracing of program execution without stopping the program."),
5807 add_com ("tdump", class_trace
, trace_dump_command
,
5808 _("Print everything collected at the current tracepoint."));
5810 add_com ("tsave", class_trace
, trace_save_command
, _("\
5811 Save the trace data to a file.\n\
5812 Use the '-ctf' option to save the data to CTF format.\n\
5813 Use the '-r' option to direct the target to save directly to the file,\n\
5814 using its own filesystem."));
5816 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5817 Define a trace state variable.\n\
5818 Argument is a $-prefixed name, optionally followed\n\
5819 by '=' and an expression that sets the initial value\n\
5820 at the start of tracing."));
5821 set_cmd_completer (c
, expression_completer
);
5823 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5824 Delete one or more trace state variables.\n\
5825 Arguments are the names of the variables to delete.\n\
5826 If no arguments are supplied, delete all variables."), &deletelist
);
5827 /* FIXME add a trace variable completer. */
5829 add_info ("tvariables", tvariables_info
, _("\
5830 Status of trace state variables and their values.\n\
5833 add_info ("static-tracepoint-markers",
5834 info_static_tracepoint_markers_command
, _("\
5835 List target static tracepoints markers.\n\
5838 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5839 Select a trace frame;\n\
5840 No argument means forward by one frame; '-' means backward by one frame."),
5841 &tfindlist
, "tfind ", 1, &cmdlist
);
5843 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5844 Select a trace frame whose PC is outside the given range (exclusive).\n\
5845 Usage: tfind outside addr1, addr2"),
5848 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5849 Select a trace frame whose PC is in the given range (inclusive).\n\
5850 Usage: tfind range addr1,addr2"),
5853 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5854 Select a trace frame by source line.\n\
5855 Argument can be a line number (with optional source file),\n\
5856 a function name, or '*' followed by an address.\n\
5857 Default argument is 'the next source line that was traced'."),
5860 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5861 Select a trace frame by tracepoint number.\n\
5862 Default is the tracepoint for the current trace frame."),
5865 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5866 Select a trace frame by PC.\n\
5867 Default is the current PC, or the PC of the current trace frame."),
5870 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5871 De-select any trace frame and resume 'live' debugging."),
5874 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5876 add_cmd ("start", class_trace
, trace_find_start_command
,
5877 _("Select the first trace frame in the trace buffer."),
5880 add_com ("tstatus", class_trace
, trace_status_command
,
5881 _("Display the status of the current trace data collection."));
5883 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5884 Stop trace data collection.\n\
5885 Usage: tstop [ <notes> ... ]\n\
5886 Any arguments supplied are recorded with the trace as a stop reason and\n\
5887 reported by tstatus (if the target supports trace notes)."));
5889 add_com ("tstart", class_trace
, trace_start_command
, _("\
5890 Start trace data collection.\n\
5891 Usage: tstart [ <notes> ... ]\n\
5892 Any arguments supplied are recorded with the trace as a note and\n\
5893 reported by tstatus (if the target supports trace notes)."));
5895 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5896 Ends a list of commands or actions.\n\
5897 Several GDB commands allow you to enter a list of commands or actions.\n\
5898 Entering \"end\" on a line by itself is the normal way to terminate\n\
5900 Note: the \"end\" command cannot be used at the gdb prompt."));
5902 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5903 Specify single-stepping behavior at a tracepoint.\n\
5904 Argument is number of instructions to trace in single-step mode\n\
5905 following the tracepoint. This command is normally followed by\n\
5906 one or more \"collect\" commands, to specify what to collect\n\
5907 while single-stepping.\n\n\
5908 Note: this command can only be used in a tracepoint \"actions\" list."));
5910 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5911 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5913 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5914 Specify one or more data items to be collected at a tracepoint.\n\
5915 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5916 collect all data (variables, registers) referenced by that expression.\n\
5917 Also accepts the following special arguments:\n\
5918 $regs -- all registers.\n\
5919 $args -- all function arguments.\n\
5920 $locals -- all variables local to the block/function scope.\n\
5921 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5922 Note: this command can only be used in a tracepoint \"actions\" list."));
5924 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5925 Specify one or more expressions to be evaluated at a tracepoint.\n\
5926 Accepts a comma-separated list of (one or more) expressions.\n\
5927 The result of each evaluation will be discarded.\n\
5928 Note: this command can only be used in a tracepoint \"actions\" list."));
5930 add_com ("actions", class_trace
, trace_actions_command
, _("\
5931 Specify the actions to be taken at a tracepoint.\n\
5932 Tracepoint actions may include collecting of specified data,\n\
5933 single-stepping, or enabling/disabling other tracepoints,\n\
5934 depending on target's capabilities."));
5936 default_collect
= xstrdup ("");
5937 add_setshow_string_cmd ("default-collect", class_trace
,
5938 &default_collect
, _("\
5939 Set the list of expressions to collect by default"), _("\
5940 Show the list of expressions to collect by default"), NULL
,
5942 &setlist
, &showlist
);
5944 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5945 &disconnected_tracing
, _("\
5946 Set whether tracing continues after GDB disconnects."), _("\
5947 Show whether tracing continues after GDB disconnects."), _("\
5948 Use this to continue a tracing run even if GDB disconnects\n\
5949 or detaches from the target. You can reconnect later and look at\n\
5950 trace data collected in the meantime."),
5951 set_disconnected_tracing
,
5956 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5957 &circular_trace_buffer
, _("\
5958 Set target's use of circular trace buffer."), _("\
5959 Show target's use of circular trace buffer."), _("\
5960 Use this to make the trace buffer into a circular buffer,\n\
5961 which will discard traceframes (oldest first) instead of filling\n\
5962 up and stopping the trace run."),
5963 set_circular_trace_buffer
,
5968 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5969 &trace_buffer_size
, _("\
5970 Set requested size of trace buffer."), _("\
5971 Show requested size of trace buffer."), _("\
5972 Use this to choose a size for the trace buffer. Some targets\n\
5973 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5974 disables any attempt to set the buffer size and lets the target choose."),
5975 set_trace_buffer_size
, NULL
,
5976 &setlist
, &showlist
);
5978 add_setshow_string_cmd ("trace-user", class_trace
,
5980 Set the user name to use for current and future trace runs"), _("\
5981 Show the user name to use for current and future trace runs"), NULL
,
5982 set_trace_user
, NULL
,
5983 &setlist
, &showlist
);
5985 add_setshow_string_cmd ("trace-notes", class_trace
,
5987 Set notes string to use for current and future trace runs"), _("\
5988 Show the notes string to use for current and future trace runs"), NULL
,
5989 set_trace_notes
, NULL
,
5990 &setlist
, &showlist
);
5992 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5993 &trace_stop_notes
, _("\
5994 Set notes string to use for future tstop commands"), _("\
5995 Show the notes string to use for future tstop commands"), NULL
,
5996 set_trace_stop_notes
, NULL
,
5997 &setlist
, &showlist
);
6001 add_target_with_completer (&tfile_ops
, filename_completer
);