1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
83 /* A hook used to notify the UI of tracepoint operations. */
85 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
86 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
91 This module defines the following debugger commands:
92 trace : set a tracepoint on a function, line, or address.
93 info trace : list all debugger-defined tracepoints.
94 delete trace : delete one or more tracepoints.
95 enable trace : enable one or more tracepoints.
96 disable trace : disable one or more tracepoints.
97 actions : specify actions to be taken at a tracepoint.
98 passcount : specify a pass count for a tracepoint.
99 tstart : start a trace experiment.
100 tstop : stop a trace experiment.
101 tstatus : query the status of a trace experiment.
102 tfind : find a trace frame in the trace buffer.
103 tdump : print everything collected at the current tracepoint.
104 save-tracepoints : write tracepoint setup into a file.
106 This module defines the following user-visible debugger variables:
107 $trace_frame : sequence number of trace frame currently being debugged.
108 $trace_line : source line of trace frame currently being debugged.
109 $trace_file : source file of trace frame currently being debugged.
110 $tracepoint : tracepoint number of trace frame currently being debugged.
114 /* ======= Important global variables: ======= */
116 /* The list of all trace state variables. We don't retain pointers to
117 any of these for any reason - API is by name or number only - so it
118 works to have a vector of objects. */
120 typedef struct trace_state_variable tsv_s
;
123 static VEC(tsv_s
) *tvariables
;
125 /* The next integer to assign to a variable. */
127 static int next_tsv_number
= 1;
129 /* Number of last traceframe collected. */
130 static int traceframe_number
;
132 /* Tracepoint for last traceframe collected. */
133 static int tracepoint_number
;
135 /* The traceframe info of the current traceframe. NULL if we haven't
136 yet attempted to fetch it, or if the target does not support
137 fetching this object, or if we're not inspecting a traceframe
139 static struct traceframe_info
*traceframe_info
;
141 /* Tracing command lists. */
142 static struct cmd_list_element
*tfindlist
;
144 /* List of expressions to collect by default at each tracepoint hit. */
145 char *default_collect
= "";
147 static int disconnected_tracing
;
149 /* This variable controls whether we ask the target for a linear or
150 circular trace buffer. */
152 static int circular_trace_buffer
;
154 /* This variable is the requested trace buffer size, or -1 to indicate
155 that we don't care and leave it up to the target to set a size. */
157 static int trace_buffer_size
= -1;
159 /* Textual notes applying to the current and/or future trace runs. */
161 char *trace_user
= NULL
;
163 /* Textual notes applying to the current and/or future trace runs. */
165 char *trace_notes
= NULL
;
167 /* Textual notes applying to the stopping of a trace. */
169 char *trace_stop_notes
= NULL
;
171 /* ======= Important command functions: ======= */
172 static void trace_actions_command (char *, int);
173 static void trace_start_command (char *, int);
174 static void trace_stop_command (char *, int);
175 static void trace_status_command (char *, int);
176 static void trace_find_command (char *, int);
177 static void trace_find_pc_command (char *, int);
178 static void trace_find_tracepoint_command (char *, int);
179 static void trace_find_line_command (char *, int);
180 static void trace_find_range_command (char *, int);
181 static void trace_find_outside_command (char *, int);
182 static void trace_dump_command (char *, int);
184 /* support routines */
186 struct collection_list
;
187 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
188 static char *mem2hex (gdb_byte
*, char *, int);
189 static void add_register (struct collection_list
*collection
,
192 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
193 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
195 static struct command_line
*
196 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
198 extern void _initialize_tracepoint (void);
200 static struct trace_status trace_status
;
202 char *stop_reason_names
[] = {
212 struct trace_status
*
213 current_trace_status (void)
215 return &trace_status
;
221 free_traceframe_info (struct traceframe_info
*info
)
225 VEC_free (mem_range_s
, info
->memory
);
226 VEC_free (int, info
->tvars
);
232 /* Free and clear the traceframe info cache of the current
236 clear_traceframe_info (void)
238 free_traceframe_info (traceframe_info
);
239 traceframe_info
= NULL
;
242 /* Set traceframe number to NUM. */
244 set_traceframe_num (int num
)
246 traceframe_number
= num
;
247 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
250 /* Set tracepoint number to NUM. */
252 set_tracepoint_num (int num
)
254 tracepoint_number
= num
;
255 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
258 /* Set externally visible debug variables for querying/printing
259 the traceframe context (line, function, file). */
262 set_traceframe_context (struct frame_info
*trace_frame
)
265 struct symbol
*traceframe_fun
;
266 struct symtab_and_line traceframe_sal
;
268 /* Save as globals for internal use. */
269 if (trace_frame
!= NULL
270 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
272 traceframe_sal
= find_pc_line (trace_pc
, 0);
273 traceframe_fun
= find_pc_function (trace_pc
);
275 /* Save linenumber as "$trace_line", a debugger variable visible to
277 set_internalvar_integer (lookup_internalvar ("trace_line"),
278 traceframe_sal
.line
);
282 init_sal (&traceframe_sal
);
283 traceframe_fun
= NULL
;
284 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
287 /* Save func name as "$trace_func", a debugger variable visible to
289 if (traceframe_fun
== NULL
290 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
291 clear_internalvar (lookup_internalvar ("trace_func"));
293 set_internalvar_string (lookup_internalvar ("trace_func"),
294 SYMBOL_LINKAGE_NAME (traceframe_fun
));
296 /* Save file name as "$trace_file", a debugger variable visible to
298 if (traceframe_sal
.symtab
== NULL
)
299 clear_internalvar (lookup_internalvar ("trace_file"));
301 set_internalvar_string (lookup_internalvar ("trace_file"),
302 symtab_to_filename_for_display (traceframe_sal
.symtab
));
305 /* Create a new trace state variable with the given name. */
307 struct trace_state_variable
*
308 create_trace_state_variable (const char *name
)
310 struct trace_state_variable tsv
;
312 memset (&tsv
, 0, sizeof (tsv
));
313 tsv
.name
= xstrdup (name
);
314 tsv
.number
= next_tsv_number
++;
315 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
318 /* Look for a trace state variable of the given name. */
320 struct trace_state_variable
*
321 find_trace_state_variable (const char *name
)
323 struct trace_state_variable
*tsv
;
326 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
327 if (strcmp (name
, tsv
->name
) == 0)
333 /* Look for a trace state variable of the given number. Return NULL if
336 struct trace_state_variable
*
337 find_trace_state_variable_by_number (int number
)
339 struct trace_state_variable
*tsv
;
342 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
343 if (tsv
->number
== number
)
350 delete_trace_state_variable (const char *name
)
352 struct trace_state_variable
*tsv
;
355 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
356 if (strcmp (name
, tsv
->name
) == 0)
358 observer_notify_tsv_deleted (tsv
);
360 xfree ((void *)tsv
->name
);
361 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
366 warning (_("No trace variable named \"$%s\", not deleting"), name
);
369 /* Throws an error if NAME is not valid syntax for a trace state
373 validate_trace_state_variable_name (const char *name
)
378 error (_("Must supply a non-empty variable name"));
380 /* All digits in the name is reserved for value history
382 for (p
= name
; isdigit (*p
); p
++)
385 error (_("$%s is not a valid trace state variable name"), name
);
387 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
390 error (_("$%s is not a valid trace state variable name"), name
);
393 /* The 'tvariable' command collects a name and optional expression to
394 evaluate into an initial value. */
397 trace_variable_command (char *args
, int from_tty
)
399 struct cleanup
*old_chain
;
401 struct trace_state_variable
*tsv
;
405 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
407 /* Only allow two syntaxes; "$name" and "$name=value". */
408 p
= skip_spaces (args
);
411 error (_("Name of trace variable should start with '$'"));
414 while (isalnum (*p
) || *p
== '_')
416 name
= savestring (name
, p
- name
);
417 old_chain
= make_cleanup (xfree
, name
);
420 if (*p
!= '=' && *p
!= '\0')
421 error (_("Syntax must be $NAME [ = EXPR ]"));
423 validate_trace_state_variable_name (name
);
426 initval
= value_as_long (parse_and_eval (++p
));
428 /* If the variable already exists, just change its initial value. */
429 tsv
= find_trace_state_variable (name
);
432 if (tsv
->initial_value
!= initval
)
434 tsv
->initial_value
= initval
;
435 observer_notify_tsv_modified (tsv
);
437 printf_filtered (_("Trace state variable $%s "
438 "now has initial value %s.\n"),
439 tsv
->name
, plongest (tsv
->initial_value
));
440 do_cleanups (old_chain
);
444 /* Create a new variable. */
445 tsv
= create_trace_state_variable (name
);
446 tsv
->initial_value
= initval
;
448 observer_notify_tsv_created (tsv
);
450 printf_filtered (_("Trace state variable $%s "
451 "created, with initial value %s.\n"),
452 tsv
->name
, plongest (tsv
->initial_value
));
454 do_cleanups (old_chain
);
458 delete_trace_variable_command (char *args
, int from_tty
)
462 struct cleanup
*back_to
;
466 if (query (_("Delete all trace state variables? ")))
467 VEC_free (tsv_s
, tvariables
);
469 observer_notify_tsv_deleted (NULL
);
473 argv
= gdb_buildargv (args
);
474 back_to
= make_cleanup_freeargv (argv
);
476 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
478 if (*argv
[ix
] == '$')
479 delete_trace_state_variable (argv
[ix
] + 1);
481 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
484 do_cleanups (back_to
);
490 tvariables_info_1 (void)
492 struct trace_state_variable
*tsv
;
495 struct cleanup
*back_to
;
496 struct ui_out
*uiout
= current_uiout
;
498 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
500 printf_filtered (_("No trace state variables.\n"));
504 /* Try to acquire values from the target. */
505 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
506 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
509 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
510 count
, "trace-variables");
511 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
512 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
513 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
515 ui_out_table_body (uiout
);
517 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
519 struct cleanup
*back_to2
;
523 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
525 name
= concat ("$", tsv
->name
, (char *) NULL
);
526 make_cleanup (xfree
, name
);
527 ui_out_field_string (uiout
, "name", name
);
528 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
530 if (tsv
->value_known
)
531 c
= plongest (tsv
->value
);
532 else if (ui_out_is_mi_like_p (uiout
))
533 /* For MI, we prefer not to use magic string constants, but rather
534 omit the field completely. The difference between unknown and
535 undefined does not seem important enough to represent. */
537 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
538 /* The value is/was defined, but we don't have it. */
541 /* It is not meaningful to ask about the value. */
544 ui_out_field_string (uiout
, "current", c
);
545 ui_out_text (uiout
, "\n");
547 do_cleanups (back_to2
);
550 do_cleanups (back_to
);
553 /* List all the trace state variables. */
556 tvariables_info (char *args
, int from_tty
)
558 tvariables_info_1 ();
561 /* Stash definitions of tsvs into the given file. */
564 save_trace_state_variables (struct ui_file
*fp
)
566 struct trace_state_variable
*tsv
;
569 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
571 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
572 if (tsv
->initial_value
)
573 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
574 fprintf_unfiltered (fp
, "\n");
578 /* ACTIONS functions: */
580 /* The three functions:
581 collect_pseudocommand,
582 while_stepping_pseudocommand, and
583 end_actions_pseudocommand
584 are placeholders for "commands" that are actually ONLY to be used
585 within a tracepoint action list. If the actual function is ever called,
586 it means that somebody issued the "command" at the top level,
587 which is always an error. */
590 end_actions_pseudocommand (char *args
, int from_tty
)
592 error (_("This command cannot be used at the top level."));
596 while_stepping_pseudocommand (char *args
, int from_tty
)
598 error (_("This command can only be used in a tracepoint actions list."));
602 collect_pseudocommand (char *args
, int from_tty
)
604 error (_("This command can only be used in a tracepoint actions list."));
608 teval_pseudocommand (char *args
, int from_tty
)
610 error (_("This command can only be used in a tracepoint actions list."));
613 /* Parse any collection options, such as /s for strings. */
616 decode_agent_options (const char *exp
, int *trace_string
)
618 struct value_print_options opts
;
625 /* Call this to borrow the print elements default for collection
627 get_user_print_options (&opts
);
632 if (target_supports_string_tracing ())
634 /* Allow an optional decimal number giving an explicit maximum
635 string length, defaulting it to the "print elements" value;
636 so "collect/s80 mystr" gets at most 80 bytes of string. */
637 *trace_string
= opts
.print_max
;
639 if (*exp
>= '0' && *exp
<= '9')
640 *trace_string
= atoi (exp
);
641 while (*exp
>= '0' && *exp
<= '9')
645 error (_("Target does not support \"/s\" option for string tracing."));
648 error (_("Undefined collection format \"%c\"."), *exp
);
650 exp
= skip_spaces_const (exp
);
655 /* Enter a list of actions for a tracepoint. */
657 trace_actions_command (char *args
, int from_tty
)
659 struct tracepoint
*t
;
660 struct command_line
*l
;
662 t
= get_tracepoint_by_number (&args
, NULL
, 1);
666 xstrprintf ("Enter actions for tracepoint %d, one per line.",
668 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
670 l
= read_command_lines (tmpbuf
, from_tty
, 1,
671 check_tracepoint_command
, t
);
672 do_cleanups (cleanups
);
673 breakpoint_set_commands (&t
->base
, l
);
675 /* else just return */
678 /* Report the results of checking the agent expression, as errors or
682 report_agent_reqs_errors (struct agent_expr
*aexpr
)
684 /* All of the "flaws" are serious bytecode generation issues that
685 should never occur. */
686 if (aexpr
->flaw
!= agent_flaw_none
)
687 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
689 /* If analysis shows a stack underflow, GDB must have done something
690 badly wrong in its bytecode generation. */
691 if (aexpr
->min_height
< 0)
692 internal_error (__FILE__
, __LINE__
,
693 _("expression has min height < 0"));
695 /* Issue this error if the stack is predicted to get too deep. The
696 limit is rather arbitrary; a better scheme might be for the
697 target to report how much stack it will have available. The
698 depth roughly corresponds to parenthesization, so a limit of 20
699 amounts to 20 levels of expression nesting, which is actually
700 a pretty big hairy expression. */
701 if (aexpr
->max_height
> 20)
702 error (_("Expression is too complicated."));
705 /* worker function */
707 validate_actionline (const char *line
, struct breakpoint
*b
)
709 struct cmd_list_element
*c
;
710 struct expression
*exp
= NULL
;
711 struct cleanup
*old_chain
= NULL
;
714 struct bp_location
*loc
;
715 struct agent_expr
*aexpr
;
716 struct tracepoint
*t
= (struct tracepoint
*) b
;
718 /* If EOF is typed, *line is NULL. */
722 p
= skip_spaces_const (line
);
724 /* Symbol lookup etc. */
725 if (*p
== '\0') /* empty line: just prompt for another line. */
728 if (*p
== '#') /* comment line */
731 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
733 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
735 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
737 int trace_string
= 0;
740 p
= decode_agent_options (p
, &trace_string
);
743 { /* Repeat over a comma-separated list. */
744 QUIT
; /* Allow user to bail out with ^C. */
745 p
= skip_spaces_const (p
);
747 if (*p
== '$') /* Look for special pseudo-symbols. */
749 if (0 == strncasecmp ("reg", p
+ 1, 3)
750 || 0 == strncasecmp ("arg", p
+ 1, 3)
751 || 0 == strncasecmp ("loc", p
+ 1, 3)
752 || 0 == strncasecmp ("_ret", p
+ 1, 4)
753 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
758 /* else fall thru, treat p as an expression and parse it! */
761 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
764 exp
= parse_exp_1 (&p
, loc
->address
,
765 block_for_pc (loc
->address
), 1);
766 old_chain
= make_cleanup (free_current_contents
, &exp
);
768 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
770 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
772 error (_("constant `%s' (value %s) "
773 "will not be collected."),
774 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
775 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
777 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
778 == LOC_OPTIMIZED_OUT
)
780 error (_("`%s' is optimized away "
781 "and cannot be collected."),
782 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
786 /* We have something to collect, make sure that the expr to
787 bytecode translator can handle it and that it's not too
789 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
790 make_cleanup_free_agent_expr (aexpr
);
792 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
793 error (_("Expression is too complicated."));
797 report_agent_reqs_errors (aexpr
);
799 do_cleanups (old_chain
);
802 while (p
&& *p
++ == ',');
805 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
808 { /* Repeat over a comma-separated list. */
809 QUIT
; /* Allow user to bail out with ^C. */
810 p
= skip_spaces_const (p
);
813 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
817 /* Only expressions are allowed for this action. */
818 exp
= parse_exp_1 (&p
, loc
->address
,
819 block_for_pc (loc
->address
), 1);
820 old_chain
= make_cleanup (free_current_contents
, &exp
);
822 /* We have something to evaluate, make sure that the expr to
823 bytecode translator can handle it and that it's not too
825 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
826 make_cleanup_free_agent_expr (aexpr
);
828 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
829 error (_("Expression is too complicated."));
832 report_agent_reqs_errors (aexpr
);
834 do_cleanups (old_chain
);
837 while (p
&& *p
++ == ',');
840 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
844 p
= skip_spaces_const (p
);
845 t
->step_count
= strtol (p
, &endp
, 0);
846 if (endp
== p
|| t
->step_count
== 0)
847 error (_("while-stepping step count `%s' is malformed."), line
);
851 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
855 error (_("`%s' is not a supported tracepoint action."), line
);
859 memrange_absolute
= -1
862 /* MEMRANGE functions: */
864 static int memrange_cmp (const void *, const void *);
866 /* Compare memranges for qsort. */
868 memrange_cmp (const void *va
, const void *vb
)
870 const struct memrange
*a
= va
, *b
= vb
;
872 if (a
->type
< b
->type
)
874 if (a
->type
> b
->type
)
876 if (a
->type
== memrange_absolute
)
878 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
880 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
885 if (a
->start
< b
->start
)
887 if (a
->start
> b
->start
)
893 /* Sort the memrange list using qsort, and merge adjacent memranges. */
895 memrange_sortmerge (struct collection_list
*memranges
)
899 qsort (memranges
->list
, memranges
->next_memrange
,
900 sizeof (struct memrange
), memrange_cmp
);
901 if (memranges
->next_memrange
> 0)
903 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
905 /* If memrange b overlaps or is adjacent to memrange a,
907 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
908 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
910 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
911 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
912 continue; /* next b, same a */
916 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
917 sizeof (struct memrange
));
919 memranges
->next_memrange
= a
+ 1;
923 /* Add a register to a collection list. */
925 add_register (struct collection_list
*collection
, unsigned int regno
)
928 printf_filtered ("collect register %d\n", regno
);
929 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
930 error (_("Internal: register number %d too large for tracepoint"),
932 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
935 /* Add a memrange to a collection list. */
937 add_memrange (struct collection_list
*memranges
,
938 int type
, bfd_signed_vma base
,
943 printf_filtered ("(%d,", type
);
945 printf_filtered (",%ld)\n", len
);
948 /* type: memrange_absolute == memory, other n == basereg */
949 memranges
->list
[memranges
->next_memrange
].type
= type
;
950 /* base: addr if memory, offset if reg relative. */
951 memranges
->list
[memranges
->next_memrange
].start
= base
;
952 /* len: we actually save end (base + len) for convenience */
953 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
954 memranges
->next_memrange
++;
955 if (memranges
->next_memrange
>= memranges
->listsize
)
957 memranges
->listsize
*= 2;
958 memranges
->list
= xrealloc (memranges
->list
,
959 memranges
->listsize
);
962 if (type
!= memrange_absolute
) /* Better collect the base register! */
963 add_register (memranges
, type
);
966 /* Add a symbol to a collection list. */
968 collect_symbol (struct collection_list
*collect
,
970 struct gdbarch
*gdbarch
,
971 long frame_regno
, long frame_offset
,
977 bfd_signed_vma offset
;
978 int treat_as_expr
= 0;
980 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
981 switch (SYMBOL_CLASS (sym
))
984 printf_filtered ("%s: don't know symbol class %d\n",
985 SYMBOL_PRINT_NAME (sym
),
989 printf_filtered ("constant %s (value %s) will not be collected.\n",
990 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
993 offset
= SYMBOL_VALUE_ADDRESS (sym
);
998 sprintf_vma (tmp
, offset
);
999 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1000 SYMBOL_PRINT_NAME (sym
), len
,
1003 /* A struct may be a C++ class with static fields, go to general
1004 expression handling. */
1005 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1008 add_memrange (collect
, memrange_absolute
, offset
, len
);
1011 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1013 printf_filtered ("LOC_REG[parm] %s: ",
1014 SYMBOL_PRINT_NAME (sym
));
1015 add_register (collect
, reg
);
1016 /* Check for doubles stored in two registers. */
1017 /* FIXME: how about larger types stored in 3 or more regs? */
1018 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1019 len
> register_size (gdbarch
, reg
))
1020 add_register (collect
, reg
+ 1);
1023 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1024 printf_filtered (" (will not collect %s)\n",
1025 SYMBOL_PRINT_NAME (sym
));
1029 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1032 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1033 SYMBOL_PRINT_NAME (sym
), len
);
1034 printf_vma (offset
);
1035 printf_filtered (" from frame ptr reg %d\n", reg
);
1037 add_memrange (collect
, reg
, offset
, len
);
1039 case LOC_REGPARM_ADDR
:
1040 reg
= SYMBOL_VALUE (sym
);
1044 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1045 SYMBOL_PRINT_NAME (sym
), len
);
1046 printf_vma (offset
);
1047 printf_filtered (" from reg %d\n", reg
);
1049 add_memrange (collect
, reg
, offset
, len
);
1053 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1056 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1057 SYMBOL_PRINT_NAME (sym
), len
);
1058 printf_vma (offset
);
1059 printf_filtered (" from frame ptr reg %d\n", reg
);
1061 add_memrange (collect
, reg
, offset
, len
);
1064 case LOC_UNRESOLVED
:
1068 case LOC_OPTIMIZED_OUT
:
1069 printf_filtered ("%s has been optimized out of existence.\n",
1070 SYMBOL_PRINT_NAME (sym
));
1078 /* Expressions are the most general case. */
1081 struct agent_expr
*aexpr
;
1082 struct cleanup
*old_chain1
= NULL
;
1084 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1086 /* It can happen that the symbol is recorded as a computed
1087 location, but it's been optimized away and doesn't actually
1088 have a location expression. */
1091 printf_filtered ("%s has been optimized out of existence.\n",
1092 SYMBOL_PRINT_NAME (sym
));
1096 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1100 report_agent_reqs_errors (aexpr
);
1102 discard_cleanups (old_chain1
);
1103 add_aexpr (collect
, aexpr
);
1105 /* Take care of the registers. */
1106 if (aexpr
->reg_mask_len
> 0)
1110 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1112 QUIT
; /* Allow user to bail out with ^C. */
1113 if (aexpr
->reg_mask
[ndx1
] != 0)
1115 /* Assume chars have 8 bits. */
1116 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1117 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1118 /* It's used -- record it. */
1119 add_register (collect
, ndx1
* 8 + ndx2
);
1126 /* Data to be passed around in the calls to the locals and args
1129 struct add_local_symbols_data
1131 struct collection_list
*collect
;
1132 struct gdbarch
*gdbarch
;
1140 /* The callback for the locals and args iterators. */
1143 do_collect_symbol (const char *print_name
,
1147 struct add_local_symbols_data
*p
= cb_data
;
1149 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1150 p
->frame_offset
, p
->pc
, p
->trace_string
);
1153 VEC_safe_push (char_ptr
, p
->collect
->wholly_collected
,
1154 xstrdup (print_name
));
1157 /* Add all locals (or args) symbols to collection list. */
1159 add_local_symbols (struct collection_list
*collect
,
1160 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1161 long frame_regno
, long frame_offset
, int type
,
1164 struct block
*block
;
1165 struct add_local_symbols_data cb_data
;
1167 cb_data
.collect
= collect
;
1168 cb_data
.gdbarch
= gdbarch
;
1170 cb_data
.frame_regno
= frame_regno
;
1171 cb_data
.frame_offset
= frame_offset
;
1173 cb_data
.trace_string
= trace_string
;
1177 block
= block_for_pc (pc
);
1180 warning (_("Can't collect locals; "
1181 "no symbol table info available.\n"));
1185 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1186 if (cb_data
.count
== 0)
1187 warning (_("No locals found in scope."));
1191 pc
= get_pc_function_start (pc
);
1192 block
= block_for_pc (pc
);
1195 warning (_("Can't collect args; no symbol table info available."));
1199 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1200 if (cb_data
.count
== 0)
1201 warning (_("No args found in scope."));
1206 add_static_trace_data (struct collection_list
*collection
)
1209 printf_filtered ("collect static trace data\n");
1210 collection
->strace_data
= 1;
1213 /* worker function */
1215 clear_collection_list (struct collection_list
*list
)
1219 list
->next_memrange
= 0;
1220 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1222 free_agent_expr (list
->aexpr_list
[ndx
]);
1223 list
->aexpr_list
[ndx
] = NULL
;
1225 list
->next_aexpr_elt
= 0;
1226 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1227 list
->strace_data
= 0;
1229 xfree (list
->aexpr_list
);
1232 VEC_free (char_ptr
, list
->wholly_collected
);
1233 VEC_free (char_ptr
, list
->computed
);
1236 /* A cleanup wrapper for function clear_collection_list. */
1239 do_clear_collection_list (void *list
)
1241 struct collection_list
*l
= list
;
1243 clear_collection_list (l
);
1246 /* Initialize collection_list CLIST. */
1249 init_collection_list (struct collection_list
*clist
)
1251 memset (clist
, 0, sizeof *clist
);
1253 clist
->listsize
= 128;
1254 clist
->list
= xcalloc (clist
->listsize
,
1255 sizeof (struct memrange
));
1257 clist
->aexpr_listsize
= 128;
1258 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1259 sizeof (struct agent_expr
*));
1262 /* Reduce a collection list to string form (for gdb protocol). */
1264 stringify_collection_list (struct collection_list
*list
)
1266 char temp_buf
[2048];
1270 char *(*str_list
)[];
1274 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1275 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1277 if (list
->strace_data
)
1280 printf_filtered ("\nCollecting static trace data\n");
1283 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1287 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1288 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1290 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1293 printf_filtered ("\nCollecting registers (mask): 0x");
1298 QUIT
; /* Allow user to bail out with ^C. */
1300 printf_filtered ("%02X", list
->regs_mask
[i
]);
1301 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1304 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1308 printf_filtered ("\n");
1309 if (list
->next_memrange
> 0 && info_verbose
)
1310 printf_filtered ("Collecting memranges: \n");
1311 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1313 QUIT
; /* Allow user to bail out with ^C. */
1314 sprintf_vma (tmp2
, list
->list
[i
].start
);
1317 printf_filtered ("(%d, %s, %ld)\n",
1320 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1322 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1324 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1331 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1333 /* The "%X" conversion specifier expects an unsigned argument,
1334 so passing -1 (memrange_absolute) to it directly gives you
1335 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1337 if (list
->list
[i
].type
== memrange_absolute
)
1338 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1340 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1343 count
+= strlen (end
);
1344 end
= temp_buf
+ count
;
1347 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1349 QUIT
; /* Allow user to bail out with ^C. */
1350 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1352 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1357 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1358 end
+= 10; /* 'X' + 8 hex digits + ',' */
1361 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1362 end
, list
->aexpr_list
[i
]->len
);
1363 count
+= 2 * list
->aexpr_list
[i
]->len
;
1368 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1373 (*str_list
)[ndx
] = NULL
;
1384 /* Add the printed expression EXP to *LIST. */
1387 append_exp (struct expression
*exp
, VEC(char_ptr
) **list
)
1389 struct ui_file
*tmp_stream
= mem_fileopen ();
1392 print_expression (exp
, tmp_stream
);
1394 text
= ui_file_xstrdup (tmp_stream
, NULL
);
1396 VEC_safe_push (char_ptr
, *list
, text
);
1397 ui_file_delete (tmp_stream
);
1401 encode_actions_1 (struct command_line
*action
,
1402 struct bp_location
*tloc
,
1404 LONGEST frame_offset
,
1405 struct collection_list
*collect
,
1406 struct collection_list
*stepping_list
)
1408 const char *action_exp
;
1409 struct expression
*exp
= NULL
;
1411 struct value
*tempval
;
1412 struct cmd_list_element
*cmd
;
1413 struct agent_expr
*aexpr
;
1415 for (; action
; action
= action
->next
)
1417 QUIT
; /* Allow user to bail out with ^C. */
1418 action_exp
= action
->line
;
1419 action_exp
= skip_spaces_const (action_exp
);
1421 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1423 error (_("Bad action list item: %s"), action_exp
);
1425 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1427 int trace_string
= 0;
1429 if (*action_exp
== '/')
1430 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1433 { /* Repeat over a comma-separated list. */
1434 QUIT
; /* Allow user to bail out with ^C. */
1435 action_exp
= skip_spaces_const (action_exp
);
1437 if (0 == strncasecmp ("$reg", action_exp
, 4))
1439 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1440 add_register (collect
, i
);
1441 action_exp
= strchr (action_exp
, ','); /* more? */
1443 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1445 add_local_symbols (collect
,
1452 action_exp
= strchr (action_exp
, ','); /* more? */
1454 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1456 add_local_symbols (collect
,
1463 action_exp
= strchr (action_exp
, ','); /* more? */
1465 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1467 struct cleanup
*old_chain1
= NULL
;
1469 aexpr
= gen_trace_for_return_address (tloc
->address
,
1473 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1476 report_agent_reqs_errors (aexpr
);
1478 discard_cleanups (old_chain1
);
1479 add_aexpr (collect
, aexpr
);
1481 /* take care of the registers */
1482 if (aexpr
->reg_mask_len
> 0)
1486 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1488 QUIT
; /* allow user to bail out with ^C */
1489 if (aexpr
->reg_mask
[ndx1
] != 0)
1491 /* assume chars have 8 bits */
1492 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1493 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1494 /* it's used -- record it */
1495 add_register (collect
,
1501 action_exp
= strchr (action_exp
, ','); /* more? */
1503 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1505 add_static_trace_data (collect
);
1506 action_exp
= strchr (action_exp
, ','); /* more? */
1511 struct cleanup
*old_chain
= NULL
;
1512 struct cleanup
*old_chain1
= NULL
;
1514 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1515 block_for_pc (tloc
->address
), 1);
1516 old_chain
= make_cleanup (free_current_contents
, &exp
);
1518 switch (exp
->elts
[0].opcode
)
1522 const char *name
= &exp
->elts
[2].string
;
1524 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1525 name
, strlen (name
));
1527 internal_error (__FILE__
, __LINE__
,
1528 _("Register $%s not available"),
1531 printf_filtered ("OP_REGISTER: ");
1532 add_register (collect
, i
);
1537 /* Safe because we know it's a simple expression. */
1538 tempval
= evaluate_expression (exp
);
1539 addr
= value_address (tempval
);
1540 /* Initialize the TYPE_LENGTH if it is a typedef. */
1541 check_typedef (exp
->elts
[1].type
);
1542 add_memrange (collect
, memrange_absolute
, addr
,
1543 TYPE_LENGTH (exp
->elts
[1].type
));
1544 append_exp (exp
, &collect
->computed
);
1549 struct symbol
*sym
= exp
->elts
[2].symbol
;
1550 char_ptr name
= (char_ptr
) SYMBOL_NATURAL_NAME (sym
);
1552 collect_symbol (collect
,
1553 exp
->elts
[2].symbol
,
1559 VEC_safe_push (char_ptr
,
1560 collect
->wholly_collected
,
1565 default: /* Full-fledged expression. */
1566 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1569 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1573 report_agent_reqs_errors (aexpr
);
1575 discard_cleanups (old_chain1
);
1576 add_aexpr (collect
, aexpr
);
1578 /* Take care of the registers. */
1579 if (aexpr
->reg_mask_len
> 0)
1584 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1586 QUIT
; /* Allow user to bail out with ^C. */
1587 if (aexpr
->reg_mask
[ndx1
] != 0)
1589 /* Assume chars have 8 bits. */
1590 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1591 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1592 /* It's used -- record it. */
1593 add_register (collect
,
1599 append_exp (exp
, &collect
->computed
);
1602 do_cleanups (old_chain
);
1605 while (action_exp
&& *action_exp
++ == ',');
1607 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1610 { /* Repeat over a comma-separated list. */
1611 QUIT
; /* Allow user to bail out with ^C. */
1612 action_exp
= skip_spaces_const (action_exp
);
1615 struct cleanup
*old_chain
= NULL
;
1616 struct cleanup
*old_chain1
= NULL
;
1618 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1619 block_for_pc (tloc
->address
), 1);
1620 old_chain
= make_cleanup (free_current_contents
, &exp
);
1622 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1623 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1626 report_agent_reqs_errors (aexpr
);
1628 discard_cleanups (old_chain1
);
1629 /* Even though we're not officially collecting, add
1630 to the collect list anyway. */
1631 add_aexpr (collect
, aexpr
);
1633 do_cleanups (old_chain
);
1636 while (action_exp
&& *action_exp
++ == ',');
1638 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1640 /* We check against nested while-stepping when setting
1641 breakpoint action, so no way to run into nested
1643 gdb_assert (stepping_list
);
1645 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1646 frame_offset
, stepping_list
, NULL
);
1649 error (_("Invalid tracepoint command '%s'"), action
->line
);
1653 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1654 and STEPPING_LIST. Return a cleanup pointer to clean up both
1655 TRACEPOINT_LIST and STEPPING_LIST. */
1658 encode_actions_and_make_cleanup (struct bp_location
*tloc
,
1659 struct collection_list
*tracepoint_list
,
1660 struct collection_list
*stepping_list
)
1662 char *default_collect_line
= NULL
;
1663 struct command_line
*actions
;
1664 struct command_line
*default_collect_action
= NULL
;
1666 LONGEST frame_offset
;
1667 struct cleanup
*back_to
, *return_chain
;
1669 return_chain
= make_cleanup (null_cleanup
, NULL
);
1670 init_collection_list (tracepoint_list
);
1671 init_collection_list (stepping_list
);
1673 make_cleanup (do_clear_collection_list
, tracepoint_list
);
1674 make_cleanup (do_clear_collection_list
, stepping_list
);
1676 back_to
= make_cleanup (null_cleanup
, NULL
);
1677 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1678 tloc
->address
, &frame_reg
, &frame_offset
);
1680 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1682 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1683 tracepoint_list
, stepping_list
);
1685 memrange_sortmerge (tracepoint_list
);
1686 memrange_sortmerge (stepping_list
);
1688 do_cleanups (back_to
);
1689 return return_chain
;
1692 /* Render all actions into gdb protocol. */
1695 encode_actions_rsp (struct bp_location
*tloc
, char ***tdp_actions
,
1696 char ***stepping_actions
)
1698 struct collection_list tracepoint_list
, stepping_list
;
1699 struct cleanup
*cleanup
;
1701 *tdp_actions
= NULL
;
1702 *stepping_actions
= NULL
;
1704 cleanup
= encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
1707 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1708 *stepping_actions
= stringify_collection_list (&stepping_list
);
1710 do_cleanups (cleanup
);
1714 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1716 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1718 collect
->aexpr_list
=
1719 xrealloc (collect
->aexpr_list
,
1720 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1721 collect
->aexpr_listsize
*= 2;
1723 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1724 collect
->next_aexpr_elt
++;
1728 process_tracepoint_on_disconnect (void)
1730 VEC(breakpoint_p
) *tp_vec
= NULL
;
1732 struct breakpoint
*b
;
1733 int has_pending_p
= 0;
1735 /* Check whether we still have pending tracepoint. If we have, warn the
1736 user that pending tracepoint will no longer work. */
1737 tp_vec
= all_tracepoints ();
1738 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1747 struct bp_location
*loc1
;
1749 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1751 if (loc1
->shlib_disabled
)
1762 VEC_free (breakpoint_p
, tp_vec
);
1765 warning (_("Pending tracepoints will not be resolved while"
1766 " GDB is disconnected\n"));
1769 /* Reset local state of tracing. */
1772 trace_reset_local_state (void)
1774 set_traceframe_num (-1);
1775 set_tracepoint_num (-1);
1776 set_traceframe_context (NULL
);
1777 clear_traceframe_info ();
1781 start_tracing (char *notes
)
1783 VEC(breakpoint_p
) *tp_vec
= NULL
;
1785 struct breakpoint
*b
;
1786 struct trace_state_variable
*tsv
;
1787 int any_enabled
= 0, num_to_download
= 0;
1790 tp_vec
= all_tracepoints ();
1792 /* No point in tracing without any tracepoints... */
1793 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1795 VEC_free (breakpoint_p
, tp_vec
);
1796 error (_("No tracepoints defined, not starting trace"));
1799 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1801 struct tracepoint
*t
= (struct tracepoint
*) b
;
1802 struct bp_location
*loc
;
1804 if (b
->enable_state
== bp_enabled
)
1807 if ((b
->type
== bp_fast_tracepoint
1808 ? may_insert_fast_tracepoints
1809 : may_insert_tracepoints
))
1812 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1813 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1818 if (target_supports_enable_disable_tracepoint ())
1819 warning (_("No tracepoints enabled"));
1822 /* No point in tracing with only disabled tracepoints that
1823 cannot be re-enabled. */
1824 VEC_free (breakpoint_p
, tp_vec
);
1825 error (_("No tracepoints enabled, not starting trace"));
1829 if (num_to_download
<= 0)
1831 VEC_free (breakpoint_p
, tp_vec
);
1832 error (_("No tracepoints that may be downloaded, not starting trace"));
1835 target_trace_init ();
1837 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1839 struct tracepoint
*t
= (struct tracepoint
*) b
;
1840 struct bp_location
*loc
;
1841 int bp_location_downloaded
= 0;
1843 /* Clear `inserted' flag. */
1844 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1847 if ((b
->type
== bp_fast_tracepoint
1848 ? !may_insert_fast_tracepoints
1849 : !may_insert_tracepoints
))
1852 t
->number_on_target
= 0;
1854 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1856 /* Since tracepoint locations are never duplicated, `inserted'
1857 flag should be zero. */
1858 gdb_assert (!loc
->inserted
);
1860 target_download_tracepoint (loc
);
1863 bp_location_downloaded
= 1;
1866 t
->number_on_target
= b
->number
;
1868 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1869 if (loc
->probe
!= NULL
)
1870 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1872 if (bp_location_downloaded
)
1873 observer_notify_breakpoint_modified (b
);
1875 VEC_free (breakpoint_p
, tp_vec
);
1877 /* Send down all the trace state variables too. */
1878 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1880 target_download_trace_state_variable (tsv
);
1883 /* Tell target to treat text-like sections as transparent. */
1884 target_trace_set_readonly_regions ();
1885 /* Set some mode flags. */
1886 target_set_disconnected_tracing (disconnected_tracing
);
1887 target_set_circular_trace_buffer (circular_trace_buffer
);
1888 target_set_trace_buffer_size (trace_buffer_size
);
1891 notes
= trace_notes
;
1892 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1894 if (!ret
&& (trace_user
|| notes
))
1895 warning (_("Target does not support trace user/notes, info ignored"));
1897 /* Now insert traps and begin collecting data. */
1898 target_trace_start ();
1900 /* Reset our local state. */
1901 trace_reset_local_state ();
1902 current_trace_status()->running
= 1;
1905 /* The tstart command requests the target to start a new trace run.
1906 The command passes any arguments it has to the target verbatim, as
1907 an optional "trace note". This is useful as for instance a warning
1908 to other users if the trace runs disconnected, and you don't want
1909 anybody else messing with the target. */
1912 trace_start_command (char *args
, int from_tty
)
1914 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1916 if (current_trace_status ()->running
)
1919 && !query (_("A trace is running already. Start a new run? ")))
1920 error (_("New trace run not started."));
1923 start_tracing (args
);
1926 /* The tstop command stops the tracing run. The command passes any
1927 supplied arguments to the target verbatim as a "stop note"; if the
1928 target supports trace notes, then it will be reported back as part
1929 of the trace run's status. */
1932 trace_stop_command (char *args
, int from_tty
)
1934 if (!current_trace_status ()->running
)
1935 error (_("Trace is not running."));
1937 stop_tracing (args
);
1941 stop_tracing (char *note
)
1944 VEC(breakpoint_p
) *tp_vec
= NULL
;
1946 struct breakpoint
*t
;
1948 target_trace_stop ();
1950 tp_vec
= all_tracepoints ();
1951 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1953 struct bp_location
*loc
;
1955 if ((t
->type
== bp_fast_tracepoint
1956 ? !may_insert_fast_tracepoints
1957 : !may_insert_tracepoints
))
1960 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1962 /* GDB can be totally absent in some disconnected trace scenarios,
1963 but we don't really care if this semaphore goes out of sync.
1964 That's why we are decrementing it here, but not taking care
1966 if (loc
->probe
!= NULL
)
1967 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1971 VEC_free (breakpoint_p
, tp_vec
);
1974 note
= trace_stop_notes
;
1975 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1978 warning (_("Target does not support trace notes, note ignored"));
1980 /* Should change in response to reply? */
1981 current_trace_status ()->running
= 0;
1984 /* tstatus command */
1986 trace_status_command (char *args
, int from_tty
)
1988 struct trace_status
*ts
= current_trace_status ();
1990 VEC(breakpoint_p
) *tp_vec
= NULL
;
1991 struct breakpoint
*t
;
1993 status
= target_get_trace_status (ts
);
1997 if (ts
->filename
!= NULL
)
1998 printf_filtered (_("Using a trace file.\n"));
2001 printf_filtered (_("Trace can not be run on this target.\n"));
2006 if (!ts
->running_known
)
2008 printf_filtered (_("Run/stop status is unknown.\n"));
2010 else if (ts
->running
)
2012 printf_filtered (_("Trace is running on the target.\n"));
2016 switch (ts
->stop_reason
)
2018 case trace_never_run
:
2019 printf_filtered (_("No trace has been run on the target.\n"));
2023 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2026 printf_filtered (_("Trace stopped by a tstop command.\n"));
2028 case trace_buffer_full
:
2029 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2031 case trace_disconnected
:
2032 printf_filtered (_("Trace stopped because of disconnection.\n"));
2034 case tracepoint_passcount
:
2035 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2036 ts
->stopping_tracepoint
);
2038 case tracepoint_error
:
2039 if (ts
->stopping_tracepoint
)
2040 printf_filtered (_("Trace stopped by an "
2041 "error (%s, tracepoint %d).\n"),
2042 ts
->stop_desc
, ts
->stopping_tracepoint
);
2044 printf_filtered (_("Trace stopped by an error (%s).\n"),
2047 case trace_stop_reason_unknown
:
2048 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2051 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2057 if (ts
->traceframes_created
>= 0
2058 && ts
->traceframe_count
!= ts
->traceframes_created
)
2060 printf_filtered (_("Buffer contains %d trace "
2061 "frames (of %d created total).\n"),
2062 ts
->traceframe_count
, ts
->traceframes_created
);
2064 else if (ts
->traceframe_count
>= 0)
2066 printf_filtered (_("Collected %d trace frames.\n"),
2067 ts
->traceframe_count
);
2070 if (ts
->buffer_free
>= 0)
2072 if (ts
->buffer_size
>= 0)
2074 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2075 ts
->buffer_free
, ts
->buffer_size
);
2076 if (ts
->buffer_size
> 0)
2077 printf_filtered (_(" (%d%% full)"),
2078 ((int) ((((long long) (ts
->buffer_size
2079 - ts
->buffer_free
)) * 100)
2080 / ts
->buffer_size
)));
2081 printf_filtered (_(".\n"));
2084 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2088 if (ts
->disconnected_tracing
)
2089 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2091 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2093 if (ts
->circular_buffer
)
2094 printf_filtered (_("Trace buffer is circular.\n"));
2096 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2097 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2099 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2100 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2102 /* Now report on what we're doing with tfind. */
2103 if (traceframe_number
>= 0)
2104 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2105 traceframe_number
, tracepoint_number
);
2107 printf_filtered (_("Not looking at any trace frame.\n"));
2109 /* Report start/stop times if supplied. */
2114 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2116 /* Reporting a run time is more readable than two long numbers. */
2117 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2118 (long int) (ts
->start_time
/ 1000000),
2119 (long int) (ts
->start_time
% 1000000),
2120 (long int) (run_time
/ 1000000),
2121 (long int) (run_time
% 1000000));
2124 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2125 (long int) (ts
->start_time
/ 1000000),
2126 (long int) (ts
->start_time
% 1000000));
2128 else if (ts
->stop_time
)
2129 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2130 (long int) (ts
->stop_time
/ 1000000),
2131 (long int) (ts
->stop_time
% 1000000));
2133 /* Now report any per-tracepoint status available. */
2134 tp_vec
= all_tracepoints ();
2136 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2137 target_get_tracepoint_status (t
, NULL
);
2139 VEC_free (breakpoint_p
, tp_vec
);
2142 /* Report the trace status to uiout, in a way suitable for MI, and not
2143 suitable for CLI. If ON_STOP is true, suppress a few fields that
2144 are not meaningful in the -trace-stop response.
2146 The implementation is essentially parallel to trace_status_command, but
2147 merging them will result in unreadable code. */
2149 trace_status_mi (int on_stop
)
2151 struct ui_out
*uiout
= current_uiout
;
2152 struct trace_status
*ts
= current_trace_status ();
2155 status
= target_get_trace_status (ts
);
2157 if (status
== -1 && ts
->filename
== NULL
)
2159 ui_out_field_string (uiout
, "supported", "0");
2163 if (ts
->filename
!= NULL
)
2164 ui_out_field_string (uiout
, "supported", "file");
2166 ui_out_field_string (uiout
, "supported", "1");
2168 if (ts
->filename
!= NULL
)
2169 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2171 gdb_assert (ts
->running_known
);
2175 ui_out_field_string (uiout
, "running", "1");
2177 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2178 Given that the frontend gets the status either on -trace-stop, or from
2179 -trace-status after re-connection, it does not seem like this
2180 information is necessary for anything. It is not necessary for either
2181 figuring the vital state of the target nor for navigation of trace
2182 frames. If the frontend wants to show the current state is some
2183 configure dialog, it can request the value when such dialog is
2184 invoked by the user. */
2188 char *stop_reason
= NULL
;
2189 int stopping_tracepoint
= -1;
2192 ui_out_field_string (uiout
, "running", "0");
2194 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2196 switch (ts
->stop_reason
)
2199 stop_reason
= "request";
2201 case trace_buffer_full
:
2202 stop_reason
= "overflow";
2204 case trace_disconnected
:
2205 stop_reason
= "disconnection";
2207 case tracepoint_passcount
:
2208 stop_reason
= "passcount";
2209 stopping_tracepoint
= ts
->stopping_tracepoint
;
2211 case tracepoint_error
:
2212 stop_reason
= "error";
2213 stopping_tracepoint
= ts
->stopping_tracepoint
;
2219 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2220 if (stopping_tracepoint
!= -1)
2221 ui_out_field_int (uiout
, "stopping-tracepoint",
2222 stopping_tracepoint
);
2223 if (ts
->stop_reason
== tracepoint_error
)
2224 ui_out_field_string (uiout
, "error-description",
2230 if (ts
->traceframe_count
!= -1)
2231 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2232 if (ts
->traceframes_created
!= -1)
2233 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2234 if (ts
->buffer_size
!= -1)
2235 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2236 if (ts
->buffer_free
!= -1)
2237 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2239 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2240 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2242 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2243 ui_out_field_string (uiout
, "notes", ts
->notes
);
2248 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2249 (long int) (ts
->start_time
/ 1000000),
2250 (long int) (ts
->start_time
% 1000000));
2251 ui_out_field_string (uiout
, "start-time", buf
);
2252 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2253 (long int) (ts
->stop_time
/ 1000000),
2254 (long int) (ts
->stop_time
% 1000000));
2255 ui_out_field_string (uiout
, "stop-time", buf
);
2259 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2260 user if she really wants to detach. */
2263 query_if_trace_running (int from_tty
)
2268 /* It can happen that the target that was tracing went away on its
2269 own, and we didn't notice. Get a status update, and if the
2270 current target doesn't even do tracing, then assume it's not
2272 if (target_get_trace_status (current_trace_status ()) < 0)
2273 current_trace_status ()->running
= 0;
2275 /* If running interactively, give the user the option to cancel and
2276 then decide what to do differently with the run. Scripts are
2277 just going to disconnect and let the target deal with it,
2278 according to how it's been instructed previously via
2279 disconnected-tracing. */
2280 if (current_trace_status ()->running
)
2282 process_tracepoint_on_disconnect ();
2284 if (current_trace_status ()->disconnected_tracing
)
2286 if (!query (_("Trace is running and will "
2287 "continue after detach; detach anyway? ")))
2288 error (_("Not confirmed."));
2292 if (!query (_("Trace is running but will "
2293 "stop on detach; detach anyway? ")))
2294 error (_("Not confirmed."));
2299 /* This function handles the details of what to do about an ongoing
2300 tracing run if the user has asked to detach or otherwise disconnect
2304 disconnect_tracing (void)
2306 /* Also we want to be out of tfind mode, otherwise things can get
2307 confusing upon reconnection. Just use these calls instead of
2308 full tfind_1 behavior because we're in the middle of detaching,
2309 and there's no point to updating current stack frame etc. */
2310 trace_reset_local_state ();
2313 /* Worker function for the various flavors of the tfind command. */
2315 tfind_1 (enum trace_find_type type
, int num
,
2316 CORE_ADDR addr1
, CORE_ADDR addr2
,
2319 int target_frameno
= -1, target_tracept
= -1;
2320 struct frame_id old_frame_id
= null_frame_id
;
2321 struct tracepoint
*tp
;
2322 struct ui_out
*uiout
= current_uiout
;
2324 /* Only try to get the current stack frame if we have a chance of
2325 succeeding. In particular, if we're trying to get a first trace
2326 frame while all threads are running, it's not going to succeed,
2327 so leave it with a default value and let the frame comparison
2328 below (correctly) decide to print out the source location of the
2330 if (!(type
== tfind_number
&& num
== -1)
2331 && (has_stack_frames () || traceframe_number
>= 0))
2332 old_frame_id
= get_frame_id (get_current_frame ());
2334 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2337 if (type
== tfind_number
2339 && target_frameno
== -1)
2341 /* We told the target to get out of tfind mode, and it did. */
2343 else if (target_frameno
== -1)
2345 /* A request for a non-existent trace frame has failed.
2346 Our response will be different, depending on FROM_TTY:
2348 If FROM_TTY is true, meaning that this command was
2349 typed interactively by the user, then give an error
2350 and DO NOT change the state of traceframe_number etc.
2352 However if FROM_TTY is false, meaning that we're either
2353 in a script, a loop, or a user-defined command, then
2354 DON'T give an error, but DO change the state of
2355 traceframe_number etc. to invalid.
2357 The rationalle is that if you typed the command, you
2358 might just have committed a typo or something, and you'd
2359 like to NOT lose your current debugging state. However
2360 if you're in a user-defined command or especially in a
2361 loop, then you need a way to detect that the command
2362 failed WITHOUT aborting. This allows you to write
2363 scripts that search thru the trace buffer until the end,
2364 and then continue on to do something else. */
2367 error (_("Target failed to find requested trace frame."));
2371 printf_filtered ("End of trace buffer.\n");
2372 #if 0 /* dubious now? */
2373 /* The following will not recurse, since it's
2375 trace_find_command ("-1", from_tty
);
2380 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2382 reinit_frame_cache ();
2383 target_dcache_invalidate ();
2385 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2387 if (target_frameno
!= get_traceframe_number ())
2388 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2390 set_current_traceframe (target_frameno
);
2392 if (target_frameno
== -1)
2393 set_traceframe_context (NULL
);
2395 set_traceframe_context (get_current_frame ());
2397 if (traceframe_number
>= 0)
2399 /* Use different branches for MI and CLI to make CLI messages
2401 if (ui_out_is_mi_like_p (uiout
))
2403 ui_out_field_string (uiout
, "found", "1");
2404 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2405 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2409 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2410 traceframe_number
, tracepoint_number
);
2415 if (ui_out_is_mi_like_p (uiout
))
2416 ui_out_field_string (uiout
, "found", "0");
2417 else if (type
== tfind_number
&& num
== -1)
2418 printf_unfiltered (_("No longer looking at any trace frame\n"));
2419 else /* This case may never occur, check. */
2420 printf_unfiltered (_("No trace frame found\n"));
2423 /* If we're in nonstop mode and getting out of looking at trace
2424 frames, there won't be any current frame to go back to and
2427 && (has_stack_frames () || traceframe_number
>= 0))
2429 enum print_what print_what
;
2431 /* NOTE: in imitation of the step command, try to determine
2432 whether we have made a transition from one function to
2433 another. If so, we'll print the "stack frame" (ie. the new
2434 function and it's arguments) -- otherwise we'll just show the
2437 if (frame_id_eq (old_frame_id
,
2438 get_frame_id (get_current_frame ())))
2439 print_what
= SRC_LINE
;
2441 print_what
= SRC_AND_LOC
;
2443 print_stack_frame (get_selected_frame (NULL
), 1, print_what
, 1);
2448 /* trace_find_command takes a trace frame number n,
2449 sends "QTFrame:<n>" to the target,
2450 and accepts a reply that may contain several optional pieces
2451 of information: a frame number, a tracepoint number, and an
2452 indication of whether this is a trap frame or a stepping frame.
2454 The minimal response is just "OK" (which indicates that the
2455 target does not give us a frame number or a tracepoint number).
2456 Instead of that, the target may send us a string containing
2458 F<hexnum> (gives the selected frame number)
2459 T<hexnum> (gives the selected tracepoint number)
2464 trace_find_command (char *args
, int from_tty
)
2465 { /* This should only be called with a numeric argument. */
2468 if (current_trace_status ()->running
2469 && current_trace_status ()->filename
== NULL
)
2470 error (_("May not look at trace frames while trace is running."));
2472 if (args
== 0 || *args
== 0)
2473 { /* TFIND with no args means find NEXT trace frame. */
2474 if (traceframe_number
== -1)
2475 frameno
= 0; /* "next" is first one. */
2477 frameno
= traceframe_number
+ 1;
2479 else if (0 == strcmp (args
, "-"))
2481 if (traceframe_number
== -1)
2482 error (_("not debugging trace buffer"));
2483 else if (from_tty
&& traceframe_number
== 0)
2484 error (_("already at start of trace buffer"));
2486 frameno
= traceframe_number
- 1;
2488 /* A hack to work around eval's need for fp to have been collected. */
2489 else if (0 == strcmp (args
, "-1"))
2492 frameno
= parse_and_eval_long (args
);
2495 error (_("invalid input (%d is less than zero)"), frameno
);
2497 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2502 trace_find_end_command (char *args
, int from_tty
)
2504 trace_find_command ("-1", from_tty
);
2509 trace_find_start_command (char *args
, int from_tty
)
2511 trace_find_command ("0", from_tty
);
2514 /* tfind pc command */
2516 trace_find_pc_command (char *args
, int from_tty
)
2520 if (current_trace_status ()->running
2521 && current_trace_status ()->filename
== NULL
)
2522 error (_("May not look at trace frames while trace is running."));
2524 if (args
== 0 || *args
== 0)
2525 pc
= regcache_read_pc (get_current_regcache ());
2527 pc
= parse_and_eval_address (args
);
2529 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2532 /* tfind tracepoint command */
2534 trace_find_tracepoint_command (char *args
, int from_tty
)
2537 struct tracepoint
*tp
;
2539 if (current_trace_status ()->running
2540 && current_trace_status ()->filename
== NULL
)
2541 error (_("May not look at trace frames while trace is running."));
2543 if (args
== 0 || *args
== 0)
2545 if (tracepoint_number
== -1)
2546 error (_("No current tracepoint -- please supply an argument."));
2548 tdp
= tracepoint_number
; /* Default is current TDP. */
2551 tdp
= parse_and_eval_long (args
);
2553 /* If we have the tracepoint on hand, use the number that the
2554 target knows about (which may be different if we disconnected
2555 and reconnected). */
2556 tp
= get_tracepoint (tdp
);
2558 tdp
= tp
->number_on_target
;
2560 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2563 /* TFIND LINE command:
2565 This command will take a sourceline for argument, just like BREAK
2566 or TRACE (ie. anything that "decode_line_1" can handle).
2568 With no argument, this command will find the next trace frame
2569 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2572 trace_find_line_command (char *args
, int from_tty
)
2574 static CORE_ADDR start_pc
, end_pc
;
2575 struct symtabs_and_lines sals
;
2576 struct symtab_and_line sal
;
2577 struct cleanup
*old_chain
;
2579 if (current_trace_status ()->running
2580 && current_trace_status ()->filename
== NULL
)
2581 error (_("May not look at trace frames while trace is running."));
2583 if (args
== 0 || *args
== 0)
2585 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2587 sals
.sals
= (struct symtab_and_line
*)
2588 xmalloc (sizeof (struct symtab_and_line
));
2593 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2597 old_chain
= make_cleanup (xfree
, sals
.sals
);
2598 if (sal
.symtab
== 0)
2599 error (_("No line number information available."));
2601 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2603 if (start_pc
== end_pc
)
2605 printf_filtered ("Line %d of \"%s\"",
2607 symtab_to_filename_for_display (sal
.symtab
));
2609 printf_filtered (" is at address ");
2610 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2612 printf_filtered (" but contains no code.\n");
2613 sal
= find_pc_line (start_pc
, 0);
2615 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2616 && start_pc
!= end_pc
)
2617 printf_filtered ("Attempting to find line %d instead.\n",
2620 error (_("Cannot find a good line."));
2624 /* Is there any case in which we get here, and have an address
2625 which the user would want to see? If we have debugging
2626 symbols and no line numbers? */
2627 error (_("Line number %d is out of range for \"%s\"."),
2628 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2630 /* Find within range of stated line. */
2632 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2634 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2635 do_cleanups (old_chain
);
2638 /* tfind range command */
2640 trace_find_range_command (char *args
, int from_tty
)
2642 static CORE_ADDR start
, stop
;
2645 if (current_trace_status ()->running
2646 && current_trace_status ()->filename
== NULL
)
2647 error (_("May not look at trace frames while trace is running."));
2649 if (args
== 0 || *args
== 0)
2650 { /* XXX FIXME: what should default behavior be? */
2651 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2655 if (0 != (tmp
= strchr (args
, ',')))
2657 *tmp
++ = '\0'; /* Terminate start address. */
2658 tmp
= skip_spaces (tmp
);
2659 start
= parse_and_eval_address (args
);
2660 stop
= parse_and_eval_address (tmp
);
2663 { /* No explicit end address? */
2664 start
= parse_and_eval_address (args
);
2665 stop
= start
+ 1; /* ??? */
2668 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2671 /* tfind outside command */
2673 trace_find_outside_command (char *args
, int from_tty
)
2675 CORE_ADDR start
, stop
;
2678 if (current_trace_status ()->running
2679 && current_trace_status ()->filename
== NULL
)
2680 error (_("May not look at trace frames while trace is running."));
2682 if (args
== 0 || *args
== 0)
2683 { /* XXX FIXME: what should default behavior be? */
2684 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2688 if (0 != (tmp
= strchr (args
, ',')))
2690 *tmp
++ = '\0'; /* Terminate start address. */
2691 tmp
= skip_spaces (tmp
);
2692 start
= parse_and_eval_address (args
);
2693 stop
= parse_and_eval_address (tmp
);
2696 { /* No explicit end address? */
2697 start
= parse_and_eval_address (args
);
2698 stop
= start
+ 1; /* ??? */
2701 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2704 /* info scope command: list the locals for a scope. */
2706 scope_info (char *args
, int from_tty
)
2708 struct symtabs_and_lines sals
;
2710 struct minimal_symbol
*msym
;
2711 struct block
*block
;
2712 const char *symname
;
2713 char *save_args
= args
;
2714 struct block_iterator iter
;
2716 struct gdbarch
*gdbarch
;
2719 if (args
== 0 || *args
== 0)
2720 error (_("requires an argument (function, "
2721 "line or *addr) to define a scope"));
2723 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2724 if (sals
.nelts
== 0)
2725 return; /* Presumably decode_line_1 has already warned. */
2727 /* Resolve line numbers to PC. */
2728 resolve_sal_pc (&sals
.sals
[0]);
2729 block
= block_for_pc (sals
.sals
[0].pc
);
2733 QUIT
; /* Allow user to bail out with ^C. */
2734 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2736 QUIT
; /* Allow user to bail out with ^C. */
2738 printf_filtered ("Scope for %s:\n", save_args
);
2741 symname
= SYMBOL_PRINT_NAME (sym
);
2742 if (symname
== NULL
|| *symname
== '\0')
2743 continue; /* Probably botched, certainly useless. */
2745 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2747 printf_filtered ("Symbol %s is ", symname
);
2749 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2750 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2751 BLOCK_START (block
),
2755 switch (SYMBOL_CLASS (sym
))
2758 case LOC_UNDEF
: /* Messed up symbol? */
2759 printf_filtered ("a bogus symbol, class %d.\n",
2760 SYMBOL_CLASS (sym
));
2761 count
--; /* Don't count this one. */
2764 printf_filtered ("a constant with value %s (%s)",
2765 plongest (SYMBOL_VALUE (sym
)),
2766 hex_string (SYMBOL_VALUE (sym
)));
2768 case LOC_CONST_BYTES
:
2769 printf_filtered ("constant bytes: ");
2770 if (SYMBOL_TYPE (sym
))
2771 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2772 fprintf_filtered (gdb_stdout
, " %02x",
2773 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2776 printf_filtered ("in static storage at address ");
2777 printf_filtered ("%s", paddress (gdbarch
,
2778 SYMBOL_VALUE_ADDRESS (sym
)));
2781 /* GDBARCH is the architecture associated with the objfile
2782 the symbol is defined in; the target architecture may be
2783 different, and may provide additional registers. However,
2784 we do not know the target architecture at this point.
2785 We assume the objfile architecture will contain all the
2786 standard registers that occur in debug info in that
2788 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2791 if (SYMBOL_IS_ARGUMENT (sym
))
2792 printf_filtered ("an argument in register $%s",
2793 gdbarch_register_name (gdbarch
, regno
));
2795 printf_filtered ("a local variable in register $%s",
2796 gdbarch_register_name (gdbarch
, regno
));
2799 printf_filtered ("an argument at stack/frame offset %s",
2800 plongest (SYMBOL_VALUE (sym
)));
2803 printf_filtered ("a local variable at frame offset %s",
2804 plongest (SYMBOL_VALUE (sym
)));
2807 printf_filtered ("a reference argument at offset %s",
2808 plongest (SYMBOL_VALUE (sym
)));
2810 case LOC_REGPARM_ADDR
:
2811 /* Note comment at LOC_REGISTER. */
2812 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2814 printf_filtered ("the address of an argument, in register $%s",
2815 gdbarch_register_name (gdbarch
, regno
));
2818 printf_filtered ("a typedef.\n");
2821 printf_filtered ("a label at address ");
2822 printf_filtered ("%s", paddress (gdbarch
,
2823 SYMBOL_VALUE_ADDRESS (sym
)));
2826 printf_filtered ("a function at address ");
2827 printf_filtered ("%s",
2828 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2830 case LOC_UNRESOLVED
:
2831 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2834 printf_filtered ("Unresolved Static");
2837 printf_filtered ("static storage at address ");
2838 printf_filtered ("%s",
2840 SYMBOL_VALUE_ADDRESS (msym
)));
2843 case LOC_OPTIMIZED_OUT
:
2844 printf_filtered ("optimized out.\n");
2847 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2850 if (SYMBOL_TYPE (sym
))
2851 printf_filtered (", length %d.\n",
2852 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2854 if (BLOCK_FUNCTION (block
))
2857 block
= BLOCK_SUPERBLOCK (block
);
2860 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2864 /* Helper for trace_dump_command. Dump the action list starting at
2865 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2866 actions of the body of a while-stepping action. STEPPING_FRAME is
2867 set if the current traceframe was determined to be a while-stepping
2871 trace_dump_actions (struct command_line
*action
,
2872 int stepping_actions
, int stepping_frame
,
2875 const char *action_exp
, *next_comma
;
2877 for (; action
!= NULL
; action
= action
->next
)
2879 struct cmd_list_element
*cmd
;
2881 QUIT
; /* Allow user to bail out with ^C. */
2882 action_exp
= action
->line
;
2883 action_exp
= skip_spaces_const (action_exp
);
2885 /* The collection actions to be done while stepping are
2886 bracketed by the commands "while-stepping" and "end". */
2888 if (*action_exp
== '#') /* comment line */
2891 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2893 error (_("Bad action list item: %s"), action_exp
);
2895 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2899 for (i
= 0; i
< action
->body_count
; ++i
)
2900 trace_dump_actions (action
->body_list
[i
],
2901 1, stepping_frame
, from_tty
);
2903 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2905 /* Display the collected data.
2906 For the trap frame, display only what was collected at
2907 the trap. Likewise for stepping frames, display only
2908 what was collected while stepping. This means that the
2909 two boolean variables, STEPPING_FRAME and
2910 STEPPING_ACTIONS should be equal. */
2911 if (stepping_frame
== stepping_actions
)
2914 struct cleanup
*old_chain
2915 = make_cleanup (free_current_contents
, &cmd
);
2916 int trace_string
= 0;
2918 if (*action_exp
== '/')
2919 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2922 { /* Repeat over a comma-separated list. */
2923 QUIT
; /* Allow user to bail out with ^C. */
2924 if (*action_exp
== ',')
2926 action_exp
= skip_spaces_const (action_exp
);
2928 next_comma
= strchr (action_exp
, ',');
2930 if (0 == strncasecmp (action_exp
, "$reg", 4))
2931 registers_info (NULL
, from_tty
);
2932 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2934 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2935 locals_info (NULL
, from_tty
);
2936 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2937 args_info (NULL
, from_tty
);
2940 if (next_comma
!= NULL
)
2942 size_t len
= next_comma
- action_exp
;
2944 cmd
= xrealloc (cmd
, len
+ 1);
2945 memcpy (cmd
, action_exp
, len
);
2950 size_t len
= strlen (action_exp
);
2952 cmd
= xrealloc (cmd
, len
+ 1);
2953 memcpy (cmd
, action_exp
, len
+ 1);
2956 printf_filtered ("%s = ", cmd
);
2957 output_command_const (cmd
, from_tty
);
2958 printf_filtered ("\n");
2960 action_exp
= next_comma
;
2962 while (action_exp
&& *action_exp
== ',');
2964 do_cleanups (old_chain
);
2970 /* Return bp_location of the tracepoint associated with the current
2971 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2972 is a stepping traceframe. */
2974 struct bp_location
*
2975 get_traceframe_location (int *stepping_frame_p
)
2977 struct tracepoint
*t
;
2978 struct bp_location
*tloc
;
2979 struct regcache
*regcache
;
2981 if (tracepoint_number
== -1)
2982 error (_("No current trace frame."));
2984 t
= get_tracepoint (tracepoint_number
);
2987 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2990 /* The current frame is a trap frame if the frame PC is equal to the
2991 tracepoint PC. If not, then the current frame was collected
2992 during single-stepping. */
2993 regcache
= get_current_regcache ();
2995 /* If the traceframe's address matches any of the tracepoint's
2996 locations, assume it is a direct hit rather than a while-stepping
2997 frame. (FIXME this is not reliable, should record each frame's
2999 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
3000 if (tloc
->address
== regcache_read_pc (regcache
))
3002 *stepping_frame_p
= 0;
3006 /* If this is a stepping frame, we don't know which location
3007 triggered. The first is as good (or bad) a guess as any... */
3008 *stepping_frame_p
= 1;
3012 /* Return all the actions, including default collect, of a tracepoint
3013 T. It constructs cleanups into the chain, and leaves the caller to
3014 handle them (call do_cleanups). */
3016 static struct command_line
*
3017 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
3019 struct command_line
*actions
;
3021 actions
= breakpoint_commands (t
);
3023 /* If there are default expressions to collect, make up a collect
3024 action and prepend to the action list to encode. Note that since
3025 validation is per-tracepoint (local var "xyz" might be valid for
3026 one tracepoint and not another, etc), we make up the action on
3027 the fly, and don't cache it. */
3028 if (*default_collect
)
3030 struct command_line
*default_collect_action
;
3031 char *default_collect_line
;
3033 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3034 make_cleanup (xfree
, default_collect_line
);
3036 validate_actionline (default_collect_line
, t
);
3037 default_collect_action
= xmalloc (sizeof (struct command_line
));
3038 make_cleanup (xfree
, default_collect_action
);
3039 default_collect_action
->next
= actions
;
3040 default_collect_action
->line
= default_collect_line
;
3041 actions
= default_collect_action
;
3047 /* The tdump command. */
3050 trace_dump_command (char *args
, int from_tty
)
3052 int stepping_frame
= 0;
3053 struct bp_location
*loc
;
3054 struct cleanup
*old_chain
;
3055 struct command_line
*actions
;
3057 /* This throws an error is not inspecting a trace frame. */
3058 loc
= get_traceframe_location (&stepping_frame
);
3060 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3061 tracepoint_number
, traceframe_number
);
3063 old_chain
= make_cleanup (null_cleanup
, NULL
);
3065 /* This command only makes sense for the current frame, not the
3067 make_cleanup_restore_current_thread ();
3068 select_frame (get_current_frame ());
3070 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3072 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3074 do_cleanups (old_chain
);
3077 /* Encode a piece of a tracepoint's source-level definition in a form
3078 that is suitable for both protocol and saving in files. */
3079 /* This version does not do multiple encodes for long strings; it should
3080 return an offset to the next piece to encode. FIXME */
3083 encode_source_string (int tpnum
, ULONGEST addr
,
3084 char *srctype
, char *src
, char *buf
, int buf_size
)
3086 if (80 + strlen (srctype
) > buf_size
)
3087 error (_("Buffer too small for source encoding"));
3088 sprintf (buf
, "%x:%s:%s:%x:%x:",
3089 tpnum
, phex_nz (addr
, sizeof (addr
)),
3090 srctype
, 0, (int) strlen (src
));
3091 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3092 error (_("Source string too long for buffer"));
3093 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3097 /* Free trace file writer. */
3100 trace_file_writer_xfree (void *arg
)
3102 struct trace_file_writer
*writer
= arg
;
3104 writer
->ops
->dtor (writer
);
3108 /* TFILE trace writer. */
3110 struct tfile_trace_file_writer
3112 struct trace_file_writer base
;
3114 /* File pointer to tfile trace file. */
3116 /* Path name of the tfile trace file. */
3120 /* This is the implementation of trace_file_write_ops method
3121 target_save. We just call the generic target
3122 target_save_trace_data to do target-side saving. */
3125 tfile_target_save (struct trace_file_writer
*self
,
3126 const char *filename
)
3128 int err
= target_save_trace_data (filename
);
3133 /* This is the implementation of trace_file_write_ops method
3137 tfile_dtor (struct trace_file_writer
*self
)
3139 struct tfile_trace_file_writer
*writer
3140 = (struct tfile_trace_file_writer
*) self
;
3142 xfree (writer
->pathname
);
3144 if (writer
->fp
!= NULL
)
3145 fclose (writer
->fp
);
3148 /* This is the implementation of trace_file_write_ops method
3149 start. It creates the trace file FILENAME and registers some
3153 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3155 struct tfile_trace_file_writer
*writer
3156 = (struct tfile_trace_file_writer
*) self
;
3158 writer
->pathname
= tilde_expand (filename
);
3159 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3160 if (writer
->fp
== NULL
)
3161 error (_("Unable to open file '%s' for saving trace data (%s)"),
3162 writer
->pathname
, safe_strerror (errno
));
3165 /* This is the implementation of trace_file_write_ops method
3166 write_header. Write the TFILE header. */
3169 tfile_write_header (struct trace_file_writer
*self
)
3171 struct tfile_trace_file_writer
*writer
3172 = (struct tfile_trace_file_writer
*) self
;
3175 /* Write a file header, with a high-bit-set char to indicate a
3176 binary file, plus a hint as what this file is, and a version
3177 number in case of future needs. */
3178 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3180 perror_with_name (writer
->pathname
);
3183 /* This is the implementation of trace_file_write_ops method
3184 write_regblock_type. Write the size of register block. */
3187 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3189 struct tfile_trace_file_writer
*writer
3190 = (struct tfile_trace_file_writer
*) self
;
3192 fprintf (writer
->fp
, "R %x\n", size
);
3195 /* This is the implementation of trace_file_write_ops method
3199 tfile_write_status (struct trace_file_writer
*self
,
3200 struct trace_status
*ts
)
3202 struct tfile_trace_file_writer
*writer
3203 = (struct tfile_trace_file_writer
*) self
;
3205 fprintf (writer
->fp
, "status %c;%s",
3206 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3207 if (ts
->stop_reason
== tracepoint_error
3208 || ts
->stop_reason
== tstop_command
)
3210 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3212 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3213 fprintf (writer
->fp
, ":%s", buf
);
3215 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3216 if (ts
->traceframe_count
>= 0)
3217 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3218 if (ts
->traceframes_created
>= 0)
3219 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3220 if (ts
->buffer_free
>= 0)
3221 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3222 if (ts
->buffer_size
>= 0)
3223 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3224 if (ts
->disconnected_tracing
)
3225 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3226 if (ts
->circular_buffer
)
3227 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3230 fprintf (writer
->fp
, ";starttime:%s",
3231 phex_nz (ts
->start_time
, sizeof (ts
->start_time
)));
3235 fprintf (writer
->fp
, ";stoptime:%s",
3236 phex_nz (ts
->stop_time
, sizeof (ts
->stop_time
)));
3238 if (ts
->notes
!= NULL
)
3240 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3242 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3243 fprintf (writer
->fp
, ";notes:%s", buf
);
3245 if (ts
->user_name
!= NULL
)
3247 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3249 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3250 fprintf (writer
->fp
, ";username:%s", buf
);
3252 fprintf (writer
->fp
, "\n");
3255 /* This is the implementation of trace_file_write_ops method
3256 write_uploaded_tsv. */
3259 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3260 struct uploaded_tsv
*utsv
)
3263 struct tfile_trace_file_writer
*writer
3264 = (struct tfile_trace_file_writer
*) self
;
3268 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3269 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3272 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3273 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3274 utsv
->builtin
, buf
);
3280 #define MAX_TRACE_UPLOAD 2000
3282 /* This is the implementation of trace_file_write_ops method
3283 write_uploaded_tp. */
3286 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3287 struct uploaded_tp
*utp
)
3289 struct tfile_trace_file_writer
*writer
3290 = (struct tfile_trace_file_writer
*) self
;
3293 char buf
[MAX_TRACE_UPLOAD
];
3295 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3296 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3297 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3298 if (utp
->type
== bp_fast_tracepoint
)
3299 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3301 fprintf (writer
->fp
,
3302 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3304 fprintf (writer
->fp
, "\n");
3305 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3306 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3307 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3308 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3309 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3310 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3313 encode_source_string (utp
->number
, utp
->addr
,
3314 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3315 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3317 if (utp
->cond_string
)
3319 encode_source_string (utp
->number
, utp
->addr
,
3320 "cond", utp
->cond_string
,
3321 buf
, MAX_TRACE_UPLOAD
);
3322 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3324 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3326 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3327 buf
, MAX_TRACE_UPLOAD
);
3328 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3330 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3331 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3333 phex_nz (utp
->traceframe_usage
,
3334 sizeof (utp
->traceframe_usage
)));
3337 /* This is the implementation of trace_file_write_ops method
3338 write_definition_end. */
3341 tfile_write_definition_end (struct trace_file_writer
*self
)
3343 struct tfile_trace_file_writer
*writer
3344 = (struct tfile_trace_file_writer
*) self
;
3346 fprintf (writer
->fp
, "\n");
3349 /* This is the implementation of trace_file_write_ops method
3353 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3356 struct tfile_trace_file_writer
*writer
3357 = (struct tfile_trace_file_writer
*) self
;
3359 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3360 perror_with_name (writer
->pathname
);
3363 /* This is the implementation of trace_file_write_ops method
3367 tfile_end (struct trace_file_writer
*self
)
3369 struct tfile_trace_file_writer
*writer
3370 = (struct tfile_trace_file_writer
*) self
;
3371 uint32_t gotten
= 0;
3373 /* Mark the end of trace data. */
3374 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3375 perror_with_name (writer
->pathname
);
3378 /* Operations to write trace buffers into TFILE format. */
3380 static const struct trace_file_write_ops tfile_write_ops
=
3386 tfile_write_regblock_type
,
3388 tfile_write_uploaded_tsv
,
3389 tfile_write_uploaded_tp
,
3390 tfile_write_definition_end
,
3391 tfile_write_raw_data
,
3396 /* Helper macros. */
3398 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3399 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3400 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3401 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3403 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3404 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3406 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3407 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3409 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3410 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3411 the save is performed on the target, otherwise GDB obtains all trace
3412 data and saves it locally. */
3415 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3416 int target_does_save
)
3418 struct trace_status
*ts
= current_trace_status ();
3420 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3421 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3423 ULONGEST offset
= 0;
3424 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3425 #define MAX_TRACE_UPLOAD 2000
3427 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3429 /* If the target is to save the data to a file on its own, then just
3430 send the command and be done with it. */
3431 if (target_does_save
)
3433 if (!writer
->ops
->target_save (writer
, filename
))
3434 error (_("Target failed to save trace data to '%s'."),
3439 /* Get the trace status first before opening the file, so if the
3440 target is losing, we can get out without touching files. */
3441 status
= target_get_trace_status (ts
);
3443 writer
->ops
->start (writer
, filename
);
3445 writer
->ops
->write_header (writer
);
3447 /* Write descriptive info. */
3449 /* Write out the size of a register block. */
3450 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3452 /* Write out status of the tracing run (aka "tstatus" info). */
3453 writer
->ops
->write_status (writer
, ts
);
3455 /* Note that we want to upload tracepoints and save those, rather
3456 than simply writing out the local ones, because the user may have
3457 changed tracepoints in GDB in preparation for a future tracing
3458 run, or maybe just mass-deleted all types of breakpoints as part
3459 of cleaning up. So as not to contaminate the session, leave the
3460 data in its uploaded form, don't make into real tracepoints. */
3462 /* Get trace state variables first, they may be checked when parsing
3463 uploaded commands. */
3465 target_upload_trace_state_variables (&uploaded_tsvs
);
3467 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3468 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3470 free_uploaded_tsvs (&uploaded_tsvs
);
3472 target_upload_tracepoints (&uploaded_tps
);
3474 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3475 target_get_tracepoint_status (NULL
, utp
);
3477 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3478 writer
->ops
->write_uploaded_tp (writer
, utp
);
3480 free_uploaded_tps (&uploaded_tps
);
3482 /* Mark the end of the definition section. */
3483 writer
->ops
->write_definition_end (writer
);
3485 /* Get and write the trace data proper. */
3490 /* The writer supports writing the contents of trace buffer
3491 directly to trace file. Don't parse the contents of trace
3493 if (writer
->ops
->write_trace_buffer
!= NULL
)
3495 /* We ask for big blocks, in the hopes of efficiency, but
3496 will take less if the target has packet size limitations
3498 gotten
= target_get_raw_trace_data (buf
, offset
,
3501 error (_("Failure to get requested trace buffer data"));
3502 /* No more data is forthcoming, we're done. */
3506 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3514 /* Parse the trace buffers according to how data are stored
3515 in trace buffer in GDBserver. */
3517 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3522 /* Read the first six bytes in, which is the tracepoint
3523 number and trace frame size. */
3525 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3527 tf_size
= (uint32_t)
3528 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3530 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3539 for (block
= 0; block
< tf_size
; )
3541 gdb_byte block_type
;
3543 /* We'll fetch one block each time, in order to
3544 handle the extremely large 'M' block. We first
3545 fetch one byte to get the type of the block. */
3546 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3548 error (_("Failure to get requested trace buffer data"));
3554 block_type
= buf
[0];
3559 = target_get_raw_trace_data (buf
, offset
,
3560 trace_regblock_size
);
3561 if (gotten
< trace_regblock_size
)
3562 error (_("Failure to get requested trace"
3565 TRACE_WRITE_R_BLOCK (writer
, buf
,
3566 trace_regblock_size
);
3570 unsigned short mlen
;
3575 t
= target_get_raw_trace_data (buf
,offset
, 10);
3577 error (_("Failure to get requested trace"
3585 extract_unsigned_integer (buf
, 8,
3587 mlen
= (unsigned short)
3588 extract_unsigned_integer (&buf
[8], 2,
3591 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3594 /* The memory contents in 'M' block may be
3595 very large. Fetch the data from the target
3596 and write them into file one by one. */
3597 for (j
= 0; j
< mlen
; )
3599 unsigned int read_length
;
3601 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3602 read_length
= MAX_TRACE_UPLOAD
;
3604 read_length
= mlen
- j
;
3606 t
= target_get_raw_trace_data (buf
,
3609 if (t
< read_length
)
3610 error (_("Failure to get requested"
3611 " trace buffer data"));
3613 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3617 gotten
+= read_length
;
3628 = target_get_raw_trace_data (buf
, offset
,
3631 error (_("Failure to get requested"
3632 " trace buffer data"));
3634 vnum
= (int) extract_signed_integer (buf
,
3638 = extract_signed_integer (&buf
[4], 8,
3641 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3645 error (_("Unknown block type '%c' (0x%x) in"
3647 block_type
, block_type
);
3657 writer
->ops
->frame_ops
->end (writer
);
3661 writer
->ops
->end (writer
);
3664 /* Return a trace writer for TFILE format. */
3666 static struct trace_file_writer
*
3667 tfile_trace_file_writer_new (void)
3669 struct tfile_trace_file_writer
*writer
3670 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3672 writer
->base
.ops
= &tfile_write_ops
;
3674 writer
->pathname
= NULL
;
3676 return (struct trace_file_writer
*) writer
;
3680 trace_save_command (char *args
, int from_tty
)
3682 int target_does_save
= 0;
3684 char *filename
= NULL
;
3685 struct cleanup
*back_to
;
3686 int generate_ctf
= 0;
3687 struct trace_file_writer
*writer
= NULL
;
3690 error_no_arg (_("file in which to save trace data"));
3692 argv
= gdb_buildargv (args
);
3693 back_to
= make_cleanup_freeargv (argv
);
3695 for (; *argv
; ++argv
)
3697 if (strcmp (*argv
, "-r") == 0)
3698 target_does_save
= 1;
3699 if (strcmp (*argv
, "-ctf") == 0)
3701 else if (**argv
== '-')
3702 error (_("unknown option `%s'"), *argv
);
3708 error_no_arg (_("file in which to save trace data"));
3711 writer
= ctf_trace_file_writer_new ();
3713 writer
= tfile_trace_file_writer_new ();
3715 make_cleanup (trace_file_writer_xfree
, writer
);
3717 trace_save (filename
, writer
, target_does_save
);
3720 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3721 generate_ctf
? "directory" : "file", filename
);
3723 do_cleanups (back_to
);
3726 /* Save the trace data to file FILENAME of tfile format. */
3729 trace_save_tfile (const char *filename
, int target_does_save
)
3731 struct trace_file_writer
*writer
;
3732 struct cleanup
*back_to
;
3734 writer
= tfile_trace_file_writer_new ();
3735 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3736 trace_save (filename
, writer
, target_does_save
);
3737 do_cleanups (back_to
);
3740 /* Save the trace data to dir DIRNAME of ctf format. */
3743 trace_save_ctf (const char *dirname
, int target_does_save
)
3745 struct trace_file_writer
*writer
;
3746 struct cleanup
*back_to
;
3748 writer
= ctf_trace_file_writer_new ();
3749 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3751 trace_save (dirname
, writer
, target_does_save
);
3752 do_cleanups (back_to
);
3755 /* Tell the target what to do with an ongoing tracing run if GDB
3756 disconnects for some reason. */
3759 set_disconnected_tracing (char *args
, int from_tty
,
3760 struct cmd_list_element
*c
)
3762 target_set_disconnected_tracing (disconnected_tracing
);
3766 set_circular_trace_buffer (char *args
, int from_tty
,
3767 struct cmd_list_element
*c
)
3769 target_set_circular_trace_buffer (circular_trace_buffer
);
3773 set_trace_buffer_size (char *args
, int from_tty
,
3774 struct cmd_list_element
*c
)
3776 target_set_trace_buffer_size (trace_buffer_size
);
3780 set_trace_user (char *args
, int from_tty
,
3781 struct cmd_list_element
*c
)
3785 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3788 warning (_("Target does not support trace notes, user ignored"));
3792 set_trace_notes (char *args
, int from_tty
,
3793 struct cmd_list_element
*c
)
3797 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3800 warning (_("Target does not support trace notes, note ignored"));
3804 set_trace_stop_notes (char *args
, int from_tty
,
3805 struct cmd_list_element
*c
)
3809 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3812 warning (_("Target does not support trace notes, stop note ignored"));
3815 /* Convert the memory pointed to by mem into hex, placing result in buf.
3816 * Return a pointer to the last char put in buf (null)
3817 * "stolen" from sparc-stub.c
3820 static const char hexchars
[] = "0123456789abcdef";
3823 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3831 *buf
++ = hexchars
[ch
>> 4];
3832 *buf
++ = hexchars
[ch
& 0xf];
3841 get_traceframe_number (void)
3843 return traceframe_number
;
3847 get_tracepoint_number (void)
3849 return tracepoint_number
;
3852 /* Make the traceframe NUM be the current trace frame. Does nothing
3853 if NUM is already current. */
3856 set_current_traceframe (int num
)
3860 if (traceframe_number
== num
)
3862 /* Nothing to do. */
3866 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3869 warning (_("could not change traceframe"));
3871 set_traceframe_num (newnum
);
3873 /* Changing the traceframe changes our view of registers and of the
3875 registers_changed ();
3877 clear_traceframe_info ();
3880 /* Make the traceframe NUM be the current trace frame, and do nothing
3884 set_traceframe_number (int num
)
3886 traceframe_number
= num
;
3889 /* A cleanup used when switching away and back from tfind mode. */
3891 struct current_traceframe_cleanup
3893 /* The traceframe we were inspecting. */
3894 int traceframe_number
;
3898 do_restore_current_traceframe_cleanup (void *arg
)
3900 struct current_traceframe_cleanup
*old
= arg
;
3902 set_current_traceframe (old
->traceframe_number
);
3906 restore_current_traceframe_cleanup_dtor (void *arg
)
3908 struct current_traceframe_cleanup
*old
= arg
;
3914 make_cleanup_restore_current_traceframe (void)
3916 struct current_traceframe_cleanup
*old
;
3918 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3919 old
->traceframe_number
= traceframe_number
;
3921 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3922 restore_current_traceframe_cleanup_dtor
);
3926 make_cleanup_restore_traceframe_number (void)
3928 return make_cleanup_restore_integer (&traceframe_number
);
3931 /* Given a number and address, return an uploaded tracepoint with that
3932 number, creating if necessary. */
3934 struct uploaded_tp
*
3935 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3937 struct uploaded_tp
*utp
;
3939 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3940 if (utp
->number
== num
&& utp
->addr
== addr
)
3942 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3943 memset (utp
, 0, sizeof (struct uploaded_tp
));
3946 utp
->actions
= NULL
;
3947 utp
->step_actions
= NULL
;
3948 utp
->cmd_strings
= NULL
;
3955 free_uploaded_tps (struct uploaded_tp
**utpp
)
3957 struct uploaded_tp
*next_one
;
3961 next_one
= (*utpp
)->next
;
3967 /* Given a number and address, return an uploaded tracepoint with that
3968 number, creating if necessary. */
3970 struct uploaded_tsv
*
3971 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3973 struct uploaded_tsv
*utsv
;
3975 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3976 if (utsv
->number
== num
)
3978 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3979 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3981 utsv
->next
= *utsvp
;
3987 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3989 struct uploaded_tsv
*next_one
;
3993 next_one
= (*utsvp
)->next
;
3999 /* FIXME this function is heuristic and will miss the cases where the
4000 conditional is semantically identical but differs in whitespace,
4001 such as "x == 0" vs "x==0". */
4004 cond_string_is_same (char *str1
, char *str2
)
4006 if (str1
== NULL
|| str2
== NULL
)
4007 return (str1
== str2
);
4009 return (strcmp (str1
, str2
) == 0);
4012 /* Look for an existing tracepoint that seems similar enough to the
4013 uploaded one. Enablement isn't compared, because the user can
4014 toggle that freely, and may have done so in anticipation of the
4015 next trace run. Return the location of matched tracepoint. */
4017 static struct bp_location
*
4018 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
4020 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
4022 struct breakpoint
*b
;
4023 struct bp_location
*loc
;
4025 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
4027 struct tracepoint
*t
= (struct tracepoint
*) b
;
4029 if (b
->type
== utp
->type
4030 && t
->step_count
== utp
->step
4031 && t
->pass_count
== utp
->pass
4032 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
4033 /* FIXME also test actions. */
4036 /* Scan the locations for an address match. */
4037 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4039 if (loc
->address
== utp
->addr
)
4047 /* Given a list of tracepoints uploaded from a target, attempt to
4048 match them up with existing tracepoints, and create new ones if not
4052 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
4054 struct uploaded_tp
*utp
;
4055 /* A set of tracepoints which are modified. */
4056 VEC(breakpoint_p
) *modified_tp
= NULL
;
4058 struct breakpoint
*b
;
4060 /* Look for GDB tracepoints that match up with our uploaded versions. */
4061 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
4063 struct bp_location
*loc
;
4064 struct tracepoint
*t
;
4066 loc
= find_matching_tracepoint_location (utp
);
4071 /* Mark this location as already inserted. */
4073 t
= (struct tracepoint
*) loc
->owner
;
4074 printf_filtered (_("Assuming tracepoint %d is same "
4075 "as target's tracepoint %d at %s.\n"),
4076 loc
->owner
->number
, utp
->number
,
4077 paddress (loc
->gdbarch
, utp
->addr
));
4079 /* The tracepoint LOC->owner was modified (the location LOC
4080 was marked as inserted in the target). Save it in
4081 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4082 observers will be notified later once for each tracepoint
4083 saved in MODIFIED_TP. */
4085 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
4087 if (b
== loc
->owner
)
4093 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
4097 t
= create_tracepoint_from_upload (utp
);
4099 printf_filtered (_("Created tracepoint %d for "
4100 "target's tracepoint %d at %s.\n"),
4101 t
->base
.number
, utp
->number
,
4102 paddress (get_current_arch (), utp
->addr
));
4104 printf_filtered (_("Failed to create tracepoint for target's "
4105 "tracepoint %d at %s, skipping it.\n"),
4107 paddress (get_current_arch (), utp
->addr
));
4109 /* Whether found or created, record the number used by the
4110 target, to help with mapping target tracepoints back to their
4111 counterparts here. */
4113 t
->number_on_target
= utp
->number
;
4116 /* Notify 'breakpoint-modified' observer that at least one of B's
4117 locations was changed. */
4118 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4119 observer_notify_breakpoint_modified (b
);
4121 VEC_free (breakpoint_p
, modified_tp
);
4122 free_uploaded_tps (uploaded_tps
);
4125 /* Trace state variables don't have much to identify them beyond their
4126 name, so just use that to detect matches. */
4128 static struct trace_state_variable
*
4129 find_matching_tsv (struct uploaded_tsv
*utsv
)
4134 return find_trace_state_variable (utsv
->name
);
4137 static struct trace_state_variable
*
4138 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4140 const char *namebase
;
4143 struct trace_state_variable
*tsv
;
4144 struct cleanup
*old_chain
;
4148 namebase
= utsv
->name
;
4149 buf
= xstrprintf ("%s", namebase
);
4154 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4157 /* Fish for a name that is not in use. */
4158 /* (should check against all internal vars?) */
4159 while (find_trace_state_variable (buf
))
4162 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4165 old_chain
= make_cleanup (xfree
, buf
);
4167 /* We have an available name, create the variable. */
4168 tsv
= create_trace_state_variable (buf
);
4169 tsv
->initial_value
= utsv
->initial_value
;
4170 tsv
->builtin
= utsv
->builtin
;
4172 observer_notify_tsv_created (tsv
);
4174 do_cleanups (old_chain
);
4179 /* Given a list of uploaded trace state variables, try to match them
4180 up with existing variables, or create additional ones. */
4183 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4186 struct uploaded_tsv
*utsv
;
4187 struct trace_state_variable
*tsv
;
4190 /* Most likely some numbers will have to be reassigned as part of
4191 the merge, so clear them all in anticipation. */
4192 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4195 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4197 tsv
= find_matching_tsv (utsv
);
4201 printf_filtered (_("Assuming trace state variable $%s "
4202 "is same as target's variable %d.\n"),
4203 tsv
->name
, utsv
->number
);
4207 tsv
= create_tsv_from_upload (utsv
);
4209 printf_filtered (_("Created trace state variable "
4210 "$%s for target's variable %d.\n"),
4211 tsv
->name
, utsv
->number
);
4213 /* Give precedence to numberings that come from the target. */
4215 tsv
->number
= utsv
->number
;
4218 /* Renumber everything that didn't get a target-assigned number. */
4220 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4221 if (tsv
->number
> highest
)
4222 highest
= tsv
->number
;
4225 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4226 if (tsv
->number
== 0)
4227 tsv
->number
= highest
++;
4229 free_uploaded_tsvs (uploaded_tsvs
);
4232 /* target tfile command */
4234 static struct target_ops tfile_ops
;
4236 /* Fill in tfile_ops with its defined operations and properties. */
4238 #define TRACE_HEADER_SIZE 8
4240 static char *trace_filename
;
4241 static int trace_fd
= -1;
4242 static off_t trace_frames_offset
;
4243 static off_t cur_offset
;
4244 static int cur_data_size
;
4245 int trace_regblock_size
;
4247 static void tfile_interp_line (char *line
,
4248 struct uploaded_tp
**utpp
,
4249 struct uploaded_tsv
**utsvp
);
4251 /* Read SIZE bytes into READBUF from the trace frame, starting at
4252 TRACE_FD's current position. Note that this call `read'
4253 underneath, hence it advances the file's seek position. Throws an
4254 error if the `read' syscall fails, or less than SIZE bytes are
4258 tfile_read (gdb_byte
*readbuf
, int size
)
4262 gotten
= read (trace_fd
, readbuf
, size
);
4264 perror_with_name (trace_filename
);
4265 else if (gotten
< size
)
4266 error (_("Premature end of file while reading trace file"));
4270 tfile_open (char *filename
, int from_tty
)
4272 volatile struct gdb_exception ex
;
4274 struct cleanup
*old_chain
;
4277 char header
[TRACE_HEADER_SIZE
];
4278 char linebuf
[1000]; /* Should be max remote packet size or so. */
4281 struct trace_status
*ts
;
4282 struct uploaded_tp
*uploaded_tps
= NULL
;
4283 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4285 target_preopen (from_tty
);
4287 error (_("No trace file specified."));
4289 filename
= tilde_expand (filename
);
4290 if (!IS_ABSOLUTE_PATH(filename
))
4292 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4297 old_chain
= make_cleanup (xfree
, filename
);
4299 flags
= O_BINARY
| O_LARGEFILE
;
4301 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4302 if (scratch_chan
< 0)
4303 perror_with_name (filename
);
4305 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4307 discard_cleanups (old_chain
); /* Don't free filename any more. */
4308 unpush_target (&tfile_ops
);
4310 trace_filename
= xstrdup (filename
);
4311 trace_fd
= scratch_chan
;
4314 /* Read the file header and test for validity. */
4315 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4317 bytes
+= TRACE_HEADER_SIZE
;
4318 if (!(header
[0] == 0x7f
4319 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4320 error (_("File is not a valid trace file."));
4322 push_target (&tfile_ops
);
4324 trace_regblock_size
= 0;
4325 ts
= current_trace_status ();
4326 /* We know we're working with a file. Record its name. */
4327 ts
->filename
= trace_filename
;
4328 /* Set defaults in case there is no status line. */
4329 ts
->running_known
= 0;
4330 ts
->stop_reason
= trace_stop_reason_unknown
;
4331 ts
->traceframe_count
= -1;
4332 ts
->buffer_free
= 0;
4333 ts
->disconnected_tracing
= 0;
4334 ts
->circular_buffer
= 0;
4336 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4338 /* Read through a section of newline-terminated lines that
4339 define things like tracepoints. */
4343 tfile_read (&byte
, 1);
4348 /* Empty line marks end of the definition section. */
4353 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4356 linebuf
[i
++] = byte
;
4358 error (_("Excessively long lines in trace file"));
4361 /* Record the starting offset of the binary trace data. */
4362 trace_frames_offset
= bytes
;
4364 /* If we don't have a blocksize, we can't interpret the
4366 if (trace_regblock_size
== 0)
4367 error (_("No register block size recorded in trace file"));
4371 /* Remove the partially set up target. */
4372 unpush_target (&tfile_ops
);
4373 throw_exception (ex
);
4376 if (ts
->traceframe_count
<= 0)
4377 warning (_("No traceframes present in this file."));
4379 /* Add the file's tracepoints and variables into the current mix. */
4381 /* Get trace state variables first, they may be checked when parsing
4382 uploaded commands. */
4383 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4385 merge_uploaded_tracepoints (&uploaded_tps
);
4388 /* Interpret the given line from the definitions part of the trace
4392 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4393 struct uploaded_tsv
**utsvp
)
4397 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4400 trace_regblock_size
= strtol (p
, &p
, 16);
4402 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4404 p
+= strlen ("status ");
4405 parse_trace_status (p
, current_trace_status ());
4407 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4409 p
+= strlen ("tp ");
4410 parse_tracepoint_definition (p
, utpp
);
4412 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4414 p
+= strlen ("tsv ");
4415 parse_tsv_definition (p
, utsvp
);
4418 warning (_("Ignoring trace file definition \"%s\""), line
);
4421 /* Parse the part of trace status syntax that is shared between
4422 the remote protocol and the trace file reader. */
4425 parse_trace_status (char *line
, struct trace_status
*ts
)
4427 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4431 ts
->running_known
= 1;
4432 ts
->running
= (*p
++ == '1');
4433 ts
->stop_reason
= trace_stop_reason_unknown
;
4434 xfree (ts
->stop_desc
);
4435 ts
->stop_desc
= NULL
;
4436 ts
->traceframe_count
= -1;
4437 ts
->traceframes_created
= -1;
4438 ts
->buffer_free
= -1;
4439 ts
->buffer_size
= -1;
4440 ts
->disconnected_tracing
= 0;
4441 ts
->circular_buffer
= 0;
4442 xfree (ts
->user_name
);
4443 ts
->user_name
= NULL
;
4446 ts
->start_time
= ts
->stop_time
= 0;
4450 p1
= strchr (p
, ':');
4452 error (_("Malformed trace status, at %s\n\
4453 Status line: '%s'\n"), p
, line
);
4454 p3
= strchr (p
, ';');
4456 p3
= p
+ strlen (p
);
4457 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4459 p
= unpack_varlen_hex (++p1
, &val
);
4460 ts
->stop_reason
= trace_buffer_full
;
4462 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4464 p
= unpack_varlen_hex (++p1
, &val
);
4465 ts
->stop_reason
= trace_never_run
;
4467 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4470 p
= unpack_varlen_hex (++p1
, &val
);
4471 ts
->stop_reason
= tracepoint_passcount
;
4472 ts
->stopping_tracepoint
= val
;
4474 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4476 p2
= strchr (++p1
, ':');
4484 ts
->stop_desc
= xmalloc (strlen (line
));
4485 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4486 ts
->stop_desc
[end
] = '\0';
4489 ts
->stop_desc
= xstrdup ("");
4491 p
= unpack_varlen_hex (++p2
, &val
);
4492 ts
->stop_reason
= tstop_command
;
4494 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4496 p
= unpack_varlen_hex (++p1
, &val
);
4497 ts
->stop_reason
= trace_disconnected
;
4499 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4501 p2
= strchr (++p1
, ':');
4504 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4505 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4506 ts
->stop_desc
[end
] = '\0';
4509 ts
->stop_desc
= xstrdup ("");
4511 p
= unpack_varlen_hex (++p2
, &val
);
4512 ts
->stopping_tracepoint
= val
;
4513 ts
->stop_reason
= tracepoint_error
;
4515 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4517 p
= unpack_varlen_hex (++p1
, &val
);
4518 ts
->traceframe_count
= val
;
4520 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4522 p
= unpack_varlen_hex (++p1
, &val
);
4523 ts
->traceframes_created
= val
;
4525 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4527 p
= unpack_varlen_hex (++p1
, &val
);
4528 ts
->buffer_free
= val
;
4530 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4532 p
= unpack_varlen_hex (++p1
, &val
);
4533 ts
->buffer_size
= val
;
4535 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4537 p
= unpack_varlen_hex (++p1
, &val
);
4538 ts
->disconnected_tracing
= val
;
4540 else if (strncmp (p
, "circular", p1
- p
) == 0)
4542 p
= unpack_varlen_hex (++p1
, &val
);
4543 ts
->circular_buffer
= val
;
4545 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4547 p
= unpack_varlen_hex (++p1
, &val
);
4548 ts
->start_time
= val
;
4550 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4552 p
= unpack_varlen_hex (++p1
, &val
);
4553 ts
->stop_time
= val
;
4555 else if (strncmp (p
, "username", p1
- p
) == 0)
4558 ts
->user_name
= xmalloc (strlen (p
) / 2);
4559 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4560 ts
->user_name
[end
] = '\0';
4563 else if (strncmp (p
, "notes", p1
- p
) == 0)
4566 ts
->notes
= xmalloc (strlen (p
) / 2);
4567 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4568 ts
->notes
[end
] = '\0';
4573 /* Silently skip unknown optional info. */
4574 p_temp
= strchr (p1
+ 1, ';');
4578 /* Must be at the end. */
4585 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4586 struct uploaded_tp
*utp
)
4589 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4591 p
= unpack_varlen_hex (p
, &uval
);
4593 tp
->base
.hit_count
+= uval
;
4595 utp
->hit_count
+= uval
;
4596 p
= unpack_varlen_hex (p
+ 1, &uval
);
4598 tp
->traceframe_usage
+= uval
;
4600 utp
->traceframe_usage
+= uval
;
4601 /* Ignore any extra, allowing for future extensions. */
4604 /* Given a line of text defining a part of a tracepoint, parse it into
4605 an "uploaded tracepoint". */
4608 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4612 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4615 char *cond
, *srctype
, *buf
;
4616 struct uploaded_tp
*utp
= NULL
;
4619 /* Both tracepoint and action definitions start with the same number
4620 and address sequence. */
4622 p
= unpack_varlen_hex (p
, &num
);
4623 p
++; /* skip a colon */
4624 p
= unpack_varlen_hex (p
, &addr
);
4625 p
++; /* skip a colon */
4628 enabled
= (*p
++ == 'E');
4629 p
++; /* skip a colon */
4630 p
= unpack_varlen_hex (p
, &step
);
4631 p
++; /* skip a colon */
4632 p
= unpack_varlen_hex (p
, &pass
);
4633 type
= bp_tracepoint
;
4635 /* Thumb through optional fields. */
4638 p
++; /* skip a colon */
4641 type
= bp_fast_tracepoint
;
4643 p
= unpack_varlen_hex (p
, &orig_size
);
4647 type
= bp_static_tracepoint
;
4653 p
= unpack_varlen_hex (p
, &xlen
);
4654 p
++; /* skip a comma */
4655 cond
= (char *) xmalloc (2 * xlen
+ 1);
4656 strncpy (cond
, p
, 2 * xlen
);
4657 cond
[2 * xlen
] = '\0';
4661 warning (_("Unrecognized char '%c' in tracepoint "
4662 "definition, skipping rest"), *p
);
4664 utp
= get_uploaded_tp (num
, addr
, utpp
);
4666 utp
->enabled
= enabled
;
4671 else if (piece
== 'A')
4673 utp
= get_uploaded_tp (num
, addr
, utpp
);
4674 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4676 else if (piece
== 'S')
4678 utp
= get_uploaded_tp (num
, addr
, utpp
);
4679 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4681 else if (piece
== 'Z')
4683 /* Parse a chunk of source form definition. */
4684 utp
= get_uploaded_tp (num
, addr
, utpp
);
4686 p
= strchr (p
, ':');
4687 p
++; /* skip a colon */
4688 p
= unpack_varlen_hex (p
, &start
);
4689 p
++; /* skip a colon */
4690 p
= unpack_varlen_hex (p
, &xlen
);
4691 p
++; /* skip a colon */
4693 buf
= alloca (strlen (line
));
4695 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4698 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4699 utp
->at_string
= xstrdup (buf
);
4700 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4701 utp
->cond_string
= xstrdup (buf
);
4702 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4703 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4705 else if (piece
== 'V')
4707 utp
= get_uploaded_tp (num
, addr
, utpp
);
4709 parse_tracepoint_status (p
, NULL
, utp
);
4713 /* Don't error out, the target might be sending us optional
4714 info that we don't care about. */
4715 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4719 /* Convert a textual description of a trace state variable into an
4723 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4726 ULONGEST num
, initval
, builtin
;
4728 struct uploaded_tsv
*utsv
= NULL
;
4730 buf
= alloca (strlen (line
));
4733 p
= unpack_varlen_hex (p
, &num
);
4734 p
++; /* skip a colon */
4735 p
= unpack_varlen_hex (p
, &initval
);
4736 p
++; /* skip a colon */
4737 p
= unpack_varlen_hex (p
, &builtin
);
4738 p
++; /* skip a colon */
4739 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4742 utsv
= get_uploaded_tsv (num
, utsvp
);
4743 utsv
->initial_value
= initval
;
4744 utsv
->builtin
= builtin
;
4745 utsv
->name
= xstrdup (buf
);
4748 /* Close the trace file and generally clean up. */
4760 xfree (trace_filename
);
4761 trace_filename
= NULL
;
4763 trace_reset_local_state ();
4767 tfile_files_info (struct target_ops
*t
)
4769 printf_filtered ("\t`%s'\n", trace_filename
);
4772 /* The trace status for a file is that tracing can never be run. */
4775 tfile_get_trace_status (struct trace_status
*ts
)
4777 /* Other bits of trace status were collected as part of opening the
4778 trace files, so nothing to do here. */
4784 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4786 /* Other bits of trace status were collected as part of opening the
4787 trace files, so nothing to do here. */
4790 /* Given the position of a traceframe in the file, figure out what
4791 address the frame was collected at. This would normally be the
4792 value of a collected PC register, but if not available, we
4796 tfile_get_traceframe_address (off_t tframe_offset
)
4800 struct tracepoint
*tp
;
4801 off_t saved_offset
= cur_offset
;
4803 /* FIXME dig pc out of collected registers. */
4805 /* Fall back to using tracepoint address. */
4806 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4807 tfile_read ((gdb_byte
*) &tpnum
, 2);
4808 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4810 (target_gdbarch ()));
4812 tp
= get_tracepoint_by_number_on_target (tpnum
);
4813 /* FIXME this is a poor heuristic if multiple locations. */
4814 if (tp
&& tp
->base
.loc
)
4815 addr
= tp
->base
.loc
->address
;
4817 /* Restore our seek position. */
4818 cur_offset
= saved_offset
;
4819 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4823 /* Given a type of search and some parameters, scan the collection of
4824 traceframes in the file looking for a match. When found, return
4825 both the traceframe and tracepoint number, otherwise -1 for
4829 tfile_trace_find (enum trace_find_type type
, int num
,
4830 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4833 int tfnum
= 0, found
= 0;
4834 unsigned int data_size
;
4835 struct tracepoint
*tp
;
4836 off_t offset
, tframe_offset
;
4846 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4847 offset
= trace_frames_offset
;
4850 tframe_offset
= offset
;
4851 tfile_read ((gdb_byte
*) &tpnum
, 2);
4852 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4854 (target_gdbarch ()));
4858 tfile_read ((gdb_byte
*) &data_size
, 4);
4859 data_size
= (unsigned int) extract_unsigned_integer
4860 ((gdb_byte
*) &data_size
, 4,
4861 gdbarch_byte_order (target_gdbarch ()));
4864 if (type
== tfind_number
)
4866 /* Looking for a specific trace frame. */
4872 /* Start from the _next_ trace frame. */
4873 if (tfnum
> traceframe_number
)
4878 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4879 if (tfaddr
== addr1
)
4883 tp
= get_tracepoint (num
);
4884 if (tp
&& tpnum
== tp
->number_on_target
)
4888 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4889 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4893 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4894 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4898 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4907 cur_offset
= offset
;
4908 cur_data_size
= data_size
;
4912 /* Skip past the traceframe's data. */
4913 lseek (trace_fd
, data_size
, SEEK_CUR
);
4914 offset
+= data_size
;
4915 /* Update our own count of traceframes. */
4918 /* Did not find what we were looking for. */
4924 /* Prototype of the callback passed to tframe_walk_blocks. */
4925 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4927 /* Callback for traceframe_walk_blocks, used to find a given block
4928 type in a traceframe. */
4931 match_blocktype (char blocktype
, void *data
)
4933 char *wantedp
= data
;
4935 if (*wantedp
== blocktype
)
4941 /* Walk over all traceframe block starting at POS offset from
4942 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4943 unmodified. If CALLBACK returns true, this returns the position in
4944 the traceframe where the block is found, relative to the start of
4945 the traceframe (cur_offset). Returns -1 if no callback call
4946 returned true, indicating that all blocks have been walked. */
4949 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4950 int pos
, void *data
)
4952 /* Iterate through a traceframe's blocks, looking for a block of the
4955 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4956 while (pos
< cur_data_size
)
4958 unsigned short mlen
;
4961 tfile_read ((gdb_byte
*) &block_type
, 1);
4965 if ((*callback
) (block_type
, data
))
4971 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4972 pos
+= trace_regblock_size
;
4975 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4976 tfile_read ((gdb_byte
*) &mlen
, 2);
4977 mlen
= (unsigned short)
4978 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4980 (target_gdbarch ()));
4981 lseek (trace_fd
, mlen
, SEEK_CUR
);
4982 pos
+= (8 + 2 + mlen
);
4985 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4989 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4990 block_type
, block_type
);
4998 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4999 position offset of a block of type TYPE_WANTED in the current trace
5000 frame, starting at POS. Returns -1 if no such block was found. */
5003 traceframe_find_block_type (char type_wanted
, int pos
)
5005 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
5008 /* Look for a block of saved registers in the traceframe, and get the
5009 requested register from it. */
5012 tfile_fetch_registers (struct target_ops
*ops
,
5013 struct regcache
*regcache
, int regno
)
5015 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
5016 int offset
, regn
, regsize
, pc_regno
;
5019 /* An uninitialized reg size says we're not going to be
5020 successful at getting register blocks. */
5021 if (!trace_regblock_size
)
5024 regs
= alloca (trace_regblock_size
);
5026 if (traceframe_find_block_type ('R', 0) >= 0)
5028 tfile_read (regs
, trace_regblock_size
);
5030 /* Assume the block is laid out in GDB register number order,
5031 each register with the size that it has in GDB. */
5033 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5035 regsize
= register_size (gdbarch
, regn
);
5036 /* Make sure we stay within block bounds. */
5037 if (offset
+ regsize
>= trace_regblock_size
)
5039 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
5043 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
5046 else if (regno
== -1)
5048 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
5056 /* We get here if no register data has been found. Mark registers
5058 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5059 regcache_raw_supply (regcache
, regn
, NULL
);
5061 /* We can often usefully guess that the PC is going to be the same
5062 as the address of the tracepoint. */
5063 pc_regno
= gdbarch_pc_regnum (gdbarch
);
5064 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
5066 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
5068 if (tp
&& tp
->base
.loc
)
5070 /* But don't try to guess if tracepoint is multi-location... */
5071 if (tp
->base
.loc
->next
)
5073 warning (_("Tracepoint %d has multiple "
5074 "locations, cannot infer $pc"),
5078 /* ... or does while-stepping. */
5079 if (tp
->step_count
> 0)
5081 warning (_("Tracepoint %d does while-stepping, "
5082 "cannot infer $pc"),
5087 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
5088 gdbarch_byte_order (gdbarch
),
5089 tp
->base
.loc
->address
);
5090 regcache_raw_supply (regcache
, pc_regno
, regs
);
5096 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5097 const char *annex
, gdb_byte
*readbuf
,
5098 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5100 /* We're only doing regular memory for now. */
5101 if (object
!= TARGET_OBJECT_MEMORY
)
5104 if (readbuf
== NULL
)
5105 error (_("tfile_xfer_partial: trace file is read-only"));
5107 if (traceframe_number
!= -1)
5111 /* Iterate through the traceframe's blocks, looking for
5113 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5115 ULONGEST maddr
, amt
;
5116 unsigned short mlen
;
5117 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5119 tfile_read ((gdb_byte
*) &maddr
, 8);
5120 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5122 tfile_read ((gdb_byte
*) &mlen
, 2);
5123 mlen
= (unsigned short)
5124 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5126 /* If the block includes the first part of the desired
5127 range, return as much it has; GDB will re-request the
5128 remainder, which might be in a different block of this
5130 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5132 amt
= (maddr
+ mlen
) - offset
;
5136 if (maddr
!= offset
)
5137 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5138 tfile_read (readbuf
, amt
);
5142 /* Skip over this block. */
5143 pos
+= (8 + 2 + mlen
);
5147 /* It's unduly pedantic to refuse to look at the executable for
5148 read-only pieces; so do the equivalent of readonly regions aka
5150 /* FIXME account for relocation at some point. */
5157 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5159 if ((s
->flags
& SEC_LOAD
) == 0
5160 || (s
->flags
& SEC_READONLY
) == 0)
5164 size
= bfd_get_section_size (s
);
5165 if (vma
<= offset
&& offset
< (vma
+ size
))
5169 amt
= (vma
+ size
) - offset
;
5173 amt
= bfd_get_section_contents (exec_bfd
, s
,
5174 readbuf
, offset
- vma
, amt
);
5180 /* Indicate failure to find the requested memory block. */
5184 /* Iterate through the blocks of a trace frame, looking for a 'V'
5185 block with a matching tsv number. */
5188 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5193 /* Iterate over blocks in current frame and find the last 'V'
5194 block in which tsv number is TSVNUM. In one trace frame, there
5195 may be multiple 'V' blocks created for a given trace variable,
5196 and the last matched 'V' block contains the updated value. */
5198 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5202 tfile_read ((gdb_byte
*) &vnum
, 4);
5203 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5205 (target_gdbarch ()));
5208 tfile_read ((gdb_byte
*) val
, 8);
5209 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5211 (target_gdbarch ()));
5221 tfile_has_all_memory (struct target_ops
*ops
)
5227 tfile_has_memory (struct target_ops
*ops
)
5233 tfile_has_stack (struct target_ops
*ops
)
5235 return traceframe_number
!= -1;
5239 tfile_has_registers (struct target_ops
*ops
)
5241 return traceframe_number
!= -1;
5244 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5245 object for the tfile target's current traceframe. */
5248 build_traceframe_info (char blocktype
, void *data
)
5250 struct traceframe_info
*info
= data
;
5256 struct mem_range
*r
;
5258 unsigned short mlen
;
5260 tfile_read ((gdb_byte
*) &maddr
, 8);
5261 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5263 (target_gdbarch ()));
5264 tfile_read ((gdb_byte
*) &mlen
, 2);
5265 mlen
= (unsigned short)
5266 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5267 2, gdbarch_byte_order
5268 (target_gdbarch ()));
5270 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5280 tfile_read ((gdb_byte
*) &vnum
, 4);
5281 VEC_safe_push (int, info
->tvars
, vnum
);
5289 warning (_("Unhandled trace block type (%d) '%c ' "
5290 "while building trace frame info."),
5291 blocktype
, blocktype
);
5298 static struct traceframe_info
*
5299 tfile_traceframe_info (void)
5301 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5303 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5308 init_tfile_ops (void)
5310 tfile_ops
.to_shortname
= "tfile";
5311 tfile_ops
.to_longname
= "Local trace dump file";
5313 = "Use a trace file as a target. Specify the filename of the trace file.";
5314 tfile_ops
.to_open
= tfile_open
;
5315 tfile_ops
.to_close
= tfile_close
;
5316 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5317 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5318 tfile_ops
.to_files_info
= tfile_files_info
;
5319 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5320 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5321 tfile_ops
.to_trace_find
= tfile_trace_find
;
5322 tfile_ops
.to_get_trace_state_variable_value
5323 = tfile_get_trace_state_variable_value
;
5324 tfile_ops
.to_stratum
= process_stratum
;
5325 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5326 tfile_ops
.to_has_memory
= tfile_has_memory
;
5327 tfile_ops
.to_has_stack
= tfile_has_stack
;
5328 tfile_ops
.to_has_registers
= tfile_has_registers
;
5329 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5330 tfile_ops
.to_magic
= OPS_MAGIC
;
5334 free_current_marker (void *arg
)
5336 struct static_tracepoint_marker
**marker_p
= arg
;
5338 if (*marker_p
!= NULL
)
5340 release_static_tracepoint_marker (*marker_p
);
5347 /* Given a line of text defining a static tracepoint marker, parse it
5348 into a "static tracepoint marker" object. Throws an error is
5349 parsing fails. If PP is non-null, it points to one past the end of
5350 the parsed marker definition. */
5353 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5354 struct static_tracepoint_marker
*marker
)
5361 p
= unpack_varlen_hex (p
, &addr
);
5362 p
++; /* skip a colon */
5364 marker
->gdbarch
= target_gdbarch ();
5365 marker
->address
= (CORE_ADDR
) addr
;
5367 endp
= strchr (p
, ':');
5369 error (_("bad marker definition: %s"), line
);
5371 marker
->str_id
= xmalloc (endp
- p
+ 1);
5372 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5373 marker
->str_id
[end
] = '\0';
5376 p
++; /* skip a colon */
5378 marker
->extra
= xmalloc (strlen (p
) + 1);
5379 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5380 marker
->extra
[end
] = '\0';
5386 /* Release a static tracepoint marker's contents. Note that the
5387 object itself isn't released here. There objects are usually on
5391 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5393 xfree (marker
->str_id
);
5394 marker
->str_id
= NULL
;
5397 /* Print MARKER to gdb_stdout. */
5400 print_one_static_tracepoint_marker (int count
,
5401 struct static_tracepoint_marker
*marker
)
5403 struct command_line
*l
;
5406 char wrap_indent
[80];
5407 char extra_field_indent
[80];
5408 struct ui_out
*uiout
= current_uiout
;
5409 struct cleanup
*bkpt_chain
;
5410 VEC(breakpoint_p
) *tracepoints
;
5412 struct symtab_and_line sal
;
5416 sal
.pc
= marker
->address
;
5418 tracepoints
= static_tracepoints_here (marker
->address
);
5420 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5422 /* A counter field to help readability. This is not a stable
5424 ui_out_field_int (uiout
, "count", count
);
5426 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5428 ui_out_field_fmt (uiout
, "enabled", "%c",
5429 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5430 ui_out_spaces (uiout
, 2);
5432 strcpy (wrap_indent
, " ");
5434 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5435 strcat (wrap_indent
, " ");
5437 strcat (wrap_indent
, " ");
5439 strcpy (extra_field_indent
, " ");
5441 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5443 sal
= find_pc_line (marker
->address
, 0);
5444 sym
= find_pc_sect_function (marker
->address
, NULL
);
5447 ui_out_text (uiout
, "in ");
5448 ui_out_field_string (uiout
, "func",
5449 SYMBOL_PRINT_NAME (sym
));
5450 ui_out_wrap_hint (uiout
, wrap_indent
);
5451 ui_out_text (uiout
, " at ");
5454 ui_out_field_skip (uiout
, "func");
5456 if (sal
.symtab
!= NULL
)
5458 ui_out_field_string (uiout
, "file",
5459 symtab_to_filename_for_display (sal
.symtab
));
5460 ui_out_text (uiout
, ":");
5462 if (ui_out_is_mi_like_p (uiout
))
5464 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5466 ui_out_field_string (uiout
, "fullname", fullname
);
5469 ui_out_field_skip (uiout
, "fullname");
5471 ui_out_field_int (uiout
, "line", sal
.line
);
5475 ui_out_field_skip (uiout
, "fullname");
5476 ui_out_field_skip (uiout
, "line");
5479 ui_out_text (uiout
, "\n");
5480 ui_out_text (uiout
, extra_field_indent
);
5481 ui_out_text (uiout
, _("Data: \""));
5482 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5483 ui_out_text (uiout
, "\"\n");
5485 if (!VEC_empty (breakpoint_p
, tracepoints
))
5487 struct cleanup
*cleanup_chain
;
5489 struct breakpoint
*b
;
5491 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5494 ui_out_text (uiout
, extra_field_indent
);
5495 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5496 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5499 ui_out_text (uiout
, ", ");
5500 ui_out_text (uiout
, "#");
5501 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5504 do_cleanups (cleanup_chain
);
5506 if (ui_out_is_mi_like_p (uiout
))
5507 ui_out_field_int (uiout
, "number-of-tracepoints",
5508 VEC_length(breakpoint_p
, tracepoints
));
5510 ui_out_text (uiout
, "\n");
5512 VEC_free (breakpoint_p
, tracepoints
);
5514 do_cleanups (bkpt_chain
);
5518 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5520 VEC(static_tracepoint_marker_p
) *markers
;
5521 struct cleanup
*old_chain
;
5522 struct static_tracepoint_marker
*marker
;
5523 struct ui_out
*uiout
= current_uiout
;
5526 /* We don't have to check target_can_use_agent and agent's capability on
5527 static tracepoint here, in order to be compatible with older GDBserver.
5528 We don't check USE_AGENT is true or not, because static tracepoints
5529 don't work without in-process agent, so we don't bother users to type
5530 `set agent on' when to use static tracepoint. */
5533 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5534 "StaticTracepointMarkersTable");
5536 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5538 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5540 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5541 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5542 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5544 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5545 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5547 ui_out_table_body (uiout
);
5549 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5550 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5553 VEC_iterate (static_tracepoint_marker_p
,
5554 markers
, i
, marker
);
5557 print_one_static_tracepoint_marker (i
+ 1, marker
);
5558 release_static_tracepoint_marker (marker
);
5561 do_cleanups (old_chain
);
5564 /* The $_sdata convenience variable is a bit special. We don't know
5565 for sure type of the value until we actually have a chance to fetch
5566 the data --- the size of the object depends on what has been
5567 collected. We solve this by making $_sdata be an internalvar that
5568 creates a new value on access. */
5570 /* Return a new value with the correct type for the sdata object of
5571 the current trace frame. Return a void value if there's no object
5574 static struct value
*
5575 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5581 /* We need to read the whole object before we know its size. */
5582 size
= target_read_alloc (¤t_target
,
5583 TARGET_OBJECT_STATIC_TRACE_DATA
,
5590 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5592 v
= allocate_value (type
);
5593 memcpy (value_contents_raw (v
), buf
, size
);
5598 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5601 #if !defined(HAVE_LIBEXPAT)
5603 struct traceframe_info
*
5604 parse_traceframe_info (const char *tframe_info
)
5606 static int have_warned
;
5611 warning (_("Can not parse XML trace frame info; XML support "
5612 "was disabled at compile time"));
5618 #else /* HAVE_LIBEXPAT */
5620 #include "xml-support.h"
5622 /* Handle the start of a <memory> element. */
5625 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5626 const struct gdb_xml_element
*element
,
5627 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5629 struct traceframe_info
*info
= user_data
;
5630 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5631 ULONGEST
*start_p
, *length_p
;
5633 start_p
= xml_find_attribute (attributes
, "start")->value
;
5634 length_p
= xml_find_attribute (attributes
, "length")->value
;
5636 r
->start
= *start_p
;
5637 r
->length
= *length_p
;
5640 /* Handle the start of a <tvar> element. */
5643 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
5644 const struct gdb_xml_element
*element
,
5646 VEC(gdb_xml_value_s
) *attributes
)
5648 struct traceframe_info
*info
= user_data
;
5649 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
5650 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
5652 VEC_safe_push (int, info
->tvars
, id
);
5655 /* Discard the constructed trace frame info (if an error occurs). */
5658 free_result (void *p
)
5660 struct traceframe_info
*result
= p
;
5662 free_traceframe_info (result
);
5665 /* The allowed elements and attributes for an XML memory map. */
5667 static const struct gdb_xml_attribute memory_attributes
[] = {
5668 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5669 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5670 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5673 static const struct gdb_xml_attribute tvar_attributes
[] = {
5674 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
5675 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5678 static const struct gdb_xml_element traceframe_info_children
[] = {
5679 { "memory", memory_attributes
, NULL
,
5680 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5681 traceframe_info_start_memory
, NULL
},
5682 { "tvar", tvar_attributes
, NULL
,
5683 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5684 traceframe_info_start_tvar
, NULL
},
5685 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5688 static const struct gdb_xml_element traceframe_info_elements
[] = {
5689 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5691 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5694 /* Parse a traceframe-info XML document. */
5696 struct traceframe_info
*
5697 parse_traceframe_info (const char *tframe_info
)
5699 struct traceframe_info
*result
;
5700 struct cleanup
*back_to
;
5702 result
= XCNEW (struct traceframe_info
);
5703 back_to
= make_cleanup (free_result
, result
);
5705 if (gdb_xml_parse_quick (_("trace frame info"),
5706 "traceframe-info.dtd", traceframe_info_elements
,
5707 tframe_info
, result
) == 0)
5709 /* Parsed successfully, keep the result. */
5710 discard_cleanups (back_to
);
5715 do_cleanups (back_to
);
5719 #endif /* HAVE_LIBEXPAT */
5721 /* Returns the traceframe_info object for the current traceframe.
5722 This is where we avoid re-fetching the object from the target if we
5723 already have it cached. */
5725 struct traceframe_info
*
5726 get_traceframe_info (void)
5728 if (traceframe_info
== NULL
)
5729 traceframe_info
= target_traceframe_info ();
5731 return traceframe_info
;
5734 /* If the target supports the query, return in RESULT the set of
5735 collected memory in the current traceframe, found within the LEN
5736 bytes range starting at MEMADDR. Returns true if the target
5737 supports the query, otherwise returns false, and RESULT is left
5741 traceframe_available_memory (VEC(mem_range_s
) **result
,
5742 CORE_ADDR memaddr
, ULONGEST len
)
5744 struct traceframe_info
*info
= get_traceframe_info ();
5748 struct mem_range
*r
;
5753 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5754 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5756 ULONGEST lo1
, hi1
, lo2
, hi2
;
5757 struct mem_range
*nr
;
5760 hi1
= memaddr
+ len
;
5763 hi2
= r
->start
+ r
->length
;
5765 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5767 nr
->start
= max (lo1
, lo2
);
5768 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5771 normalize_mem_ranges (*result
);
5778 /* Implementation of `sdata' variable. */
5780 static const struct internalvar_funcs sdata_funcs
=
5787 /* module initialization */
5789 _initialize_tracepoint (void)
5791 struct cmd_list_element
*c
;
5793 /* Explicitly create without lookup, since that tries to create a
5794 value with a void typed value, and when we get here, gdbarch
5795 isn't initialized yet. At this point, we're quite sure there
5796 isn't another convenience variable of the same name. */
5797 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5799 traceframe_number
= -1;
5800 tracepoint_number
= -1;
5802 add_info ("scope", scope_info
,
5803 _("List the variables local to a scope"));
5805 add_cmd ("tracepoints", class_trace
, NULL
,
5806 _("Tracing of program execution without stopping the program."),
5809 add_com ("tdump", class_trace
, trace_dump_command
,
5810 _("Print everything collected at the current tracepoint."));
5812 add_com ("tsave", class_trace
, trace_save_command
, _("\
5813 Save the trace data to a file.\n\
5814 Use the '-ctf' option to save the data to CTF format.\n\
5815 Use the '-r' option to direct the target to save directly to the file,\n\
5816 using its own filesystem."));
5818 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5819 Define a trace state variable.\n\
5820 Argument is a $-prefixed name, optionally followed\n\
5821 by '=' and an expression that sets the initial value\n\
5822 at the start of tracing."));
5823 set_cmd_completer (c
, expression_completer
);
5825 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5826 Delete one or more trace state variables.\n\
5827 Arguments are the names of the variables to delete.\n\
5828 If no arguments are supplied, delete all variables."), &deletelist
);
5829 /* FIXME add a trace variable completer. */
5831 add_info ("tvariables", tvariables_info
, _("\
5832 Status of trace state variables and their values.\n\
5835 add_info ("static-tracepoint-markers",
5836 info_static_tracepoint_markers_command
, _("\
5837 List target static tracepoints markers.\n\
5840 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5841 Select a trace frame;\n\
5842 No argument means forward by one frame; '-' means backward by one frame."),
5843 &tfindlist
, "tfind ", 1, &cmdlist
);
5845 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5846 Select a trace frame whose PC is outside the given range (exclusive).\n\
5847 Usage: tfind outside addr1, addr2"),
5850 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5851 Select a trace frame whose PC is in the given range (inclusive).\n\
5852 Usage: tfind range addr1,addr2"),
5855 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5856 Select a trace frame by source line.\n\
5857 Argument can be a line number (with optional source file),\n\
5858 a function name, or '*' followed by an address.\n\
5859 Default argument is 'the next source line that was traced'."),
5862 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5863 Select a trace frame by tracepoint number.\n\
5864 Default is the tracepoint for the current trace frame."),
5867 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5868 Select a trace frame by PC.\n\
5869 Default is the current PC, or the PC of the current trace frame."),
5872 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5873 De-select any trace frame and resume 'live' debugging."),
5876 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5878 add_cmd ("start", class_trace
, trace_find_start_command
,
5879 _("Select the first trace frame in the trace buffer."),
5882 add_com ("tstatus", class_trace
, trace_status_command
,
5883 _("Display the status of the current trace data collection."));
5885 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5886 Stop trace data collection.\n\
5887 Usage: tstop [ <notes> ... ]\n\
5888 Any arguments supplied are recorded with the trace as a stop reason and\n\
5889 reported by tstatus (if the target supports trace notes)."));
5891 add_com ("tstart", class_trace
, trace_start_command
, _("\
5892 Start trace data collection.\n\
5893 Usage: tstart [ <notes> ... ]\n\
5894 Any arguments supplied are recorded with the trace as a note and\n\
5895 reported by tstatus (if the target supports trace notes)."));
5897 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5898 Ends a list of commands or actions.\n\
5899 Several GDB commands allow you to enter a list of commands or actions.\n\
5900 Entering \"end\" on a line by itself is the normal way to terminate\n\
5902 Note: the \"end\" command cannot be used at the gdb prompt."));
5904 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5905 Specify single-stepping behavior at a tracepoint.\n\
5906 Argument is number of instructions to trace in single-step mode\n\
5907 following the tracepoint. This command is normally followed by\n\
5908 one or more \"collect\" commands, to specify what to collect\n\
5909 while single-stepping.\n\n\
5910 Note: this command can only be used in a tracepoint \"actions\" list."));
5912 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5913 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5915 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5916 Specify one or more data items to be collected at a tracepoint.\n\
5917 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5918 collect all data (variables, registers) referenced by that expression.\n\
5919 Also accepts the following special arguments:\n\
5920 $regs -- all registers.\n\
5921 $args -- all function arguments.\n\
5922 $locals -- all variables local to the block/function scope.\n\
5923 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5924 Note: this command can only be used in a tracepoint \"actions\" list."));
5926 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5927 Specify one or more expressions to be evaluated at a tracepoint.\n\
5928 Accepts a comma-separated list of (one or more) expressions.\n\
5929 The result of each evaluation will be discarded.\n\
5930 Note: this command can only be used in a tracepoint \"actions\" list."));
5932 add_com ("actions", class_trace
, trace_actions_command
, _("\
5933 Specify the actions to be taken at a tracepoint.\n\
5934 Tracepoint actions may include collecting of specified data,\n\
5935 single-stepping, or enabling/disabling other tracepoints,\n\
5936 depending on target's capabilities."));
5938 default_collect
= xstrdup ("");
5939 add_setshow_string_cmd ("default-collect", class_trace
,
5940 &default_collect
, _("\
5941 Set the list of expressions to collect by default"), _("\
5942 Show the list of expressions to collect by default"), NULL
,
5944 &setlist
, &showlist
);
5946 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5947 &disconnected_tracing
, _("\
5948 Set whether tracing continues after GDB disconnects."), _("\
5949 Show whether tracing continues after GDB disconnects."), _("\
5950 Use this to continue a tracing run even if GDB disconnects\n\
5951 or detaches from the target. You can reconnect later and look at\n\
5952 trace data collected in the meantime."),
5953 set_disconnected_tracing
,
5958 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5959 &circular_trace_buffer
, _("\
5960 Set target's use of circular trace buffer."), _("\
5961 Show target's use of circular trace buffer."), _("\
5962 Use this to make the trace buffer into a circular buffer,\n\
5963 which will discard traceframes (oldest first) instead of filling\n\
5964 up and stopping the trace run."),
5965 set_circular_trace_buffer
,
5970 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5971 &trace_buffer_size
, _("\
5972 Set requested size of trace buffer."), _("\
5973 Show requested size of trace buffer."), _("\
5974 Use this to choose a size for the trace buffer. Some targets\n\
5975 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5976 disables any attempt to set the buffer size and lets the target choose."),
5977 set_trace_buffer_size
, NULL
,
5978 &setlist
, &showlist
);
5980 add_setshow_string_cmd ("trace-user", class_trace
,
5982 Set the user name to use for current and future trace runs"), _("\
5983 Show the user name to use for current and future trace runs"), NULL
,
5984 set_trace_user
, NULL
,
5985 &setlist
, &showlist
);
5987 add_setshow_string_cmd ("trace-notes", class_trace
,
5989 Set notes string to use for current and future trace runs"), _("\
5990 Show the notes string to use for current and future trace runs"), NULL
,
5991 set_trace_notes
, NULL
,
5992 &setlist
, &showlist
);
5994 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5995 &trace_stop_notes
, _("\
5996 Set notes string to use for future tstop commands"), _("\
5997 Show the notes string to use for future tstop commands"), NULL
,
5998 set_trace_stop_notes
, NULL
,
5999 &setlist
, &showlist
);
6003 add_target_with_completer (&tfile_ops
, filename_completer
);