1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
29 #include "target-dcache.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "filestuff.h"
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
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
88 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
93 This module defines the following debugger commands:
94 trace : set a tracepoint on a function, line, or address.
95 info trace : list all debugger-defined tracepoints.
96 delete trace : delete one or more tracepoints.
97 enable trace : enable one or more tracepoints.
98 disable trace : disable one or more tracepoints.
99 actions : specify actions to be taken at a tracepoint.
100 passcount : specify a pass count for a tracepoint.
101 tstart : start a trace experiment.
102 tstop : stop a trace experiment.
103 tstatus : query the status of a trace experiment.
104 tfind : find a trace frame in the trace buffer.
105 tdump : print everything collected at the current tracepoint.
106 save-tracepoints : write tracepoint setup into a file.
108 This module defines the following user-visible debugger variables:
109 $trace_frame : sequence number of trace frame currently being debugged.
110 $trace_line : source line of trace frame currently being debugged.
111 $trace_file : source file of trace frame currently being debugged.
112 $tracepoint : tracepoint number of trace frame currently being debugged.
116 /* ======= Important global variables: ======= */
118 /* The list of all trace state variables. We don't retain pointers to
119 any of these for any reason - API is by name or number only - so it
120 works to have a vector of objects. */
122 typedef struct trace_state_variable tsv_s
;
125 static VEC(tsv_s
) *tvariables
;
127 /* The next integer to assign to a variable. */
129 static int next_tsv_number
= 1;
131 /* Number of last traceframe collected. */
132 static int traceframe_number
;
134 /* Tracepoint for last traceframe collected. */
135 static int tracepoint_number
;
137 /* The traceframe info of the current traceframe. NULL if we haven't
138 yet attempted to fetch it, or if the target does not support
139 fetching this object, or if we're not inspecting a traceframe
141 static struct traceframe_info
*traceframe_info
;
143 /* Tracing command lists. */
144 static struct cmd_list_element
*tfindlist
;
146 /* List of expressions to collect by default at each tracepoint hit. */
147 char *default_collect
= "";
149 static int disconnected_tracing
;
151 /* This variable controls whether we ask the target for a linear or
152 circular trace buffer. */
154 static int circular_trace_buffer
;
156 /* This variable is the requested trace buffer size, or -1 to indicate
157 that we don't care and leave it up to the target to set a size. */
159 static int trace_buffer_size
= -1;
161 /* Textual notes applying to the current and/or future trace runs. */
163 char *trace_user
= NULL
;
165 /* Textual notes applying to the current and/or future trace runs. */
167 char *trace_notes
= NULL
;
169 /* Textual notes applying to the stopping of a trace. */
171 char *trace_stop_notes
= NULL
;
173 /* ======= Important command functions: ======= */
174 static void trace_actions_command (char *, int);
175 static void trace_start_command (char *, int);
176 static void trace_stop_command (char *, int);
177 static void trace_status_command (char *, int);
178 static void trace_find_command (char *, int);
179 static void trace_find_pc_command (char *, int);
180 static void trace_find_tracepoint_command (char *, int);
181 static void trace_find_line_command (char *, int);
182 static void trace_find_range_command (char *, int);
183 static void trace_find_outside_command (char *, int);
184 static void trace_dump_command (char *, int);
186 /* support routines */
188 struct collection_list
;
189 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
190 static char *mem2hex (gdb_byte
*, char *, int);
191 static void add_register (struct collection_list
*collection
,
194 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
195 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
197 static struct command_line
*
198 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
200 extern void _initialize_tracepoint (void);
202 static struct trace_status trace_status
;
204 char *stop_reason_names
[] = {
214 struct trace_status
*
215 current_trace_status (void)
217 return &trace_status
;
223 free_traceframe_info (struct traceframe_info
*info
)
227 VEC_free (mem_range_s
, info
->memory
);
228 VEC_free (int, info
->tvars
);
234 /* Free and clear the traceframe info cache of the current
238 clear_traceframe_info (void)
240 free_traceframe_info (traceframe_info
);
241 traceframe_info
= NULL
;
244 /* Set traceframe number to NUM. */
246 set_traceframe_num (int num
)
248 traceframe_number
= num
;
249 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
252 /* Set tracepoint number to NUM. */
254 set_tracepoint_num (int num
)
256 tracepoint_number
= num
;
257 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
260 /* Set externally visible debug variables for querying/printing
261 the traceframe context (line, function, file). */
264 set_traceframe_context (struct frame_info
*trace_frame
)
267 struct symbol
*traceframe_fun
;
268 struct symtab_and_line traceframe_sal
;
270 /* Save as globals for internal use. */
271 if (trace_frame
!= NULL
272 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
274 traceframe_sal
= find_pc_line (trace_pc
, 0);
275 traceframe_fun
= find_pc_function (trace_pc
);
277 /* Save linenumber as "$trace_line", a debugger variable visible to
279 set_internalvar_integer (lookup_internalvar ("trace_line"),
280 traceframe_sal
.line
);
284 init_sal (&traceframe_sal
);
285 traceframe_fun
= NULL
;
286 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
289 /* Save func name as "$trace_func", a debugger variable visible to
291 if (traceframe_fun
== NULL
292 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
293 clear_internalvar (lookup_internalvar ("trace_func"));
295 set_internalvar_string (lookup_internalvar ("trace_func"),
296 SYMBOL_LINKAGE_NAME (traceframe_fun
));
298 /* Save file name as "$trace_file", a debugger variable visible to
300 if (traceframe_sal
.symtab
== NULL
)
301 clear_internalvar (lookup_internalvar ("trace_file"));
303 set_internalvar_string (lookup_internalvar ("trace_file"),
304 symtab_to_filename_for_display (traceframe_sal
.symtab
));
307 /* Create a new trace state variable with the given name. */
309 struct trace_state_variable
*
310 create_trace_state_variable (const char *name
)
312 struct trace_state_variable tsv
;
314 memset (&tsv
, 0, sizeof (tsv
));
315 tsv
.name
= xstrdup (name
);
316 tsv
.number
= next_tsv_number
++;
317 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
320 /* Look for a trace state variable of the given name. */
322 struct trace_state_variable
*
323 find_trace_state_variable (const char *name
)
325 struct trace_state_variable
*tsv
;
328 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
329 if (strcmp (name
, tsv
->name
) == 0)
335 /* Look for a trace state variable of the given number. Return NULL if
338 struct trace_state_variable
*
339 find_trace_state_variable_by_number (int number
)
341 struct trace_state_variable
*tsv
;
344 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
345 if (tsv
->number
== number
)
352 delete_trace_state_variable (const char *name
)
354 struct trace_state_variable
*tsv
;
357 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
358 if (strcmp (name
, tsv
->name
) == 0)
360 observer_notify_tsv_deleted (tsv
);
362 xfree ((void *)tsv
->name
);
363 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
368 warning (_("No trace variable named \"$%s\", not deleting"), name
);
371 /* Throws an error if NAME is not valid syntax for a trace state
375 validate_trace_state_variable_name (const char *name
)
380 error (_("Must supply a non-empty variable name"));
382 /* All digits in the name is reserved for value history
384 for (p
= name
; isdigit (*p
); p
++)
387 error (_("$%s is not a valid trace state variable name"), name
);
389 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
392 error (_("$%s is not a valid trace state variable name"), name
);
395 /* The 'tvariable' command collects a name and optional expression to
396 evaluate into an initial value. */
399 trace_variable_command (char *args
, int from_tty
)
401 struct cleanup
*old_chain
;
403 struct trace_state_variable
*tsv
;
407 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
409 /* Only allow two syntaxes; "$name" and "$name=value". */
410 p
= skip_spaces (args
);
413 error (_("Name of trace variable should start with '$'"));
416 while (isalnum (*p
) || *p
== '_')
418 name
= savestring (name
, p
- name
);
419 old_chain
= make_cleanup (xfree
, name
);
422 if (*p
!= '=' && *p
!= '\0')
423 error (_("Syntax must be $NAME [ = EXPR ]"));
425 validate_trace_state_variable_name (name
);
428 initval
= value_as_long (parse_and_eval (++p
));
430 /* If the variable already exists, just change its initial value. */
431 tsv
= find_trace_state_variable (name
);
434 if (tsv
->initial_value
!= initval
)
436 tsv
->initial_value
= initval
;
437 observer_notify_tsv_modified (tsv
);
439 printf_filtered (_("Trace state variable $%s "
440 "now has initial value %s.\n"),
441 tsv
->name
, plongest (tsv
->initial_value
));
442 do_cleanups (old_chain
);
446 /* Create a new variable. */
447 tsv
= create_trace_state_variable (name
);
448 tsv
->initial_value
= initval
;
450 observer_notify_tsv_created (tsv
);
452 printf_filtered (_("Trace state variable $%s "
453 "created, with initial value %s.\n"),
454 tsv
->name
, plongest (tsv
->initial_value
));
456 do_cleanups (old_chain
);
460 delete_trace_variable_command (char *args
, int from_tty
)
464 struct cleanup
*back_to
;
468 if (query (_("Delete all trace state variables? ")))
469 VEC_free (tsv_s
, tvariables
);
471 observer_notify_tsv_deleted (NULL
);
475 argv
= gdb_buildargv (args
);
476 back_to
= make_cleanup_freeargv (argv
);
478 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
480 if (*argv
[ix
] == '$')
481 delete_trace_state_variable (argv
[ix
] + 1);
483 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
486 do_cleanups (back_to
);
492 tvariables_info_1 (void)
494 struct trace_state_variable
*tsv
;
497 struct cleanup
*back_to
;
498 struct ui_out
*uiout
= current_uiout
;
500 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
502 printf_filtered (_("No trace state variables.\n"));
506 /* Try to acquire values from the target. */
507 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
508 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
511 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
512 count
, "trace-variables");
513 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
514 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
515 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
517 ui_out_table_body (uiout
);
519 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
521 struct cleanup
*back_to2
;
525 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
527 name
= concat ("$", tsv
->name
, (char *) NULL
);
528 make_cleanup (xfree
, name
);
529 ui_out_field_string (uiout
, "name", name
);
530 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
532 if (tsv
->value_known
)
533 c
= plongest (tsv
->value
);
534 else if (ui_out_is_mi_like_p (uiout
))
535 /* For MI, we prefer not to use magic string constants, but rather
536 omit the field completely. The difference between unknown and
537 undefined does not seem important enough to represent. */
539 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
540 /* The value is/was defined, but we don't have it. */
543 /* It is not meaningful to ask about the value. */
546 ui_out_field_string (uiout
, "current", c
);
547 ui_out_text (uiout
, "\n");
549 do_cleanups (back_to2
);
552 do_cleanups (back_to
);
555 /* List all the trace state variables. */
558 tvariables_info (char *args
, int from_tty
)
560 tvariables_info_1 ();
563 /* Stash definitions of tsvs into the given file. */
566 save_trace_state_variables (struct ui_file
*fp
)
568 struct trace_state_variable
*tsv
;
571 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
573 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
574 if (tsv
->initial_value
)
575 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
576 fprintf_unfiltered (fp
, "\n");
580 /* ACTIONS functions: */
582 /* The three functions:
583 collect_pseudocommand,
584 while_stepping_pseudocommand, and
585 end_actions_pseudocommand
586 are placeholders for "commands" that are actually ONLY to be used
587 within a tracepoint action list. If the actual function is ever called,
588 it means that somebody issued the "command" at the top level,
589 which is always an error. */
592 end_actions_pseudocommand (char *args
, int from_tty
)
594 error (_("This command cannot be used at the top level."));
598 while_stepping_pseudocommand (char *args
, int from_tty
)
600 error (_("This command can only be used in a tracepoint actions list."));
604 collect_pseudocommand (char *args
, int from_tty
)
606 error (_("This command can only be used in a tracepoint actions list."));
610 teval_pseudocommand (char *args
, int from_tty
)
612 error (_("This command can only be used in a tracepoint actions list."));
615 /* Parse any collection options, such as /s for strings. */
618 decode_agent_options (const char *exp
, int *trace_string
)
620 struct value_print_options opts
;
627 /* Call this to borrow the print elements default for collection
629 get_user_print_options (&opts
);
634 if (target_supports_string_tracing ())
636 /* Allow an optional decimal number giving an explicit maximum
637 string length, defaulting it to the "print elements" value;
638 so "collect/s80 mystr" gets at most 80 bytes of string. */
639 *trace_string
= opts
.print_max
;
641 if (*exp
>= '0' && *exp
<= '9')
642 *trace_string
= atoi (exp
);
643 while (*exp
>= '0' && *exp
<= '9')
647 error (_("Target does not support \"/s\" option for string tracing."));
650 error (_("Undefined collection format \"%c\"."), *exp
);
652 exp
= skip_spaces_const (exp
);
657 /* Enter a list of actions for a tracepoint. */
659 trace_actions_command (char *args
, int from_tty
)
661 struct tracepoint
*t
;
662 struct command_line
*l
;
664 t
= get_tracepoint_by_number (&args
, NULL
, 1);
668 xstrprintf ("Enter actions for tracepoint %d, one per line.",
670 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
672 l
= read_command_lines (tmpbuf
, from_tty
, 1,
673 check_tracepoint_command
, t
);
674 do_cleanups (cleanups
);
675 breakpoint_set_commands (&t
->base
, l
);
677 /* else just return */
680 /* Report the results of checking the agent expression, as errors or
684 report_agent_reqs_errors (struct agent_expr
*aexpr
)
686 /* All of the "flaws" are serious bytecode generation issues that
687 should never occur. */
688 if (aexpr
->flaw
!= agent_flaw_none
)
689 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
691 /* If analysis shows a stack underflow, GDB must have done something
692 badly wrong in its bytecode generation. */
693 if (aexpr
->min_height
< 0)
694 internal_error (__FILE__
, __LINE__
,
695 _("expression has min height < 0"));
697 /* Issue this error if the stack is predicted to get too deep. The
698 limit is rather arbitrary; a better scheme might be for the
699 target to report how much stack it will have available. The
700 depth roughly corresponds to parenthesization, so a limit of 20
701 amounts to 20 levels of expression nesting, which is actually
702 a pretty big hairy expression. */
703 if (aexpr
->max_height
> 20)
704 error (_("Expression is too complicated."));
707 /* worker function */
709 validate_actionline (const char *line
, struct breakpoint
*b
)
711 struct cmd_list_element
*c
;
712 struct expression
*exp
= NULL
;
713 struct cleanup
*old_chain
= NULL
;
716 struct bp_location
*loc
;
717 struct agent_expr
*aexpr
;
718 struct tracepoint
*t
= (struct tracepoint
*) b
;
720 /* If EOF is typed, *line is NULL. */
724 p
= skip_spaces_const (line
);
726 /* Symbol lookup etc. */
727 if (*p
== '\0') /* empty line: just prompt for another line. */
730 if (*p
== '#') /* comment line */
733 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
735 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
737 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
739 int trace_string
= 0;
742 p
= decode_agent_options (p
, &trace_string
);
745 { /* Repeat over a comma-separated list. */
746 QUIT
; /* Allow user to bail out with ^C. */
747 p
= skip_spaces_const (p
);
749 if (*p
== '$') /* Look for special pseudo-symbols. */
751 if (0 == strncasecmp ("reg", p
+ 1, 3)
752 || 0 == strncasecmp ("arg", p
+ 1, 3)
753 || 0 == strncasecmp ("loc", p
+ 1, 3)
754 || 0 == strncasecmp ("_ret", p
+ 1, 4)
755 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
760 /* else fall thru, treat p as an expression and parse it! */
763 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
766 exp
= parse_exp_1 (&p
, loc
->address
,
767 block_for_pc (loc
->address
), 1);
768 old_chain
= make_cleanup (free_current_contents
, &exp
);
770 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
772 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
774 error (_("constant `%s' (value %s) "
775 "will not be collected."),
776 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
777 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
779 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
780 == LOC_OPTIMIZED_OUT
)
782 error (_("`%s' is optimized away "
783 "and cannot be collected."),
784 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
788 /* We have something to collect, make sure that the expr to
789 bytecode translator can handle it and that it's not too
791 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
792 make_cleanup_free_agent_expr (aexpr
);
794 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
795 error (_("Expression is too complicated."));
799 report_agent_reqs_errors (aexpr
);
801 do_cleanups (old_chain
);
804 while (p
&& *p
++ == ',');
807 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
810 { /* Repeat over a comma-separated list. */
811 QUIT
; /* Allow user to bail out with ^C. */
812 p
= skip_spaces_const (p
);
815 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
819 /* Only expressions are allowed for this action. */
820 exp
= parse_exp_1 (&p
, loc
->address
,
821 block_for_pc (loc
->address
), 1);
822 old_chain
= make_cleanup (free_current_contents
, &exp
);
824 /* We have something to evaluate, make sure that the expr to
825 bytecode translator can handle it and that it's not too
827 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
828 make_cleanup_free_agent_expr (aexpr
);
830 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
831 error (_("Expression is too complicated."));
834 report_agent_reqs_errors (aexpr
);
836 do_cleanups (old_chain
);
839 while (p
&& *p
++ == ',');
842 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
846 p
= skip_spaces_const (p
);
847 t
->step_count
= strtol (p
, &endp
, 0);
848 if (endp
== p
|| t
->step_count
== 0)
849 error (_("while-stepping step count `%s' is malformed."), line
);
853 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
857 error (_("`%s' is not a supported tracepoint action."), line
);
861 memrange_absolute
= -1
864 /* MEMRANGE functions: */
866 static int memrange_cmp (const void *, const void *);
868 /* Compare memranges for qsort. */
870 memrange_cmp (const void *va
, const void *vb
)
872 const struct memrange
*a
= va
, *b
= vb
;
874 if (a
->type
< b
->type
)
876 if (a
->type
> b
->type
)
878 if (a
->type
== memrange_absolute
)
880 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
882 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
887 if (a
->start
< b
->start
)
889 if (a
->start
> b
->start
)
895 /* Sort the memrange list using qsort, and merge adjacent memranges. */
897 memrange_sortmerge (struct collection_list
*memranges
)
901 qsort (memranges
->list
, memranges
->next_memrange
,
902 sizeof (struct memrange
), memrange_cmp
);
903 if (memranges
->next_memrange
> 0)
905 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
907 /* If memrange b overlaps or is adjacent to memrange a,
909 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
910 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
912 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
913 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
914 continue; /* next b, same a */
918 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
919 sizeof (struct memrange
));
921 memranges
->next_memrange
= a
+ 1;
925 /* Add a register to a collection list. */
927 add_register (struct collection_list
*collection
, unsigned int regno
)
930 printf_filtered ("collect register %d\n", regno
);
931 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
932 error (_("Internal: register number %d too large for tracepoint"),
934 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
937 /* Add a memrange to a collection list. */
939 add_memrange (struct collection_list
*memranges
,
940 int type
, bfd_signed_vma base
,
945 printf_filtered ("(%d,", type
);
947 printf_filtered (",%ld)\n", len
);
950 /* type: memrange_absolute == memory, other n == basereg */
951 memranges
->list
[memranges
->next_memrange
].type
= type
;
952 /* base: addr if memory, offset if reg relative. */
953 memranges
->list
[memranges
->next_memrange
].start
= base
;
954 /* len: we actually save end (base + len) for convenience */
955 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
956 memranges
->next_memrange
++;
957 if (memranges
->next_memrange
>= memranges
->listsize
)
959 memranges
->listsize
*= 2;
960 memranges
->list
= xrealloc (memranges
->list
,
961 memranges
->listsize
);
964 if (type
!= memrange_absolute
) /* Better collect the base register! */
965 add_register (memranges
, type
);
968 /* Add a symbol to a collection list. */
970 collect_symbol (struct collection_list
*collect
,
972 struct gdbarch
*gdbarch
,
973 long frame_regno
, long frame_offset
,
979 bfd_signed_vma offset
;
980 int treat_as_expr
= 0;
982 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
983 switch (SYMBOL_CLASS (sym
))
986 printf_filtered ("%s: don't know symbol class %d\n",
987 SYMBOL_PRINT_NAME (sym
),
991 printf_filtered ("constant %s (value %s) will not be collected.\n",
992 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
995 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1000 sprintf_vma (tmp
, offset
);
1001 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1002 SYMBOL_PRINT_NAME (sym
), len
,
1005 /* A struct may be a C++ class with static fields, go to general
1006 expression handling. */
1007 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1010 add_memrange (collect
, memrange_absolute
, offset
, len
);
1013 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1015 printf_filtered ("LOC_REG[parm] %s: ",
1016 SYMBOL_PRINT_NAME (sym
));
1017 add_register (collect
, reg
);
1018 /* Check for doubles stored in two registers. */
1019 /* FIXME: how about larger types stored in 3 or more regs? */
1020 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1021 len
> register_size (gdbarch
, reg
))
1022 add_register (collect
, reg
+ 1);
1025 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1026 printf_filtered (" (will not collect %s)\n",
1027 SYMBOL_PRINT_NAME (sym
));
1031 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1034 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1035 SYMBOL_PRINT_NAME (sym
), len
);
1036 printf_vma (offset
);
1037 printf_filtered (" from frame ptr reg %d\n", reg
);
1039 add_memrange (collect
, reg
, offset
, len
);
1041 case LOC_REGPARM_ADDR
:
1042 reg
= SYMBOL_VALUE (sym
);
1046 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1047 SYMBOL_PRINT_NAME (sym
), len
);
1048 printf_vma (offset
);
1049 printf_filtered (" from reg %d\n", reg
);
1051 add_memrange (collect
, reg
, offset
, len
);
1055 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1058 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1059 SYMBOL_PRINT_NAME (sym
), len
);
1060 printf_vma (offset
);
1061 printf_filtered (" from frame ptr reg %d\n", reg
);
1063 add_memrange (collect
, reg
, offset
, len
);
1066 case LOC_UNRESOLVED
:
1070 case LOC_OPTIMIZED_OUT
:
1071 printf_filtered ("%s has been optimized out of existence.\n",
1072 SYMBOL_PRINT_NAME (sym
));
1080 /* Expressions are the most general case. */
1083 struct agent_expr
*aexpr
;
1084 struct cleanup
*old_chain1
= NULL
;
1086 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1088 /* It can happen that the symbol is recorded as a computed
1089 location, but it's been optimized away and doesn't actually
1090 have a location expression. */
1093 printf_filtered ("%s has been optimized out of existence.\n",
1094 SYMBOL_PRINT_NAME (sym
));
1098 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1102 report_agent_reqs_errors (aexpr
);
1104 discard_cleanups (old_chain1
);
1105 add_aexpr (collect
, aexpr
);
1107 /* Take care of the registers. */
1108 if (aexpr
->reg_mask_len
> 0)
1112 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1114 QUIT
; /* Allow user to bail out with ^C. */
1115 if (aexpr
->reg_mask
[ndx1
] != 0)
1117 /* Assume chars have 8 bits. */
1118 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1119 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1120 /* It's used -- record it. */
1121 add_register (collect
, ndx1
* 8 + ndx2
);
1128 /* Data to be passed around in the calls to the locals and args
1131 struct add_local_symbols_data
1133 struct collection_list
*collect
;
1134 struct gdbarch
*gdbarch
;
1142 /* The callback for the locals and args iterators. */
1145 do_collect_symbol (const char *print_name
,
1149 struct add_local_symbols_data
*p
= cb_data
;
1151 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1152 p
->frame_offset
, p
->pc
, p
->trace_string
);
1155 VEC_safe_push (char_ptr
, p
->collect
->wholly_collected
,
1156 xstrdup (print_name
));
1159 /* Add all locals (or args) symbols to collection list. */
1161 add_local_symbols (struct collection_list
*collect
,
1162 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1163 long frame_regno
, long frame_offset
, int type
,
1166 struct block
*block
;
1167 struct add_local_symbols_data cb_data
;
1169 cb_data
.collect
= collect
;
1170 cb_data
.gdbarch
= gdbarch
;
1172 cb_data
.frame_regno
= frame_regno
;
1173 cb_data
.frame_offset
= frame_offset
;
1175 cb_data
.trace_string
= trace_string
;
1179 block
= block_for_pc (pc
);
1182 warning (_("Can't collect locals; "
1183 "no symbol table info available.\n"));
1187 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1188 if (cb_data
.count
== 0)
1189 warning (_("No locals found in scope."));
1193 pc
= get_pc_function_start (pc
);
1194 block
= block_for_pc (pc
);
1197 warning (_("Can't collect args; no symbol table info available."));
1201 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1202 if (cb_data
.count
== 0)
1203 warning (_("No args found in scope."));
1208 add_static_trace_data (struct collection_list
*collection
)
1211 printf_filtered ("collect static trace data\n");
1212 collection
->strace_data
= 1;
1215 /* worker function */
1217 clear_collection_list (struct collection_list
*list
)
1221 list
->next_memrange
= 0;
1222 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1224 free_agent_expr (list
->aexpr_list
[ndx
]);
1225 list
->aexpr_list
[ndx
] = NULL
;
1227 list
->next_aexpr_elt
= 0;
1228 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1229 list
->strace_data
= 0;
1231 xfree (list
->aexpr_list
);
1234 VEC_free (char_ptr
, list
->wholly_collected
);
1235 VEC_free (char_ptr
, list
->computed
);
1238 /* A cleanup wrapper for function clear_collection_list. */
1241 do_clear_collection_list (void *list
)
1243 struct collection_list
*l
= list
;
1245 clear_collection_list (l
);
1248 /* Initialize collection_list CLIST. */
1251 init_collection_list (struct collection_list
*clist
)
1253 memset (clist
, 0, sizeof *clist
);
1255 clist
->listsize
= 128;
1256 clist
->list
= xcalloc (clist
->listsize
,
1257 sizeof (struct memrange
));
1259 clist
->aexpr_listsize
= 128;
1260 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1261 sizeof (struct agent_expr
*));
1264 /* Reduce a collection list to string form (for gdb protocol). */
1266 stringify_collection_list (struct collection_list
*list
)
1268 char temp_buf
[2048];
1272 char *(*str_list
)[];
1276 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1277 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1279 if (list
->strace_data
)
1282 printf_filtered ("\nCollecting static trace data\n");
1285 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1289 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1290 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1292 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1295 printf_filtered ("\nCollecting registers (mask): 0x");
1300 QUIT
; /* Allow user to bail out with ^C. */
1302 printf_filtered ("%02X", list
->regs_mask
[i
]);
1303 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1306 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1310 printf_filtered ("\n");
1311 if (list
->next_memrange
> 0 && info_verbose
)
1312 printf_filtered ("Collecting memranges: \n");
1313 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1315 QUIT
; /* Allow user to bail out with ^C. */
1316 sprintf_vma (tmp2
, list
->list
[i
].start
);
1319 printf_filtered ("(%d, %s, %ld)\n",
1322 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1324 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1326 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1333 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1335 /* The "%X" conversion specifier expects an unsigned argument,
1336 so passing -1 (memrange_absolute) to it directly gives you
1337 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1339 if (list
->list
[i
].type
== memrange_absolute
)
1340 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1342 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1345 count
+= strlen (end
);
1346 end
= temp_buf
+ count
;
1349 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1351 QUIT
; /* Allow user to bail out with ^C. */
1352 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1354 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1359 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1360 end
+= 10; /* 'X' + 8 hex digits + ',' */
1363 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1364 end
, list
->aexpr_list
[i
]->len
);
1365 count
+= 2 * list
->aexpr_list
[i
]->len
;
1370 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1375 (*str_list
)[ndx
] = NULL
;
1386 /* Add the printed expression EXP to *LIST. */
1389 append_exp (struct expression
*exp
, VEC(char_ptr
) **list
)
1391 struct ui_file
*tmp_stream
= mem_fileopen ();
1394 print_expression (exp
, tmp_stream
);
1396 text
= ui_file_xstrdup (tmp_stream
, NULL
);
1398 VEC_safe_push (char_ptr
, *list
, text
);
1399 ui_file_delete (tmp_stream
);
1403 encode_actions_1 (struct command_line
*action
,
1404 struct bp_location
*tloc
,
1406 LONGEST frame_offset
,
1407 struct collection_list
*collect
,
1408 struct collection_list
*stepping_list
)
1410 const char *action_exp
;
1411 struct expression
*exp
= NULL
;
1413 struct value
*tempval
;
1414 struct cmd_list_element
*cmd
;
1415 struct agent_expr
*aexpr
;
1417 for (; action
; action
= action
->next
)
1419 QUIT
; /* Allow user to bail out with ^C. */
1420 action_exp
= action
->line
;
1421 action_exp
= skip_spaces_const (action_exp
);
1423 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1425 error (_("Bad action list item: %s"), action_exp
);
1427 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1429 int trace_string
= 0;
1431 if (*action_exp
== '/')
1432 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1435 { /* Repeat over a comma-separated list. */
1436 QUIT
; /* Allow user to bail out with ^C. */
1437 action_exp
= skip_spaces_const (action_exp
);
1439 if (0 == strncasecmp ("$reg", action_exp
, 4))
1441 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1442 add_register (collect
, i
);
1443 action_exp
= strchr (action_exp
, ','); /* more? */
1445 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1447 add_local_symbols (collect
,
1454 action_exp
= strchr (action_exp
, ','); /* more? */
1456 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1458 add_local_symbols (collect
,
1465 action_exp
= strchr (action_exp
, ','); /* more? */
1467 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1469 struct cleanup
*old_chain1
= NULL
;
1471 aexpr
= gen_trace_for_return_address (tloc
->address
,
1475 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1478 report_agent_reqs_errors (aexpr
);
1480 discard_cleanups (old_chain1
);
1481 add_aexpr (collect
, aexpr
);
1483 /* take care of the registers */
1484 if (aexpr
->reg_mask_len
> 0)
1488 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1490 QUIT
; /* allow user to bail out with ^C */
1491 if (aexpr
->reg_mask
[ndx1
] != 0)
1493 /* assume chars have 8 bits */
1494 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1495 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1496 /* it's used -- record it */
1497 add_register (collect
,
1503 action_exp
= strchr (action_exp
, ','); /* more? */
1505 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1507 add_static_trace_data (collect
);
1508 action_exp
= strchr (action_exp
, ','); /* more? */
1513 struct cleanup
*old_chain
= NULL
;
1514 struct cleanup
*old_chain1
= NULL
;
1516 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1517 block_for_pc (tloc
->address
), 1);
1518 old_chain
= make_cleanup (free_current_contents
, &exp
);
1520 switch (exp
->elts
[0].opcode
)
1524 const char *name
= &exp
->elts
[2].string
;
1526 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1527 name
, strlen (name
));
1529 internal_error (__FILE__
, __LINE__
,
1530 _("Register $%s not available"),
1533 printf_filtered ("OP_REGISTER: ");
1534 add_register (collect
, i
);
1539 /* Safe because we know it's a simple expression. */
1540 tempval
= evaluate_expression (exp
);
1541 addr
= value_address (tempval
);
1542 /* Initialize the TYPE_LENGTH if it is a typedef. */
1543 check_typedef (exp
->elts
[1].type
);
1544 add_memrange (collect
, memrange_absolute
, addr
,
1545 TYPE_LENGTH (exp
->elts
[1].type
));
1546 append_exp (exp
, &collect
->computed
);
1551 struct symbol
*sym
= exp
->elts
[2].symbol
;
1552 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1554 collect_symbol (collect
,
1555 exp
->elts
[2].symbol
,
1561 VEC_safe_push (char_ptr
,
1562 collect
->wholly_collected
,
1567 default: /* Full-fledged expression. */
1568 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1571 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1575 report_agent_reqs_errors (aexpr
);
1577 discard_cleanups (old_chain1
);
1578 add_aexpr (collect
, aexpr
);
1580 /* Take care of the registers. */
1581 if (aexpr
->reg_mask_len
> 0)
1586 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1588 QUIT
; /* Allow user to bail out with ^C. */
1589 if (aexpr
->reg_mask
[ndx1
] != 0)
1591 /* Assume chars have 8 bits. */
1592 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1593 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1594 /* It's used -- record it. */
1595 add_register (collect
,
1601 append_exp (exp
, &collect
->computed
);
1604 do_cleanups (old_chain
);
1607 while (action_exp
&& *action_exp
++ == ',');
1609 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1612 { /* Repeat over a comma-separated list. */
1613 QUIT
; /* Allow user to bail out with ^C. */
1614 action_exp
= skip_spaces_const (action_exp
);
1617 struct cleanup
*old_chain
= NULL
;
1618 struct cleanup
*old_chain1
= NULL
;
1620 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1621 block_for_pc (tloc
->address
), 1);
1622 old_chain
= make_cleanup (free_current_contents
, &exp
);
1624 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1625 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1628 report_agent_reqs_errors (aexpr
);
1630 discard_cleanups (old_chain1
);
1631 /* Even though we're not officially collecting, add
1632 to the collect list anyway. */
1633 add_aexpr (collect
, aexpr
);
1635 do_cleanups (old_chain
);
1638 while (action_exp
&& *action_exp
++ == ',');
1640 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1642 /* We check against nested while-stepping when setting
1643 breakpoint action, so no way to run into nested
1645 gdb_assert (stepping_list
);
1647 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1648 frame_offset
, stepping_list
, NULL
);
1651 error (_("Invalid tracepoint command '%s'"), action
->line
);
1655 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1656 and STEPPING_LIST. Return a cleanup pointer to clean up both
1657 TRACEPOINT_LIST and STEPPING_LIST. */
1660 encode_actions_and_make_cleanup (struct bp_location
*tloc
,
1661 struct collection_list
*tracepoint_list
,
1662 struct collection_list
*stepping_list
)
1664 char *default_collect_line
= NULL
;
1665 struct command_line
*actions
;
1666 struct command_line
*default_collect_action
= NULL
;
1668 LONGEST frame_offset
;
1669 struct cleanup
*back_to
, *return_chain
;
1671 return_chain
= make_cleanup (null_cleanup
, NULL
);
1672 init_collection_list (tracepoint_list
);
1673 init_collection_list (stepping_list
);
1675 make_cleanup (do_clear_collection_list
, tracepoint_list
);
1676 make_cleanup (do_clear_collection_list
, stepping_list
);
1678 back_to
= make_cleanup (null_cleanup
, NULL
);
1679 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1680 tloc
->address
, &frame_reg
, &frame_offset
);
1682 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1684 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1685 tracepoint_list
, stepping_list
);
1687 memrange_sortmerge (tracepoint_list
);
1688 memrange_sortmerge (stepping_list
);
1690 do_cleanups (back_to
);
1691 return return_chain
;
1694 /* Render all actions into gdb protocol. */
1697 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1698 char ***stepping_actions
)
1700 struct collection_list tracepoint_list
, stepping_list
;
1701 struct cleanup
*cleanup
;
1703 *tdp_actions
= NULL
;
1704 *stepping_actions
= NULL
;
1706 cleanup
= encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
1709 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1710 *stepping_actions
= stringify_collection_list (&stepping_list
);
1712 do_cleanups (cleanup
);
1716 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1718 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1720 collect
->aexpr_list
=
1721 xrealloc (collect
->aexpr_list
,
1722 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1723 collect
->aexpr_listsize
*= 2;
1725 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1726 collect
->next_aexpr_elt
++;
1730 process_tracepoint_on_disconnect (void)
1732 VEC(breakpoint_p
) *tp_vec
= NULL
;
1734 struct breakpoint
*b
;
1735 int has_pending_p
= 0;
1737 /* Check whether we still have pending tracepoint. If we have, warn the
1738 user that pending tracepoint will no longer work. */
1739 tp_vec
= all_tracepoints ();
1740 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1749 struct bp_location
*loc1
;
1751 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1753 if (loc1
->shlib_disabled
)
1764 VEC_free (breakpoint_p
, tp_vec
);
1767 warning (_("Pending tracepoints will not be resolved while"
1768 " GDB is disconnected\n"));
1771 /* Reset local state of tracing. */
1774 trace_reset_local_state (void)
1776 set_traceframe_num (-1);
1777 set_tracepoint_num (-1);
1778 set_traceframe_context (NULL
);
1779 clear_traceframe_info ();
1783 start_tracing (char *notes
)
1785 VEC(breakpoint_p
) *tp_vec
= NULL
;
1787 struct breakpoint
*b
;
1788 struct trace_state_variable
*tsv
;
1789 int any_enabled
= 0, num_to_download
= 0;
1792 tp_vec
= all_tracepoints ();
1794 /* No point in tracing without any tracepoints... */
1795 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1797 VEC_free (breakpoint_p
, tp_vec
);
1798 error (_("No tracepoints defined, not starting trace"));
1801 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1803 struct tracepoint
*t
= (struct tracepoint
*) b
;
1804 struct bp_location
*loc
;
1806 if (b
->enable_state
== bp_enabled
)
1809 if ((b
->type
== bp_fast_tracepoint
1810 ? may_insert_fast_tracepoints
1811 : may_insert_tracepoints
))
1814 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1815 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1820 if (target_supports_enable_disable_tracepoint ())
1821 warning (_("No tracepoints enabled"));
1824 /* No point in tracing with only disabled tracepoints that
1825 cannot be re-enabled. */
1826 VEC_free (breakpoint_p
, tp_vec
);
1827 error (_("No tracepoints enabled, not starting trace"));
1831 if (num_to_download
<= 0)
1833 VEC_free (breakpoint_p
, tp_vec
);
1834 error (_("No tracepoints that may be downloaded, not starting trace"));
1837 target_trace_init ();
1839 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1841 struct tracepoint
*t
= (struct tracepoint
*) b
;
1842 struct bp_location
*loc
;
1843 int bp_location_downloaded
= 0;
1845 /* Clear `inserted' flag. */
1846 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1849 if ((b
->type
== bp_fast_tracepoint
1850 ? !may_insert_fast_tracepoints
1851 : !may_insert_tracepoints
))
1854 t
->number_on_target
= 0;
1856 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1858 /* Since tracepoint locations are never duplicated, `inserted'
1859 flag should be zero. */
1860 gdb_assert (!loc
->inserted
);
1862 target_download_tracepoint (loc
);
1865 bp_location_downloaded
= 1;
1868 t
->number_on_target
= b
->number
;
1870 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1871 if (loc
->probe
!= NULL
)
1872 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1874 if (bp_location_downloaded
)
1875 observer_notify_breakpoint_modified (b
);
1877 VEC_free (breakpoint_p
, tp_vec
);
1879 /* Send down all the trace state variables too. */
1880 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1882 target_download_trace_state_variable (tsv
);
1885 /* Tell target to treat text-like sections as transparent. */
1886 target_trace_set_readonly_regions ();
1887 /* Set some mode flags. */
1888 target_set_disconnected_tracing (disconnected_tracing
);
1889 target_set_circular_trace_buffer (circular_trace_buffer
);
1890 target_set_trace_buffer_size (trace_buffer_size
);
1893 notes
= trace_notes
;
1894 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1896 if (!ret
&& (trace_user
|| notes
))
1897 warning (_("Target does not support trace user/notes, info ignored"));
1899 /* Now insert traps and begin collecting data. */
1900 target_trace_start ();
1902 /* Reset our local state. */
1903 trace_reset_local_state ();
1904 current_trace_status()->running
= 1;
1907 /* The tstart command requests the target to start a new trace run.
1908 The command passes any arguments it has to the target verbatim, as
1909 an optional "trace note". This is useful as for instance a warning
1910 to other users if the trace runs disconnected, and you don't want
1911 anybody else messing with the target. */
1914 trace_start_command (char *args
, int from_tty
)
1916 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1918 if (current_trace_status ()->running
)
1921 && !query (_("A trace is running already. Start a new run? ")))
1922 error (_("New trace run not started."));
1925 start_tracing (args
);
1928 /* The tstop command stops the tracing run. The command passes any
1929 supplied arguments to the target verbatim as a "stop note"; if the
1930 target supports trace notes, then it will be reported back as part
1931 of the trace run's status. */
1934 trace_stop_command (char *args
, int from_tty
)
1936 if (!current_trace_status ()->running
)
1937 error (_("Trace is not running."));
1939 stop_tracing (args
);
1943 stop_tracing (char *note
)
1946 VEC(breakpoint_p
) *tp_vec
= NULL
;
1948 struct breakpoint
*t
;
1950 target_trace_stop ();
1952 tp_vec
= all_tracepoints ();
1953 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1955 struct bp_location
*loc
;
1957 if ((t
->type
== bp_fast_tracepoint
1958 ? !may_insert_fast_tracepoints
1959 : !may_insert_tracepoints
))
1962 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1964 /* GDB can be totally absent in some disconnected trace scenarios,
1965 but we don't really care if this semaphore goes out of sync.
1966 That's why we are decrementing it here, but not taking care
1968 if (loc
->probe
!= NULL
)
1969 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1973 VEC_free (breakpoint_p
, tp_vec
);
1976 note
= trace_stop_notes
;
1977 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1980 warning (_("Target does not support trace notes, note ignored"));
1982 /* Should change in response to reply? */
1983 current_trace_status ()->running
= 0;
1986 /* tstatus command */
1988 trace_status_command (char *args
, int from_tty
)
1990 struct trace_status
*ts
= current_trace_status ();
1992 VEC(breakpoint_p
) *tp_vec
= NULL
;
1993 struct breakpoint
*t
;
1995 status
= target_get_trace_status (ts
);
1999 if (ts
->filename
!= NULL
)
2000 printf_filtered (_("Using a trace file.\n"));
2003 printf_filtered (_("Trace can not be run on this target.\n"));
2008 if (!ts
->running_known
)
2010 printf_filtered (_("Run/stop status is unknown.\n"));
2012 else if (ts
->running
)
2014 printf_filtered (_("Trace is running on the target.\n"));
2018 switch (ts
->stop_reason
)
2020 case trace_never_run
:
2021 printf_filtered (_("No trace has been run on the target.\n"));
2025 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2028 printf_filtered (_("Trace stopped by a tstop command.\n"));
2030 case trace_buffer_full
:
2031 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2033 case trace_disconnected
:
2034 printf_filtered (_("Trace stopped because of disconnection.\n"));
2036 case tracepoint_passcount
:
2037 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2038 ts
->stopping_tracepoint
);
2040 case tracepoint_error
:
2041 if (ts
->stopping_tracepoint
)
2042 printf_filtered (_("Trace stopped by an "
2043 "error (%s, tracepoint %d).\n"),
2044 ts
->stop_desc
, ts
->stopping_tracepoint
);
2046 printf_filtered (_("Trace stopped by an error (%s).\n"),
2049 case trace_stop_reason_unknown
:
2050 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2053 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2059 if (ts
->traceframes_created
>= 0
2060 && ts
->traceframe_count
!= ts
->traceframes_created
)
2062 printf_filtered (_("Buffer contains %d trace "
2063 "frames (of %d created total).\n"),
2064 ts
->traceframe_count
, ts
->traceframes_created
);
2066 else if (ts
->traceframe_count
>= 0)
2068 printf_filtered (_("Collected %d trace frames.\n"),
2069 ts
->traceframe_count
);
2072 if (ts
->buffer_free
>= 0)
2074 if (ts
->buffer_size
>= 0)
2076 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2077 ts
->buffer_free
, ts
->buffer_size
);
2078 if (ts
->buffer_size
> 0)
2079 printf_filtered (_(" (%d%% full)"),
2080 ((int) ((((long long) (ts
->buffer_size
2081 - ts
->buffer_free
)) * 100)
2082 / ts
->buffer_size
)));
2083 printf_filtered (_(".\n"));
2086 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2090 if (ts
->disconnected_tracing
)
2091 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2093 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2095 if (ts
->circular_buffer
)
2096 printf_filtered (_("Trace buffer is circular.\n"));
2098 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2099 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2101 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2102 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2104 /* Now report on what we're doing with tfind. */
2105 if (traceframe_number
>= 0)
2106 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2107 traceframe_number
, tracepoint_number
);
2109 printf_filtered (_("Not looking at any trace frame.\n"));
2111 /* Report start/stop times if supplied. */
2116 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2118 /* Reporting a run time is more readable than two long numbers. */
2119 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2120 (long int) (ts
->start_time
/ 1000000),
2121 (long int) (ts
->start_time
% 1000000),
2122 (long int) (run_time
/ 1000000),
2123 (long int) (run_time
% 1000000));
2126 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2127 (long int) (ts
->start_time
/ 1000000),
2128 (long int) (ts
->start_time
% 1000000));
2130 else if (ts
->stop_time
)
2131 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2132 (long int) (ts
->stop_time
/ 1000000),
2133 (long int) (ts
->stop_time
% 1000000));
2135 /* Now report any per-tracepoint status available. */
2136 tp_vec
= all_tracepoints ();
2138 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2139 target_get_tracepoint_status (t
, NULL
);
2141 VEC_free (breakpoint_p
, tp_vec
);
2144 /* Report the trace status to uiout, in a way suitable for MI, and not
2145 suitable for CLI. If ON_STOP is true, suppress a few fields that
2146 are not meaningful in the -trace-stop response.
2148 The implementation is essentially parallel to trace_status_command, but
2149 merging them will result in unreadable code. */
2151 trace_status_mi (int on_stop
)
2153 struct ui_out
*uiout
= current_uiout
;
2154 struct trace_status
*ts
= current_trace_status ();
2157 status
= target_get_trace_status (ts
);
2159 if (status
== -1 && ts
->filename
== NULL
)
2161 ui_out_field_string (uiout
, "supported", "0");
2165 if (ts
->filename
!= NULL
)
2166 ui_out_field_string (uiout
, "supported", "file");
2168 ui_out_field_string (uiout
, "supported", "1");
2170 if (ts
->filename
!= NULL
)
2171 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2173 gdb_assert (ts
->running_known
);
2177 ui_out_field_string (uiout
, "running", "1");
2179 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2180 Given that the frontend gets the status either on -trace-stop, or from
2181 -trace-status after re-connection, it does not seem like this
2182 information is necessary for anything. It is not necessary for either
2183 figuring the vital state of the target nor for navigation of trace
2184 frames. If the frontend wants to show the current state is some
2185 configure dialog, it can request the value when such dialog is
2186 invoked by the user. */
2190 char *stop_reason
= NULL
;
2191 int stopping_tracepoint
= -1;
2194 ui_out_field_string (uiout
, "running", "0");
2196 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2198 switch (ts
->stop_reason
)
2201 stop_reason
= "request";
2203 case trace_buffer_full
:
2204 stop_reason
= "overflow";
2206 case trace_disconnected
:
2207 stop_reason
= "disconnection";
2209 case tracepoint_passcount
:
2210 stop_reason
= "passcount";
2211 stopping_tracepoint
= ts
->stopping_tracepoint
;
2213 case tracepoint_error
:
2214 stop_reason
= "error";
2215 stopping_tracepoint
= ts
->stopping_tracepoint
;
2221 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2222 if (stopping_tracepoint
!= -1)
2223 ui_out_field_int (uiout
, "stopping-tracepoint",
2224 stopping_tracepoint
);
2225 if (ts
->stop_reason
== tracepoint_error
)
2226 ui_out_field_string (uiout
, "error-description",
2232 if (ts
->traceframe_count
!= -1)
2233 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2234 if (ts
->traceframes_created
!= -1)
2235 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2236 if (ts
->buffer_size
!= -1)
2237 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2238 if (ts
->buffer_free
!= -1)
2239 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2241 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2242 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2244 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2245 ui_out_field_string (uiout
, "notes", ts
->notes
);
2250 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2251 (long int) (ts
->start_time
/ 1000000),
2252 (long int) (ts
->start_time
% 1000000));
2253 ui_out_field_string (uiout
, "start-time", buf
);
2254 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2255 (long int) (ts
->stop_time
/ 1000000),
2256 (long int) (ts
->stop_time
% 1000000));
2257 ui_out_field_string (uiout
, "stop-time", buf
);
2261 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2262 user if she really wants to detach. */
2265 query_if_trace_running (int from_tty
)
2270 /* It can happen that the target that was tracing went away on its
2271 own, and we didn't notice. Get a status update, and if the
2272 current target doesn't even do tracing, then assume it's not
2274 if (target_get_trace_status (current_trace_status ()) < 0)
2275 current_trace_status ()->running
= 0;
2277 /* If running interactively, give the user the option to cancel and
2278 then decide what to do differently with the run. Scripts are
2279 just going to disconnect and let the target deal with it,
2280 according to how it's been instructed previously via
2281 disconnected-tracing. */
2282 if (current_trace_status ()->running
)
2284 process_tracepoint_on_disconnect ();
2286 if (current_trace_status ()->disconnected_tracing
)
2288 if (!query (_("Trace is running and will "
2289 "continue after detach; detach anyway? ")))
2290 error (_("Not confirmed."));
2294 if (!query (_("Trace is running but will "
2295 "stop on detach; detach anyway? ")))
2296 error (_("Not confirmed."));
2301 /* This function handles the details of what to do about an ongoing
2302 tracing run if the user has asked to detach or otherwise disconnect
2306 disconnect_tracing (void)
2308 /* Also we want to be out of tfind mode, otherwise things can get
2309 confusing upon reconnection. Just use these calls instead of
2310 full tfind_1 behavior because we're in the middle of detaching,
2311 and there's no point to updating current stack frame etc. */
2312 trace_reset_local_state ();
2315 /* Worker function for the various flavors of the tfind command. */
2317 tfind_1 (enum trace_find_type type
, int num
,
2318 CORE_ADDR addr1
, CORE_ADDR addr2
,
2321 int target_frameno
= -1, target_tracept
= -1;
2322 struct frame_id old_frame_id
= null_frame_id
;
2323 struct tracepoint
*tp
;
2324 struct ui_out
*uiout
= current_uiout
;
2326 /* Only try to get the current stack frame if we have a chance of
2327 succeeding. In particular, if we're trying to get a first trace
2328 frame while all threads are running, it's not going to succeed,
2329 so leave it with a default value and let the frame comparison
2330 below (correctly) decide to print out the source location of the
2332 if (!(type
== tfind_number
&& num
== -1)
2333 && (has_stack_frames () || traceframe_number
>= 0))
2334 old_frame_id
= get_frame_id (get_current_frame ());
2336 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2339 if (type
== tfind_number
2341 && target_frameno
== -1)
2343 /* We told the target to get out of tfind mode, and it did. */
2345 else if (target_frameno
== -1)
2347 /* A request for a non-existent trace frame has failed.
2348 Our response will be different, depending on FROM_TTY:
2350 If FROM_TTY is true, meaning that this command was
2351 typed interactively by the user, then give an error
2352 and DO NOT change the state of traceframe_number etc.
2354 However if FROM_TTY is false, meaning that we're either
2355 in a script, a loop, or a user-defined command, then
2356 DON'T give an error, but DO change the state of
2357 traceframe_number etc. to invalid.
2359 The rationalle is that if you typed the command, you
2360 might just have committed a typo or something, and you'd
2361 like to NOT lose your current debugging state. However
2362 if you're in a user-defined command or especially in a
2363 loop, then you need a way to detect that the command
2364 failed WITHOUT aborting. This allows you to write
2365 scripts that search thru the trace buffer until the end,
2366 and then continue on to do something else. */
2369 error (_("Target failed to find requested trace frame."));
2373 printf_filtered ("End of trace buffer.\n");
2374 #if 0 /* dubious now? */
2375 /* The following will not recurse, since it's
2377 trace_find_command ("-1", from_tty
);
2382 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2384 reinit_frame_cache ();
2385 target_dcache_invalidate ();
2387 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2389 if (target_frameno
!= get_traceframe_number ())
2390 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2392 set_current_traceframe (target_frameno
);
2394 if (target_frameno
== -1)
2395 set_traceframe_context (NULL
);
2397 set_traceframe_context (get_current_frame ());
2399 if (traceframe_number
>= 0)
2401 /* Use different branches for MI and CLI to make CLI messages
2403 if (ui_out_is_mi_like_p (uiout
))
2405 ui_out_field_string (uiout
, "found", "1");
2406 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2407 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2411 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2412 traceframe_number
, tracepoint_number
);
2417 if (ui_out_is_mi_like_p (uiout
))
2418 ui_out_field_string (uiout
, "found", "0");
2419 else if (type
== tfind_number
&& num
== -1)
2420 printf_unfiltered (_("No longer looking at any trace frame\n"));
2421 else /* This case may never occur, check. */
2422 printf_unfiltered (_("No trace frame found\n"));
2425 /* If we're in nonstop mode and getting out of looking at trace
2426 frames, there won't be any current frame to go back to and
2429 && (has_stack_frames () || traceframe_number
>= 0))
2431 enum print_what print_what
;
2433 /* NOTE: in imitation of the step command, try to determine
2434 whether we have made a transition from one function to
2435 another. If so, we'll print the "stack frame" (ie. the new
2436 function and it's arguments) -- otherwise we'll just show the
2439 if (frame_id_eq (old_frame_id
,
2440 get_frame_id (get_current_frame ())))
2441 print_what
= SRC_LINE
;
2443 print_what
= SRC_AND_LOC
;
2445 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2450 /* trace_find_command takes a trace frame number n,
2451 sends "QTFrame:<n>" to the target,
2452 and accepts a reply that may contain several optional pieces
2453 of information: a frame number, a tracepoint number, and an
2454 indication of whether this is a trap frame or a stepping frame.
2456 The minimal response is just "OK" (which indicates that the
2457 target does not give us a frame number or a tracepoint number).
2458 Instead of that, the target may send us a string containing
2460 F<hexnum> (gives the selected frame number)
2461 T<hexnum> (gives the selected tracepoint number)
2466 trace_find_command (char *args
, int from_tty
)
2467 { /* This should only be called with a numeric argument. */
2470 if (current_trace_status ()->running
2471 && current_trace_status ()->filename
== NULL
)
2472 error (_("May not look at trace frames while trace is running."));
2474 if (args
== 0 || *args
== 0)
2475 { /* TFIND with no args means find NEXT trace frame. */
2476 if (traceframe_number
== -1)
2477 frameno
= 0; /* "next" is first one. */
2479 frameno
= traceframe_number
+ 1;
2481 else if (0 == strcmp (args
, "-"))
2483 if (traceframe_number
== -1)
2484 error (_("not debugging trace buffer"));
2485 else if (from_tty
&& traceframe_number
== 0)
2486 error (_("already at start of trace buffer"));
2488 frameno
= traceframe_number
- 1;
2490 /* A hack to work around eval's need for fp to have been collected. */
2491 else if (0 == strcmp (args
, "-1"))
2494 frameno
= parse_and_eval_long (args
);
2497 error (_("invalid input (%d is less than zero)"), frameno
);
2499 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2504 trace_find_end_command (char *args
, int from_tty
)
2506 trace_find_command ("-1", from_tty
);
2511 trace_find_start_command (char *args
, int from_tty
)
2513 trace_find_command ("0", from_tty
);
2516 /* tfind pc command */
2518 trace_find_pc_command (char *args
, int from_tty
)
2522 if (current_trace_status ()->running
2523 && current_trace_status ()->filename
== NULL
)
2524 error (_("May not look at trace frames while trace is running."));
2526 if (args
== 0 || *args
== 0)
2527 pc
= regcache_read_pc (get_current_regcache ());
2529 pc
= parse_and_eval_address (args
);
2531 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2534 /* tfind tracepoint command */
2536 trace_find_tracepoint_command (char *args
, int from_tty
)
2539 struct tracepoint
*tp
;
2541 if (current_trace_status ()->running
2542 && current_trace_status ()->filename
== NULL
)
2543 error (_("May not look at trace frames while trace is running."));
2545 if (args
== 0 || *args
== 0)
2547 if (tracepoint_number
== -1)
2548 error (_("No current tracepoint -- please supply an argument."));
2550 tdp
= tracepoint_number
; /* Default is current TDP. */
2553 tdp
= parse_and_eval_long (args
);
2555 /* If we have the tracepoint on hand, use the number that the
2556 target knows about (which may be different if we disconnected
2557 and reconnected). */
2558 tp
= get_tracepoint (tdp
);
2560 tdp
= tp
->number_on_target
;
2562 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2565 /* TFIND LINE command:
2567 This command will take a sourceline for argument, just like BREAK
2568 or TRACE (ie. anything that "decode_line_1" can handle).
2570 With no argument, this command will find the next trace frame
2571 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2574 trace_find_line_command (char *args
, int from_tty
)
2576 static CORE_ADDR start_pc
, end_pc
;
2577 struct symtabs_and_lines sals
;
2578 struct symtab_and_line sal
;
2579 struct cleanup
*old_chain
;
2581 if (current_trace_status ()->running
2582 && current_trace_status ()->filename
== NULL
)
2583 error (_("May not look at trace frames while trace is running."));
2585 if (args
== 0 || *args
== 0)
2587 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2589 sals
.sals
= (struct symtab_and_line
*)
2590 xmalloc (sizeof (struct symtab_and_line
));
2595 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2599 old_chain
= make_cleanup (xfree
, sals
.sals
);
2600 if (sal
.symtab
== 0)
2601 error (_("No line number information available."));
2603 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2605 if (start_pc
== end_pc
)
2607 printf_filtered ("Line %d of \"%s\"",
2609 symtab_to_filename_for_display (sal
.symtab
));
2611 printf_filtered (" is at address ");
2612 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2614 printf_filtered (" but contains no code.\n");
2615 sal
= find_pc_line (start_pc
, 0);
2617 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2618 && start_pc
!= end_pc
)
2619 printf_filtered ("Attempting to find line %d instead.\n",
2622 error (_("Cannot find a good line."));
2626 /* Is there any case in which we get here, and have an address
2627 which the user would want to see? If we have debugging
2628 symbols and no line numbers? */
2629 error (_("Line number %d is out of range for \"%s\"."),
2630 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2632 /* Find within range of stated line. */
2634 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2636 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2637 do_cleanups (old_chain
);
2640 /* tfind range command */
2642 trace_find_range_command (char *args
, int from_tty
)
2644 static CORE_ADDR start
, stop
;
2647 if (current_trace_status ()->running
2648 && current_trace_status ()->filename
== NULL
)
2649 error (_("May not look at trace frames while trace is running."));
2651 if (args
== 0 || *args
== 0)
2652 { /* XXX FIXME: what should default behavior be? */
2653 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2657 if (0 != (tmp
= strchr (args
, ',')))
2659 *tmp
++ = '\0'; /* Terminate start address. */
2660 tmp
= skip_spaces (tmp
);
2661 start
= parse_and_eval_address (args
);
2662 stop
= parse_and_eval_address (tmp
);
2665 { /* No explicit end address? */
2666 start
= parse_and_eval_address (args
);
2667 stop
= start
+ 1; /* ??? */
2670 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2673 /* tfind outside command */
2675 trace_find_outside_command (char *args
, int from_tty
)
2677 CORE_ADDR start
, stop
;
2680 if (current_trace_status ()->running
2681 && current_trace_status ()->filename
== NULL
)
2682 error (_("May not look at trace frames while trace is running."));
2684 if (args
== 0 || *args
== 0)
2685 { /* XXX FIXME: what should default behavior be? */
2686 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2690 if (0 != (tmp
= strchr (args
, ',')))
2692 *tmp
++ = '\0'; /* Terminate start address. */
2693 tmp
= skip_spaces (tmp
);
2694 start
= parse_and_eval_address (args
);
2695 stop
= parse_and_eval_address (tmp
);
2698 { /* No explicit end address? */
2699 start
= parse_and_eval_address (args
);
2700 stop
= start
+ 1; /* ??? */
2703 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2706 /* info scope command: list the locals for a scope. */
2708 scope_info (char *args
, int from_tty
)
2710 struct symtabs_and_lines sals
;
2712 struct minimal_symbol
*msym
;
2713 struct block
*block
;
2714 const char *symname
;
2715 char *save_args
= args
;
2716 struct block_iterator iter
;
2718 struct gdbarch
*gdbarch
;
2721 if (args
== 0 || *args
== 0)
2722 error (_("requires an argument (function, "
2723 "line or *addr) to define a scope"));
2725 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2726 if (sals
.nelts
== 0)
2727 return; /* Presumably decode_line_1 has already warned. */
2729 /* Resolve line numbers to PC. */
2730 resolve_sal_pc (&sals
.sals
[0]);
2731 block
= block_for_pc (sals
.sals
[0].pc
);
2735 QUIT
; /* Allow user to bail out with ^C. */
2736 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2738 QUIT
; /* Allow user to bail out with ^C. */
2740 printf_filtered ("Scope for %s:\n", save_args
);
2743 symname
= SYMBOL_PRINT_NAME (sym
);
2744 if (symname
== NULL
|| *symname
== '\0')
2745 continue; /* Probably botched, certainly useless. */
2747 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2749 printf_filtered ("Symbol %s is ", symname
);
2751 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2752 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2753 BLOCK_START (block
),
2757 switch (SYMBOL_CLASS (sym
))
2760 case LOC_UNDEF
: /* Messed up symbol? */
2761 printf_filtered ("a bogus symbol, class %d.\n",
2762 SYMBOL_CLASS (sym
));
2763 count
--; /* Don't count this one. */
2766 printf_filtered ("a constant with value %s (%s)",
2767 plongest (SYMBOL_VALUE (sym
)),
2768 hex_string (SYMBOL_VALUE (sym
)));
2770 case LOC_CONST_BYTES
:
2771 printf_filtered ("constant bytes: ");
2772 if (SYMBOL_TYPE (sym
))
2773 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2774 fprintf_filtered (gdb_stdout
, " %02x",
2775 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2778 printf_filtered ("in static storage at address ");
2779 printf_filtered ("%s", paddress (gdbarch
,
2780 SYMBOL_VALUE_ADDRESS (sym
)));
2783 /* GDBARCH is the architecture associated with the objfile
2784 the symbol is defined in; the target architecture may be
2785 different, and may provide additional registers. However,
2786 we do not know the target architecture at this point.
2787 We assume the objfile architecture will contain all the
2788 standard registers that occur in debug info in that
2790 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2793 if (SYMBOL_IS_ARGUMENT (sym
))
2794 printf_filtered ("an argument in register $%s",
2795 gdbarch_register_name (gdbarch
, regno
));
2797 printf_filtered ("a local variable in register $%s",
2798 gdbarch_register_name (gdbarch
, regno
));
2801 printf_filtered ("an argument at stack/frame offset %s",
2802 plongest (SYMBOL_VALUE (sym
)));
2805 printf_filtered ("a local variable at frame offset %s",
2806 plongest (SYMBOL_VALUE (sym
)));
2809 printf_filtered ("a reference argument at offset %s",
2810 plongest (SYMBOL_VALUE (sym
)));
2812 case LOC_REGPARM_ADDR
:
2813 /* Note comment at LOC_REGISTER. */
2814 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2816 printf_filtered ("the address of an argument, in register $%s",
2817 gdbarch_register_name (gdbarch
, regno
));
2820 printf_filtered ("a typedef.\n");
2823 printf_filtered ("a label at address ");
2824 printf_filtered ("%s", paddress (gdbarch
,
2825 SYMBOL_VALUE_ADDRESS (sym
)));
2828 printf_filtered ("a function at address ");
2829 printf_filtered ("%s",
2830 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2832 case LOC_UNRESOLVED
:
2833 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2836 printf_filtered ("Unresolved Static");
2839 printf_filtered ("static storage at address ");
2840 printf_filtered ("%s",
2842 SYMBOL_VALUE_ADDRESS (msym
)));
2845 case LOC_OPTIMIZED_OUT
:
2846 printf_filtered ("optimized out.\n");
2849 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2852 if (SYMBOL_TYPE (sym
))
2853 printf_filtered (", length %d.\n",
2854 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2856 if (BLOCK_FUNCTION (block
))
2859 block
= BLOCK_SUPERBLOCK (block
);
2862 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2866 /* Helper for trace_dump_command. Dump the action list starting at
2867 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2868 actions of the body of a while-stepping action. STEPPING_FRAME is
2869 set if the current traceframe was determined to be a while-stepping
2873 trace_dump_actions (struct command_line
*action
,
2874 int stepping_actions
, int stepping_frame
,
2877 const char *action_exp
, *next_comma
;
2879 for (; action
!= NULL
; action
= action
->next
)
2881 struct cmd_list_element
*cmd
;
2883 QUIT
; /* Allow user to bail out with ^C. */
2884 action_exp
= action
->line
;
2885 action_exp
= skip_spaces_const (action_exp
);
2887 /* The collection actions to be done while stepping are
2888 bracketed by the commands "while-stepping" and "end". */
2890 if (*action_exp
== '#') /* comment line */
2893 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2895 error (_("Bad action list item: %s"), action_exp
);
2897 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2901 for (i
= 0; i
< action
->body_count
; ++i
)
2902 trace_dump_actions (action
->body_list
[i
],
2903 1, stepping_frame
, from_tty
);
2905 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2907 /* Display the collected data.
2908 For the trap frame, display only what was collected at
2909 the trap. Likewise for stepping frames, display only
2910 what was collected while stepping. This means that the
2911 two boolean variables, STEPPING_FRAME and
2912 STEPPING_ACTIONS should be equal. */
2913 if (stepping_frame
== stepping_actions
)
2916 struct cleanup
*old_chain
2917 = make_cleanup (free_current_contents
, &cmd
);
2918 int trace_string
= 0;
2920 if (*action_exp
== '/')
2921 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2924 { /* Repeat over a comma-separated list. */
2925 QUIT
; /* Allow user to bail out with ^C. */
2926 if (*action_exp
== ',')
2928 action_exp
= skip_spaces_const (action_exp
);
2930 next_comma
= strchr (action_exp
, ',');
2932 if (0 == strncasecmp (action_exp
, "$reg", 4))
2933 registers_info (NULL
, from_tty
);
2934 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2936 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2937 locals_info (NULL
, from_tty
);
2938 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2939 args_info (NULL
, from_tty
);
2942 if (next_comma
!= NULL
)
2944 size_t len
= next_comma
- action_exp
;
2946 cmd
= xrealloc (cmd
, len
+ 1);
2947 memcpy (cmd
, action_exp
, len
);
2952 size_t len
= strlen (action_exp
);
2954 cmd
= xrealloc (cmd
, len
+ 1);
2955 memcpy (cmd
, action_exp
, len
+ 1);
2958 printf_filtered ("%s = ", cmd
);
2959 output_command_const (cmd
, from_tty
);
2960 printf_filtered ("\n");
2962 action_exp
= next_comma
;
2964 while (action_exp
&& *action_exp
== ',');
2966 do_cleanups (old_chain
);
2972 /* Return bp_location of the tracepoint associated with the current
2973 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2974 is a stepping traceframe. */
2976 struct bp_location
*
2977 get_traceframe_location (int *stepping_frame_p
)
2979 struct tracepoint
*t
;
2980 struct bp_location
*tloc
;
2981 struct regcache
*regcache
;
2983 if (tracepoint_number
== -1)
2984 error (_("No current trace frame."));
2986 t
= get_tracepoint (tracepoint_number
);
2989 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2992 /* The current frame is a trap frame if the frame PC is equal to the
2993 tracepoint PC. If not, then the current frame was collected
2994 during single-stepping. */
2995 regcache
= get_current_regcache ();
2997 /* If the traceframe's address matches any of the tracepoint's
2998 locations, assume it is a direct hit rather than a while-stepping
2999 frame. (FIXME this is not reliable, should record each frame's
3001 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
3002 if (tloc
->address
== regcache_read_pc (regcache
))
3004 *stepping_frame_p
= 0;
3008 /* If this is a stepping frame, we don't know which location
3009 triggered. The first is as good (or bad) a guess as any... */
3010 *stepping_frame_p
= 1;
3014 /* Return all the actions, including default collect, of a tracepoint
3015 T. It constructs cleanups into the chain, and leaves the caller to
3016 handle them (call do_cleanups). */
3018 static struct command_line
*
3019 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3021 struct command_line
*actions
;
3023 actions
= breakpoint_commands (t
);
3025 /* If there are default expressions to collect, make up a collect
3026 action and prepend to the action list to encode. Note that since
3027 validation is per-tracepoint (local var "xyz" might be valid for
3028 one tracepoint and not another, etc), we make up the action on
3029 the fly, and don't cache it. */
3030 if (*default_collect
)
3032 struct command_line
*default_collect_action
;
3033 char *default_collect_line
;
3035 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3036 make_cleanup (xfree
, default_collect_line
);
3038 validate_actionline (default_collect_line
, t
);
3039 default_collect_action
= xmalloc (sizeof (struct command_line
));
3040 make_cleanup (xfree
, default_collect_action
);
3041 default_collect_action
->next
= actions
;
3042 default_collect_action
->line
= default_collect_line
;
3043 actions
= default_collect_action
;
3049 /* The tdump command. */
3052 trace_dump_command (char *args
, int from_tty
)
3054 int stepping_frame
= 0;
3055 struct bp_location
*loc
;
3056 struct cleanup
*old_chain
;
3057 struct command_line
*actions
;
3059 /* This throws an error is not inspecting a trace frame. */
3060 loc
= get_traceframe_location (&stepping_frame
);
3062 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3063 tracepoint_number
, traceframe_number
);
3065 old_chain
= make_cleanup (null_cleanup
, NULL
);
3067 /* This command only makes sense for the current frame, not the
3069 make_cleanup_restore_current_thread ();
3070 select_frame (get_current_frame ());
3072 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3074 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3076 do_cleanups (old_chain
);
3079 /* Encode a piece of a tracepoint's source-level definition in a form
3080 that is suitable for both protocol and saving in files. */
3081 /* This version does not do multiple encodes for long strings; it should
3082 return an offset to the next piece to encode. FIXME */
3085 encode_source_string (int tpnum
, ULONGEST addr
,
3086 char *srctype
, char *src
, char *buf
, int buf_size
)
3088 if (80 + strlen (srctype
) > buf_size
)
3089 error (_("Buffer too small for source encoding"));
3090 sprintf (buf
, "%x:%s:%s:%x:%x:",
3091 tpnum
, phex_nz (addr
, sizeof (addr
)),
3092 srctype
, 0, (int) strlen (src
));
3093 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3094 error (_("Source string too long for buffer"));
3095 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), strlen (src
));
3099 /* Free trace file writer. */
3102 trace_file_writer_xfree (void *arg
)
3104 struct trace_file_writer
*writer
= arg
;
3106 writer
->ops
->dtor (writer
);
3110 /* TFILE trace writer. */
3112 struct tfile_trace_file_writer
3114 struct trace_file_writer base
;
3116 /* File pointer to tfile trace file. */
3118 /* Path name of the tfile trace file. */
3122 /* This is the implementation of trace_file_write_ops method
3123 target_save. We just call the generic target
3124 target_save_trace_data to do target-side saving. */
3127 tfile_target_save (struct trace_file_writer
*self
,
3128 const char *filename
)
3130 int err
= target_save_trace_data (filename
);
3135 /* This is the implementation of trace_file_write_ops method
3139 tfile_dtor (struct trace_file_writer
*self
)
3141 struct tfile_trace_file_writer
*writer
3142 = (struct tfile_trace_file_writer
*) self
;
3144 xfree (writer
->pathname
);
3146 if (writer
->fp
!= NULL
)
3147 fclose (writer
->fp
);
3150 /* This is the implementation of trace_file_write_ops method
3151 start. It creates the trace file FILENAME and registers some
3155 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3157 struct tfile_trace_file_writer
*writer
3158 = (struct tfile_trace_file_writer
*) self
;
3160 writer
->pathname
= tilde_expand (filename
);
3161 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3162 if (writer
->fp
== NULL
)
3163 error (_("Unable to open file '%s' for saving trace data (%s)"),
3164 writer
->pathname
, safe_strerror (errno
));
3167 /* This is the implementation of trace_file_write_ops method
3168 write_header. Write the TFILE header. */
3171 tfile_write_header (struct trace_file_writer
*self
)
3173 struct tfile_trace_file_writer
*writer
3174 = (struct tfile_trace_file_writer
*) self
;
3177 /* Write a file header, with a high-bit-set char to indicate a
3178 binary file, plus a hint as what this file is, and a version
3179 number in case of future needs. */
3180 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3182 perror_with_name (writer
->pathname
);
3185 /* This is the implementation of trace_file_write_ops method
3186 write_regblock_type. Write the size of register block. */
3189 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3191 struct tfile_trace_file_writer
*writer
3192 = (struct tfile_trace_file_writer
*) self
;
3194 fprintf (writer
->fp
, "R %x\n", size
);
3197 /* This is the implementation of trace_file_write_ops method
3201 tfile_write_status (struct trace_file_writer
*self
,
3202 struct trace_status
*ts
)
3204 struct tfile_trace_file_writer
*writer
3205 = (struct tfile_trace_file_writer
*) self
;
3207 fprintf (writer
->fp
, "status %c;%s",
3208 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3209 if (ts
->stop_reason
== tracepoint_error
3210 || ts
->stop_reason
== tstop_command
)
3212 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3214 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, strlen (ts
->stop_desc
));
3215 fprintf (writer
->fp
, ":%s", buf
);
3217 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3218 if (ts
->traceframe_count
>= 0)
3219 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3220 if (ts
->traceframes_created
>= 0)
3221 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3222 if (ts
->buffer_free
>= 0)
3223 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3224 if (ts
->buffer_size
>= 0)
3225 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3226 if (ts
->disconnected_tracing
)
3227 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3228 if (ts
->circular_buffer
)
3229 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3232 fprintf (writer
->fp
, ";starttime:%s",
3233 phex_nz (ts
->start_time
, sizeof (ts
->start_time
)));
3237 fprintf (writer
->fp
, ";stoptime:%s",
3238 phex_nz (ts
->stop_time
, sizeof (ts
->stop_time
)));
3240 if (ts
->notes
!= NULL
)
3242 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3244 bin2hex ((gdb_byte
*) ts
->notes
, buf
, strlen (ts
->notes
));
3245 fprintf (writer
->fp
, ";notes:%s", buf
);
3247 if (ts
->user_name
!= NULL
)
3249 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3251 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, strlen (ts
->user_name
));
3252 fprintf (writer
->fp
, ";username:%s", buf
);
3254 fprintf (writer
->fp
, "\n");
3257 /* This is the implementation of trace_file_write_ops method
3258 write_uploaded_tsv. */
3261 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3262 struct uploaded_tsv
*utsv
)
3265 struct tfile_trace_file_writer
*writer
3266 = (struct tfile_trace_file_writer
*) self
;
3270 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3271 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, strlen (utsv
->name
));
3274 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3275 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3276 utsv
->builtin
, buf
);
3282 #define MAX_TRACE_UPLOAD 2000
3284 /* This is the implementation of trace_file_write_ops method
3285 write_uploaded_tp. */
3288 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3289 struct uploaded_tp
*utp
)
3291 struct tfile_trace_file_writer
*writer
3292 = (struct tfile_trace_file_writer
*) self
;
3295 char buf
[MAX_TRACE_UPLOAD
];
3297 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3298 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3299 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3300 if (utp
->type
== bp_fast_tracepoint
)
3301 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3303 fprintf (writer
->fp
,
3304 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3306 fprintf (writer
->fp
, "\n");
3307 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3308 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3309 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3310 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3311 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3312 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3315 encode_source_string (utp
->number
, utp
->addr
,
3316 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3317 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3319 if (utp
->cond_string
)
3321 encode_source_string (utp
->number
, utp
->addr
,
3322 "cond", utp
->cond_string
,
3323 buf
, MAX_TRACE_UPLOAD
);
3324 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3326 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3328 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3329 buf
, MAX_TRACE_UPLOAD
);
3330 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3332 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3333 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3335 phex_nz (utp
->traceframe_usage
,
3336 sizeof (utp
->traceframe_usage
)));
3339 /* This is the implementation of trace_file_write_ops method
3340 write_definition_end. */
3343 tfile_write_definition_end (struct trace_file_writer
*self
)
3345 struct tfile_trace_file_writer
*writer
3346 = (struct tfile_trace_file_writer
*) self
;
3348 fprintf (writer
->fp
, "\n");
3351 /* This is the implementation of trace_file_write_ops method
3355 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3358 struct tfile_trace_file_writer
*writer
3359 = (struct tfile_trace_file_writer
*) self
;
3361 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3362 perror_with_name (writer
->pathname
);
3365 /* This is the implementation of trace_file_write_ops method
3369 tfile_end (struct trace_file_writer
*self
)
3371 struct tfile_trace_file_writer
*writer
3372 = (struct tfile_trace_file_writer
*) self
;
3373 uint32_t gotten
= 0;
3375 /* Mark the end of trace data. */
3376 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3377 perror_with_name (writer
->pathname
);
3380 /* Operations to write trace buffers into TFILE format. */
3382 static const struct trace_file_write_ops tfile_write_ops
=
3388 tfile_write_regblock_type
,
3390 tfile_write_uploaded_tsv
,
3391 tfile_write_uploaded_tp
,
3392 tfile_write_definition_end
,
3393 tfile_write_raw_data
,
3398 /* Helper macros. */
3400 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3401 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3402 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3403 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3405 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3406 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3408 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3409 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3411 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3412 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3413 the save is performed on the target, otherwise GDB obtains all trace
3414 data and saves it locally. */
3417 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3418 int target_does_save
)
3420 struct trace_status
*ts
= current_trace_status ();
3422 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3423 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3425 ULONGEST offset
= 0;
3426 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3427 #define MAX_TRACE_UPLOAD 2000
3429 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3431 /* If the target is to save the data to a file on its own, then just
3432 send the command and be done with it. */
3433 if (target_does_save
)
3435 if (!writer
->ops
->target_save (writer
, filename
))
3436 error (_("Target failed to save trace data to '%s'."),
3441 /* Get the trace status first before opening the file, so if the
3442 target is losing, we can get out without touching files. */
3443 status
= target_get_trace_status (ts
);
3445 writer
->ops
->start (writer
, filename
);
3447 writer
->ops
->write_header (writer
);
3449 /* Write descriptive info. */
3451 /* Write out the size of a register block. */
3452 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3454 /* Write out status of the tracing run (aka "tstatus" info). */
3455 writer
->ops
->write_status (writer
, ts
);
3457 /* Note that we want to upload tracepoints and save those, rather
3458 than simply writing out the local ones, because the user may have
3459 changed tracepoints in GDB in preparation for a future tracing
3460 run, or maybe just mass-deleted all types of breakpoints as part
3461 of cleaning up. So as not to contaminate the session, leave the
3462 data in its uploaded form, don't make into real tracepoints. */
3464 /* Get trace state variables first, they may be checked when parsing
3465 uploaded commands. */
3467 target_upload_trace_state_variables (&uploaded_tsvs
);
3469 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3470 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3472 free_uploaded_tsvs (&uploaded_tsvs
);
3474 target_upload_tracepoints (&uploaded_tps
);
3476 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3477 target_get_tracepoint_status (NULL
, utp
);
3479 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3480 writer
->ops
->write_uploaded_tp (writer
, utp
);
3482 free_uploaded_tps (&uploaded_tps
);
3484 /* Mark the end of the definition section. */
3485 writer
->ops
->write_definition_end (writer
);
3487 /* Get and write the trace data proper. */
3492 /* The writer supports writing the contents of trace buffer
3493 directly to trace file. Don't parse the contents of trace
3495 if (writer
->ops
->write_trace_buffer
!= NULL
)
3497 /* We ask for big blocks, in the hopes of efficiency, but
3498 will take less if the target has packet size limitations
3500 gotten
= target_get_raw_trace_data (buf
, offset
,
3503 error (_("Failure to get requested trace buffer data"));
3504 /* No more data is forthcoming, we're done. */
3508 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3516 /* Parse the trace buffers according to how data are stored
3517 in trace buffer in GDBserver. */
3519 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3524 /* Read the first six bytes in, which is the tracepoint
3525 number and trace frame size. */
3527 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3529 tf_size
= (uint32_t)
3530 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3532 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3541 for (block
= 0; block
< tf_size
; )
3543 gdb_byte block_type
;
3545 /* We'll fetch one block each time, in order to
3546 handle the extremely large 'M' block. We first
3547 fetch one byte to get the type of the block. */
3548 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3550 error (_("Failure to get requested trace buffer data"));
3556 block_type
= buf
[0];
3561 = target_get_raw_trace_data (buf
, offset
,
3562 trace_regblock_size
);
3563 if (gotten
< trace_regblock_size
)
3564 error (_("Failure to get requested trace"
3567 TRACE_WRITE_R_BLOCK (writer
, buf
,
3568 trace_regblock_size
);
3572 unsigned short mlen
;
3577 t
= target_get_raw_trace_data (buf
,offset
, 10);
3579 error (_("Failure to get requested trace"
3587 extract_unsigned_integer (buf
, 8,
3589 mlen
= (unsigned short)
3590 extract_unsigned_integer (&buf
[8], 2,
3593 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3596 /* The memory contents in 'M' block may be
3597 very large. Fetch the data from the target
3598 and write them into file one by one. */
3599 for (j
= 0; j
< mlen
; )
3601 unsigned int read_length
;
3603 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3604 read_length
= MAX_TRACE_UPLOAD
;
3606 read_length
= mlen
- j
;
3608 t
= target_get_raw_trace_data (buf
,
3611 if (t
< read_length
)
3612 error (_("Failure to get requested"
3613 " trace buffer data"));
3615 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3619 gotten
+= read_length
;
3630 = target_get_raw_trace_data (buf
, offset
,
3633 error (_("Failure to get requested"
3634 " trace buffer data"));
3636 vnum
= (int) extract_signed_integer (buf
,
3640 = extract_signed_integer (&buf
[4], 8,
3643 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3647 error (_("Unknown block type '%c' (0x%x) in"
3649 block_type
, block_type
);
3659 writer
->ops
->frame_ops
->end (writer
);
3663 writer
->ops
->end (writer
);
3666 /* Return a trace writer for TFILE format. */
3668 static struct trace_file_writer
*
3669 tfile_trace_file_writer_new (void)
3671 struct tfile_trace_file_writer
*writer
3672 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3674 writer
->base
.ops
= &tfile_write_ops
;
3676 writer
->pathname
= NULL
;
3678 return (struct trace_file_writer
*) writer
;
3682 trace_save_command (char *args
, int from_tty
)
3684 int target_does_save
= 0;
3686 char *filename
= NULL
;
3687 struct cleanup
*back_to
;
3688 int generate_ctf
= 0;
3689 struct trace_file_writer
*writer
= NULL
;
3692 error_no_arg (_("file in which to save trace data"));
3694 argv
= gdb_buildargv (args
);
3695 back_to
= make_cleanup_freeargv (argv
);
3697 for (; *argv
; ++argv
)
3699 if (strcmp (*argv
, "-r") == 0)
3700 target_does_save
= 1;
3701 if (strcmp (*argv
, "-ctf") == 0)
3703 else if (**argv
== '-')
3704 error (_("unknown option `%s'"), *argv
);
3710 error_no_arg (_("file in which to save trace data"));
3713 writer
= ctf_trace_file_writer_new ();
3715 writer
= tfile_trace_file_writer_new ();
3717 make_cleanup (trace_file_writer_xfree
, writer
);
3719 trace_save (filename
, writer
, target_does_save
);
3722 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3723 generate_ctf
? "directory" : "file", filename
);
3725 do_cleanups (back_to
);
3728 /* Save the trace data to file FILENAME of tfile format. */
3731 trace_save_tfile (const char *filename
, int target_does_save
)
3733 struct trace_file_writer
*writer
;
3734 struct cleanup
*back_to
;
3736 writer
= tfile_trace_file_writer_new ();
3737 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3738 trace_save (filename
, writer
, target_does_save
);
3739 do_cleanups (back_to
);
3742 /* Save the trace data to dir DIRNAME of ctf format. */
3745 trace_save_ctf (const char *dirname
, int target_does_save
)
3747 struct trace_file_writer
*writer
;
3748 struct cleanup
*back_to
;
3750 writer
= ctf_trace_file_writer_new ();
3751 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3753 trace_save (dirname
, writer
, target_does_save
);
3754 do_cleanups (back_to
);
3757 /* Tell the target what to do with an ongoing tracing run if GDB
3758 disconnects for some reason. */
3761 set_disconnected_tracing (char *args
, int from_tty
,
3762 struct cmd_list_element
*c
)
3764 target_set_disconnected_tracing (disconnected_tracing
);
3768 set_circular_trace_buffer (char *args
, int from_tty
,
3769 struct cmd_list_element
*c
)
3771 target_set_circular_trace_buffer (circular_trace_buffer
);
3775 set_trace_buffer_size (char *args
, int from_tty
,
3776 struct cmd_list_element
*c
)
3778 target_set_trace_buffer_size (trace_buffer_size
);
3782 set_trace_user (char *args
, int from_tty
,
3783 struct cmd_list_element
*c
)
3787 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3790 warning (_("Target does not support trace notes, user ignored"));
3794 set_trace_notes (char *args
, int from_tty
,
3795 struct cmd_list_element
*c
)
3799 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3802 warning (_("Target does not support trace notes, note ignored"));
3806 set_trace_stop_notes (char *args
, int from_tty
,
3807 struct cmd_list_element
*c
)
3811 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3814 warning (_("Target does not support trace notes, stop note ignored"));
3817 /* Convert the memory pointed to by mem into hex, placing result in buf.
3818 * Return a pointer to the last char put in buf (null)
3819 * "stolen" from sparc-stub.c
3822 static const char hexchars
[] = "0123456789abcdef";
3825 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3833 *buf
++ = hexchars
[ch
>> 4];
3834 *buf
++ = hexchars
[ch
& 0xf];
3843 get_traceframe_number (void)
3845 return traceframe_number
;
3849 get_tracepoint_number (void)
3851 return tracepoint_number
;
3854 /* Make the traceframe NUM be the current trace frame. Does nothing
3855 if NUM is already current. */
3858 set_current_traceframe (int num
)
3862 if (traceframe_number
== num
)
3864 /* Nothing to do. */
3868 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3871 warning (_("could not change traceframe"));
3873 set_traceframe_num (newnum
);
3875 /* Changing the traceframe changes our view of registers and of the
3877 registers_changed ();
3879 clear_traceframe_info ();
3882 /* Make the traceframe NUM be the current trace frame, and do nothing
3886 set_traceframe_number (int num
)
3888 traceframe_number
= num
;
3891 /* A cleanup used when switching away and back from tfind mode. */
3893 struct current_traceframe_cleanup
3895 /* The traceframe we were inspecting. */
3896 int traceframe_number
;
3900 do_restore_current_traceframe_cleanup (void *arg
)
3902 struct current_traceframe_cleanup
*old
= arg
;
3904 set_current_traceframe (old
->traceframe_number
);
3908 restore_current_traceframe_cleanup_dtor (void *arg
)
3910 struct current_traceframe_cleanup
*old
= arg
;
3916 make_cleanup_restore_current_traceframe (void)
3918 struct current_traceframe_cleanup
*old
;
3920 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3921 old
->traceframe_number
= traceframe_number
;
3923 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3924 restore_current_traceframe_cleanup_dtor
);
3928 make_cleanup_restore_traceframe_number (void)
3930 return make_cleanup_restore_integer (&traceframe_number
);
3933 /* Given a number and address, return an uploaded tracepoint with that
3934 number, creating if necessary. */
3936 struct uploaded_tp
*
3937 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3939 struct uploaded_tp
*utp
;
3941 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3942 if (utp
->number
== num
&& utp
->addr
== addr
)
3944 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3945 memset (utp
, 0, sizeof (struct uploaded_tp
));
3948 utp
->actions
= NULL
;
3949 utp
->step_actions
= NULL
;
3950 utp
->cmd_strings
= NULL
;
3957 free_uploaded_tps (struct uploaded_tp
**utpp
)
3959 struct uploaded_tp
*next_one
;
3963 next_one
= (*utpp
)->next
;
3969 /* Given a number and address, return an uploaded tracepoint with that
3970 number, creating if necessary. */
3972 struct uploaded_tsv
*
3973 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3975 struct uploaded_tsv
*utsv
;
3977 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3978 if (utsv
->number
== num
)
3980 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3981 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3983 utsv
->next
= *utsvp
;
3989 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3991 struct uploaded_tsv
*next_one
;
3995 next_one
= (*utsvp
)->next
;
4001 /* FIXME this function is heuristic and will miss the cases where the
4002 conditional is semantically identical but differs in whitespace,
4003 such as "x == 0" vs "x==0". */
4006 cond_string_is_same (char *str1
, char *str2
)
4008 if (str1
== NULL
|| str2
== NULL
)
4009 return (str1
== str2
);
4011 return (strcmp (str1
, str2
) == 0);
4014 /* Look for an existing tracepoint that seems similar enough to the
4015 uploaded one. Enablement isn't compared, because the user can
4016 toggle that freely, and may have done so in anticipation of the
4017 next trace run. Return the location of matched tracepoint. */
4019 static struct bp_location
*
4020 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
4022 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
4024 struct breakpoint
*b
;
4025 struct bp_location
*loc
;
4027 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
4029 struct tracepoint
*t
= (struct tracepoint
*) b
;
4031 if (b
->type
== utp
->type
4032 && t
->step_count
== utp
->step
4033 && t
->pass_count
== utp
->pass
4034 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
4035 /* FIXME also test actions. */
4038 /* Scan the locations for an address match. */
4039 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4041 if (loc
->address
== utp
->addr
)
4049 /* Given a list of tracepoints uploaded from a target, attempt to
4050 match them up with existing tracepoints, and create new ones if not
4054 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
4056 struct uploaded_tp
*utp
;
4057 /* A set of tracepoints which are modified. */
4058 VEC(breakpoint_p
) *modified_tp
= NULL
;
4060 struct breakpoint
*b
;
4062 /* Look for GDB tracepoints that match up with our uploaded versions. */
4063 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
4065 struct bp_location
*loc
;
4066 struct tracepoint
*t
;
4068 loc
= find_matching_tracepoint_location (utp
);
4073 /* Mark this location as already inserted. */
4075 t
= (struct tracepoint
*) loc
->owner
;
4076 printf_filtered (_("Assuming tracepoint %d is same "
4077 "as target's tracepoint %d at %s.\n"),
4078 loc
->owner
->number
, utp
->number
,
4079 paddress (loc
->gdbarch
, utp
->addr
));
4081 /* The tracepoint LOC->owner was modified (the location LOC
4082 was marked as inserted in the target). Save it in
4083 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4084 observers will be notified later once for each tracepoint
4085 saved in MODIFIED_TP. */
4087 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
4089 if (b
== loc
->owner
)
4095 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
4099 t
= create_tracepoint_from_upload (utp
);
4101 printf_filtered (_("Created tracepoint %d for "
4102 "target's tracepoint %d at %s.\n"),
4103 t
->base
.number
, utp
->number
,
4104 paddress (get_current_arch (), utp
->addr
));
4106 printf_filtered (_("Failed to create tracepoint for target's "
4107 "tracepoint %d at %s, skipping it.\n"),
4109 paddress (get_current_arch (), utp
->addr
));
4111 /* Whether found or created, record the number used by the
4112 target, to help with mapping target tracepoints back to their
4113 counterparts here. */
4115 t
->number_on_target
= utp
->number
;
4118 /* Notify 'breakpoint-modified' observer that at least one of B's
4119 locations was changed. */
4120 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4121 observer_notify_breakpoint_modified (b
);
4123 VEC_free (breakpoint_p
, modified_tp
);
4124 free_uploaded_tps (uploaded_tps
);
4127 /* Trace state variables don't have much to identify them beyond their
4128 name, so just use that to detect matches. */
4130 static struct trace_state_variable
*
4131 find_matching_tsv (struct uploaded_tsv
*utsv
)
4136 return find_trace_state_variable (utsv
->name
);
4139 static struct trace_state_variable
*
4140 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4142 const char *namebase
;
4145 struct trace_state_variable
*tsv
;
4146 struct cleanup
*old_chain
;
4150 namebase
= utsv
->name
;
4151 buf
= xstrprintf ("%s", namebase
);
4156 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4159 /* Fish for a name that is not in use. */
4160 /* (should check against all internal vars?) */
4161 while (find_trace_state_variable (buf
))
4164 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4167 old_chain
= make_cleanup (xfree
, buf
);
4169 /* We have an available name, create the variable. */
4170 tsv
= create_trace_state_variable (buf
);
4171 tsv
->initial_value
= utsv
->initial_value
;
4172 tsv
->builtin
= utsv
->builtin
;
4174 observer_notify_tsv_created (tsv
);
4176 do_cleanups (old_chain
);
4181 /* Given a list of uploaded trace state variables, try to match them
4182 up with existing variables, or create additional ones. */
4185 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4188 struct uploaded_tsv
*utsv
;
4189 struct trace_state_variable
*tsv
;
4192 /* Most likely some numbers will have to be reassigned as part of
4193 the merge, so clear them all in anticipation. */
4194 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4197 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4199 tsv
= find_matching_tsv (utsv
);
4203 printf_filtered (_("Assuming trace state variable $%s "
4204 "is same as target's variable %d.\n"),
4205 tsv
->name
, utsv
->number
);
4209 tsv
= create_tsv_from_upload (utsv
);
4211 printf_filtered (_("Created trace state variable "
4212 "$%s for target's variable %d.\n"),
4213 tsv
->name
, utsv
->number
);
4215 /* Give precedence to numberings that come from the target. */
4217 tsv
->number
= utsv
->number
;
4220 /* Renumber everything that didn't get a target-assigned number. */
4222 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4223 if (tsv
->number
> highest
)
4224 highest
= tsv
->number
;
4227 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4228 if (tsv
->number
== 0)
4229 tsv
->number
= highest
++;
4231 free_uploaded_tsvs (uploaded_tsvs
);
4234 /* target tfile command */
4236 static struct target_ops tfile_ops
;
4238 /* Fill in tfile_ops with its defined operations and properties. */
4240 #define TRACE_HEADER_SIZE 8
4242 static char *trace_filename
;
4243 static int trace_fd
= -1;
4244 static off_t trace_frames_offset
;
4245 static off_t cur_offset
;
4246 static int cur_data_size
;
4247 int trace_regblock_size
;
4249 static void tfile_interp_line (char *line
,
4250 struct uploaded_tp
**utpp
,
4251 struct uploaded_tsv
**utsvp
);
4253 /* Read SIZE bytes into READBUF from the trace frame, starting at
4254 TRACE_FD's current position. Note that this call `read'
4255 underneath, hence it advances the file's seek position. Throws an
4256 error if the `read' syscall fails, or less than SIZE bytes are
4260 tfile_read (gdb_byte
*readbuf
, int size
)
4264 gotten
= read (trace_fd
, readbuf
, size
);
4266 perror_with_name (trace_filename
);
4267 else if (gotten
< size
)
4268 error (_("Premature end of file while reading trace file"));
4272 tfile_open (char *filename
, int from_tty
)
4274 volatile struct gdb_exception ex
;
4276 struct cleanup
*old_chain
;
4279 char header
[TRACE_HEADER_SIZE
];
4280 char linebuf
[1000]; /* Should be max remote packet size or so. */
4283 struct trace_status
*ts
;
4284 struct uploaded_tp
*uploaded_tps
= NULL
;
4285 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4287 target_preopen (from_tty
);
4289 error (_("No trace file specified."));
4291 filename
= tilde_expand (filename
);
4292 if (!IS_ABSOLUTE_PATH(filename
))
4294 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4299 old_chain
= make_cleanup (xfree
, filename
);
4301 flags
= O_BINARY
| O_LARGEFILE
;
4303 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4304 if (scratch_chan
< 0)
4305 perror_with_name (filename
);
4307 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4309 discard_cleanups (old_chain
); /* Don't free filename any more. */
4310 unpush_target (&tfile_ops
);
4312 trace_filename
= xstrdup (filename
);
4313 trace_fd
= scratch_chan
;
4316 /* Read the file header and test for validity. */
4317 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4319 bytes
+= TRACE_HEADER_SIZE
;
4320 if (!(header
[0] == 0x7f
4321 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4322 error (_("File is not a valid trace file."));
4324 push_target (&tfile_ops
);
4326 trace_regblock_size
= 0;
4327 ts
= current_trace_status ();
4328 /* We know we're working with a file. Record its name. */
4329 ts
->filename
= trace_filename
;
4330 /* Set defaults in case there is no status line. */
4331 ts
->running_known
= 0;
4332 ts
->stop_reason
= trace_stop_reason_unknown
;
4333 ts
->traceframe_count
= -1;
4334 ts
->buffer_free
= 0;
4335 ts
->disconnected_tracing
= 0;
4336 ts
->circular_buffer
= 0;
4338 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4340 /* Read through a section of newline-terminated lines that
4341 define things like tracepoints. */
4345 tfile_read (&byte
, 1);
4350 /* Empty line marks end of the definition section. */
4355 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4358 linebuf
[i
++] = byte
;
4360 error (_("Excessively long lines in trace file"));
4363 /* Record the starting offset of the binary trace data. */
4364 trace_frames_offset
= bytes
;
4366 /* If we don't have a blocksize, we can't interpret the
4368 if (trace_regblock_size
== 0)
4369 error (_("No register block size recorded in trace file"));
4373 /* Remove the partially set up target. */
4374 unpush_target (&tfile_ops
);
4375 throw_exception (ex
);
4378 inferior_appeared (current_inferior (), TFILE_PID
);
4379 inferior_ptid
= pid_to_ptid (TFILE_PID
);
4380 add_thread_silent (inferior_ptid
);
4382 if (ts
->traceframe_count
<= 0)
4383 warning (_("No traceframes present in this file."));
4385 /* Add the file's tracepoints and variables into the current mix. */
4387 /* Get trace state variables first, they may be checked when parsing
4388 uploaded commands. */
4389 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4391 merge_uploaded_tracepoints (&uploaded_tps
);
4393 post_create_inferior (&tfile_ops
, from_tty
);
4396 /* Interpret the given line from the definitions part of the trace
4400 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4401 struct uploaded_tsv
**utsvp
)
4405 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4408 trace_regblock_size
= strtol (p
, &p
, 16);
4410 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4412 p
+= strlen ("status ");
4413 parse_trace_status (p
, current_trace_status ());
4415 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4417 p
+= strlen ("tp ");
4418 parse_tracepoint_definition (p
, utpp
);
4420 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4422 p
+= strlen ("tsv ");
4423 parse_tsv_definition (p
, utsvp
);
4426 warning (_("Ignoring trace file definition \"%s\""), line
);
4429 /* Parse the part of trace status syntax that is shared between
4430 the remote protocol and the trace file reader. */
4433 parse_trace_status (char *line
, struct trace_status
*ts
)
4435 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4439 ts
->running_known
= 1;
4440 ts
->running
= (*p
++ == '1');
4441 ts
->stop_reason
= trace_stop_reason_unknown
;
4442 xfree (ts
->stop_desc
);
4443 ts
->stop_desc
= NULL
;
4444 ts
->traceframe_count
= -1;
4445 ts
->traceframes_created
= -1;
4446 ts
->buffer_free
= -1;
4447 ts
->buffer_size
= -1;
4448 ts
->disconnected_tracing
= 0;
4449 ts
->circular_buffer
= 0;
4450 xfree (ts
->user_name
);
4451 ts
->user_name
= NULL
;
4454 ts
->start_time
= ts
->stop_time
= 0;
4458 p1
= strchr (p
, ':');
4460 error (_("Malformed trace status, at %s\n\
4461 Status line: '%s'\n"), p
, line
);
4462 p3
= strchr (p
, ';');
4464 p3
= p
+ strlen (p
);
4465 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4467 p
= unpack_varlen_hex (++p1
, &val
);
4468 ts
->stop_reason
= trace_buffer_full
;
4470 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4472 p
= unpack_varlen_hex (++p1
, &val
);
4473 ts
->stop_reason
= trace_never_run
;
4475 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4478 p
= unpack_varlen_hex (++p1
, &val
);
4479 ts
->stop_reason
= tracepoint_passcount
;
4480 ts
->stopping_tracepoint
= val
;
4482 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4484 p2
= strchr (++p1
, ':');
4492 ts
->stop_desc
= xmalloc (strlen (line
));
4493 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4494 ts
->stop_desc
[end
] = '\0';
4497 ts
->stop_desc
= xstrdup ("");
4499 p
= unpack_varlen_hex (++p2
, &val
);
4500 ts
->stop_reason
= tstop_command
;
4502 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4504 p
= unpack_varlen_hex (++p1
, &val
);
4505 ts
->stop_reason
= trace_disconnected
;
4507 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4509 p2
= strchr (++p1
, ':');
4512 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4513 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4514 ts
->stop_desc
[end
] = '\0';
4517 ts
->stop_desc
= xstrdup ("");
4519 p
= unpack_varlen_hex (++p2
, &val
);
4520 ts
->stopping_tracepoint
= val
;
4521 ts
->stop_reason
= tracepoint_error
;
4523 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4525 p
= unpack_varlen_hex (++p1
, &val
);
4526 ts
->traceframe_count
= val
;
4528 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4530 p
= unpack_varlen_hex (++p1
, &val
);
4531 ts
->traceframes_created
= val
;
4533 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4535 p
= unpack_varlen_hex (++p1
, &val
);
4536 ts
->buffer_free
= val
;
4538 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4540 p
= unpack_varlen_hex (++p1
, &val
);
4541 ts
->buffer_size
= val
;
4543 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4545 p
= unpack_varlen_hex (++p1
, &val
);
4546 ts
->disconnected_tracing
= val
;
4548 else if (strncmp (p
, "circular", p1
- p
) == 0)
4550 p
= unpack_varlen_hex (++p1
, &val
);
4551 ts
->circular_buffer
= val
;
4553 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4555 p
= unpack_varlen_hex (++p1
, &val
);
4556 ts
->start_time
= val
;
4558 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4560 p
= unpack_varlen_hex (++p1
, &val
);
4561 ts
->stop_time
= val
;
4563 else if (strncmp (p
, "username", p1
- p
) == 0)
4566 ts
->user_name
= xmalloc (strlen (p
) / 2);
4567 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4568 ts
->user_name
[end
] = '\0';
4571 else if (strncmp (p
, "notes", p1
- p
) == 0)
4574 ts
->notes
= xmalloc (strlen (p
) / 2);
4575 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4576 ts
->notes
[end
] = '\0';
4581 /* Silently skip unknown optional info. */
4582 p_temp
= strchr (p1
+ 1, ';');
4586 /* Must be at the end. */
4593 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4594 struct uploaded_tp
*utp
)
4597 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4599 p
= unpack_varlen_hex (p
, &uval
);
4601 tp
->base
.hit_count
+= uval
;
4603 utp
->hit_count
+= uval
;
4604 p
= unpack_varlen_hex (p
+ 1, &uval
);
4606 tp
->traceframe_usage
+= uval
;
4608 utp
->traceframe_usage
+= uval
;
4609 /* Ignore any extra, allowing for future extensions. */
4612 /* Given a line of text defining a part of a tracepoint, parse it into
4613 an "uploaded tracepoint". */
4616 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4620 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4623 char *cond
, *srctype
, *buf
;
4624 struct uploaded_tp
*utp
= NULL
;
4627 /* Both tracepoint and action definitions start with the same number
4628 and address sequence. */
4630 p
= unpack_varlen_hex (p
, &num
);
4631 p
++; /* skip a colon */
4632 p
= unpack_varlen_hex (p
, &addr
);
4633 p
++; /* skip a colon */
4636 enabled
= (*p
++ == 'E');
4637 p
++; /* skip a colon */
4638 p
= unpack_varlen_hex (p
, &step
);
4639 p
++; /* skip a colon */
4640 p
= unpack_varlen_hex (p
, &pass
);
4641 type
= bp_tracepoint
;
4643 /* Thumb through optional fields. */
4646 p
++; /* skip a colon */
4649 type
= bp_fast_tracepoint
;
4651 p
= unpack_varlen_hex (p
, &orig_size
);
4655 type
= bp_static_tracepoint
;
4661 p
= unpack_varlen_hex (p
, &xlen
);
4662 p
++; /* skip a comma */
4663 cond
= (char *) xmalloc (2 * xlen
+ 1);
4664 strncpy (cond
, p
, 2 * xlen
);
4665 cond
[2 * xlen
] = '\0';
4669 warning (_("Unrecognized char '%c' in tracepoint "
4670 "definition, skipping rest"), *p
);
4672 utp
= get_uploaded_tp (num
, addr
, utpp
);
4674 utp
->enabled
= enabled
;
4679 else if (piece
== 'A')
4681 utp
= get_uploaded_tp (num
, addr
, utpp
);
4682 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4684 else if (piece
== 'S')
4686 utp
= get_uploaded_tp (num
, addr
, utpp
);
4687 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4689 else if (piece
== 'Z')
4691 /* Parse a chunk of source form definition. */
4692 utp
= get_uploaded_tp (num
, addr
, utpp
);
4694 p
= strchr (p
, ':');
4695 p
++; /* skip a colon */
4696 p
= unpack_varlen_hex (p
, &start
);
4697 p
++; /* skip a colon */
4698 p
= unpack_varlen_hex (p
, &xlen
);
4699 p
++; /* skip a colon */
4701 buf
= alloca (strlen (line
));
4703 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4706 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4707 utp
->at_string
= xstrdup (buf
);
4708 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4709 utp
->cond_string
= xstrdup (buf
);
4710 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4711 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4713 else if (piece
== 'V')
4715 utp
= get_uploaded_tp (num
, addr
, utpp
);
4717 parse_tracepoint_status (p
, NULL
, utp
);
4721 /* Don't error out, the target might be sending us optional
4722 info that we don't care about. */
4723 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4727 /* Convert a textual description of a trace state variable into an
4731 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4734 ULONGEST num
, initval
, builtin
;
4736 struct uploaded_tsv
*utsv
= NULL
;
4738 buf
= alloca (strlen (line
));
4741 p
= unpack_varlen_hex (p
, &num
);
4742 p
++; /* skip a colon */
4743 p
= unpack_varlen_hex (p
, &initval
);
4744 p
++; /* skip a colon */
4745 p
= unpack_varlen_hex (p
, &builtin
);
4746 p
++; /* skip a colon */
4747 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4750 utsv
= get_uploaded_tsv (num
, utsvp
);
4751 utsv
->initial_value
= initval
;
4752 utsv
->builtin
= builtin
;
4753 utsv
->name
= xstrdup (buf
);
4756 /* Close the trace file and generally clean up. */
4759 tfile_close (struct target_ops
*self
)
4766 pid
= ptid_get_pid (inferior_ptid
);
4767 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4768 exit_inferior_silent (pid
);
4772 xfree (trace_filename
);
4773 trace_filename
= NULL
;
4775 trace_reset_local_state ();
4779 tfile_files_info (struct target_ops
*t
)
4781 printf_filtered ("\t`%s'\n", trace_filename
);
4784 /* The trace status for a file is that tracing can never be run. */
4787 tfile_get_trace_status (struct trace_status
*ts
)
4789 /* Other bits of trace status were collected as part of opening the
4790 trace files, so nothing to do here. */
4796 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4798 /* Other bits of trace status were collected as part of opening the
4799 trace files, so nothing to do here. */
4802 /* Given the position of a traceframe in the file, figure out what
4803 address the frame was collected at. This would normally be the
4804 value of a collected PC register, but if not available, we
4808 tfile_get_traceframe_address (off_t tframe_offset
)
4812 struct tracepoint
*tp
;
4813 off_t saved_offset
= cur_offset
;
4815 /* FIXME dig pc out of collected registers. */
4817 /* Fall back to using tracepoint address. */
4818 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4819 tfile_read ((gdb_byte
*) &tpnum
, 2);
4820 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4822 (target_gdbarch ()));
4824 tp
= get_tracepoint_by_number_on_target (tpnum
);
4825 /* FIXME this is a poor heuristic if multiple locations. */
4826 if (tp
&& tp
->base
.loc
)
4827 addr
= tp
->base
.loc
->address
;
4829 /* Restore our seek position. */
4830 cur_offset
= saved_offset
;
4831 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4835 /* Given a type of search and some parameters, scan the collection of
4836 traceframes in the file looking for a match. When found, return
4837 both the traceframe and tracepoint number, otherwise -1 for
4841 tfile_trace_find (enum trace_find_type type
, int num
,
4842 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4845 int tfnum
= 0, found
= 0;
4846 unsigned int data_size
;
4847 struct tracepoint
*tp
;
4848 off_t offset
, tframe_offset
;
4858 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4859 offset
= trace_frames_offset
;
4862 tframe_offset
= offset
;
4863 tfile_read ((gdb_byte
*) &tpnum
, 2);
4864 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4866 (target_gdbarch ()));
4870 tfile_read ((gdb_byte
*) &data_size
, 4);
4871 data_size
= (unsigned int) extract_unsigned_integer
4872 ((gdb_byte
*) &data_size
, 4,
4873 gdbarch_byte_order (target_gdbarch ()));
4876 if (type
== tfind_number
)
4878 /* Looking for a specific trace frame. */
4884 /* Start from the _next_ trace frame. */
4885 if (tfnum
> traceframe_number
)
4890 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4891 if (tfaddr
== addr1
)
4895 tp
= get_tracepoint (num
);
4896 if (tp
&& tpnum
== tp
->number_on_target
)
4900 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4901 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4905 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4906 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4910 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4919 cur_offset
= offset
;
4920 cur_data_size
= data_size
;
4924 /* Skip past the traceframe's data. */
4925 lseek (trace_fd
, data_size
, SEEK_CUR
);
4926 offset
+= data_size
;
4927 /* Update our own count of traceframes. */
4930 /* Did not find what we were looking for. */
4936 /* Prototype of the callback passed to tframe_walk_blocks. */
4937 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4939 /* Callback for traceframe_walk_blocks, used to find a given block
4940 type in a traceframe. */
4943 match_blocktype (char blocktype
, void *data
)
4945 char *wantedp
= data
;
4947 if (*wantedp
== blocktype
)
4953 /* Walk over all traceframe block starting at POS offset from
4954 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4955 unmodified. If CALLBACK returns true, this returns the position in
4956 the traceframe where the block is found, relative to the start of
4957 the traceframe (cur_offset). Returns -1 if no callback call
4958 returned true, indicating that all blocks have been walked. */
4961 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4962 int pos
, void *data
)
4964 /* Iterate through a traceframe's blocks, looking for a block of the
4967 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4968 while (pos
< cur_data_size
)
4970 unsigned short mlen
;
4973 tfile_read ((gdb_byte
*) &block_type
, 1);
4977 if ((*callback
) (block_type
, data
))
4983 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4984 pos
+= trace_regblock_size
;
4987 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4988 tfile_read ((gdb_byte
*) &mlen
, 2);
4989 mlen
= (unsigned short)
4990 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4992 (target_gdbarch ()));
4993 lseek (trace_fd
, mlen
, SEEK_CUR
);
4994 pos
+= (8 + 2 + mlen
);
4997 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
5001 error (_("Unknown block type '%c' (0x%x) in trace frame"),
5002 block_type
, block_type
);
5010 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
5011 position offset of a block of type TYPE_WANTED in the current trace
5012 frame, starting at POS. Returns -1 if no such block was found. */
5015 traceframe_find_block_type (char type_wanted
, int pos
)
5017 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
5020 /* Look for a block of saved registers in the traceframe, and get the
5021 requested register from it. */
5024 tfile_fetch_registers (struct target_ops
*ops
,
5025 struct regcache
*regcache
, int regno
)
5027 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5028 int offset
, regn
, regsize
, pc_regno
;
5031 /* An uninitialized reg size says we're not going to be
5032 successful at getting register blocks. */
5033 if (!trace_regblock_size
)
5036 regs
= alloca (trace_regblock_size
);
5038 if (traceframe_find_block_type ('R', 0) >= 0)
5040 tfile_read (regs
, trace_regblock_size
);
5042 /* Assume the block is laid out in GDB register number order,
5043 each register with the size that it has in GDB. */
5045 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5047 regsize
= register_size (gdbarch
, regn
);
5048 /* Make sure we stay within block bounds. */
5049 if (offset
+ regsize
>= trace_regblock_size
)
5051 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
5055 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
5058 else if (regno
== -1)
5060 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
5068 /* We get here if no register data has been found. Mark registers
5070 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5071 regcache_raw_supply (regcache
, regn
, NULL
);
5073 /* We can often usefully guess that the PC is going to be the same
5074 as the address of the tracepoint. */
5075 pc_regno
= gdbarch_pc_regnum (gdbarch
);
5077 /* XXX This guessing code below only works if the PC register isn't
5078 a pseudo-register. The value of a pseudo-register isn't stored
5079 in the (non-readonly) regcache -- instead it's recomputed
5080 (probably from some other cached raw register) whenever the
5081 register is read. This guesswork should probably move to some
5083 if (pc_regno
< 0 || pc_regno
>= gdbarch_num_regs (gdbarch
))
5086 if (regno
== -1 || regno
== pc_regno
)
5088 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
5090 if (tp
&& tp
->base
.loc
)
5092 /* But don't try to guess if tracepoint is multi-location... */
5093 if (tp
->base
.loc
->next
)
5095 warning (_("Tracepoint %d has multiple "
5096 "locations, cannot infer $pc"),
5100 /* ... or does while-stepping. */
5101 if (tp
->step_count
> 0)
5103 warning (_("Tracepoint %d does while-stepping, "
5104 "cannot infer $pc"),
5109 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
5110 gdbarch_byte_order (gdbarch
),
5111 tp
->base
.loc
->address
);
5112 regcache_raw_supply (regcache
, pc_regno
, regs
);
5117 static enum target_xfer_status
5118 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5119 const char *annex
, gdb_byte
*readbuf
,
5120 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
5121 ULONGEST
*xfered_len
)
5123 /* We're only doing regular memory for now. */
5124 if (object
!= TARGET_OBJECT_MEMORY
)
5125 return TARGET_XFER_E_IO
;
5127 if (readbuf
== NULL
)
5128 error (_("tfile_xfer_partial: trace file is read-only"));
5130 if (traceframe_number
!= -1)
5134 /* Iterate through the traceframe's blocks, looking for
5136 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5138 ULONGEST maddr
, amt
;
5139 unsigned short mlen
;
5140 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5142 tfile_read ((gdb_byte
*) &maddr
, 8);
5143 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5145 tfile_read ((gdb_byte
*) &mlen
, 2);
5146 mlen
= (unsigned short)
5147 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5149 /* If the block includes the first part of the desired
5150 range, return as much it has; GDB will re-request the
5151 remainder, which might be in a different block of this
5153 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5155 amt
= (maddr
+ mlen
) - offset
;
5159 if (maddr
!= offset
)
5160 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5161 tfile_read (readbuf
, amt
);
5163 return TARGET_XFER_OK
;
5166 /* Skip over this block. */
5167 pos
+= (8 + 2 + mlen
);
5171 /* It's unduly pedantic to refuse to look at the executable for
5172 read-only pieces; so do the equivalent of readonly regions aka
5174 /* FIXME account for relocation at some point. */
5181 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5183 if ((s
->flags
& SEC_LOAD
) == 0
5184 || (s
->flags
& SEC_READONLY
) == 0)
5188 size
= bfd_get_section_size (s
);
5189 if (vma
<= offset
&& offset
< (vma
+ size
))
5193 amt
= (vma
+ size
) - offset
;
5197 *xfered_len
= bfd_get_section_contents (exec_bfd
, s
,
5198 readbuf
, offset
- vma
, amt
);
5199 return TARGET_XFER_OK
;
5204 /* Indicate failure to find the requested memory block. */
5205 return TARGET_XFER_E_IO
;
5208 /* Iterate through the blocks of a trace frame, looking for a 'V'
5209 block with a matching tsv number. */
5212 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5217 /* Iterate over blocks in current frame and find the last 'V'
5218 block in which tsv number is TSVNUM. In one trace frame, there
5219 may be multiple 'V' blocks created for a given trace variable,
5220 and the last matched 'V' block contains the updated value. */
5222 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5226 tfile_read ((gdb_byte
*) &vnum
, 4);
5227 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5229 (target_gdbarch ()));
5232 tfile_read ((gdb_byte
*) val
, 8);
5233 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5235 (target_gdbarch ()));
5245 tfile_has_all_memory (struct target_ops
*ops
)
5251 tfile_has_memory (struct target_ops
*ops
)
5257 tfile_has_stack (struct target_ops
*ops
)
5259 return traceframe_number
!= -1;
5263 tfile_has_registers (struct target_ops
*ops
)
5265 return traceframe_number
!= -1;
5269 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
5274 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5275 object for the tfile target's current traceframe. */
5278 build_traceframe_info (char blocktype
, void *data
)
5280 struct traceframe_info
*info
= data
;
5286 struct mem_range
*r
;
5288 unsigned short mlen
;
5290 tfile_read ((gdb_byte
*) &maddr
, 8);
5291 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5293 (target_gdbarch ()));
5294 tfile_read ((gdb_byte
*) &mlen
, 2);
5295 mlen
= (unsigned short)
5296 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5297 2, gdbarch_byte_order
5298 (target_gdbarch ()));
5300 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5310 tfile_read ((gdb_byte
*) &vnum
, 4);
5311 VEC_safe_push (int, info
->tvars
, vnum
);
5319 warning (_("Unhandled trace block type (%d) '%c ' "
5320 "while building trace frame info."),
5321 blocktype
, blocktype
);
5328 static struct traceframe_info
*
5329 tfile_traceframe_info (void)
5331 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5333 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5338 init_tfile_ops (void)
5340 tfile_ops
.to_shortname
= "tfile";
5341 tfile_ops
.to_longname
= "Local trace dump file";
5343 = "Use a trace file as a target. Specify the filename of the trace file.";
5344 tfile_ops
.to_open
= tfile_open
;
5345 tfile_ops
.to_close
= tfile_close
;
5346 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5347 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5348 tfile_ops
.to_files_info
= tfile_files_info
;
5349 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5350 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5351 tfile_ops
.to_trace_find
= tfile_trace_find
;
5352 tfile_ops
.to_get_trace_state_variable_value
5353 = tfile_get_trace_state_variable_value
;
5354 tfile_ops
.to_stratum
= process_stratum
;
5355 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5356 tfile_ops
.to_has_memory
= tfile_has_memory
;
5357 tfile_ops
.to_has_stack
= tfile_has_stack
;
5358 tfile_ops
.to_has_registers
= tfile_has_registers
;
5359 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5360 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
5361 tfile_ops
.to_magic
= OPS_MAGIC
;
5365 free_current_marker (void *arg
)
5367 struct static_tracepoint_marker
**marker_p
= arg
;
5369 if (*marker_p
!= NULL
)
5371 release_static_tracepoint_marker (*marker_p
);
5378 /* Given a line of text defining a static tracepoint marker, parse it
5379 into a "static tracepoint marker" object. Throws an error is
5380 parsing fails. If PP is non-null, it points to one past the end of
5381 the parsed marker definition. */
5384 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5385 struct static_tracepoint_marker
*marker
)
5392 p
= unpack_varlen_hex (p
, &addr
);
5393 p
++; /* skip a colon */
5395 marker
->gdbarch
= target_gdbarch ();
5396 marker
->address
= (CORE_ADDR
) addr
;
5398 endp
= strchr (p
, ':');
5400 error (_("bad marker definition: %s"), line
);
5402 marker
->str_id
= xmalloc (endp
- p
+ 1);
5403 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5404 marker
->str_id
[end
] = '\0';
5407 p
++; /* skip a colon */
5409 marker
->extra
= xmalloc (strlen (p
) + 1);
5410 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5411 marker
->extra
[end
] = '\0';
5417 /* Release a static tracepoint marker's contents. Note that the
5418 object itself isn't released here. There objects are usually on
5422 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5424 xfree (marker
->str_id
);
5425 marker
->str_id
= NULL
;
5428 /* Print MARKER to gdb_stdout. */
5431 print_one_static_tracepoint_marker (int count
,
5432 struct static_tracepoint_marker
*marker
)
5434 struct command_line
*l
;
5437 char wrap_indent
[80];
5438 char extra_field_indent
[80];
5439 struct ui_out
*uiout
= current_uiout
;
5440 struct cleanup
*bkpt_chain
;
5441 VEC(breakpoint_p
) *tracepoints
;
5443 struct symtab_and_line sal
;
5447 sal
.pc
= marker
->address
;
5449 tracepoints
= static_tracepoints_here (marker
->address
);
5451 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5453 /* A counter field to help readability. This is not a stable
5455 ui_out_field_int (uiout
, "count", count
);
5457 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5459 ui_out_field_fmt (uiout
, "enabled", "%c",
5460 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5461 ui_out_spaces (uiout
, 2);
5463 strcpy (wrap_indent
, " ");
5465 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5466 strcat (wrap_indent
, " ");
5468 strcat (wrap_indent
, " ");
5470 strcpy (extra_field_indent
, " ");
5472 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5474 sal
= find_pc_line (marker
->address
, 0);
5475 sym
= find_pc_sect_function (marker
->address
, NULL
);
5478 ui_out_text (uiout
, "in ");
5479 ui_out_field_string (uiout
, "func",
5480 SYMBOL_PRINT_NAME (sym
));
5481 ui_out_wrap_hint (uiout
, wrap_indent
);
5482 ui_out_text (uiout
, " at ");
5485 ui_out_field_skip (uiout
, "func");
5487 if (sal
.symtab
!= NULL
)
5489 ui_out_field_string (uiout
, "file",
5490 symtab_to_filename_for_display (sal
.symtab
));
5491 ui_out_text (uiout
, ":");
5493 if (ui_out_is_mi_like_p (uiout
))
5495 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5497 ui_out_field_string (uiout
, "fullname", fullname
);
5500 ui_out_field_skip (uiout
, "fullname");
5502 ui_out_field_int (uiout
, "line", sal
.line
);
5506 ui_out_field_skip (uiout
, "fullname");
5507 ui_out_field_skip (uiout
, "line");
5510 ui_out_text (uiout
, "\n");
5511 ui_out_text (uiout
, extra_field_indent
);
5512 ui_out_text (uiout
, _("Data: \""));
5513 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5514 ui_out_text (uiout
, "\"\n");
5516 if (!VEC_empty (breakpoint_p
, tracepoints
))
5518 struct cleanup
*cleanup_chain
;
5520 struct breakpoint
*b
;
5522 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5525 ui_out_text (uiout
, extra_field_indent
);
5526 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5527 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5530 ui_out_text (uiout
, ", ");
5531 ui_out_text (uiout
, "#");
5532 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5535 do_cleanups (cleanup_chain
);
5537 if (ui_out_is_mi_like_p (uiout
))
5538 ui_out_field_int (uiout
, "number-of-tracepoints",
5539 VEC_length(breakpoint_p
, tracepoints
));
5541 ui_out_text (uiout
, "\n");
5543 VEC_free (breakpoint_p
, tracepoints
);
5545 do_cleanups (bkpt_chain
);
5549 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5551 VEC(static_tracepoint_marker_p
) *markers
;
5552 struct cleanup
*old_chain
;
5553 struct static_tracepoint_marker
*marker
;
5554 struct ui_out
*uiout
= current_uiout
;
5557 /* We don't have to check target_can_use_agent and agent's capability on
5558 static tracepoint here, in order to be compatible with older GDBserver.
5559 We don't check USE_AGENT is true or not, because static tracepoints
5560 don't work without in-process agent, so we don't bother users to type
5561 `set agent on' when to use static tracepoint. */
5564 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5565 "StaticTracepointMarkersTable");
5567 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5569 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5571 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5572 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5573 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5575 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5576 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5578 ui_out_table_body (uiout
);
5580 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5581 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5584 VEC_iterate (static_tracepoint_marker_p
,
5585 markers
, i
, marker
);
5588 print_one_static_tracepoint_marker (i
+ 1, marker
);
5589 release_static_tracepoint_marker (marker
);
5592 do_cleanups (old_chain
);
5595 /* The $_sdata convenience variable is a bit special. We don't know
5596 for sure type of the value until we actually have a chance to fetch
5597 the data --- the size of the object depends on what has been
5598 collected. We solve this by making $_sdata be an internalvar that
5599 creates a new value on access. */
5601 /* Return a new value with the correct type for the sdata object of
5602 the current trace frame. Return a void value if there's no object
5605 static struct value
*
5606 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5612 /* We need to read the whole object before we know its size. */
5613 size
= target_read_alloc (¤t_target
,
5614 TARGET_OBJECT_STATIC_TRACE_DATA
,
5621 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5623 v
= allocate_value (type
);
5624 memcpy (value_contents_raw (v
), buf
, size
);
5629 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5632 #if !defined(HAVE_LIBEXPAT)
5634 struct traceframe_info
*
5635 parse_traceframe_info (const char *tframe_info
)
5637 static int have_warned
;
5642 warning (_("Can not parse XML trace frame info; XML support "
5643 "was disabled at compile time"));
5649 #else /* HAVE_LIBEXPAT */
5651 #include "xml-support.h"
5653 /* Handle the start of a <memory> element. */
5656 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5657 const struct gdb_xml_element
*element
,
5658 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5660 struct traceframe_info
*info
= user_data
;
5661 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5662 ULONGEST
*start_p
, *length_p
;
5664 start_p
= xml_find_attribute (attributes
, "start")->value
;
5665 length_p
= xml_find_attribute (attributes
, "length")->value
;
5667 r
->start
= *start_p
;
5668 r
->length
= *length_p
;
5671 /* Handle the start of a <tvar> element. */
5674 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
5675 const struct gdb_xml_element
*element
,
5677 VEC(gdb_xml_value_s
) *attributes
)
5679 struct traceframe_info
*info
= user_data
;
5680 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
5681 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
5683 VEC_safe_push (int, info
->tvars
, id
);
5686 /* Discard the constructed trace frame info (if an error occurs). */
5689 free_result (void *p
)
5691 struct traceframe_info
*result
= p
;
5693 free_traceframe_info (result
);
5696 /* The allowed elements and attributes for an XML memory map. */
5698 static const struct gdb_xml_attribute memory_attributes
[] = {
5699 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5700 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5701 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5704 static const struct gdb_xml_attribute tvar_attributes
[] = {
5705 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
5706 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5709 static const struct gdb_xml_element traceframe_info_children
[] = {
5710 { "memory", memory_attributes
, NULL
,
5711 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5712 traceframe_info_start_memory
, NULL
},
5713 { "tvar", tvar_attributes
, NULL
,
5714 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5715 traceframe_info_start_tvar
, NULL
},
5716 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5719 static const struct gdb_xml_element traceframe_info_elements
[] = {
5720 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5722 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5725 /* Parse a traceframe-info XML document. */
5727 struct traceframe_info
*
5728 parse_traceframe_info (const char *tframe_info
)
5730 struct traceframe_info
*result
;
5731 struct cleanup
*back_to
;
5733 result
= XCNEW (struct traceframe_info
);
5734 back_to
= make_cleanup (free_result
, result
);
5736 if (gdb_xml_parse_quick (_("trace frame info"),
5737 "traceframe-info.dtd", traceframe_info_elements
,
5738 tframe_info
, result
) == 0)
5740 /* Parsed successfully, keep the result. */
5741 discard_cleanups (back_to
);
5746 do_cleanups (back_to
);
5750 #endif /* HAVE_LIBEXPAT */
5752 /* Returns the traceframe_info object for the current traceframe.
5753 This is where we avoid re-fetching the object from the target if we
5754 already have it cached. */
5756 struct traceframe_info
*
5757 get_traceframe_info (void)
5759 if (traceframe_info
== NULL
)
5760 traceframe_info
= target_traceframe_info ();
5762 return traceframe_info
;
5765 /* If the target supports the query, return in RESULT the set of
5766 collected memory in the current traceframe, found within the LEN
5767 bytes range starting at MEMADDR. Returns true if the target
5768 supports the query, otherwise returns false, and RESULT is left
5772 traceframe_available_memory (VEC(mem_range_s
) **result
,
5773 CORE_ADDR memaddr
, ULONGEST len
)
5775 struct traceframe_info
*info
= get_traceframe_info ();
5779 struct mem_range
*r
;
5784 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5785 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5787 ULONGEST lo1
, hi1
, lo2
, hi2
;
5788 struct mem_range
*nr
;
5791 hi1
= memaddr
+ len
;
5794 hi2
= r
->start
+ r
->length
;
5796 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5798 nr
->start
= max (lo1
, lo2
);
5799 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5802 normalize_mem_ranges (*result
);
5809 /* Implementation of `sdata' variable. */
5811 static const struct internalvar_funcs sdata_funcs
=
5818 /* module initialization */
5820 _initialize_tracepoint (void)
5822 struct cmd_list_element
*c
;
5824 /* Explicitly create without lookup, since that tries to create a
5825 value with a void typed value, and when we get here, gdbarch
5826 isn't initialized yet. At this point, we're quite sure there
5827 isn't another convenience variable of the same name. */
5828 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5830 traceframe_number
= -1;
5831 tracepoint_number
= -1;
5833 add_info ("scope", scope_info
,
5834 _("List the variables local to a scope"));
5836 add_cmd ("tracepoints", class_trace
, NULL
,
5837 _("Tracing of program execution without stopping the program."),
5840 add_com ("tdump", class_trace
, trace_dump_command
,
5841 _("Print everything collected at the current tracepoint."));
5843 add_com ("tsave", class_trace
, trace_save_command
, _("\
5844 Save the trace data to a file.\n\
5845 Use the '-ctf' option to save the data to CTF format.\n\
5846 Use the '-r' option to direct the target to save directly to the file,\n\
5847 using its own filesystem."));
5849 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5850 Define a trace state variable.\n\
5851 Argument is a $-prefixed name, optionally followed\n\
5852 by '=' and an expression that sets the initial value\n\
5853 at the start of tracing."));
5854 set_cmd_completer (c
, expression_completer
);
5856 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5857 Delete one or more trace state variables.\n\
5858 Arguments are the names of the variables to delete.\n\
5859 If no arguments are supplied, delete all variables."), &deletelist
);
5860 /* FIXME add a trace variable completer. */
5862 add_info ("tvariables", tvariables_info
, _("\
5863 Status of trace state variables and their values.\n\
5866 add_info ("static-tracepoint-markers",
5867 info_static_tracepoint_markers_command
, _("\
5868 List target static tracepoints markers.\n\
5871 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5872 Select a trace frame;\n\
5873 No argument means forward by one frame; '-' means backward by one frame."),
5874 &tfindlist
, "tfind ", 1, &cmdlist
);
5876 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5877 Select a trace frame whose PC is outside the given range (exclusive).\n\
5878 Usage: tfind outside addr1, addr2"),
5881 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5882 Select a trace frame whose PC is in the given range (inclusive).\n\
5883 Usage: tfind range addr1,addr2"),
5886 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5887 Select a trace frame by source line.\n\
5888 Argument can be a line number (with optional source file),\n\
5889 a function name, or '*' followed by an address.\n\
5890 Default argument is 'the next source line that was traced'."),
5893 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5894 Select a trace frame by tracepoint number.\n\
5895 Default is the tracepoint for the current trace frame."),
5898 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5899 Select a trace frame by PC.\n\
5900 Default is the current PC, or the PC of the current trace frame."),
5903 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5904 De-select any trace frame and resume 'live' debugging."),
5907 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5909 add_cmd ("start", class_trace
, trace_find_start_command
,
5910 _("Select the first trace frame in the trace buffer."),
5913 add_com ("tstatus", class_trace
, trace_status_command
,
5914 _("Display the status of the current trace data collection."));
5916 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5917 Stop trace data collection.\n\
5918 Usage: tstop [ <notes> ... ]\n\
5919 Any arguments supplied are recorded with the trace as a stop reason and\n\
5920 reported by tstatus (if the target supports trace notes)."));
5922 add_com ("tstart", class_trace
, trace_start_command
, _("\
5923 Start trace data collection.\n\
5924 Usage: tstart [ <notes> ... ]\n\
5925 Any arguments supplied are recorded with the trace as a note and\n\
5926 reported by tstatus (if the target supports trace notes)."));
5928 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5929 Ends a list of commands or actions.\n\
5930 Several GDB commands allow you to enter a list of commands or actions.\n\
5931 Entering \"end\" on a line by itself is the normal way to terminate\n\
5933 Note: the \"end\" command cannot be used at the gdb prompt."));
5935 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5936 Specify single-stepping behavior at a tracepoint.\n\
5937 Argument is number of instructions to trace in single-step mode\n\
5938 following the tracepoint. This command is normally followed by\n\
5939 one or more \"collect\" commands, to specify what to collect\n\
5940 while single-stepping.\n\n\
5941 Note: this command can only be used in a tracepoint \"actions\" list."));
5943 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5944 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5946 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5947 Specify one or more data items to be collected at a tracepoint.\n\
5948 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5949 collect all data (variables, registers) referenced by that expression.\n\
5950 Also accepts the following special arguments:\n\
5951 $regs -- all registers.\n\
5952 $args -- all function arguments.\n\
5953 $locals -- all variables local to the block/function scope.\n\
5954 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5955 Note: this command can only be used in a tracepoint \"actions\" list."));
5957 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5958 Specify one or more expressions to be evaluated at a tracepoint.\n\
5959 Accepts a comma-separated list of (one or more) expressions.\n\
5960 The result of each evaluation will be discarded.\n\
5961 Note: this command can only be used in a tracepoint \"actions\" list."));
5963 add_com ("actions", class_trace
, trace_actions_command
, _("\
5964 Specify the actions to be taken at a tracepoint.\n\
5965 Tracepoint actions may include collecting of specified data,\n\
5966 single-stepping, or enabling/disabling other tracepoints,\n\
5967 depending on target's capabilities."));
5969 default_collect
= xstrdup ("");
5970 add_setshow_string_cmd ("default-collect", class_trace
,
5971 &default_collect
, _("\
5972 Set the list of expressions to collect by default"), _("\
5973 Show the list of expressions to collect by default"), NULL
,
5975 &setlist
, &showlist
);
5977 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5978 &disconnected_tracing
, _("\
5979 Set whether tracing continues after GDB disconnects."), _("\
5980 Show whether tracing continues after GDB disconnects."), _("\
5981 Use this to continue a tracing run even if GDB disconnects\n\
5982 or detaches from the target. You can reconnect later and look at\n\
5983 trace data collected in the meantime."),
5984 set_disconnected_tracing
,
5989 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5990 &circular_trace_buffer
, _("\
5991 Set target's use of circular trace buffer."), _("\
5992 Show target's use of circular trace buffer."), _("\
5993 Use this to make the trace buffer into a circular buffer,\n\
5994 which will discard traceframes (oldest first) instead of filling\n\
5995 up and stopping the trace run."),
5996 set_circular_trace_buffer
,
6001 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
6002 &trace_buffer_size
, _("\
6003 Set requested size of trace buffer."), _("\
6004 Show requested size of trace buffer."), _("\
6005 Use this to choose a size for the trace buffer. Some targets\n\
6006 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
6007 disables any attempt to set the buffer size and lets the target choose."),
6008 set_trace_buffer_size
, NULL
,
6009 &setlist
, &showlist
);
6011 add_setshow_string_cmd ("trace-user", class_trace
,
6013 Set the user name to use for current and future trace runs"), _("\
6014 Show the user name to use for current and future trace runs"), NULL
,
6015 set_trace_user
, NULL
,
6016 &setlist
, &showlist
);
6018 add_setshow_string_cmd ("trace-notes", class_trace
,
6020 Set notes string to use for current and future trace runs"), _("\
6021 Show the notes string to use for current and future trace runs"), NULL
,
6022 set_trace_notes
, NULL
,
6023 &setlist
, &showlist
);
6025 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
6026 &trace_stop_notes
, _("\
6027 Set notes string to use for future tstop commands"), _("\
6028 Show the notes string to use for future tstop commands"), NULL
,
6029 set_trace_stop_notes
, NULL
,
6030 &setlist
, &showlist
);
6034 add_target_with_completer (&tfile_ops
, filename_completer
);