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"
59 /* readline include files */
60 #include "readline/readline.h"
61 #include "readline/history.h"
63 /* readline defines this. */
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
86 /* A hook used to notify the UI of tracepoint operations. */
88 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
89 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
91 extern void (*deprecated_readline_begin_hook
) (char *, ...);
92 extern char *(*deprecated_readline_hook
) (char *);
93 extern void (*deprecated_readline_end_hook
) (void);
98 This module defines the following debugger commands:
99 trace : set a tracepoint on a function, line, or address.
100 info trace : list all debugger-defined tracepoints.
101 delete trace : delete one or more tracepoints.
102 enable trace : enable one or more tracepoints.
103 disable trace : disable one or more tracepoints.
104 actions : specify actions to be taken at a tracepoint.
105 passcount : specify a pass count for a tracepoint.
106 tstart : start a trace experiment.
107 tstop : stop a trace experiment.
108 tstatus : query the status of a trace experiment.
109 tfind : find a trace frame in the trace buffer.
110 tdump : print everything collected at the current tracepoint.
111 save-tracepoints : write tracepoint setup into a file.
113 This module defines the following user-visible debugger variables:
114 $trace_frame : sequence number of trace frame currently being debugged.
115 $trace_line : source line of trace frame currently being debugged.
116 $trace_file : source file of trace frame currently being debugged.
117 $tracepoint : tracepoint number of trace frame currently being debugged.
121 /* ======= Important global variables: ======= */
123 /* The list of all trace state variables. We don't retain pointers to
124 any of these for any reason - API is by name or number only - so it
125 works to have a vector of objects. */
127 typedef struct trace_state_variable tsv_s
;
130 /* An object describing the contents of a traceframe. */
132 struct traceframe_info
134 /* Collected memory. */
135 VEC(mem_range_s
) *memory
;
138 static VEC(tsv_s
) *tvariables
;
140 /* The next integer to assign to a variable. */
142 static int next_tsv_number
= 1;
144 /* Number of last traceframe collected. */
145 static int traceframe_number
;
147 /* Tracepoint for last traceframe collected. */
148 static int tracepoint_number
;
150 /* Symbol for function for last traceframe collected. */
151 static struct symbol
*traceframe_fun
;
153 /* Symtab and line for last traceframe collected. */
154 static struct symtab_and_line traceframe_sal
;
156 /* The traceframe info of the current traceframe. NULL if we haven't
157 yet attempted to fetch it, or if the target does not support
158 fetching this object, or if we're not inspecting a traceframe
160 static struct traceframe_info
*traceframe_info
;
162 /* Tracing command lists. */
163 static struct cmd_list_element
*tfindlist
;
165 /* List of expressions to collect by default at each tracepoint hit. */
166 char *default_collect
= "";
168 static int disconnected_tracing
;
170 /* This variable controls whether we ask the target for a linear or
171 circular trace buffer. */
173 static int circular_trace_buffer
;
175 /* This variable is the requested trace buffer size, or -1 to indicate
176 that we don't care and leave it up to the target to set a size. */
178 static int trace_buffer_size
= -1;
180 /* Textual notes applying to the current and/or future trace runs. */
182 char *trace_user
= NULL
;
184 /* Textual notes applying to the current and/or future trace runs. */
186 char *trace_notes
= NULL
;
188 /* Textual notes applying to the stopping of a trace. */
190 char *trace_stop_notes
= NULL
;
192 /* ======= Important command functions: ======= */
193 static void trace_actions_command (char *, int);
194 static void trace_start_command (char *, int);
195 static void trace_stop_command (char *, int);
196 static void trace_status_command (char *, int);
197 static void trace_find_command (char *, int);
198 static void trace_find_pc_command (char *, int);
199 static void trace_find_tracepoint_command (char *, int);
200 static void trace_find_line_command (char *, int);
201 static void trace_find_range_command (char *, int);
202 static void trace_find_outside_command (char *, int);
203 static void trace_dump_command (char *, int);
205 /* support routines */
207 struct collection_list
;
208 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
209 static char *mem2hex (gdb_byte
*, char *, int);
210 static void add_register (struct collection_list
*collection
,
213 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
214 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
217 extern void _initialize_tracepoint (void);
219 static struct trace_status trace_status
;
221 char *stop_reason_names
[] = {
231 struct trace_status
*
232 current_trace_status (void)
234 return &trace_status
;
240 free_traceframe_info (struct traceframe_info
*info
)
244 VEC_free (mem_range_s
, info
->memory
);
250 /* Free and clear the traceframe info cache of the current
254 clear_traceframe_info (void)
256 free_traceframe_info (traceframe_info
);
257 traceframe_info
= NULL
;
260 /* Set traceframe number to NUM. */
262 set_traceframe_num (int num
)
264 traceframe_number
= num
;
265 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
268 /* Set tracepoint number to NUM. */
270 set_tracepoint_num (int num
)
272 tracepoint_number
= num
;
273 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
276 /* Set externally visible debug variables for querying/printing
277 the traceframe context (line, function, file). */
280 set_traceframe_context (struct frame_info
*trace_frame
)
284 /* Save as globals for internal use. */
285 if (trace_frame
!= NULL
286 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
288 traceframe_sal
= find_pc_line (trace_pc
, 0);
289 traceframe_fun
= find_pc_function (trace_pc
);
291 /* Save linenumber as "$trace_line", a debugger variable visible to
293 set_internalvar_integer (lookup_internalvar ("trace_line"),
294 traceframe_sal
.line
);
298 init_sal (&traceframe_sal
);
299 traceframe_fun
= NULL
;
300 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
303 /* Save func name as "$trace_func", a debugger variable visible to
305 if (traceframe_fun
== NULL
306 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
307 clear_internalvar (lookup_internalvar ("trace_func"));
309 set_internalvar_string (lookup_internalvar ("trace_func"),
310 SYMBOL_LINKAGE_NAME (traceframe_fun
));
312 /* Save file name as "$trace_file", a debugger variable visible to
314 if (traceframe_sal
.symtab
== NULL
)
315 clear_internalvar (lookup_internalvar ("trace_file"));
317 set_internalvar_string (lookup_internalvar ("trace_file"),
318 symtab_to_filename_for_display (traceframe_sal
.symtab
));
321 /* Create a new trace state variable with the given name. */
323 struct trace_state_variable
*
324 create_trace_state_variable (const char *name
)
326 struct trace_state_variable tsv
;
328 memset (&tsv
, 0, sizeof (tsv
));
329 tsv
.name
= xstrdup (name
);
330 tsv
.number
= next_tsv_number
++;
331 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
334 /* Look for a trace state variable of the given name. */
336 struct trace_state_variable
*
337 find_trace_state_variable (const char *name
)
339 struct trace_state_variable
*tsv
;
342 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
343 if (strcmp (name
, tsv
->name
) == 0)
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
864 int type
; /* memrange_absolute for absolute memory range,
865 else basereg number. */
866 bfd_signed_vma start
;
870 struct collection_list
872 unsigned char regs_mask
[32]; /* room for up to 256 regs */
875 struct memrange
*list
;
876 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
878 struct agent_expr
**aexpr_list
;
880 /* True is the user requested a collection of "$_sdata", "static
884 tracepoint_list
, stepping_list
;
886 /* MEMRANGE functions: */
888 static int memrange_cmp (const void *, const void *);
890 /* Compare memranges for qsort. */
892 memrange_cmp (const void *va
, const void *vb
)
894 const struct memrange
*a
= va
, *b
= vb
;
896 if (a
->type
< b
->type
)
898 if (a
->type
> b
->type
)
900 if (a
->type
== memrange_absolute
)
902 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
904 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
909 if (a
->start
< b
->start
)
911 if (a
->start
> b
->start
)
917 /* Sort the memrange list using qsort, and merge adjacent memranges. */
919 memrange_sortmerge (struct collection_list
*memranges
)
923 qsort (memranges
->list
, memranges
->next_memrange
,
924 sizeof (struct memrange
), memrange_cmp
);
925 if (memranges
->next_memrange
> 0)
927 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
929 /* If memrange b overlaps or is adjacent to memrange a,
931 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
932 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
934 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
935 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
936 continue; /* next b, same a */
940 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
941 sizeof (struct memrange
));
943 memranges
->next_memrange
= a
+ 1;
947 /* Add a register to a collection list. */
949 add_register (struct collection_list
*collection
, unsigned int regno
)
952 printf_filtered ("collect register %d\n", regno
);
953 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
954 error (_("Internal: register number %d too large for tracepoint"),
956 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
959 /* Add a memrange to a collection list. */
961 add_memrange (struct collection_list
*memranges
,
962 int type
, bfd_signed_vma base
,
967 printf_filtered ("(%d,", type
);
969 printf_filtered (",%ld)\n", len
);
972 /* type: memrange_absolute == memory, other n == basereg */
973 memranges
->list
[memranges
->next_memrange
].type
= type
;
974 /* base: addr if memory, offset if reg relative. */
975 memranges
->list
[memranges
->next_memrange
].start
= base
;
976 /* len: we actually save end (base + len) for convenience */
977 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
978 memranges
->next_memrange
++;
979 if (memranges
->next_memrange
>= memranges
->listsize
)
981 memranges
->listsize
*= 2;
982 memranges
->list
= xrealloc (memranges
->list
,
983 memranges
->listsize
);
986 if (type
!= memrange_absolute
) /* Better collect the base register! */
987 add_register (memranges
, type
);
990 /* Add a symbol to a collection list. */
992 collect_symbol (struct collection_list
*collect
,
994 struct gdbarch
*gdbarch
,
995 long frame_regno
, long frame_offset
,
1001 bfd_signed_vma offset
;
1002 int treat_as_expr
= 0;
1004 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1005 switch (SYMBOL_CLASS (sym
))
1008 printf_filtered ("%s: don't know symbol class %d\n",
1009 SYMBOL_PRINT_NAME (sym
),
1010 SYMBOL_CLASS (sym
));
1013 printf_filtered ("constant %s (value %s) will not be collected.\n",
1014 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1017 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1022 sprintf_vma (tmp
, offset
);
1023 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1024 SYMBOL_PRINT_NAME (sym
), len
,
1027 /* A struct may be a C++ class with static fields, go to general
1028 expression handling. */
1029 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1032 add_memrange (collect
, memrange_absolute
, offset
, len
);
1035 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1037 printf_filtered ("LOC_REG[parm] %s: ",
1038 SYMBOL_PRINT_NAME (sym
));
1039 add_register (collect
, reg
);
1040 /* Check for doubles stored in two registers. */
1041 /* FIXME: how about larger types stored in 3 or more regs? */
1042 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1043 len
> register_size (gdbarch
, reg
))
1044 add_register (collect
, reg
+ 1);
1047 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1048 printf_filtered (" (will not collect %s)\n",
1049 SYMBOL_PRINT_NAME (sym
));
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
);
1063 case LOC_REGPARM_ADDR
:
1064 reg
= SYMBOL_VALUE (sym
);
1068 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1069 SYMBOL_PRINT_NAME (sym
), len
);
1070 printf_vma (offset
);
1071 printf_filtered (" from reg %d\n", reg
);
1073 add_memrange (collect
, reg
, offset
, len
);
1077 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1080 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1081 SYMBOL_PRINT_NAME (sym
), len
);
1082 printf_vma (offset
);
1083 printf_filtered (" from frame ptr reg %d\n", reg
);
1085 add_memrange (collect
, reg
, offset
, len
);
1088 case LOC_UNRESOLVED
:
1092 case LOC_OPTIMIZED_OUT
:
1093 printf_filtered ("%s has been optimized out of existence.\n",
1094 SYMBOL_PRINT_NAME (sym
));
1102 /* Expressions are the most general case. */
1105 struct agent_expr
*aexpr
;
1106 struct cleanup
*old_chain1
= NULL
;
1108 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1110 /* It can happen that the symbol is recorded as a computed
1111 location, but it's been optimized away and doesn't actually
1112 have a location expression. */
1115 printf_filtered ("%s has been optimized out of existence.\n",
1116 SYMBOL_PRINT_NAME (sym
));
1120 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1124 report_agent_reqs_errors (aexpr
);
1126 discard_cleanups (old_chain1
);
1127 add_aexpr (collect
, aexpr
);
1129 /* Take care of the registers. */
1130 if (aexpr
->reg_mask_len
> 0)
1134 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1136 QUIT
; /* Allow user to bail out with ^C. */
1137 if (aexpr
->reg_mask
[ndx1
] != 0)
1139 /* Assume chars have 8 bits. */
1140 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1141 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1142 /* It's used -- record it. */
1143 add_register (collect
, ndx1
* 8 + ndx2
);
1150 /* Data to be passed around in the calls to the locals and args
1153 struct add_local_symbols_data
1155 struct collection_list
*collect
;
1156 struct gdbarch
*gdbarch
;
1164 /* The callback for the locals and args iterators. */
1167 do_collect_symbol (const char *print_name
,
1171 struct add_local_symbols_data
*p
= cb_data
;
1173 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1174 p
->frame_offset
, p
->pc
, p
->trace_string
);
1178 /* Add all locals (or args) symbols to collection list. */
1180 add_local_symbols (struct collection_list
*collect
,
1181 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1182 long frame_regno
, long frame_offset
, int type
,
1185 struct block
*block
;
1186 struct add_local_symbols_data cb_data
;
1188 cb_data
.collect
= collect
;
1189 cb_data
.gdbarch
= gdbarch
;
1191 cb_data
.frame_regno
= frame_regno
;
1192 cb_data
.frame_offset
= frame_offset
;
1194 cb_data
.trace_string
= trace_string
;
1198 block
= block_for_pc (pc
);
1201 warning (_("Can't collect locals; "
1202 "no symbol table info available.\n"));
1206 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1207 if (cb_data
.count
== 0)
1208 warning (_("No locals found in scope."));
1212 pc
= get_pc_function_start (pc
);
1213 block
= block_for_pc (pc
);
1216 warning (_("Can't collect args; no symbol table info available."));
1220 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1221 if (cb_data
.count
== 0)
1222 warning (_("No args found in scope."));
1227 add_static_trace_data (struct collection_list
*collection
)
1230 printf_filtered ("collect static trace data\n");
1231 collection
->strace_data
= 1;
1234 /* worker function */
1236 clear_collection_list (struct collection_list
*list
)
1240 list
->next_memrange
= 0;
1241 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1243 free_agent_expr (list
->aexpr_list
[ndx
]);
1244 list
->aexpr_list
[ndx
] = NULL
;
1246 list
->next_aexpr_elt
= 0;
1247 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1248 list
->strace_data
= 0;
1251 /* Reduce a collection list to string form (for gdb protocol). */
1253 stringify_collection_list (struct collection_list
*list
, char *string
)
1255 char temp_buf
[2048];
1259 char *(*str_list
)[];
1263 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1264 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1266 if (list
->strace_data
)
1269 printf_filtered ("\nCollecting static trace data\n");
1272 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1276 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1277 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1279 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1282 printf_filtered ("\nCollecting registers (mask): 0x");
1287 QUIT
; /* Allow user to bail out with ^C. */
1289 printf_filtered ("%02X", list
->regs_mask
[i
]);
1290 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1293 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1297 printf_filtered ("\n");
1298 if (list
->next_memrange
> 0 && info_verbose
)
1299 printf_filtered ("Collecting memranges: \n");
1300 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1302 QUIT
; /* Allow user to bail out with ^C. */
1303 sprintf_vma (tmp2
, list
->list
[i
].start
);
1306 printf_filtered ("(%d, %s, %ld)\n",
1309 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1311 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1313 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1320 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1322 /* The "%X" conversion specifier expects an unsigned argument,
1323 so passing -1 (memrange_absolute) to it directly gives you
1324 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1326 if (list
->list
[i
].type
== memrange_absolute
)
1327 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1329 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1332 count
+= strlen (end
);
1333 end
= temp_buf
+ count
;
1336 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1338 QUIT
; /* Allow user to bail out with ^C. */
1339 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1341 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1346 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1347 end
+= 10; /* 'X' + 8 hex digits + ',' */
1350 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1351 end
, list
->aexpr_list
[i
]->len
);
1352 count
+= 2 * list
->aexpr_list
[i
]->len
;
1357 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1362 (*str_list
)[ndx
] = NULL
;
1375 encode_actions_1 (struct command_line
*action
,
1376 struct breakpoint
*t
,
1377 struct bp_location
*tloc
,
1379 LONGEST frame_offset
,
1380 struct collection_list
*collect
,
1381 struct collection_list
*stepping_list
)
1383 const char *action_exp
;
1384 struct expression
*exp
= NULL
;
1386 struct value
*tempval
;
1387 struct cmd_list_element
*cmd
;
1388 struct agent_expr
*aexpr
;
1390 for (; action
; action
= action
->next
)
1392 QUIT
; /* Allow user to bail out with ^C. */
1393 action_exp
= action
->line
;
1394 action_exp
= skip_spaces_const (action_exp
);
1396 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1398 error (_("Bad action list item: %s"), action_exp
);
1400 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1402 int trace_string
= 0;
1404 if (*action_exp
== '/')
1405 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1408 { /* Repeat over a comma-separated list. */
1409 QUIT
; /* Allow user to bail out with ^C. */
1410 action_exp
= skip_spaces_const (action_exp
);
1412 if (0 == strncasecmp ("$reg", action_exp
, 4))
1414 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1415 add_register (collect
, i
);
1416 action_exp
= strchr (action_exp
, ','); /* more? */
1418 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1420 add_local_symbols (collect
,
1427 action_exp
= strchr (action_exp
, ','); /* more? */
1429 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1431 add_local_symbols (collect
,
1438 action_exp
= strchr (action_exp
, ','); /* more? */
1440 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1442 struct cleanup
*old_chain1
= NULL
;
1444 aexpr
= gen_trace_for_return_address (tloc
->address
,
1448 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1451 report_agent_reqs_errors (aexpr
);
1453 discard_cleanups (old_chain1
);
1454 add_aexpr (collect
, aexpr
);
1456 /* take care of the registers */
1457 if (aexpr
->reg_mask_len
> 0)
1461 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1463 QUIT
; /* allow user to bail out with ^C */
1464 if (aexpr
->reg_mask
[ndx1
] != 0)
1466 /* assume chars have 8 bits */
1467 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1468 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1469 /* it's used -- record it */
1470 add_register (collect
,
1476 action_exp
= strchr (action_exp
, ','); /* more? */
1478 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1480 add_static_trace_data (collect
);
1481 action_exp
= strchr (action_exp
, ','); /* more? */
1486 struct cleanup
*old_chain
= NULL
;
1487 struct cleanup
*old_chain1
= NULL
;
1489 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1490 block_for_pc (tloc
->address
), 1);
1491 old_chain
= make_cleanup (free_current_contents
, &exp
);
1493 switch (exp
->elts
[0].opcode
)
1497 const char *name
= &exp
->elts
[2].string
;
1499 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1500 name
, strlen (name
));
1502 internal_error (__FILE__
, __LINE__
,
1503 _("Register $%s not available"),
1506 printf_filtered ("OP_REGISTER: ");
1507 add_register (collect
, i
);
1512 /* Safe because we know it's a simple expression. */
1513 tempval
= evaluate_expression (exp
);
1514 addr
= value_address (tempval
);
1515 /* Initialize the TYPE_LENGTH if it is a typedef. */
1516 check_typedef (exp
->elts
[1].type
);
1517 add_memrange (collect
, memrange_absolute
, addr
,
1518 TYPE_LENGTH (exp
->elts
[1].type
));
1522 collect_symbol (collect
,
1523 exp
->elts
[2].symbol
,
1531 default: /* Full-fledged expression. */
1532 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1535 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1539 report_agent_reqs_errors (aexpr
);
1541 discard_cleanups (old_chain1
);
1542 add_aexpr (collect
, aexpr
);
1544 /* Take care of the registers. */
1545 if (aexpr
->reg_mask_len
> 0)
1550 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1552 QUIT
; /* Allow user to bail out with ^C. */
1553 if (aexpr
->reg_mask
[ndx1
] != 0)
1555 /* Assume chars have 8 bits. */
1556 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1557 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1558 /* It's used -- record it. */
1559 add_register (collect
,
1566 do_cleanups (old_chain
);
1569 while (action_exp
&& *action_exp
++ == ',');
1571 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1574 { /* Repeat over a comma-separated list. */
1575 QUIT
; /* Allow user to bail out with ^C. */
1576 action_exp
= skip_spaces_const (action_exp
);
1579 struct cleanup
*old_chain
= NULL
;
1580 struct cleanup
*old_chain1
= NULL
;
1582 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1583 block_for_pc (tloc
->address
), 1);
1584 old_chain
= make_cleanup (free_current_contents
, &exp
);
1586 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1587 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1590 report_agent_reqs_errors (aexpr
);
1592 discard_cleanups (old_chain1
);
1593 /* Even though we're not officially collecting, add
1594 to the collect list anyway. */
1595 add_aexpr (collect
, aexpr
);
1597 do_cleanups (old_chain
);
1600 while (action_exp
&& *action_exp
++ == ',');
1602 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1604 /* We check against nested while-stepping when setting
1605 breakpoint action, so no way to run into nested
1607 gdb_assert (stepping_list
);
1609 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1610 frame_offset
, stepping_list
, NULL
);
1613 error (_("Invalid tracepoint command '%s'"), action
->line
);
1617 /* Render all actions into gdb protocol. */
1620 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1621 char ***tdp_actions
, char ***stepping_actions
)
1623 static char tdp_buff
[2048], step_buff
[2048];
1624 char *default_collect_line
= NULL
;
1625 struct command_line
*actions
;
1626 struct command_line
*default_collect_action
= NULL
;
1628 LONGEST frame_offset
;
1629 struct cleanup
*back_to
;
1631 back_to
= make_cleanup (null_cleanup
, NULL
);
1633 clear_collection_list (&tracepoint_list
);
1634 clear_collection_list (&stepping_list
);
1636 *tdp_actions
= NULL
;
1637 *stepping_actions
= NULL
;
1639 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1640 tloc
->address
, &frame_reg
, &frame_offset
);
1642 actions
= breakpoint_commands (t
);
1644 /* If there are default expressions to collect, make up a collect
1645 action and prepend to the action list to encode. Note that since
1646 validation is per-tracepoint (local var "xyz" might be valid for
1647 one tracepoint and not another, etc), we make up the action on
1648 the fly, and don't cache it. */
1649 if (*default_collect
)
1651 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1652 make_cleanup (xfree
, default_collect_line
);
1654 validate_actionline (default_collect_line
, t
);
1656 default_collect_action
= xmalloc (sizeof (struct command_line
));
1657 make_cleanup (xfree
, default_collect_action
);
1658 default_collect_action
->next
= actions
;
1659 default_collect_action
->line
= default_collect_line
;
1660 actions
= default_collect_action
;
1662 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1663 &tracepoint_list
, &stepping_list
);
1665 memrange_sortmerge (&tracepoint_list
);
1666 memrange_sortmerge (&stepping_list
);
1668 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1670 *stepping_actions
= stringify_collection_list (&stepping_list
,
1673 do_cleanups (back_to
);
1677 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1679 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1681 collect
->aexpr_list
=
1682 xrealloc (collect
->aexpr_list
,
1683 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1684 collect
->aexpr_listsize
*= 2;
1686 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1687 collect
->next_aexpr_elt
++;
1691 process_tracepoint_on_disconnect (void)
1693 VEC(breakpoint_p
) *tp_vec
= NULL
;
1695 struct breakpoint
*b
;
1696 int has_pending_p
= 0;
1698 /* Check whether we still have pending tracepoint. If we have, warn the
1699 user that pending tracepoint will no longer work. */
1700 tp_vec
= all_tracepoints ();
1701 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1710 struct bp_location
*loc1
;
1712 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1714 if (loc1
->shlib_disabled
)
1725 VEC_free (breakpoint_p
, tp_vec
);
1728 warning (_("Pending tracepoints will not be resolved while"
1729 " GDB is disconnected\n"));
1734 start_tracing (char *notes
)
1736 VEC(breakpoint_p
) *tp_vec
= NULL
;
1738 struct breakpoint
*b
;
1739 struct trace_state_variable
*tsv
;
1740 int any_enabled
= 0, num_to_download
= 0;
1743 tp_vec
= all_tracepoints ();
1745 /* No point in tracing without any tracepoints... */
1746 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1748 VEC_free (breakpoint_p
, tp_vec
);
1749 error (_("No tracepoints defined, not starting trace"));
1752 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1754 struct tracepoint
*t
= (struct tracepoint
*) b
;
1755 struct bp_location
*loc
;
1757 if (b
->enable_state
== bp_enabled
)
1760 if ((b
->type
== bp_fast_tracepoint
1761 ? may_insert_fast_tracepoints
1762 : may_insert_tracepoints
))
1765 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1766 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1771 if (target_supports_enable_disable_tracepoint ())
1772 warning (_("No tracepoints enabled"));
1775 /* No point in tracing with only disabled tracepoints that
1776 cannot be re-enabled. */
1777 VEC_free (breakpoint_p
, tp_vec
);
1778 error (_("No tracepoints enabled, not starting trace"));
1782 if (num_to_download
<= 0)
1784 VEC_free (breakpoint_p
, tp_vec
);
1785 error (_("No tracepoints that may be downloaded, not starting trace"));
1788 target_trace_init ();
1790 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1792 struct tracepoint
*t
= (struct tracepoint
*) b
;
1793 struct bp_location
*loc
;
1794 int bp_location_downloaded
= 0;
1796 /* Clear `inserted' flag. */
1797 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1800 if ((b
->type
== bp_fast_tracepoint
1801 ? !may_insert_fast_tracepoints
1802 : !may_insert_tracepoints
))
1805 t
->number_on_target
= 0;
1807 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1809 /* Since tracepoint locations are never duplicated, `inserted'
1810 flag should be zero. */
1811 gdb_assert (!loc
->inserted
);
1813 target_download_tracepoint (loc
);
1816 bp_location_downloaded
= 1;
1819 t
->number_on_target
= b
->number
;
1821 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1822 if (loc
->probe
!= NULL
)
1823 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1825 if (bp_location_downloaded
)
1826 observer_notify_breakpoint_modified (b
);
1828 VEC_free (breakpoint_p
, tp_vec
);
1830 /* Send down all the trace state variables too. */
1831 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1833 target_download_trace_state_variable (tsv
);
1836 /* Tell target to treat text-like sections as transparent. */
1837 target_trace_set_readonly_regions ();
1838 /* Set some mode flags. */
1839 target_set_disconnected_tracing (disconnected_tracing
);
1840 target_set_circular_trace_buffer (circular_trace_buffer
);
1841 target_set_trace_buffer_size (trace_buffer_size
);
1844 notes
= trace_notes
;
1845 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1847 if (!ret
&& (trace_user
|| notes
))
1848 warning (_("Target does not support trace user/notes, info ignored"));
1850 /* Now insert traps and begin collecting data. */
1851 target_trace_start ();
1853 /* Reset our local state. */
1854 set_traceframe_num (-1);
1855 set_tracepoint_num (-1);
1856 set_traceframe_context (NULL
);
1857 current_trace_status()->running
= 1;
1858 clear_traceframe_info ();
1861 /* The tstart command requests the target to start a new trace run.
1862 The command passes any arguments it has to the target verbatim, as
1863 an optional "trace note". This is useful as for instance a warning
1864 to other users if the trace runs disconnected, and you don't want
1865 anybody else messing with the target. */
1868 trace_start_command (char *args
, int from_tty
)
1870 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1872 if (current_trace_status ()->running
)
1875 && !query (_("A trace is running already. Start a new run? ")))
1876 error (_("New trace run not started."));
1879 start_tracing (args
);
1882 /* The tstop command stops the tracing run. The command passes any
1883 supplied arguments to the target verbatim as a "stop note"; if the
1884 target supports trace notes, then it will be reported back as part
1885 of the trace run's status. */
1888 trace_stop_command (char *args
, int from_tty
)
1890 if (!current_trace_status ()->running
)
1891 error (_("Trace is not running."));
1893 stop_tracing (args
);
1897 stop_tracing (char *note
)
1900 VEC(breakpoint_p
) *tp_vec
= NULL
;
1902 struct breakpoint
*t
;
1904 target_trace_stop ();
1906 tp_vec
= all_tracepoints ();
1907 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1909 struct bp_location
*loc
;
1911 if ((t
->type
== bp_fast_tracepoint
1912 ? !may_insert_fast_tracepoints
1913 : !may_insert_tracepoints
))
1916 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1918 /* GDB can be totally absent in some disconnected trace scenarios,
1919 but we don't really care if this semaphore goes out of sync.
1920 That's why we are decrementing it here, but not taking care
1922 if (loc
->probe
!= NULL
)
1923 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1927 VEC_free (breakpoint_p
, tp_vec
);
1930 note
= trace_stop_notes
;
1931 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1934 warning (_("Target does not support trace notes, note ignored"));
1936 /* Should change in response to reply? */
1937 current_trace_status ()->running
= 0;
1940 /* tstatus command */
1942 trace_status_command (char *args
, int from_tty
)
1944 struct trace_status
*ts
= current_trace_status ();
1946 VEC(breakpoint_p
) *tp_vec
= NULL
;
1947 struct breakpoint
*t
;
1949 status
= target_get_trace_status (ts
);
1953 if (ts
->filename
!= NULL
)
1954 printf_filtered (_("Using a trace file.\n"));
1957 printf_filtered (_("Trace can not be run on this target.\n"));
1962 if (!ts
->running_known
)
1964 printf_filtered (_("Run/stop status is unknown.\n"));
1966 else if (ts
->running
)
1968 printf_filtered (_("Trace is running on the target.\n"));
1972 switch (ts
->stop_reason
)
1974 case trace_never_run
:
1975 printf_filtered (_("No trace has been run on the target.\n"));
1979 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1982 printf_filtered (_("Trace stopped by a tstop command.\n"));
1984 case trace_buffer_full
:
1985 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1987 case trace_disconnected
:
1988 printf_filtered (_("Trace stopped because of disconnection.\n"));
1990 case tracepoint_passcount
:
1991 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1992 ts
->stopping_tracepoint
);
1994 case tracepoint_error
:
1995 if (ts
->stopping_tracepoint
)
1996 printf_filtered (_("Trace stopped by an "
1997 "error (%s, tracepoint %d).\n"),
1998 ts
->stop_desc
, ts
->stopping_tracepoint
);
2000 printf_filtered (_("Trace stopped by an error (%s).\n"),
2003 case trace_stop_reason_unknown
:
2004 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2007 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2013 if (ts
->traceframes_created
>= 0
2014 && ts
->traceframe_count
!= ts
->traceframes_created
)
2016 printf_filtered (_("Buffer contains %d trace "
2017 "frames (of %d created total).\n"),
2018 ts
->traceframe_count
, ts
->traceframes_created
);
2020 else if (ts
->traceframe_count
>= 0)
2022 printf_filtered (_("Collected %d trace frames.\n"),
2023 ts
->traceframe_count
);
2026 if (ts
->buffer_free
>= 0)
2028 if (ts
->buffer_size
>= 0)
2030 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2031 ts
->buffer_free
, ts
->buffer_size
);
2032 if (ts
->buffer_size
> 0)
2033 printf_filtered (_(" (%d%% full)"),
2034 ((int) ((((long long) (ts
->buffer_size
2035 - ts
->buffer_free
)) * 100)
2036 / ts
->buffer_size
)));
2037 printf_filtered (_(".\n"));
2040 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2044 if (ts
->disconnected_tracing
)
2045 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2047 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2049 if (ts
->circular_buffer
)
2050 printf_filtered (_("Trace buffer is circular.\n"));
2052 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2053 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2055 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2056 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2058 /* Now report on what we're doing with tfind. */
2059 if (traceframe_number
>= 0)
2060 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2061 traceframe_number
, tracepoint_number
);
2063 printf_filtered (_("Not looking at any trace frame.\n"));
2065 /* Report start/stop times if supplied. */
2070 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2072 /* Reporting a run time is more readable than two long numbers. */
2073 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2074 (long int) ts
->start_time
/ 1000000,
2075 (long int) ts
->start_time
% 1000000,
2076 (long int) run_time
/ 1000000,
2077 (long int) run_time
% 1000000);
2080 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2081 (long int) ts
->start_time
/ 1000000,
2082 (long int) ts
->start_time
% 1000000);
2084 else if (ts
->stop_time
)
2085 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2086 (long int) ts
->stop_time
/ 1000000,
2087 (long int) ts
->stop_time
% 1000000);
2089 /* Now report any per-tracepoint status available. */
2090 tp_vec
= all_tracepoints ();
2092 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2093 target_get_tracepoint_status (t
, NULL
);
2095 VEC_free (breakpoint_p
, tp_vec
);
2098 /* Report the trace status to uiout, in a way suitable for MI, and not
2099 suitable for CLI. If ON_STOP is true, suppress a few fields that
2100 are not meaningful in the -trace-stop response.
2102 The implementation is essentially parallel to trace_status_command, but
2103 merging them will result in unreadable code. */
2105 trace_status_mi (int on_stop
)
2107 struct ui_out
*uiout
= current_uiout
;
2108 struct trace_status
*ts
= current_trace_status ();
2111 status
= target_get_trace_status (ts
);
2113 if (status
== -1 && ts
->filename
== NULL
)
2115 ui_out_field_string (uiout
, "supported", "0");
2119 if (ts
->filename
!= NULL
)
2120 ui_out_field_string (uiout
, "supported", "file");
2122 ui_out_field_string (uiout
, "supported", "1");
2124 if (ts
->filename
!= NULL
)
2125 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2127 gdb_assert (ts
->running_known
);
2131 ui_out_field_string (uiout
, "running", "1");
2133 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2134 Given that the frontend gets the status either on -trace-stop, or from
2135 -trace-status after re-connection, it does not seem like this
2136 information is necessary for anything. It is not necessary for either
2137 figuring the vital state of the target nor for navigation of trace
2138 frames. If the frontend wants to show the current state is some
2139 configure dialog, it can request the value when such dialog is
2140 invoked by the user. */
2144 char *stop_reason
= NULL
;
2145 int stopping_tracepoint
= -1;
2148 ui_out_field_string (uiout
, "running", "0");
2150 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2152 switch (ts
->stop_reason
)
2155 stop_reason
= "request";
2157 case trace_buffer_full
:
2158 stop_reason
= "overflow";
2160 case trace_disconnected
:
2161 stop_reason
= "disconnection";
2163 case tracepoint_passcount
:
2164 stop_reason
= "passcount";
2165 stopping_tracepoint
= ts
->stopping_tracepoint
;
2167 case tracepoint_error
:
2168 stop_reason
= "error";
2169 stopping_tracepoint
= ts
->stopping_tracepoint
;
2175 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2176 if (stopping_tracepoint
!= -1)
2177 ui_out_field_int (uiout
, "stopping-tracepoint",
2178 stopping_tracepoint
);
2179 if (ts
->stop_reason
== tracepoint_error
)
2180 ui_out_field_string (uiout
, "error-description",
2186 if (ts
->traceframe_count
!= -1)
2187 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2188 if (ts
->traceframes_created
!= -1)
2189 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2190 if (ts
->buffer_size
!= -1)
2191 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2192 if (ts
->buffer_free
!= -1)
2193 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2195 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2196 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2198 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2199 ui_out_field_string (uiout
, "notes", ts
->notes
);
2204 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2205 (long int) ts
->start_time
/ 1000000,
2206 (long int) ts
->start_time
% 1000000);
2207 ui_out_field_string (uiout
, "start-time", buf
);
2208 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2209 (long int) ts
->stop_time
/ 1000000,
2210 (long int) ts
->stop_time
% 1000000);
2211 ui_out_field_string (uiout
, "stop-time", buf
);
2215 /* This function handles the details of what to do about an ongoing
2216 tracing run if the user has asked to detach or otherwise disconnect
2219 disconnect_tracing (int from_tty
)
2221 /* It can happen that the target that was tracing went away on its
2222 own, and we didn't notice. Get a status update, and if the
2223 current target doesn't even do tracing, then assume it's not
2225 if (target_get_trace_status (current_trace_status ()) < 0)
2226 current_trace_status ()->running
= 0;
2228 /* If running interactively, give the user the option to cancel and
2229 then decide what to do differently with the run. Scripts are
2230 just going to disconnect and let the target deal with it,
2231 according to how it's been instructed previously via
2232 disconnected-tracing. */
2233 if (current_trace_status ()->running
&& from_tty
)
2235 process_tracepoint_on_disconnect ();
2237 if (current_trace_status ()->disconnected_tracing
)
2239 if (!query (_("Trace is running and will "
2240 "continue after detach; detach anyway? ")))
2241 error (_("Not confirmed."));
2245 if (!query (_("Trace is running but will "
2246 "stop on detach; detach anyway? ")))
2247 error (_("Not confirmed."));
2251 /* Also we want to be out of tfind mode, otherwise things can get
2252 confusing upon reconnection. Just use these calls instead of
2253 full tfind_1 behavior because we're in the middle of detaching,
2254 and there's no point to updating current stack frame etc. */
2255 set_current_traceframe (-1);
2256 set_tracepoint_num (-1);
2257 set_traceframe_context (NULL
);
2260 /* Worker function for the various flavors of the tfind command. */
2262 tfind_1 (enum trace_find_type type
, int num
,
2263 ULONGEST addr1
, ULONGEST addr2
,
2266 int target_frameno
= -1, target_tracept
= -1;
2267 struct frame_id old_frame_id
= null_frame_id
;
2268 struct tracepoint
*tp
;
2269 struct ui_out
*uiout
= current_uiout
;
2271 /* Only try to get the current stack frame if we have a chance of
2272 succeeding. In particular, if we're trying to get a first trace
2273 frame while all threads are running, it's not going to succeed,
2274 so leave it with a default value and let the frame comparison
2275 below (correctly) decide to print out the source location of the
2277 if (!(type
== tfind_number
&& num
== -1)
2278 && (has_stack_frames () || traceframe_number
>= 0))
2279 old_frame_id
= get_frame_id (get_current_frame ());
2281 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2284 if (type
== tfind_number
2286 && target_frameno
== -1)
2288 /* We told the target to get out of tfind mode, and it did. */
2290 else if (target_frameno
== -1)
2292 /* A request for a non-existent trace frame has failed.
2293 Our response will be different, depending on FROM_TTY:
2295 If FROM_TTY is true, meaning that this command was
2296 typed interactively by the user, then give an error
2297 and DO NOT change the state of traceframe_number etc.
2299 However if FROM_TTY is false, meaning that we're either
2300 in a script, a loop, or a user-defined command, then
2301 DON'T give an error, but DO change the state of
2302 traceframe_number etc. to invalid.
2304 The rationalle is that if you typed the command, you
2305 might just have committed a typo or something, and you'd
2306 like to NOT lose your current debugging state. However
2307 if you're in a user-defined command or especially in a
2308 loop, then you need a way to detect that the command
2309 failed WITHOUT aborting. This allows you to write
2310 scripts that search thru the trace buffer until the end,
2311 and then continue on to do something else. */
2314 error (_("Target failed to find requested trace frame."));
2318 printf_filtered ("End of trace buffer.\n");
2319 #if 0 /* dubious now? */
2320 /* The following will not recurse, since it's
2322 trace_find_command ("-1", from_tty
);
2327 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2329 reinit_frame_cache ();
2330 target_dcache_invalidate ();
2332 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2334 if (target_frameno
!= get_traceframe_number ())
2335 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2337 set_current_traceframe (target_frameno
);
2339 if (target_frameno
== -1)
2340 set_traceframe_context (NULL
);
2342 set_traceframe_context (get_current_frame ());
2344 if (traceframe_number
>= 0)
2346 /* Use different branches for MI and CLI to make CLI messages
2348 if (ui_out_is_mi_like_p (uiout
))
2350 ui_out_field_string (uiout
, "found", "1");
2351 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2352 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2356 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2357 traceframe_number
, tracepoint_number
);
2362 if (ui_out_is_mi_like_p (uiout
))
2363 ui_out_field_string (uiout
, "found", "0");
2364 else if (type
== tfind_number
&& num
== -1)
2365 printf_unfiltered (_("No longer looking at any trace frame\n"));
2366 else /* This case may never occur, check. */
2367 printf_unfiltered (_("No trace frame found\n"));
2370 /* If we're in nonstop mode and getting out of looking at trace
2371 frames, there won't be any current frame to go back to and
2374 && (has_stack_frames () || traceframe_number
>= 0))
2376 enum print_what print_what
;
2378 /* NOTE: in imitation of the step command, try to determine
2379 whether we have made a transition from one function to
2380 another. If so, we'll print the "stack frame" (ie. the new
2381 function and it's arguments) -- otherwise we'll just show the
2384 if (frame_id_eq (old_frame_id
,
2385 get_frame_id (get_current_frame ())))
2386 print_what
= SRC_LINE
;
2388 print_what
= SRC_AND_LOC
;
2390 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2395 /* trace_find_command takes a trace frame number n,
2396 sends "QTFrame:<n>" to the target,
2397 and accepts a reply that may contain several optional pieces
2398 of information: a frame number, a tracepoint number, and an
2399 indication of whether this is a trap frame or a stepping frame.
2401 The minimal response is just "OK" (which indicates that the
2402 target does not give us a frame number or a tracepoint number).
2403 Instead of that, the target may send us a string containing
2405 F<hexnum> (gives the selected frame number)
2406 T<hexnum> (gives the selected tracepoint number)
2411 trace_find_command (char *args
, int from_tty
)
2412 { /* This should only be called with a numeric argument. */
2415 if (current_trace_status ()->running
2416 && current_trace_status ()->filename
== NULL
)
2417 error (_("May not look at trace frames while trace is running."));
2419 if (args
== 0 || *args
== 0)
2420 { /* TFIND with no args means find NEXT trace frame. */
2421 if (traceframe_number
== -1)
2422 frameno
= 0; /* "next" is first one. */
2424 frameno
= traceframe_number
+ 1;
2426 else if (0 == strcmp (args
, "-"))
2428 if (traceframe_number
== -1)
2429 error (_("not debugging trace buffer"));
2430 else if (from_tty
&& traceframe_number
== 0)
2431 error (_("already at start of trace buffer"));
2433 frameno
= traceframe_number
- 1;
2435 /* A hack to work around eval's need for fp to have been collected. */
2436 else if (0 == strcmp (args
, "-1"))
2439 frameno
= parse_and_eval_long (args
);
2442 error (_("invalid input (%d is less than zero)"), frameno
);
2444 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2449 trace_find_end_command (char *args
, int from_tty
)
2451 trace_find_command ("-1", from_tty
);
2456 trace_find_start_command (char *args
, int from_tty
)
2458 trace_find_command ("0", from_tty
);
2461 /* tfind pc command */
2463 trace_find_pc_command (char *args
, int from_tty
)
2467 if (current_trace_status ()->running
2468 && current_trace_status ()->filename
== NULL
)
2469 error (_("May not look at trace frames while trace is running."));
2471 if (args
== 0 || *args
== 0)
2472 pc
= regcache_read_pc (get_current_regcache ());
2474 pc
= parse_and_eval_address (args
);
2476 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2479 /* tfind tracepoint command */
2481 trace_find_tracepoint_command (char *args
, int from_tty
)
2484 struct tracepoint
*tp
;
2486 if (current_trace_status ()->running
2487 && current_trace_status ()->filename
== NULL
)
2488 error (_("May not look at trace frames while trace is running."));
2490 if (args
== 0 || *args
== 0)
2492 if (tracepoint_number
== -1)
2493 error (_("No current tracepoint -- please supply an argument."));
2495 tdp
= tracepoint_number
; /* Default is current TDP. */
2498 tdp
= parse_and_eval_long (args
);
2500 /* If we have the tracepoint on hand, use the number that the
2501 target knows about (which may be different if we disconnected
2502 and reconnected). */
2503 tp
= get_tracepoint (tdp
);
2505 tdp
= tp
->number_on_target
;
2507 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2510 /* TFIND LINE command:
2512 This command will take a sourceline for argument, just like BREAK
2513 or TRACE (ie. anything that "decode_line_1" can handle).
2515 With no argument, this command will find the next trace frame
2516 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2519 trace_find_line_command (char *args
, int from_tty
)
2521 static CORE_ADDR start_pc
, end_pc
;
2522 struct symtabs_and_lines sals
;
2523 struct symtab_and_line sal
;
2524 struct cleanup
*old_chain
;
2526 if (current_trace_status ()->running
2527 && current_trace_status ()->filename
== NULL
)
2528 error (_("May not look at trace frames while trace is running."));
2530 if (args
== 0 || *args
== 0)
2532 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2534 sals
.sals
= (struct symtab_and_line
*)
2535 xmalloc (sizeof (struct symtab_and_line
));
2540 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2544 old_chain
= make_cleanup (xfree
, sals
.sals
);
2545 if (sal
.symtab
== 0)
2546 error (_("No line number information available."));
2548 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2550 if (start_pc
== end_pc
)
2552 printf_filtered ("Line %d of \"%s\"",
2554 symtab_to_filename_for_display (sal
.symtab
));
2556 printf_filtered (" is at address ");
2557 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2559 printf_filtered (" but contains no code.\n");
2560 sal
= find_pc_line (start_pc
, 0);
2562 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2563 && start_pc
!= end_pc
)
2564 printf_filtered ("Attempting to find line %d instead.\n",
2567 error (_("Cannot find a good line."));
2571 /* Is there any case in which we get here, and have an address
2572 which the user would want to see? If we have debugging
2573 symbols and no line numbers? */
2574 error (_("Line number %d is out of range for \"%s\"."),
2575 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2577 /* Find within range of stated line. */
2579 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2581 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2582 do_cleanups (old_chain
);
2585 /* tfind range command */
2587 trace_find_range_command (char *args
, int from_tty
)
2589 static CORE_ADDR start
, stop
;
2592 if (current_trace_status ()->running
2593 && current_trace_status ()->filename
== NULL
)
2594 error (_("May not look at trace frames while trace is running."));
2596 if (args
== 0 || *args
== 0)
2597 { /* XXX FIXME: what should default behavior be? */
2598 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2602 if (0 != (tmp
= strchr (args
, ',')))
2604 *tmp
++ = '\0'; /* Terminate start address. */
2605 tmp
= skip_spaces (tmp
);
2606 start
= parse_and_eval_address (args
);
2607 stop
= parse_and_eval_address (tmp
);
2610 { /* No explicit end address? */
2611 start
= parse_and_eval_address (args
);
2612 stop
= start
+ 1; /* ??? */
2615 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2618 /* tfind outside command */
2620 trace_find_outside_command (char *args
, int from_tty
)
2622 CORE_ADDR start
, stop
;
2625 if (current_trace_status ()->running
2626 && current_trace_status ()->filename
== NULL
)
2627 error (_("May not look at trace frames while trace is running."));
2629 if (args
== 0 || *args
== 0)
2630 { /* XXX FIXME: what should default behavior be? */
2631 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2635 if (0 != (tmp
= strchr (args
, ',')))
2637 *tmp
++ = '\0'; /* Terminate start address. */
2638 tmp
= skip_spaces (tmp
);
2639 start
= parse_and_eval_address (args
);
2640 stop
= parse_and_eval_address (tmp
);
2643 { /* No explicit end address? */
2644 start
= parse_and_eval_address (args
);
2645 stop
= start
+ 1; /* ??? */
2648 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2651 /* info scope command: list the locals for a scope. */
2653 scope_info (char *args
, int from_tty
)
2655 struct symtabs_and_lines sals
;
2657 struct minimal_symbol
*msym
;
2658 struct block
*block
;
2659 const char *symname
;
2660 char *save_args
= args
;
2661 struct block_iterator iter
;
2663 struct gdbarch
*gdbarch
;
2666 if (args
== 0 || *args
== 0)
2667 error (_("requires an argument (function, "
2668 "line or *addr) to define a scope"));
2670 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2671 if (sals
.nelts
== 0)
2672 return; /* Presumably decode_line_1 has already warned. */
2674 /* Resolve line numbers to PC. */
2675 resolve_sal_pc (&sals
.sals
[0]);
2676 block
= block_for_pc (sals
.sals
[0].pc
);
2680 QUIT
; /* Allow user to bail out with ^C. */
2681 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2683 QUIT
; /* Allow user to bail out with ^C. */
2685 printf_filtered ("Scope for %s:\n", save_args
);
2688 symname
= SYMBOL_PRINT_NAME (sym
);
2689 if (symname
== NULL
|| *symname
== '\0')
2690 continue; /* Probably botched, certainly useless. */
2692 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2694 printf_filtered ("Symbol %s is ", symname
);
2696 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2697 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2698 BLOCK_START (block
),
2702 switch (SYMBOL_CLASS (sym
))
2705 case LOC_UNDEF
: /* Messed up symbol? */
2706 printf_filtered ("a bogus symbol, class %d.\n",
2707 SYMBOL_CLASS (sym
));
2708 count
--; /* Don't count this one. */
2711 printf_filtered ("a constant with value %s (%s)",
2712 plongest (SYMBOL_VALUE (sym
)),
2713 hex_string (SYMBOL_VALUE (sym
)));
2715 case LOC_CONST_BYTES
:
2716 printf_filtered ("constant bytes: ");
2717 if (SYMBOL_TYPE (sym
))
2718 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2719 fprintf_filtered (gdb_stdout
, " %02x",
2720 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2723 printf_filtered ("in static storage at address ");
2724 printf_filtered ("%s", paddress (gdbarch
,
2725 SYMBOL_VALUE_ADDRESS (sym
)));
2728 /* GDBARCH is the architecture associated with the objfile
2729 the symbol is defined in; the target architecture may be
2730 different, and may provide additional registers. However,
2731 we do not know the target architecture at this point.
2732 We assume the objfile architecture will contain all the
2733 standard registers that occur in debug info in that
2735 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2738 if (SYMBOL_IS_ARGUMENT (sym
))
2739 printf_filtered ("an argument in register $%s",
2740 gdbarch_register_name (gdbarch
, regno
));
2742 printf_filtered ("a local variable in register $%s",
2743 gdbarch_register_name (gdbarch
, regno
));
2746 printf_filtered ("an argument at stack/frame offset %s",
2747 plongest (SYMBOL_VALUE (sym
)));
2750 printf_filtered ("a local variable at frame offset %s",
2751 plongest (SYMBOL_VALUE (sym
)));
2754 printf_filtered ("a reference argument at offset %s",
2755 plongest (SYMBOL_VALUE (sym
)));
2757 case LOC_REGPARM_ADDR
:
2758 /* Note comment at LOC_REGISTER. */
2759 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2761 printf_filtered ("the address of an argument, in register $%s",
2762 gdbarch_register_name (gdbarch
, regno
));
2765 printf_filtered ("a typedef.\n");
2768 printf_filtered ("a label at address ");
2769 printf_filtered ("%s", paddress (gdbarch
,
2770 SYMBOL_VALUE_ADDRESS (sym
)));
2773 printf_filtered ("a function at address ");
2774 printf_filtered ("%s",
2775 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2777 case LOC_UNRESOLVED
:
2778 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2781 printf_filtered ("Unresolved Static");
2784 printf_filtered ("static storage at address ");
2785 printf_filtered ("%s",
2787 SYMBOL_VALUE_ADDRESS (msym
)));
2790 case LOC_OPTIMIZED_OUT
:
2791 printf_filtered ("optimized out.\n");
2794 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2797 if (SYMBOL_TYPE (sym
))
2798 printf_filtered (", length %d.\n",
2799 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2801 if (BLOCK_FUNCTION (block
))
2804 block
= BLOCK_SUPERBLOCK (block
);
2807 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2811 /* Helper for trace_dump_command. Dump the action list starting at
2812 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2813 actions of the body of a while-stepping action. STEPPING_FRAME is
2814 set if the current traceframe was determined to be a while-stepping
2818 trace_dump_actions (struct command_line
*action
,
2819 int stepping_actions
, int stepping_frame
,
2822 const char *action_exp
, *next_comma
;
2824 for (; action
!= NULL
; action
= action
->next
)
2826 struct cmd_list_element
*cmd
;
2828 QUIT
; /* Allow user to bail out with ^C. */
2829 action_exp
= action
->line
;
2830 action_exp
= skip_spaces_const (action_exp
);
2832 /* The collection actions to be done while stepping are
2833 bracketed by the commands "while-stepping" and "end". */
2835 if (*action_exp
== '#') /* comment line */
2838 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2840 error (_("Bad action list item: %s"), action_exp
);
2842 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2846 for (i
= 0; i
< action
->body_count
; ++i
)
2847 trace_dump_actions (action
->body_list
[i
],
2848 1, stepping_frame
, from_tty
);
2850 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2852 /* Display the collected data.
2853 For the trap frame, display only what was collected at
2854 the trap. Likewise for stepping frames, display only
2855 what was collected while stepping. This means that the
2856 two boolean variables, STEPPING_FRAME and
2857 STEPPING_ACTIONS should be equal. */
2858 if (stepping_frame
== stepping_actions
)
2861 struct cleanup
*old_chain
2862 = make_cleanup (free_current_contents
, &cmd
);
2863 int trace_string
= 0;
2865 if (*action_exp
== '/')
2866 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2869 { /* Repeat over a comma-separated list. */
2870 QUIT
; /* Allow user to bail out with ^C. */
2871 if (*action_exp
== ',')
2873 action_exp
= skip_spaces_const (action_exp
);
2875 next_comma
= strchr (action_exp
, ',');
2877 if (0 == strncasecmp (action_exp
, "$reg", 4))
2878 registers_info (NULL
, from_tty
);
2879 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2881 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2882 locals_info (NULL
, from_tty
);
2883 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2884 args_info (NULL
, from_tty
);
2887 if (next_comma
!= NULL
)
2889 size_t len
= next_comma
- action_exp
;
2891 cmd
= xrealloc (cmd
, len
+ 1);
2892 memcpy (cmd
, action_exp
, len
);
2897 size_t len
= strlen (action_exp
);
2899 cmd
= xrealloc (cmd
, len
+ 1);
2900 memcpy (cmd
, action_exp
, len
+ 1);
2903 printf_filtered ("%s = ", cmd
);
2904 output_command_const (cmd
, from_tty
);
2905 printf_filtered ("\n");
2907 action_exp
= next_comma
;
2909 while (action_exp
&& *action_exp
== ',');
2911 do_cleanups (old_chain
);
2917 /* The tdump command. */
2920 trace_dump_command (char *args
, int from_tty
)
2922 struct regcache
*regcache
;
2923 struct tracepoint
*t
;
2924 int stepping_frame
= 0;
2925 struct bp_location
*loc
;
2926 char *default_collect_line
= NULL
;
2927 struct command_line
*actions
, *default_collect_action
= NULL
;
2928 struct cleanup
*old_chain
= NULL
;
2930 if (tracepoint_number
== -1)
2932 warning (_("No current trace frame."));
2936 t
= get_tracepoint (tracepoint_number
);
2939 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2942 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2943 tracepoint_number
, traceframe_number
);
2945 /* The current frame is a trap frame if the frame PC is equal
2946 to the tracepoint PC. If not, then the current frame was
2947 collected during single-stepping. */
2949 regcache
= get_current_regcache ();
2951 /* If the traceframe's address matches any of the tracepoint's
2952 locations, assume it is a direct hit rather than a while-stepping
2953 frame. (FIXME this is not reliable, should record each frame's
2956 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2957 if (loc
->address
== regcache_read_pc (regcache
))
2960 actions
= breakpoint_commands (&t
->base
);
2962 /* If there is a default-collect list, make up a collect command,
2963 prepend to the tracepoint's commands, and pass the whole mess to
2964 the trace dump scanner. We need to validate because
2965 default-collect might have been junked since the trace run. */
2966 if (*default_collect
)
2968 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2969 old_chain
= make_cleanup (xfree
, default_collect_line
);
2970 validate_actionline (default_collect_line
, &t
->base
);
2971 default_collect_action
= xmalloc (sizeof (struct command_line
));
2972 make_cleanup (xfree
, default_collect_action
);
2973 default_collect_action
->next
= actions
;
2974 default_collect_action
->line
= default_collect_line
;
2975 actions
= default_collect_action
;
2978 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2980 if (*default_collect
)
2981 do_cleanups (old_chain
);
2984 /* Encode a piece of a tracepoint's source-level definition in a form
2985 that is suitable for both protocol and saving in files. */
2986 /* This version does not do multiple encodes for long strings; it should
2987 return an offset to the next piece to encode. FIXME */
2990 encode_source_string (int tpnum
, ULONGEST addr
,
2991 char *srctype
, char *src
, char *buf
, int buf_size
)
2993 if (80 + strlen (srctype
) > buf_size
)
2994 error (_("Buffer too small for source encoding"));
2995 sprintf (buf
, "%x:%s:%s:%x:%x:",
2996 tpnum
, phex_nz (addr
, sizeof (addr
)),
2997 srctype
, 0, (int) strlen (src
));
2998 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2999 error (_("Source string too long for buffer"));
3000 bin2hex (src
, buf
+ strlen (buf
), 0);
3004 /* Free trace file writer. */
3007 trace_file_writer_xfree (void *arg
)
3009 struct trace_file_writer
*writer
= arg
;
3011 writer
->ops
->dtor (writer
);
3015 /* TFILE trace writer. */
3017 struct tfile_trace_file_writer
3019 struct trace_file_writer base
;
3021 /* File pointer to tfile trace file. */
3023 /* Path name of the tfile trace file. */
3027 /* This is the implementation of trace_file_write_ops method
3028 target_save. We just call the generic target
3029 target_save_trace_data to do target-side saving. */
3032 tfile_target_save (struct trace_file_writer
*self
,
3033 const char *filename
)
3035 int err
= target_save_trace_data (filename
);
3040 /* This is the implementation of trace_file_write_ops method
3044 tfile_dtor (struct trace_file_writer
*self
)
3046 struct tfile_trace_file_writer
*writer
3047 = (struct tfile_trace_file_writer
*) self
;
3049 xfree (writer
->pathname
);
3051 if (writer
->fp
!= NULL
)
3052 fclose (writer
->fp
);
3055 /* This is the implementation of trace_file_write_ops method
3056 start. It creates the trace file FILENAME and registers some
3060 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3062 struct tfile_trace_file_writer
*writer
3063 = (struct tfile_trace_file_writer
*) self
;
3065 writer
->pathname
= tilde_expand (filename
);
3066 writer
->fp
= fopen (writer
->pathname
, "wb");
3067 if (writer
->fp
== NULL
)
3068 error (_("Unable to open file '%s' for saving trace data (%s)"),
3069 filename
, safe_strerror (errno
));
3072 /* This is the implementation of trace_file_write_ops method
3073 write_header. Write the TFILE header. */
3076 tfile_write_header (struct trace_file_writer
*self
)
3078 struct tfile_trace_file_writer
*writer
3079 = (struct tfile_trace_file_writer
*) self
;
3082 /* Write a file header, with a high-bit-set char to indicate a
3083 binary file, plus a hint as what this file is, and a version
3084 number in case of future needs. */
3085 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3087 perror_with_name (writer
->pathname
);
3090 /* This is the implementation of trace_file_write_ops method
3091 write_regblock_type. Write the size of register block. */
3094 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3096 struct tfile_trace_file_writer
*writer
3097 = (struct tfile_trace_file_writer
*) self
;
3099 fprintf (writer
->fp
, "R %x\n", size
);
3102 /* This is the implementation of trace_file_write_ops method
3106 tfile_write_status (struct trace_file_writer
*self
,
3107 struct trace_status
*ts
)
3109 struct tfile_trace_file_writer
*writer
3110 = (struct tfile_trace_file_writer
*) self
;
3112 fprintf (writer
->fp
, "status %c;%s",
3113 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3114 if (ts
->stop_reason
== tracepoint_error
3115 || ts
->stop_reason
== tstop_command
)
3117 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3119 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3120 fprintf (writer
->fp
, ":%s", buf
);
3122 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3123 if (ts
->traceframe_count
>= 0)
3124 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3125 if (ts
->traceframes_created
>= 0)
3126 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3127 if (ts
->buffer_free
>= 0)
3128 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3129 if (ts
->buffer_size
>= 0)
3130 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3131 if (ts
->disconnected_tracing
)
3132 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3133 if (ts
->circular_buffer
)
3134 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3135 if (ts
->notes
!= NULL
)
3137 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3139 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3140 fprintf (writer
->fp
, ";notes:%s", buf
);
3142 if (ts
->user_name
!= NULL
)
3144 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3146 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3147 fprintf (writer
->fp
, ";username:%s", buf
);
3149 fprintf (writer
->fp
, "\n");
3152 /* This is the implementation of trace_file_write_ops method
3153 write_uploaded_tsv. */
3156 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3157 struct uploaded_tsv
*utsv
)
3160 struct tfile_trace_file_writer
*writer
3161 = (struct tfile_trace_file_writer
*) self
;
3165 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3166 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3169 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3170 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3171 utsv
->builtin
, buf
);
3177 #define MAX_TRACE_UPLOAD 2000
3179 /* This is the implementation of trace_file_write_ops method
3180 write_uploaded_tp. */
3183 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3184 struct uploaded_tp
*utp
)
3186 struct tfile_trace_file_writer
*writer
3187 = (struct tfile_trace_file_writer
*) self
;
3190 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3192 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3193 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3194 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3195 if (utp
->type
== bp_fast_tracepoint
)
3196 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3198 fprintf (writer
->fp
,
3199 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3201 fprintf (writer
->fp
, "\n");
3202 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3203 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3204 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3205 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3206 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3207 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3210 encode_source_string (utp
->number
, utp
->addr
,
3211 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3212 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3214 if (utp
->cond_string
)
3216 encode_source_string (utp
->number
, utp
->addr
,
3217 "cond", utp
->cond_string
,
3218 buf
, MAX_TRACE_UPLOAD
);
3219 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3221 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3223 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3224 buf
, MAX_TRACE_UPLOAD
);
3225 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3227 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3228 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3230 phex_nz (utp
->traceframe_usage
,
3231 sizeof (utp
->traceframe_usage
)));
3234 /* This is the implementation of trace_file_write_ops method
3235 write_definition_end. */
3238 tfile_write_definition_end (struct trace_file_writer
*self
)
3240 struct tfile_trace_file_writer
*writer
3241 = (struct tfile_trace_file_writer
*) self
;
3243 fprintf (writer
->fp
, "\n");
3246 /* This is the implementation of trace_file_write_ops method
3250 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3253 struct tfile_trace_file_writer
*writer
3254 = (struct tfile_trace_file_writer
*) self
;
3256 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3257 perror_with_name (writer
->pathname
);
3260 /* This is the implementation of trace_file_write_ops method
3264 tfile_end (struct trace_file_writer
*self
)
3266 struct tfile_trace_file_writer
*writer
3267 = (struct tfile_trace_file_writer
*) self
;
3268 uint32_t gotten
= 0;
3270 /* Mark the end of trace data. */
3271 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3272 perror_with_name (writer
->pathname
);
3275 /* Operations to write trace buffers into TFILE format. */
3277 static const struct trace_file_write_ops tfile_write_ops
=
3283 tfile_write_regblock_type
,
3285 tfile_write_uploaded_tsv
,
3286 tfile_write_uploaded_tp
,
3287 tfile_write_definition_end
,
3288 tfile_write_raw_data
,
3293 /* Helper macros. */
3295 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3296 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3297 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3298 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3300 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3301 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3303 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3304 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3306 extern int trace_regblock_size
;
3308 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3309 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3310 the save is performed on the target, otherwise GDB obtains all trace
3311 data and saves it locally. */
3314 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3315 int target_does_save
)
3317 struct trace_status
*ts
= current_trace_status ();
3319 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3320 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3322 ULONGEST offset
= 0;
3323 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3325 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3327 /* If the target is to save the data to a file on its own, then just
3328 send the command and be done with it. */
3329 if (target_does_save
)
3331 if (!writer
->ops
->target_save (writer
, filename
))
3332 error (_("Target failed to save trace data to '%s'."),
3337 /* Get the trace status first before opening the file, so if the
3338 target is losing, we can get out without touching files. */
3339 status
= target_get_trace_status (ts
);
3341 writer
->ops
->start (writer
, filename
);
3343 writer
->ops
->write_header (writer
);
3345 /* Write descriptive info. */
3347 /* Write out the size of a register block. */
3348 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3350 /* Write out status of the tracing run (aka "tstatus" info). */
3351 writer
->ops
->write_status (writer
, ts
);
3353 /* Note that we want to upload tracepoints and save those, rather
3354 than simply writing out the local ones, because the user may have
3355 changed tracepoints in GDB in preparation for a future tracing
3356 run, or maybe just mass-deleted all types of breakpoints as part
3357 of cleaning up. So as not to contaminate the session, leave the
3358 data in its uploaded form, don't make into real tracepoints. */
3360 /* Get trace state variables first, they may be checked when parsing
3361 uploaded commands. */
3363 target_upload_trace_state_variables (&uploaded_tsvs
);
3365 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3366 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3368 free_uploaded_tsvs (&uploaded_tsvs
);
3370 target_upload_tracepoints (&uploaded_tps
);
3372 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3373 target_get_tracepoint_status (NULL
, utp
);
3375 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3376 writer
->ops
->write_uploaded_tp (writer
, utp
);
3378 free_uploaded_tps (&uploaded_tps
);
3380 /* Mark the end of the definition section. */
3381 writer
->ops
->write_definition_end (writer
);
3383 /* Get and write the trace data proper. */
3388 /* The writer supports writing the contents of trace buffer
3389 directly to trace file. Don't parse the contents of trace
3391 if (writer
->ops
->write_trace_buffer
!= NULL
)
3393 /* We ask for big blocks, in the hopes of efficiency, but
3394 will take less if the target has packet size limitations
3396 gotten
= target_get_raw_trace_data (buf
, offset
,
3399 error (_("Failure to get requested trace buffer data"));
3400 /* No more data is forthcoming, we're done. */
3404 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3412 /* Parse the trace buffers according to how data are stored
3413 in trace buffer in GDBserver. */
3415 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3420 /* Read the first six bytes in, which is the tracepoint
3421 number and trace frame size. */
3423 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3425 tf_size
= (uint32_t)
3426 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3428 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3437 for (block
= 0; block
< tf_size
; )
3439 gdb_byte block_type
;
3441 /* We'll fetch one block each time, in order to
3442 handle the extremely large 'M' block. We first
3443 fetch one byte to get the type of the block. */
3444 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3446 error (_("Failure to get requested trace buffer data"));
3452 block_type
= buf
[0];
3457 = target_get_raw_trace_data (buf
, offset
,
3458 trace_regblock_size
);
3459 if (gotten
< trace_regblock_size
)
3460 error (_("Failure to get requested trace"
3463 TRACE_WRITE_R_BLOCK (writer
, buf
,
3464 trace_regblock_size
);
3468 unsigned short mlen
;
3473 t
= target_get_raw_trace_data (buf
,offset
, 10);
3475 error (_("Failure to get requested trace"
3483 extract_unsigned_integer (buf
, 8,
3485 mlen
= (unsigned short)
3486 extract_unsigned_integer (&buf
[8], 2,
3489 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3492 /* The memory contents in 'M' block may be
3493 very large. Fetch the data from the target
3494 and write them into file one by one. */
3495 for (j
= 0; j
< mlen
; )
3497 unsigned int read_length
;
3499 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3500 read_length
= MAX_TRACE_UPLOAD
;
3502 read_length
= mlen
- j
;
3504 t
= target_get_raw_trace_data (buf
,
3507 if (t
< read_length
)
3508 error (_("Failure to get requested"
3509 " trace buffer data"));
3511 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3515 gotten
+= read_length
;
3526 = target_get_raw_trace_data (buf
, offset
,
3529 error (_("Failure to get requested"
3530 " trace buffer data"));
3532 vnum
= (int) extract_signed_integer (buf
,
3536 = extract_signed_integer (&buf
[4], 8,
3539 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3543 error (_("Unknown block type '%c' (0x%x) in"
3545 block_type
, block_type
);
3555 writer
->ops
->frame_ops
->end (writer
);
3559 writer
->ops
->end (writer
);
3562 /* Return a trace writer for TFILE format. */
3564 static struct trace_file_writer
*
3565 tfile_trace_file_writer_new (void)
3567 struct tfile_trace_file_writer
*writer
3568 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3570 writer
->base
.ops
= &tfile_write_ops
;
3572 writer
->pathname
= NULL
;
3574 return (struct trace_file_writer
*) writer
;
3578 trace_save_command (char *args
, int from_tty
)
3580 int target_does_save
= 0;
3582 char *filename
= NULL
;
3583 struct cleanup
*back_to
;
3584 int generate_ctf
= 0;
3585 struct trace_file_writer
*writer
= NULL
;
3588 error_no_arg (_("file in which to save trace data"));
3590 argv
= gdb_buildargv (args
);
3591 back_to
= make_cleanup_freeargv (argv
);
3593 for (; *argv
; ++argv
)
3595 if (strcmp (*argv
, "-r") == 0)
3596 target_does_save
= 1;
3597 if (strcmp (*argv
, "-ctf") == 0)
3599 else if (**argv
== '-')
3600 error (_("unknown option `%s'"), *argv
);
3606 error_no_arg (_("file in which to save trace data"));
3609 writer
= ctf_trace_file_writer_new ();
3611 writer
= tfile_trace_file_writer_new ();
3613 make_cleanup (trace_file_writer_xfree
, writer
);
3615 trace_save (filename
, writer
, target_does_save
);
3618 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3619 generate_ctf
? "directory" : "file", filename
);
3621 do_cleanups (back_to
);
3624 /* Save the trace data to file FILENAME of tfile format. */
3627 trace_save_tfile (const char *filename
, int target_does_save
)
3629 struct trace_file_writer
*writer
;
3630 struct cleanup
*back_to
;
3632 writer
= tfile_trace_file_writer_new ();
3633 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3634 trace_save (filename
, writer
, target_does_save
);
3635 do_cleanups (back_to
);
3638 /* Save the trace data to dir DIRNAME of ctf format. */
3641 trace_save_ctf (const char *dirname
, int target_does_save
)
3643 struct trace_file_writer
*writer
;
3644 struct cleanup
*back_to
;
3646 writer
= ctf_trace_file_writer_new ();
3647 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3649 trace_save (dirname
, writer
, target_does_save
);
3650 do_cleanups (back_to
);
3653 /* Tell the target what to do with an ongoing tracing run if GDB
3654 disconnects for some reason. */
3657 set_disconnected_tracing (char *args
, int from_tty
,
3658 struct cmd_list_element
*c
)
3660 target_set_disconnected_tracing (disconnected_tracing
);
3664 set_circular_trace_buffer (char *args
, int from_tty
,
3665 struct cmd_list_element
*c
)
3667 target_set_circular_trace_buffer (circular_trace_buffer
);
3671 set_trace_buffer_size (char *args
, int from_tty
,
3672 struct cmd_list_element
*c
)
3674 target_set_trace_buffer_size (trace_buffer_size
);
3678 set_trace_user (char *args
, int from_tty
,
3679 struct cmd_list_element
*c
)
3683 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3686 warning (_("Target does not support trace notes, user ignored"));
3690 set_trace_notes (char *args
, int from_tty
,
3691 struct cmd_list_element
*c
)
3695 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3698 warning (_("Target does not support trace notes, note ignored"));
3702 set_trace_stop_notes (char *args
, int from_tty
,
3703 struct cmd_list_element
*c
)
3707 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3710 warning (_("Target does not support trace notes, stop note ignored"));
3713 /* Convert the memory pointed to by mem into hex, placing result in buf.
3714 * Return a pointer to the last char put in buf (null)
3715 * "stolen" from sparc-stub.c
3718 static const char hexchars
[] = "0123456789abcdef";
3721 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3729 *buf
++ = hexchars
[ch
>> 4];
3730 *buf
++ = hexchars
[ch
& 0xf];
3739 get_traceframe_number (void)
3741 return traceframe_number
;
3744 /* Make the traceframe NUM be the current trace frame. Does nothing
3745 if NUM is already current. */
3748 set_current_traceframe (int num
)
3752 if (traceframe_number
== num
)
3754 /* Nothing to do. */
3758 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3761 warning (_("could not change traceframe"));
3763 set_traceframe_num (newnum
);
3765 /* Changing the traceframe changes our view of registers and of the
3767 registers_changed ();
3769 clear_traceframe_info ();
3772 /* Make the traceframe NUM be the current trace frame, and do nothing
3776 set_traceframe_number (int num
)
3778 traceframe_number
= num
;
3781 /* A cleanup used when switching away and back from tfind mode. */
3783 struct current_traceframe_cleanup
3785 /* The traceframe we were inspecting. */
3786 int traceframe_number
;
3790 do_restore_current_traceframe_cleanup (void *arg
)
3792 struct current_traceframe_cleanup
*old
= arg
;
3794 set_current_traceframe (old
->traceframe_number
);
3798 restore_current_traceframe_cleanup_dtor (void *arg
)
3800 struct current_traceframe_cleanup
*old
= arg
;
3806 make_cleanup_restore_current_traceframe (void)
3808 struct current_traceframe_cleanup
*old
;
3810 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3811 old
->traceframe_number
= traceframe_number
;
3813 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3814 restore_current_traceframe_cleanup_dtor
);
3818 make_cleanup_restore_traceframe_number (void)
3820 return make_cleanup_restore_integer (&traceframe_number
);
3823 /* Given a number and address, return an uploaded tracepoint with that
3824 number, creating if necessary. */
3826 struct uploaded_tp
*
3827 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3829 struct uploaded_tp
*utp
;
3831 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3832 if (utp
->number
== num
&& utp
->addr
== addr
)
3834 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3835 memset (utp
, 0, sizeof (struct uploaded_tp
));
3838 utp
->actions
= NULL
;
3839 utp
->step_actions
= NULL
;
3840 utp
->cmd_strings
= NULL
;
3847 free_uploaded_tps (struct uploaded_tp
**utpp
)
3849 struct uploaded_tp
*next_one
;
3853 next_one
= (*utpp
)->next
;
3859 /* Given a number and address, return an uploaded tracepoint with that
3860 number, creating if necessary. */
3862 static struct uploaded_tsv
*
3863 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3865 struct uploaded_tsv
*utsv
;
3867 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3868 if (utsv
->number
== num
)
3870 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3871 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3873 utsv
->next
= *utsvp
;
3879 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3881 struct uploaded_tsv
*next_one
;
3885 next_one
= (*utsvp
)->next
;
3891 /* FIXME this function is heuristic and will miss the cases where the
3892 conditional is semantically identical but differs in whitespace,
3893 such as "x == 0" vs "x==0". */
3896 cond_string_is_same (char *str1
, char *str2
)
3898 if (str1
== NULL
|| str2
== NULL
)
3899 return (str1
== str2
);
3901 return (strcmp (str1
, str2
) == 0);
3904 /* Look for an existing tracepoint that seems similar enough to the
3905 uploaded one. Enablement isn't compared, because the user can
3906 toggle that freely, and may have done so in anticipation of the
3907 next trace run. Return the location of matched tracepoint. */
3909 static struct bp_location
*
3910 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3912 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3914 struct breakpoint
*b
;
3915 struct bp_location
*loc
;
3917 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3919 struct tracepoint
*t
= (struct tracepoint
*) b
;
3921 if (b
->type
== utp
->type
3922 && t
->step_count
== utp
->step
3923 && t
->pass_count
== utp
->pass
3924 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3925 /* FIXME also test actions. */
3928 /* Scan the locations for an address match. */
3929 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3931 if (loc
->address
== utp
->addr
)
3939 /* Given a list of tracepoints uploaded from a target, attempt to
3940 match them up with existing tracepoints, and create new ones if not
3944 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3946 struct uploaded_tp
*utp
;
3947 /* A set of tracepoints which are modified. */
3948 VEC(breakpoint_p
) *modified_tp
= NULL
;
3950 struct breakpoint
*b
;
3952 /* Look for GDB tracepoints that match up with our uploaded versions. */
3953 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3955 struct bp_location
*loc
;
3956 struct tracepoint
*t
;
3958 loc
= find_matching_tracepoint_location (utp
);
3963 /* Mark this location as already inserted. */
3965 t
= (struct tracepoint
*) loc
->owner
;
3966 printf_filtered (_("Assuming tracepoint %d is same "
3967 "as target's tracepoint %d at %s.\n"),
3968 loc
->owner
->number
, utp
->number
,
3969 paddress (loc
->gdbarch
, utp
->addr
));
3971 /* The tracepoint LOC->owner was modified (the location LOC
3972 was marked as inserted in the target). Save it in
3973 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3974 observers will be notified later once for each tracepoint
3975 saved in MODIFIED_TP. */
3977 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3979 if (b
== loc
->owner
)
3985 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3989 t
= create_tracepoint_from_upload (utp
);
3991 printf_filtered (_("Created tracepoint %d for "
3992 "target's tracepoint %d at %s.\n"),
3993 t
->base
.number
, utp
->number
,
3994 paddress (get_current_arch (), utp
->addr
));
3996 printf_filtered (_("Failed to create tracepoint for target's "
3997 "tracepoint %d at %s, skipping it.\n"),
3999 paddress (get_current_arch (), utp
->addr
));
4001 /* Whether found or created, record the number used by the
4002 target, to help with mapping target tracepoints back to their
4003 counterparts here. */
4005 t
->number_on_target
= utp
->number
;
4008 /* Notify 'breakpoint-modified' observer that at least one of B's
4009 locations was changed. */
4010 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4011 observer_notify_breakpoint_modified (b
);
4013 VEC_free (breakpoint_p
, modified_tp
);
4014 free_uploaded_tps (uploaded_tps
);
4017 /* Trace state variables don't have much to identify them beyond their
4018 name, so just use that to detect matches. */
4020 static struct trace_state_variable
*
4021 find_matching_tsv (struct uploaded_tsv
*utsv
)
4026 return find_trace_state_variable (utsv
->name
);
4029 static struct trace_state_variable
*
4030 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4032 const char *namebase
;
4035 struct trace_state_variable
*tsv
;
4036 struct cleanup
*old_chain
;
4040 namebase
= utsv
->name
;
4041 buf
= xstrprintf ("%s", namebase
);
4046 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4049 /* Fish for a name that is not in use. */
4050 /* (should check against all internal vars?) */
4051 while (find_trace_state_variable (buf
))
4054 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4057 old_chain
= make_cleanup (xfree
, buf
);
4059 /* We have an available name, create the variable. */
4060 tsv
= create_trace_state_variable (buf
);
4061 tsv
->initial_value
= utsv
->initial_value
;
4062 tsv
->builtin
= utsv
->builtin
;
4064 observer_notify_tsv_created (tsv
);
4066 do_cleanups (old_chain
);
4071 /* Given a list of uploaded trace state variables, try to match them
4072 up with existing variables, or create additional ones. */
4075 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4078 struct uploaded_tsv
*utsv
;
4079 struct trace_state_variable
*tsv
;
4082 /* Most likely some numbers will have to be reassigned as part of
4083 the merge, so clear them all in anticipation. */
4084 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4087 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4089 tsv
= find_matching_tsv (utsv
);
4093 printf_filtered (_("Assuming trace state variable $%s "
4094 "is same as target's variable %d.\n"),
4095 tsv
->name
, utsv
->number
);
4099 tsv
= create_tsv_from_upload (utsv
);
4101 printf_filtered (_("Created trace state variable "
4102 "$%s for target's variable %d.\n"),
4103 tsv
->name
, utsv
->number
);
4105 /* Give precedence to numberings that come from the target. */
4107 tsv
->number
= utsv
->number
;
4110 /* Renumber everything that didn't get a target-assigned number. */
4112 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4113 if (tsv
->number
> highest
)
4114 highest
= tsv
->number
;
4117 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4118 if (tsv
->number
== 0)
4119 tsv
->number
= highest
++;
4121 free_uploaded_tsvs (uploaded_tsvs
);
4124 /* target tfile command */
4126 static struct target_ops tfile_ops
;
4128 /* Fill in tfile_ops with its defined operations and properties. */
4130 #define TRACE_HEADER_SIZE 8
4132 static char *trace_filename
;
4133 static int trace_fd
= -1;
4134 static off_t trace_frames_offset
;
4135 static off_t cur_offset
;
4136 static int cur_data_size
;
4137 int trace_regblock_size
;
4139 static void tfile_interp_line (char *line
,
4140 struct uploaded_tp
**utpp
,
4141 struct uploaded_tsv
**utsvp
);
4143 /* Read SIZE bytes into READBUF from the trace frame, starting at
4144 TRACE_FD's current position. Note that this call `read'
4145 underneath, hence it advances the file's seek position. Throws an
4146 error if the `read' syscall fails, or less than SIZE bytes are
4150 tfile_read (gdb_byte
*readbuf
, int size
)
4154 gotten
= read (trace_fd
, readbuf
, size
);
4156 perror_with_name (trace_filename
);
4157 else if (gotten
< size
)
4158 error (_("Premature end of file while reading trace file"));
4162 tfile_open (char *filename
, int from_tty
)
4164 volatile struct gdb_exception ex
;
4166 struct cleanup
*old_chain
;
4169 char header
[TRACE_HEADER_SIZE
];
4170 char linebuf
[1000]; /* Should be max remote packet size or so. */
4173 struct trace_status
*ts
;
4174 struct uploaded_tp
*uploaded_tps
= NULL
;
4175 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4177 target_preopen (from_tty
);
4179 error (_("No trace file specified."));
4181 filename
= tilde_expand (filename
);
4182 if (!IS_ABSOLUTE_PATH(filename
))
4184 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4189 old_chain
= make_cleanup (xfree
, filename
);
4191 flags
= O_BINARY
| O_LARGEFILE
;
4193 scratch_chan
= open (filename
, flags
, 0);
4194 if (scratch_chan
< 0)
4195 perror_with_name (filename
);
4197 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4199 discard_cleanups (old_chain
); /* Don't free filename any more. */
4200 unpush_target (&tfile_ops
);
4202 trace_filename
= xstrdup (filename
);
4203 trace_fd
= scratch_chan
;
4206 /* Read the file header and test for validity. */
4207 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4209 bytes
+= TRACE_HEADER_SIZE
;
4210 if (!(header
[0] == 0x7f
4211 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4212 error (_("File is not a valid trace file."));
4214 push_target (&tfile_ops
);
4216 trace_regblock_size
= 0;
4217 ts
= current_trace_status ();
4218 /* We know we're working with a file. Record its name. */
4219 ts
->filename
= trace_filename
;
4220 /* Set defaults in case there is no status line. */
4221 ts
->running_known
= 0;
4222 ts
->stop_reason
= trace_stop_reason_unknown
;
4223 ts
->traceframe_count
= -1;
4224 ts
->buffer_free
= 0;
4225 ts
->disconnected_tracing
= 0;
4226 ts
->circular_buffer
= 0;
4228 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4230 /* Read through a section of newline-terminated lines that
4231 define things like tracepoints. */
4235 tfile_read (&byte
, 1);
4240 /* Empty line marks end of the definition section. */
4245 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4248 linebuf
[i
++] = byte
;
4250 error (_("Excessively long lines in trace file"));
4253 /* Record the starting offset of the binary trace data. */
4254 trace_frames_offset
= bytes
;
4256 /* If we don't have a blocksize, we can't interpret the
4258 if (trace_regblock_size
== 0)
4259 error (_("No register block size recorded in trace file"));
4263 /* Pop the partially set up target. */
4265 throw_exception (ex
);
4268 inferior_appeared (current_inferior (), TFILE_PID
);
4269 inferior_ptid
= pid_to_ptid (TFILE_PID
);
4270 add_thread_silent (inferior_ptid
);
4272 if (ts
->traceframe_count
<= 0)
4273 warning (_("No traceframes present in this file."));
4275 /* Add the file's tracepoints and variables into the current mix. */
4277 /* Get trace state variables first, they may be checked when parsing
4278 uploaded commands. */
4279 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4281 merge_uploaded_tracepoints (&uploaded_tps
);
4283 post_create_inferior (&tfile_ops
, from_tty
);
4286 /* Interpret the given line from the definitions part of the trace
4290 tfile_interp_line (char *line
,
4291 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
4295 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4298 trace_regblock_size
= strtol (p
, &p
, 16);
4300 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4302 p
+= strlen ("status ");
4303 parse_trace_status (p
, current_trace_status ());
4305 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4307 p
+= strlen ("tp ");
4308 parse_tracepoint_definition (p
, utpp
);
4310 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4312 p
+= strlen ("tsv ");
4313 parse_tsv_definition (p
, utsvp
);
4316 warning (_("Ignoring trace file definition \"%s\""), line
);
4319 /* Parse the part of trace status syntax that is shared between
4320 the remote protocol and the trace file reader. */
4323 parse_trace_status (char *line
, struct trace_status
*ts
)
4325 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4329 ts
->running_known
= 1;
4330 ts
->running
= (*p
++ == '1');
4331 ts
->stop_reason
= trace_stop_reason_unknown
;
4332 xfree (ts
->stop_desc
);
4333 ts
->stop_desc
= NULL
;
4334 ts
->traceframe_count
= -1;
4335 ts
->traceframes_created
= -1;
4336 ts
->buffer_free
= -1;
4337 ts
->buffer_size
= -1;
4338 ts
->disconnected_tracing
= 0;
4339 ts
->circular_buffer
= 0;
4340 xfree (ts
->user_name
);
4341 ts
->user_name
= NULL
;
4344 ts
->start_time
= ts
->stop_time
= 0;
4348 p1
= strchr (p
, ':');
4350 error (_("Malformed trace status, at %s\n\
4351 Status line: '%s'\n"), p
, line
);
4352 p3
= strchr (p
, ';');
4354 p3
= p
+ strlen (p
);
4355 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4357 p
= unpack_varlen_hex (++p1
, &val
);
4358 ts
->stop_reason
= trace_buffer_full
;
4360 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4362 p
= unpack_varlen_hex (++p1
, &val
);
4363 ts
->stop_reason
= trace_never_run
;
4365 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4368 p
= unpack_varlen_hex (++p1
, &val
);
4369 ts
->stop_reason
= tracepoint_passcount
;
4370 ts
->stopping_tracepoint
= val
;
4372 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4374 p2
= strchr (++p1
, ':');
4382 ts
->stop_desc
= xmalloc (strlen (line
));
4383 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
4384 ts
->stop_desc
[end
] = '\0';
4387 ts
->stop_desc
= xstrdup ("");
4389 p
= unpack_varlen_hex (++p2
, &val
);
4390 ts
->stop_reason
= tstop_command
;
4392 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4394 p
= unpack_varlen_hex (++p1
, &val
);
4395 ts
->stop_reason
= trace_disconnected
;
4397 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4399 p2
= strchr (++p1
, ':');
4402 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4403 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
4404 ts
->stop_desc
[end
] = '\0';
4407 ts
->stop_desc
= xstrdup ("");
4409 p
= unpack_varlen_hex (++p2
, &val
);
4410 ts
->stopping_tracepoint
= val
;
4411 ts
->stop_reason
= tracepoint_error
;
4413 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4415 p
= unpack_varlen_hex (++p1
, &val
);
4416 ts
->traceframe_count
= val
;
4418 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4420 p
= unpack_varlen_hex (++p1
, &val
);
4421 ts
->traceframes_created
= val
;
4423 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4425 p
= unpack_varlen_hex (++p1
, &val
);
4426 ts
->buffer_free
= val
;
4428 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4430 p
= unpack_varlen_hex (++p1
, &val
);
4431 ts
->buffer_size
= val
;
4433 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4435 p
= unpack_varlen_hex (++p1
, &val
);
4436 ts
->disconnected_tracing
= val
;
4438 else if (strncmp (p
, "circular", p1
- p
) == 0)
4440 p
= unpack_varlen_hex (++p1
, &val
);
4441 ts
->circular_buffer
= val
;
4443 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4445 p
= unpack_varlen_hex (++p1
, &val
);
4446 ts
->start_time
= val
;
4448 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4450 p
= unpack_varlen_hex (++p1
, &val
);
4451 ts
->stop_time
= val
;
4453 else if (strncmp (p
, "username", p1
- p
) == 0)
4456 ts
->user_name
= xmalloc (strlen (p
) / 2);
4457 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
4458 ts
->user_name
[end
] = '\0';
4461 else if (strncmp (p
, "notes", p1
- p
) == 0)
4464 ts
->notes
= xmalloc (strlen (p
) / 2);
4465 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
4466 ts
->notes
[end
] = '\0';
4471 /* Silently skip unknown optional info. */
4472 p_temp
= strchr (p1
+ 1, ';');
4476 /* Must be at the end. */
4483 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4484 struct uploaded_tp
*utp
)
4487 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4489 p
= unpack_varlen_hex (p
, &uval
);
4491 tp
->base
.hit_count
+= uval
;
4493 utp
->hit_count
+= uval
;
4494 p
= unpack_varlen_hex (p
+ 1, &uval
);
4496 tp
->traceframe_usage
+= uval
;
4498 utp
->traceframe_usage
+= uval
;
4499 /* Ignore any extra, allowing for future extensions. */
4502 /* Given a line of text defining a part of a tracepoint, parse it into
4503 an "uploaded tracepoint". */
4506 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4510 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4513 char *cond
, *srctype
, *buf
;
4514 struct uploaded_tp
*utp
= NULL
;
4517 /* Both tracepoint and action definitions start with the same number
4518 and address sequence. */
4520 p
= unpack_varlen_hex (p
, &num
);
4521 p
++; /* skip a colon */
4522 p
= unpack_varlen_hex (p
, &addr
);
4523 p
++; /* skip a colon */
4526 enabled
= (*p
++ == 'E');
4527 p
++; /* skip a colon */
4528 p
= unpack_varlen_hex (p
, &step
);
4529 p
++; /* skip a colon */
4530 p
= unpack_varlen_hex (p
, &pass
);
4531 type
= bp_tracepoint
;
4533 /* Thumb through optional fields. */
4536 p
++; /* skip a colon */
4539 type
= bp_fast_tracepoint
;
4541 p
= unpack_varlen_hex (p
, &orig_size
);
4545 type
= bp_static_tracepoint
;
4551 p
= unpack_varlen_hex (p
, &xlen
);
4552 p
++; /* skip a comma */
4553 cond
= (char *) xmalloc (2 * xlen
+ 1);
4554 strncpy (cond
, p
, 2 * xlen
);
4555 cond
[2 * xlen
] = '\0';
4559 warning (_("Unrecognized char '%c' in tracepoint "
4560 "definition, skipping rest"), *p
);
4562 utp
= get_uploaded_tp (num
, addr
, utpp
);
4564 utp
->enabled
= enabled
;
4569 else if (piece
== 'A')
4571 utp
= get_uploaded_tp (num
, addr
, utpp
);
4572 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4574 else if (piece
== 'S')
4576 utp
= get_uploaded_tp (num
, addr
, utpp
);
4577 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4579 else if (piece
== 'Z')
4581 /* Parse a chunk of source form definition. */
4582 utp
= get_uploaded_tp (num
, addr
, utpp
);
4584 p
= strchr (p
, ':');
4585 p
++; /* skip a colon */
4586 p
= unpack_varlen_hex (p
, &start
);
4587 p
++; /* skip a colon */
4588 p
= unpack_varlen_hex (p
, &xlen
);
4589 p
++; /* skip a colon */
4591 buf
= alloca (strlen (line
));
4593 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4596 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4597 utp
->at_string
= xstrdup (buf
);
4598 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4599 utp
->cond_string
= xstrdup (buf
);
4600 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4601 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4603 else if (piece
== 'V')
4605 utp
= get_uploaded_tp (num
, addr
, utpp
);
4607 parse_tracepoint_status (p
, NULL
, utp
);
4611 /* Don't error out, the target might be sending us optional
4612 info that we don't care about. */
4613 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4617 /* Convert a textual description of a trace state variable into an
4621 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4624 ULONGEST num
, initval
, builtin
;
4626 struct uploaded_tsv
*utsv
= NULL
;
4628 buf
= alloca (strlen (line
));
4631 p
= unpack_varlen_hex (p
, &num
);
4632 p
++; /* skip a colon */
4633 p
= unpack_varlen_hex (p
, &initval
);
4634 p
++; /* skip a colon */
4635 p
= unpack_varlen_hex (p
, &builtin
);
4636 p
++; /* skip a colon */
4637 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4640 utsv
= get_uploaded_tsv (num
, utsvp
);
4641 utsv
->initial_value
= initval
;
4642 utsv
->builtin
= builtin
;
4643 utsv
->name
= xstrdup (buf
);
4646 /* Close the trace file and generally clean up. */
4656 pid
= ptid_get_pid (inferior_ptid
);
4657 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4658 exit_inferior_silent (pid
);
4662 xfree (trace_filename
);
4663 trace_filename
= NULL
;
4667 tfile_files_info (struct target_ops
*t
)
4669 printf_filtered ("\t`%s'\n", trace_filename
);
4672 /* The trace status for a file is that tracing can never be run. */
4675 tfile_get_trace_status (struct trace_status
*ts
)
4677 /* Other bits of trace status were collected as part of opening the
4678 trace files, so nothing to do here. */
4684 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4686 /* Other bits of trace status were collected as part of opening the
4687 trace files, so nothing to do here. */
4690 /* Given the position of a traceframe in the file, figure out what
4691 address the frame was collected at. This would normally be the
4692 value of a collected PC register, but if not available, we
4696 tfile_get_traceframe_address (off_t tframe_offset
)
4700 struct tracepoint
*tp
;
4701 off_t saved_offset
= cur_offset
;
4703 /* FIXME dig pc out of collected registers. */
4705 /* Fall back to using tracepoint address. */
4706 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4707 tfile_read ((gdb_byte
*) &tpnum
, 2);
4708 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4710 (target_gdbarch ()));
4712 tp
= get_tracepoint_by_number_on_target (tpnum
);
4713 /* FIXME this is a poor heuristic if multiple locations. */
4714 if (tp
&& tp
->base
.loc
)
4715 addr
= tp
->base
.loc
->address
;
4717 /* Restore our seek position. */
4718 cur_offset
= saved_offset
;
4719 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4723 /* Given a type of search and some parameters, scan the collection of
4724 traceframes in the file looking for a match. When found, return
4725 both the traceframe and tracepoint number, otherwise -1 for
4729 tfile_trace_find (enum trace_find_type type
, int num
,
4730 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4733 int tfnum
= 0, found
= 0;
4734 unsigned int data_size
;
4735 struct tracepoint
*tp
;
4736 off_t offset
, tframe_offset
;
4746 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4747 offset
= trace_frames_offset
;
4750 tframe_offset
= offset
;
4751 tfile_read ((gdb_byte
*) &tpnum
, 2);
4752 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4754 (target_gdbarch ()));
4758 tfile_read ((gdb_byte
*) &data_size
, 4);
4759 data_size
= (unsigned int) extract_unsigned_integer
4760 ((gdb_byte
*) &data_size
, 4,
4761 gdbarch_byte_order (target_gdbarch ()));
4764 if (type
== tfind_number
)
4766 /* Looking for a specific trace frame. */
4772 /* Start from the _next_ trace frame. */
4773 if (tfnum
> traceframe_number
)
4778 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4779 if (tfaddr
== addr1
)
4783 tp
= get_tracepoint (num
);
4784 if (tp
&& tpnum
== tp
->number_on_target
)
4788 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4789 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4793 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4794 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4798 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4807 cur_offset
= offset
;
4808 cur_data_size
= data_size
;
4812 /* Skip past the traceframe's data. */
4813 lseek (trace_fd
, data_size
, SEEK_CUR
);
4814 offset
+= data_size
;
4815 /* Update our own count of traceframes. */
4818 /* Did not find what we were looking for. */
4824 /* Prototype of the callback passed to tframe_walk_blocks. */
4825 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4827 /* Callback for traceframe_walk_blocks, used to find a given block
4828 type in a traceframe. */
4831 match_blocktype (char blocktype
, void *data
)
4833 char *wantedp
= data
;
4835 if (*wantedp
== blocktype
)
4841 /* Walk over all traceframe block starting at POS offset from
4842 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4843 unmodified. If CALLBACK returns true, this returns the position in
4844 the traceframe where the block is found, relative to the start of
4845 the traceframe (cur_offset). Returns -1 if no callback call
4846 returned true, indicating that all blocks have been walked. */
4849 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4850 int pos
, void *data
)
4852 /* Iterate through a traceframe's blocks, looking for a block of the
4855 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4856 while (pos
< cur_data_size
)
4858 unsigned short mlen
;
4861 tfile_read (&block_type
, 1);
4865 if ((*callback
) (block_type
, data
))
4871 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4872 pos
+= trace_regblock_size
;
4875 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4876 tfile_read ((gdb_byte
*) &mlen
, 2);
4877 mlen
= (unsigned short)
4878 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4880 (target_gdbarch ()));
4881 lseek (trace_fd
, mlen
, SEEK_CUR
);
4882 pos
+= (8 + 2 + mlen
);
4885 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4889 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4890 block_type
, block_type
);
4898 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4899 position offset of a block of type TYPE_WANTED in the current trace
4900 frame, starting at POS. Returns -1 if no such block was found. */
4903 traceframe_find_block_type (char type_wanted
, int pos
)
4905 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4908 /* Look for a block of saved registers in the traceframe, and get the
4909 requested register from it. */
4912 tfile_fetch_registers (struct target_ops
*ops
,
4913 struct regcache
*regcache
, int regno
)
4915 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4916 int offset
, regn
, regsize
, pc_regno
;
4919 /* An uninitialized reg size says we're not going to be
4920 successful at getting register blocks. */
4921 if (!trace_regblock_size
)
4924 regs
= alloca (trace_regblock_size
);
4926 if (traceframe_find_block_type ('R', 0) >= 0)
4928 tfile_read (regs
, trace_regblock_size
);
4930 /* Assume the block is laid out in GDB register number order,
4931 each register with the size that it has in GDB. */
4933 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4935 regsize
= register_size (gdbarch
, regn
);
4936 /* Make sure we stay within block bounds. */
4937 if (offset
+ regsize
>= trace_regblock_size
)
4939 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4943 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4946 else if (regno
== -1)
4948 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4956 /* We get here if no register data has been found. Mark registers
4958 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4959 regcache_raw_supply (regcache
, regn
, NULL
);
4961 /* We can often usefully guess that the PC is going to be the same
4962 as the address of the tracepoint. */
4963 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4964 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4966 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4968 if (tp
&& tp
->base
.loc
)
4970 /* But don't try to guess if tracepoint is multi-location... */
4971 if (tp
->base
.loc
->next
)
4973 warning (_("Tracepoint %d has multiple "
4974 "locations, cannot infer $pc"),
4978 /* ... or does while-stepping. */
4979 if (tp
->step_count
> 0)
4981 warning (_("Tracepoint %d does while-stepping, "
4982 "cannot infer $pc"),
4987 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4988 gdbarch_byte_order (gdbarch
),
4989 tp
->base
.loc
->address
);
4990 regcache_raw_supply (regcache
, pc_regno
, regs
);
4996 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4997 const char *annex
, gdb_byte
*readbuf
,
4998 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5000 /* We're only doing regular memory for now. */
5001 if (object
!= TARGET_OBJECT_MEMORY
)
5004 if (readbuf
== NULL
)
5005 error (_("tfile_xfer_partial: trace file is read-only"));
5007 if (traceframe_number
!= -1)
5011 /* Iterate through the traceframe's blocks, looking for
5013 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5015 ULONGEST maddr
, amt
;
5016 unsigned short mlen
;
5017 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5019 tfile_read ((gdb_byte
*) &maddr
, 8);
5020 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5022 tfile_read ((gdb_byte
*) &mlen
, 2);
5023 mlen
= (unsigned short)
5024 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5026 /* If the block includes the first part of the desired
5027 range, return as much it has; GDB will re-request the
5028 remainder, which might be in a different block of this
5030 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5032 amt
= (maddr
+ mlen
) - offset
;
5036 if (maddr
!= offset
)
5037 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5038 tfile_read (readbuf
, amt
);
5042 /* Skip over this block. */
5043 pos
+= (8 + 2 + mlen
);
5047 /* It's unduly pedantic to refuse to look at the executable for
5048 read-only pieces; so do the equivalent of readonly regions aka
5050 /* FIXME account for relocation at some point. */
5057 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5059 if ((s
->flags
& SEC_LOAD
) == 0
5060 || (s
->flags
& SEC_READONLY
) == 0)
5064 size
= bfd_get_section_size (s
);
5065 if (vma
<= offset
&& offset
< (vma
+ size
))
5069 amt
= (vma
+ size
) - offset
;
5073 amt
= bfd_get_section_contents (exec_bfd
, s
,
5074 readbuf
, offset
- vma
, amt
);
5080 /* Indicate failure to find the requested memory block. */
5084 /* Iterate through the blocks of a trace frame, looking for a 'V'
5085 block with a matching tsv number. */
5088 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5093 /* Iterate over blocks in current frame and find the last 'V'
5094 block in which tsv number is TSVNUM. In one trace frame, there
5095 may be multiple 'V' blocks created for a given trace variable,
5096 and the last matched 'V' block contains the updated value. */
5098 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5102 tfile_read ((gdb_byte
*) &vnum
, 4);
5103 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5105 (target_gdbarch ()));
5108 tfile_read ((gdb_byte
*) val
, 8);
5109 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5111 (target_gdbarch ()));
5121 tfile_has_all_memory (struct target_ops
*ops
)
5127 tfile_has_memory (struct target_ops
*ops
)
5133 tfile_has_stack (struct target_ops
*ops
)
5135 return traceframe_number
!= -1;
5139 tfile_has_registers (struct target_ops
*ops
)
5141 return traceframe_number
!= -1;
5145 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
5150 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5151 object for the tfile target's current traceframe. */
5154 build_traceframe_info (char blocktype
, void *data
)
5156 struct traceframe_info
*info
= data
;
5162 struct mem_range
*r
;
5164 unsigned short mlen
;
5166 tfile_read ((gdb_byte
*) &maddr
, 8);
5167 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5169 (target_gdbarch ()));
5170 tfile_read ((gdb_byte
*) &mlen
, 2);
5171 mlen
= (unsigned short)
5172 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5173 2, gdbarch_byte_order
5174 (target_gdbarch ()));
5176 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5189 warning (_("Unhandled trace block type (%d) '%c ' "
5190 "while building trace frame info."),
5191 blocktype
, blocktype
);
5198 static struct traceframe_info
*
5199 tfile_traceframe_info (void)
5201 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5203 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5208 init_tfile_ops (void)
5210 tfile_ops
.to_shortname
= "tfile";
5211 tfile_ops
.to_longname
= "Local trace dump file";
5213 = "Use a trace file as a target. Specify the filename of the trace file.";
5214 tfile_ops
.to_open
= tfile_open
;
5215 tfile_ops
.to_close
= tfile_close
;
5216 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5217 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5218 tfile_ops
.to_files_info
= tfile_files_info
;
5219 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5220 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5221 tfile_ops
.to_trace_find
= tfile_trace_find
;
5222 tfile_ops
.to_get_trace_state_variable_value
5223 = tfile_get_trace_state_variable_value
;
5224 tfile_ops
.to_stratum
= process_stratum
;
5225 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5226 tfile_ops
.to_has_memory
= tfile_has_memory
;
5227 tfile_ops
.to_has_stack
= tfile_has_stack
;
5228 tfile_ops
.to_has_registers
= tfile_has_registers
;
5229 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5230 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
5231 tfile_ops
.to_magic
= OPS_MAGIC
;
5235 free_current_marker (void *arg
)
5237 struct static_tracepoint_marker
**marker_p
= arg
;
5239 if (*marker_p
!= NULL
)
5241 release_static_tracepoint_marker (*marker_p
);
5248 /* Given a line of text defining a static tracepoint marker, parse it
5249 into a "static tracepoint marker" object. Throws an error is
5250 parsing fails. If PP is non-null, it points to one past the end of
5251 the parsed marker definition. */
5254 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5255 struct static_tracepoint_marker
*marker
)
5262 p
= unpack_varlen_hex (p
, &addr
);
5263 p
++; /* skip a colon */
5265 marker
->gdbarch
= target_gdbarch ();
5266 marker
->address
= (CORE_ADDR
) addr
;
5268 endp
= strchr (p
, ':');
5270 error (_("bad marker definition: %s"), line
);
5272 marker
->str_id
= xmalloc (endp
- p
+ 1);
5273 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5274 marker
->str_id
[end
] = '\0';
5277 p
++; /* skip a colon */
5279 marker
->extra
= xmalloc (strlen (p
) + 1);
5280 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5281 marker
->extra
[end
] = '\0';
5287 /* Release a static tracepoint marker's contents. Note that the
5288 object itself isn't released here. There objects are usually on
5292 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5294 xfree (marker
->str_id
);
5295 marker
->str_id
= NULL
;
5298 /* Print MARKER to gdb_stdout. */
5301 print_one_static_tracepoint_marker (int count
,
5302 struct static_tracepoint_marker
*marker
)
5304 struct command_line
*l
;
5307 char wrap_indent
[80];
5308 char extra_field_indent
[80];
5309 struct ui_out
*uiout
= current_uiout
;
5310 struct cleanup
*bkpt_chain
;
5311 VEC(breakpoint_p
) *tracepoints
;
5313 struct symtab_and_line sal
;
5317 sal
.pc
= marker
->address
;
5319 tracepoints
= static_tracepoints_here (marker
->address
);
5321 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5323 /* A counter field to help readability. This is not a stable
5325 ui_out_field_int (uiout
, "count", count
);
5327 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5329 ui_out_field_fmt (uiout
, "enabled", "%c",
5330 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5331 ui_out_spaces (uiout
, 2);
5333 strcpy (wrap_indent
, " ");
5335 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5336 strcat (wrap_indent
, " ");
5338 strcat (wrap_indent
, " ");
5340 strcpy (extra_field_indent
, " ");
5342 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5344 sal
= find_pc_line (marker
->address
, 0);
5345 sym
= find_pc_sect_function (marker
->address
, NULL
);
5348 ui_out_text (uiout
, "in ");
5349 ui_out_field_string (uiout
, "func",
5350 SYMBOL_PRINT_NAME (sym
));
5351 ui_out_wrap_hint (uiout
, wrap_indent
);
5352 ui_out_text (uiout
, " at ");
5355 ui_out_field_skip (uiout
, "func");
5357 if (sal
.symtab
!= NULL
)
5359 ui_out_field_string (uiout
, "file",
5360 symtab_to_filename_for_display (sal
.symtab
));
5361 ui_out_text (uiout
, ":");
5363 if (ui_out_is_mi_like_p (uiout
))
5365 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5367 ui_out_field_string (uiout
, "fullname", fullname
);
5370 ui_out_field_skip (uiout
, "fullname");
5372 ui_out_field_int (uiout
, "line", sal
.line
);
5376 ui_out_field_skip (uiout
, "fullname");
5377 ui_out_field_skip (uiout
, "line");
5380 ui_out_text (uiout
, "\n");
5381 ui_out_text (uiout
, extra_field_indent
);
5382 ui_out_text (uiout
, _("Data: \""));
5383 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5384 ui_out_text (uiout
, "\"\n");
5386 if (!VEC_empty (breakpoint_p
, tracepoints
))
5388 struct cleanup
*cleanup_chain
;
5390 struct breakpoint
*b
;
5392 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5395 ui_out_text (uiout
, extra_field_indent
);
5396 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5397 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5400 ui_out_text (uiout
, ", ");
5401 ui_out_text (uiout
, "#");
5402 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5405 do_cleanups (cleanup_chain
);
5407 if (ui_out_is_mi_like_p (uiout
))
5408 ui_out_field_int (uiout
, "number-of-tracepoints",
5409 VEC_length(breakpoint_p
, tracepoints
));
5411 ui_out_text (uiout
, "\n");
5413 VEC_free (breakpoint_p
, tracepoints
);
5415 do_cleanups (bkpt_chain
);
5419 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5421 VEC(static_tracepoint_marker_p
) *markers
;
5422 struct cleanup
*old_chain
;
5423 struct static_tracepoint_marker
*marker
;
5424 struct ui_out
*uiout
= current_uiout
;
5427 /* We don't have to check target_can_use_agent and agent's capability on
5428 static tracepoint here, in order to be compatible with older GDBserver.
5429 We don't check USE_AGENT is true or not, because static tracepoints
5430 don't work without in-process agent, so we don't bother users to type
5431 `set agent on' when to use static tracepoint. */
5434 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5435 "StaticTracepointMarkersTable");
5437 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5439 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5441 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5442 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5443 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5445 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5446 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5448 ui_out_table_body (uiout
);
5450 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5451 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5454 VEC_iterate (static_tracepoint_marker_p
,
5455 markers
, i
, marker
);
5458 print_one_static_tracepoint_marker (i
+ 1, marker
);
5459 release_static_tracepoint_marker (marker
);
5462 do_cleanups (old_chain
);
5465 /* The $_sdata convenience variable is a bit special. We don't know
5466 for sure type of the value until we actually have a chance to fetch
5467 the data --- the size of the object depends on what has been
5468 collected. We solve this by making $_sdata be an internalvar that
5469 creates a new value on access. */
5471 /* Return a new value with the correct type for the sdata object of
5472 the current trace frame. Return a void value if there's no object
5475 static struct value
*
5476 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5482 /* We need to read the whole object before we know its size. */
5483 size
= target_read_alloc (¤t_target
,
5484 TARGET_OBJECT_STATIC_TRACE_DATA
,
5491 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5493 v
= allocate_value (type
);
5494 memcpy (value_contents_raw (v
), buf
, size
);
5499 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5502 #if !defined(HAVE_LIBEXPAT)
5504 struct traceframe_info
*
5505 parse_traceframe_info (const char *tframe_info
)
5507 static int have_warned
;
5512 warning (_("Can not parse XML trace frame info; XML support "
5513 "was disabled at compile time"));
5519 #else /* HAVE_LIBEXPAT */
5521 #include "xml-support.h"
5523 /* Handle the start of a <memory> element. */
5526 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5527 const struct gdb_xml_element
*element
,
5528 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5530 struct traceframe_info
*info
= user_data
;
5531 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5532 ULONGEST
*start_p
, *length_p
;
5534 start_p
= xml_find_attribute (attributes
, "start")->value
;
5535 length_p
= xml_find_attribute (attributes
, "length")->value
;
5537 r
->start
= *start_p
;
5538 r
->length
= *length_p
;
5541 /* Discard the constructed trace frame info (if an error occurs). */
5544 free_result (void *p
)
5546 struct traceframe_info
*result
= p
;
5548 free_traceframe_info (result
);
5551 /* The allowed elements and attributes for an XML memory map. */
5553 static const struct gdb_xml_attribute memory_attributes
[] = {
5554 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5555 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5556 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5559 static const struct gdb_xml_element traceframe_info_children
[] = {
5560 { "memory", memory_attributes
, NULL
,
5561 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5562 traceframe_info_start_memory
, NULL
},
5563 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5566 static const struct gdb_xml_element traceframe_info_elements
[] = {
5567 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5569 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5572 /* Parse a traceframe-info XML document. */
5574 struct traceframe_info
*
5575 parse_traceframe_info (const char *tframe_info
)
5577 struct traceframe_info
*result
;
5578 struct cleanup
*back_to
;
5580 result
= XCNEW (struct traceframe_info
);
5581 back_to
= make_cleanup (free_result
, result
);
5583 if (gdb_xml_parse_quick (_("trace frame info"),
5584 "traceframe-info.dtd", traceframe_info_elements
,
5585 tframe_info
, result
) == 0)
5587 /* Parsed successfully, keep the result. */
5588 discard_cleanups (back_to
);
5593 do_cleanups (back_to
);
5597 #endif /* HAVE_LIBEXPAT */
5599 /* Returns the traceframe_info object for the current traceframe.
5600 This is where we avoid re-fetching the object from the target if we
5601 already have it cached. */
5603 static struct traceframe_info
*
5604 get_traceframe_info (void)
5606 if (traceframe_info
== NULL
)
5607 traceframe_info
= target_traceframe_info ();
5609 return traceframe_info
;
5612 /* If the target supports the query, return in RESULT the set of
5613 collected memory in the current traceframe, found within the LEN
5614 bytes range starting at MEMADDR. Returns true if the target
5615 supports the query, otherwise returns false, and RESULT is left
5619 traceframe_available_memory (VEC(mem_range_s
) **result
,
5620 CORE_ADDR memaddr
, ULONGEST len
)
5622 struct traceframe_info
*info
= get_traceframe_info ();
5626 struct mem_range
*r
;
5631 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5632 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5634 ULONGEST lo1
, hi1
, lo2
, hi2
;
5635 struct mem_range
*nr
;
5638 hi1
= memaddr
+ len
;
5641 hi2
= r
->start
+ r
->length
;
5643 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5645 nr
->start
= max (lo1
, lo2
);
5646 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5649 normalize_mem_ranges (*result
);
5656 /* Implementation of `sdata' variable. */
5658 static const struct internalvar_funcs sdata_funcs
=
5665 /* module initialization */
5667 _initialize_tracepoint (void)
5669 struct cmd_list_element
*c
;
5671 /* Explicitly create without lookup, since that tries to create a
5672 value with a void typed value, and when we get here, gdbarch
5673 isn't initialized yet. At this point, we're quite sure there
5674 isn't another convenience variable of the same name. */
5675 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5677 traceframe_number
= -1;
5678 tracepoint_number
= -1;
5680 if (tracepoint_list
.list
== NULL
)
5682 tracepoint_list
.listsize
= 128;
5683 tracepoint_list
.list
= xmalloc
5684 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5686 if (tracepoint_list
.aexpr_list
== NULL
)
5688 tracepoint_list
.aexpr_listsize
= 128;
5689 tracepoint_list
.aexpr_list
= xmalloc
5690 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5693 if (stepping_list
.list
== NULL
)
5695 stepping_list
.listsize
= 128;
5696 stepping_list
.list
= xmalloc
5697 (stepping_list
.listsize
* sizeof (struct memrange
));
5700 if (stepping_list
.aexpr_list
== NULL
)
5702 stepping_list
.aexpr_listsize
= 128;
5703 stepping_list
.aexpr_list
= xmalloc
5704 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5707 add_info ("scope", scope_info
,
5708 _("List the variables local to a scope"));
5710 add_cmd ("tracepoints", class_trace
, NULL
,
5711 _("Tracing of program execution without stopping the program."),
5714 add_com ("tdump", class_trace
, trace_dump_command
,
5715 _("Print everything collected at the current tracepoint."));
5717 add_com ("tsave", class_trace
, trace_save_command
, _("\
5718 Save the trace data to a file.\n\
5719 Use the '-ctf' option to save the data to CTF format.\n\
5720 Use the '-r' option to direct the target to save directly to the file,\n\
5721 using its own filesystem."));
5723 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5724 Define a trace state variable.\n\
5725 Argument is a $-prefixed name, optionally followed\n\
5726 by '=' and an expression that sets the initial value\n\
5727 at the start of tracing."));
5728 set_cmd_completer (c
, expression_completer
);
5730 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5731 Delete one or more trace state variables.\n\
5732 Arguments are the names of the variables to delete.\n\
5733 If no arguments are supplied, delete all variables."), &deletelist
);
5734 /* FIXME add a trace variable completer. */
5736 add_info ("tvariables", tvariables_info
, _("\
5737 Status of trace state variables and their values.\n\
5740 add_info ("static-tracepoint-markers",
5741 info_static_tracepoint_markers_command
, _("\
5742 List target static tracepoints markers.\n\
5745 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5746 Select a trace frame;\n\
5747 No argument means forward by one frame; '-' means backward by one frame."),
5748 &tfindlist
, "tfind ", 1, &cmdlist
);
5750 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5751 Select a trace frame whose PC is outside the given range (exclusive).\n\
5752 Usage: tfind outside addr1, addr2"),
5755 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5756 Select a trace frame whose PC is in the given range (inclusive).\n\
5757 Usage: tfind range addr1,addr2"),
5760 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5761 Select a trace frame by source line.\n\
5762 Argument can be a line number (with optional source file),\n\
5763 a function name, or '*' followed by an address.\n\
5764 Default argument is 'the next source line that was traced'."),
5767 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5768 Select a trace frame by tracepoint number.\n\
5769 Default is the tracepoint for the current trace frame."),
5772 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5773 Select a trace frame by PC.\n\
5774 Default is the current PC, or the PC of the current trace frame."),
5777 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5778 De-select any trace frame and resume 'live' debugging."),
5781 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5783 add_cmd ("start", class_trace
, trace_find_start_command
,
5784 _("Select the first trace frame in the trace buffer."),
5787 add_com ("tstatus", class_trace
, trace_status_command
,
5788 _("Display the status of the current trace data collection."));
5790 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5791 Stop trace data collection.\n\
5792 Usage: tstop [ <notes> ... ]\n\
5793 Any arguments supplied are recorded with the trace as a stop reason and\n\
5794 reported by tstatus (if the target supports trace notes)."));
5796 add_com ("tstart", class_trace
, trace_start_command
, _("\
5797 Start trace data collection.\n\
5798 Usage: tstart [ <notes> ... ]\n\
5799 Any arguments supplied are recorded with the trace as a note and\n\
5800 reported by tstatus (if the target supports trace notes)."));
5802 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5803 Ends a list of commands or actions.\n\
5804 Several GDB commands allow you to enter a list of commands or actions.\n\
5805 Entering \"end\" on a line by itself is the normal way to terminate\n\
5807 Note: the \"end\" command cannot be used at the gdb prompt."));
5809 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5810 Specify single-stepping behavior at a tracepoint.\n\
5811 Argument is number of instructions to trace in single-step mode\n\
5812 following the tracepoint. This command is normally followed by\n\
5813 one or more \"collect\" commands, to specify what to collect\n\
5814 while single-stepping.\n\n\
5815 Note: this command can only be used in a tracepoint \"actions\" list."));
5817 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5818 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5820 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5821 Specify one or more data items to be collected at a tracepoint.\n\
5822 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5823 collect all data (variables, registers) referenced by that expression.\n\
5824 Also accepts the following special arguments:\n\
5825 $regs -- all registers.\n\
5826 $args -- all function arguments.\n\
5827 $locals -- all variables local to the block/function scope.\n\
5828 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5829 Note: this command can only be used in a tracepoint \"actions\" list."));
5831 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5832 Specify one or more expressions to be evaluated at a tracepoint.\n\
5833 Accepts a comma-separated list of (one or more) expressions.\n\
5834 The result of each evaluation will be discarded.\n\
5835 Note: this command can only be used in a tracepoint \"actions\" list."));
5837 add_com ("actions", class_trace
, trace_actions_command
, _("\
5838 Specify the actions to be taken at a tracepoint.\n\
5839 Tracepoint actions may include collecting of specified data,\n\
5840 single-stepping, or enabling/disabling other tracepoints,\n\
5841 depending on target's capabilities."));
5843 default_collect
= xstrdup ("");
5844 add_setshow_string_cmd ("default-collect", class_trace
,
5845 &default_collect
, _("\
5846 Set the list of expressions to collect by default"), _("\
5847 Show the list of expressions to collect by default"), NULL
,
5849 &setlist
, &showlist
);
5851 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5852 &disconnected_tracing
, _("\
5853 Set whether tracing continues after GDB disconnects."), _("\
5854 Show whether tracing continues after GDB disconnects."), _("\
5855 Use this to continue a tracing run even if GDB disconnects\n\
5856 or detaches from the target. You can reconnect later and look at\n\
5857 trace data collected in the meantime."),
5858 set_disconnected_tracing
,
5863 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5864 &circular_trace_buffer
, _("\
5865 Set target's use of circular trace buffer."), _("\
5866 Show target's use of circular trace buffer."), _("\
5867 Use this to make the trace buffer into a circular buffer,\n\
5868 which will discard traceframes (oldest first) instead of filling\n\
5869 up and stopping the trace run."),
5870 set_circular_trace_buffer
,
5875 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5876 &trace_buffer_size
, _("\
5877 Set requested size of trace buffer."), _("\
5878 Show requested size of trace buffer."), _("\
5879 Use this to choose a size for the trace buffer. Some targets\n\
5880 may have fixed or limited buffer sizes. A value of -1 disables\n\
5881 any attempt to set the buffer size and lets the target choose."),
5882 set_trace_buffer_size
, NULL
,
5883 &setlist
, &showlist
);
5885 add_setshow_string_cmd ("trace-user", class_trace
,
5887 Set the user name to use for current and future trace runs"), _("\
5888 Show the user name to use for current and future trace runs"), NULL
,
5889 set_trace_user
, NULL
,
5890 &setlist
, &showlist
);
5892 add_setshow_string_cmd ("trace-notes", class_trace
,
5894 Set notes string to use for current and future trace runs"), _("\
5895 Show the notes string to use for current and future trace runs"), NULL
,
5896 set_trace_notes
, NULL
,
5897 &setlist
, &showlist
);
5899 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5900 &trace_stop_notes
, _("\
5901 Set notes string to use for future tstop commands"), _("\
5902 Show the notes string to use for future tstop commands"), NULL
,
5903 set_trace_stop_notes
, NULL
,
5904 &setlist
, &showlist
);
5908 add_target_with_completer (&tfile_ops
, filename_completer
);