1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
88 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
90 extern void (*deprecated_readline_begin_hook
) (char *, ...);
91 extern char *(*deprecated_readline_hook
) (char *);
92 extern void (*deprecated_readline_end_hook
) (void);
97 This module defines the following debugger commands:
98 trace : set a tracepoint on a function, line, or address.
99 info trace : list all debugger-defined tracepoints.
100 delete trace : delete one or more tracepoints.
101 enable trace : enable one or more tracepoints.
102 disable trace : disable one or more tracepoints.
103 actions : specify actions to be taken at a tracepoint.
104 passcount : specify a pass count for a tracepoint.
105 tstart : start a trace experiment.
106 tstop : stop a trace experiment.
107 tstatus : query the status of a trace experiment.
108 tfind : find a trace frame in the trace buffer.
109 tdump : print everything collected at the current tracepoint.
110 save-tracepoints : write tracepoint setup into a file.
112 This module defines the following user-visible debugger variables:
113 $trace_frame : sequence number of trace frame currently being debugged.
114 $trace_line : source line of trace frame currently being debugged.
115 $trace_file : source file of trace frame currently being debugged.
116 $tracepoint : tracepoint number of trace frame currently being debugged.
120 /* ======= Important global variables: ======= */
122 /* The list of all trace state variables. We don't retain pointers to
123 any of these for any reason - API is by name or number only - so it
124 works to have a vector of objects. */
126 typedef struct trace_state_variable tsv_s
;
129 static VEC(tsv_s
) *tvariables
;
131 /* The next integer to assign to a variable. */
133 static int next_tsv_number
= 1;
135 /* Number of last traceframe collected. */
136 static int traceframe_number
;
138 /* Tracepoint for last traceframe collected. */
139 static int tracepoint_number
;
141 /* Symbol for function for last traceframe collected. */
142 static struct symbol
*traceframe_fun
;
144 /* Symtab and line for last traceframe collected. */
145 static struct symtab_and_line traceframe_sal
;
147 /* The traceframe info of the current traceframe. NULL if we haven't
148 yet attempted to fetch it, or if the target does not support
149 fetching this object, or if we're not inspecting a traceframe
151 static struct traceframe_info
*traceframe_info
;
153 /* Tracing command lists. */
154 static struct cmd_list_element
*tfindlist
;
156 /* List of expressions to collect by default at each tracepoint hit. */
157 char *default_collect
= "";
159 static int disconnected_tracing
;
161 /* This variable controls whether we ask the target for a linear or
162 circular trace buffer. */
164 static int circular_trace_buffer
;
166 /* This variable is the requested trace buffer size, or -1 to indicate
167 that we don't care and leave it up to the target to set a size. */
169 static int trace_buffer_size
= -1;
171 /* Textual notes applying to the current and/or future trace runs. */
173 char *trace_user
= NULL
;
175 /* Textual notes applying to the current and/or future trace runs. */
177 char *trace_notes
= NULL
;
179 /* Textual notes applying to the stopping of a trace. */
181 char *trace_stop_notes
= NULL
;
183 /* ======= Important command functions: ======= */
184 static void trace_actions_command (char *, int);
185 static void trace_start_command (char *, int);
186 static void trace_stop_command (char *, int);
187 static void trace_status_command (char *, int);
188 static void trace_find_command (char *, int);
189 static void trace_find_pc_command (char *, int);
190 static void trace_find_tracepoint_command (char *, int);
191 static void trace_find_line_command (char *, int);
192 static void trace_find_range_command (char *, int);
193 static void trace_find_outside_command (char *, int);
194 static void trace_dump_command (char *, int);
196 /* support routines */
198 struct collection_list
;
199 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
200 static char *mem2hex (gdb_byte
*, char *, int);
201 static void add_register (struct collection_list
*collection
,
204 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
205 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
208 extern void _initialize_tracepoint (void);
210 static struct trace_status trace_status
;
212 char *stop_reason_names
[] = {
222 struct trace_status
*
223 current_trace_status (void)
225 return &trace_status
;
231 free_traceframe_info (struct traceframe_info
*info
)
235 VEC_free (mem_range_s
, info
->memory
);
241 /* Free and clear the traceframe info cache of the current
245 clear_traceframe_info (void)
247 free_traceframe_info (traceframe_info
);
248 traceframe_info
= NULL
;
251 /* Set traceframe number to NUM. */
253 set_traceframe_num (int num
)
255 traceframe_number
= num
;
256 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
259 /* Set tracepoint number to NUM. */
261 set_tracepoint_num (int num
)
263 tracepoint_number
= num
;
264 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
267 /* Set externally visible debug variables for querying/printing
268 the traceframe context (line, function, file). */
271 set_traceframe_context (struct frame_info
*trace_frame
)
275 /* Save as globals for internal use. */
276 if (trace_frame
!= NULL
277 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
279 traceframe_sal
= find_pc_line (trace_pc
, 0);
280 traceframe_fun
= find_pc_function (trace_pc
);
282 /* Save linenumber as "$trace_line", a debugger variable visible to
284 set_internalvar_integer (lookup_internalvar ("trace_line"),
285 traceframe_sal
.line
);
289 init_sal (&traceframe_sal
);
290 traceframe_fun
= NULL
;
291 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
294 /* Save func name as "$trace_func", a debugger variable visible to
296 if (traceframe_fun
== NULL
297 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
298 clear_internalvar (lookup_internalvar ("trace_func"));
300 set_internalvar_string (lookup_internalvar ("trace_func"),
301 SYMBOL_LINKAGE_NAME (traceframe_fun
));
303 /* Save file name as "$trace_file", a debugger variable visible to
305 if (traceframe_sal
.symtab
== NULL
)
306 clear_internalvar (lookup_internalvar ("trace_file"));
308 set_internalvar_string (lookup_internalvar ("trace_file"),
309 symtab_to_filename_for_display (traceframe_sal
.symtab
));
312 /* Create a new trace state variable with the given name. */
314 struct trace_state_variable
*
315 create_trace_state_variable (const char *name
)
317 struct trace_state_variable tsv
;
319 memset (&tsv
, 0, sizeof (tsv
));
320 tsv
.name
= xstrdup (name
);
321 tsv
.number
= next_tsv_number
++;
322 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
325 /* Look for a trace state variable of the given name. */
327 struct trace_state_variable
*
328 find_trace_state_variable (const char *name
)
330 struct trace_state_variable
*tsv
;
333 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
334 if (strcmp (name
, tsv
->name
) == 0)
341 delete_trace_state_variable (const char *name
)
343 struct trace_state_variable
*tsv
;
346 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
347 if (strcmp (name
, tsv
->name
) == 0)
349 observer_notify_tsv_deleted (tsv
);
351 xfree ((void *)tsv
->name
);
352 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
357 warning (_("No trace variable named \"$%s\", not deleting"), name
);
360 /* Throws an error if NAME is not valid syntax for a trace state
364 validate_trace_state_variable_name (const char *name
)
369 error (_("Must supply a non-empty variable name"));
371 /* All digits in the name is reserved for value history
373 for (p
= name
; isdigit (*p
); p
++)
376 error (_("$%s is not a valid trace state variable name"), name
);
378 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
381 error (_("$%s is not a valid trace state variable name"), name
);
384 /* The 'tvariable' command collects a name and optional expression to
385 evaluate into an initial value. */
388 trace_variable_command (char *args
, int from_tty
)
390 struct cleanup
*old_chain
;
392 struct trace_state_variable
*tsv
;
396 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
398 /* Only allow two syntaxes; "$name" and "$name=value". */
399 p
= skip_spaces (args
);
402 error (_("Name of trace variable should start with '$'"));
405 while (isalnum (*p
) || *p
== '_')
407 name
= savestring (name
, p
- name
);
408 old_chain
= make_cleanup (xfree
, name
);
411 if (*p
!= '=' && *p
!= '\0')
412 error (_("Syntax must be $NAME [ = EXPR ]"));
414 validate_trace_state_variable_name (name
);
417 initval
= value_as_long (parse_and_eval (++p
));
419 /* If the variable already exists, just change its initial value. */
420 tsv
= find_trace_state_variable (name
);
423 if (tsv
->initial_value
!= initval
)
425 tsv
->initial_value
= initval
;
426 observer_notify_tsv_modified (tsv
);
428 printf_filtered (_("Trace state variable $%s "
429 "now has initial value %s.\n"),
430 tsv
->name
, plongest (tsv
->initial_value
));
431 do_cleanups (old_chain
);
435 /* Create a new variable. */
436 tsv
= create_trace_state_variable (name
);
437 tsv
->initial_value
= initval
;
439 observer_notify_tsv_created (tsv
);
441 printf_filtered (_("Trace state variable $%s "
442 "created, with initial value %s.\n"),
443 tsv
->name
, plongest (tsv
->initial_value
));
445 do_cleanups (old_chain
);
449 delete_trace_variable_command (char *args
, int from_tty
)
453 struct cleanup
*back_to
;
457 if (query (_("Delete all trace state variables? ")))
458 VEC_free (tsv_s
, tvariables
);
460 observer_notify_tsv_deleted (NULL
);
464 argv
= gdb_buildargv (args
);
465 back_to
= make_cleanup_freeargv (argv
);
467 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
469 if (*argv
[ix
] == '$')
470 delete_trace_state_variable (argv
[ix
] + 1);
472 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
475 do_cleanups (back_to
);
481 tvariables_info_1 (void)
483 struct trace_state_variable
*tsv
;
486 struct cleanup
*back_to
;
487 struct ui_out
*uiout
= current_uiout
;
489 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
491 printf_filtered (_("No trace state variables.\n"));
495 /* Try to acquire values from the target. */
496 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
497 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
500 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
501 count
, "trace-variables");
502 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
503 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
504 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
506 ui_out_table_body (uiout
);
508 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
510 struct cleanup
*back_to2
;
514 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
516 name
= concat ("$", tsv
->name
, (char *) NULL
);
517 make_cleanup (xfree
, name
);
518 ui_out_field_string (uiout
, "name", name
);
519 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
521 if (tsv
->value_known
)
522 c
= plongest (tsv
->value
);
523 else if (ui_out_is_mi_like_p (uiout
))
524 /* For MI, we prefer not to use magic string constants, but rather
525 omit the field completely. The difference between unknown and
526 undefined does not seem important enough to represent. */
528 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
529 /* The value is/was defined, but we don't have it. */
532 /* It is not meaningful to ask about the value. */
535 ui_out_field_string (uiout
, "current", c
);
536 ui_out_text (uiout
, "\n");
538 do_cleanups (back_to2
);
541 do_cleanups (back_to
);
544 /* List all the trace state variables. */
547 tvariables_info (char *args
, int from_tty
)
549 tvariables_info_1 ();
552 /* Stash definitions of tsvs into the given file. */
555 save_trace_state_variables (struct ui_file
*fp
)
557 struct trace_state_variable
*tsv
;
560 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
562 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
563 if (tsv
->initial_value
)
564 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
565 fprintf_unfiltered (fp
, "\n");
569 /* ACTIONS functions: */
571 /* The three functions:
572 collect_pseudocommand,
573 while_stepping_pseudocommand, and
574 end_actions_pseudocommand
575 are placeholders for "commands" that are actually ONLY to be used
576 within a tracepoint action list. If the actual function is ever called,
577 it means that somebody issued the "command" at the top level,
578 which is always an error. */
581 end_actions_pseudocommand (char *args
, int from_tty
)
583 error (_("This command cannot be used at the top level."));
587 while_stepping_pseudocommand (char *args
, int from_tty
)
589 error (_("This command can only be used in a tracepoint actions list."));
593 collect_pseudocommand (char *args
, int from_tty
)
595 error (_("This command can only be used in a tracepoint actions list."));
599 teval_pseudocommand (char *args
, int from_tty
)
601 error (_("This command can only be used in a tracepoint actions list."));
604 /* Parse any collection options, such as /s for strings. */
607 decode_agent_options (const char *exp
, int *trace_string
)
609 struct value_print_options opts
;
616 /* Call this to borrow the print elements default for collection
618 get_user_print_options (&opts
);
623 if (target_supports_string_tracing ())
625 /* Allow an optional decimal number giving an explicit maximum
626 string length, defaulting it to the "print elements" value;
627 so "collect/s80 mystr" gets at most 80 bytes of string. */
628 *trace_string
= opts
.print_max
;
630 if (*exp
>= '0' && *exp
<= '9')
631 *trace_string
= atoi (exp
);
632 while (*exp
>= '0' && *exp
<= '9')
636 error (_("Target does not support \"/s\" option for string tracing."));
639 error (_("Undefined collection format \"%c\"."), *exp
);
641 exp
= skip_spaces_const (exp
);
646 /* Enter a list of actions for a tracepoint. */
648 trace_actions_command (char *args
, int from_tty
)
650 struct tracepoint
*t
;
651 struct command_line
*l
;
653 t
= get_tracepoint_by_number (&args
, NULL
, 1);
657 xstrprintf ("Enter actions for tracepoint %d, one per line.",
659 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
661 l
= read_command_lines (tmpbuf
, from_tty
, 1,
662 check_tracepoint_command
, t
);
663 do_cleanups (cleanups
);
664 breakpoint_set_commands (&t
->base
, l
);
666 /* else just return */
669 /* Report the results of checking the agent expression, as errors or
673 report_agent_reqs_errors (struct agent_expr
*aexpr
)
675 /* All of the "flaws" are serious bytecode generation issues that
676 should never occur. */
677 if (aexpr
->flaw
!= agent_flaw_none
)
678 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
680 /* If analysis shows a stack underflow, GDB must have done something
681 badly wrong in its bytecode generation. */
682 if (aexpr
->min_height
< 0)
683 internal_error (__FILE__
, __LINE__
,
684 _("expression has min height < 0"));
686 /* Issue this error if the stack is predicted to get too deep. The
687 limit is rather arbitrary; a better scheme might be for the
688 target to report how much stack it will have available. The
689 depth roughly corresponds to parenthesization, so a limit of 20
690 amounts to 20 levels of expression nesting, which is actually
691 a pretty big hairy expression. */
692 if (aexpr
->max_height
> 20)
693 error (_("Expression is too complicated."));
696 /* worker function */
698 validate_actionline (const char *line
, struct breakpoint
*b
)
700 struct cmd_list_element
*c
;
701 struct expression
*exp
= NULL
;
702 struct cleanup
*old_chain
= NULL
;
705 struct bp_location
*loc
;
706 struct agent_expr
*aexpr
;
707 struct tracepoint
*t
= (struct tracepoint
*) b
;
709 /* If EOF is typed, *line is NULL. */
713 p
= skip_spaces_const (line
);
715 /* Symbol lookup etc. */
716 if (*p
== '\0') /* empty line: just prompt for another line. */
719 if (*p
== '#') /* comment line */
722 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
724 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
726 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
728 int trace_string
= 0;
731 p
= decode_agent_options (p
, &trace_string
);
734 { /* Repeat over a comma-separated list. */
735 QUIT
; /* Allow user to bail out with ^C. */
736 p
= skip_spaces_const (p
);
738 if (*p
== '$') /* Look for special pseudo-symbols. */
740 if (0 == strncasecmp ("reg", p
+ 1, 3)
741 || 0 == strncasecmp ("arg", p
+ 1, 3)
742 || 0 == strncasecmp ("loc", p
+ 1, 3)
743 || 0 == strncasecmp ("_ret", p
+ 1, 4)
744 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
749 /* else fall thru, treat p as an expression and parse it! */
752 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
755 exp
= parse_exp_1 (&p
, loc
->address
,
756 block_for_pc (loc
->address
), 1);
757 old_chain
= make_cleanup (free_current_contents
, &exp
);
759 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
761 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
763 error (_("constant `%s' (value %s) "
764 "will not be collected."),
765 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
766 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
768 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
769 == LOC_OPTIMIZED_OUT
)
771 error (_("`%s' is optimized away "
772 "and cannot be collected."),
773 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
777 /* We have something to collect, make sure that the expr to
778 bytecode translator can handle it and that it's not too
780 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
781 make_cleanup_free_agent_expr (aexpr
);
783 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
784 error (_("Expression is too complicated."));
788 report_agent_reqs_errors (aexpr
);
790 do_cleanups (old_chain
);
793 while (p
&& *p
++ == ',');
796 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
799 { /* Repeat over a comma-separated list. */
800 QUIT
; /* Allow user to bail out with ^C. */
801 p
= skip_spaces_const (p
);
804 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
808 /* Only expressions are allowed for this action. */
809 exp
= parse_exp_1 (&p
, loc
->address
,
810 block_for_pc (loc
->address
), 1);
811 old_chain
= make_cleanup (free_current_contents
, &exp
);
813 /* We have something to evaluate, make sure that the expr to
814 bytecode translator can handle it and that it's not too
816 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
817 make_cleanup_free_agent_expr (aexpr
);
819 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
820 error (_("Expression is too complicated."));
823 report_agent_reqs_errors (aexpr
);
825 do_cleanups (old_chain
);
828 while (p
&& *p
++ == ',');
831 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
835 p
= skip_spaces_const (p
);
836 t
->step_count
= strtol (p
, &endp
, 0);
837 if (endp
== p
|| t
->step_count
== 0)
838 error (_("while-stepping step count `%s' is malformed."), line
);
842 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
846 error (_("`%s' is not a supported tracepoint action."), line
);
850 memrange_absolute
= -1
855 int type
; /* memrange_absolute for absolute memory range,
856 else basereg number. */
857 bfd_signed_vma start
;
861 struct collection_list
863 unsigned char regs_mask
[32]; /* room for up to 256 regs */
866 struct memrange
*list
;
867 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
869 struct agent_expr
**aexpr_list
;
871 /* True is the user requested a collection of "$_sdata", "static
875 tracepoint_list
, stepping_list
;
877 /* MEMRANGE functions: */
879 static int memrange_cmp (const void *, const void *);
881 /* Compare memranges for qsort. */
883 memrange_cmp (const void *va
, const void *vb
)
885 const struct memrange
*a
= va
, *b
= vb
;
887 if (a
->type
< b
->type
)
889 if (a
->type
> b
->type
)
891 if (a
->type
== memrange_absolute
)
893 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
895 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
900 if (a
->start
< b
->start
)
902 if (a
->start
> b
->start
)
908 /* Sort the memrange list using qsort, and merge adjacent memranges. */
910 memrange_sortmerge (struct collection_list
*memranges
)
914 qsort (memranges
->list
, memranges
->next_memrange
,
915 sizeof (struct memrange
), memrange_cmp
);
916 if (memranges
->next_memrange
> 0)
918 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
920 /* If memrange b overlaps or is adjacent to memrange a,
922 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
923 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
925 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
926 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
927 continue; /* next b, same a */
931 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
932 sizeof (struct memrange
));
934 memranges
->next_memrange
= a
+ 1;
938 /* Add a register to a collection list. */
940 add_register (struct collection_list
*collection
, unsigned int regno
)
943 printf_filtered ("collect register %d\n", regno
);
944 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
945 error (_("Internal: register number %d too large for tracepoint"),
947 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
950 /* Add a memrange to a collection list. */
952 add_memrange (struct collection_list
*memranges
,
953 int type
, bfd_signed_vma base
,
958 printf_filtered ("(%d,", type
);
960 printf_filtered (",%ld)\n", len
);
963 /* type: memrange_absolute == memory, other n == basereg */
964 memranges
->list
[memranges
->next_memrange
].type
= type
;
965 /* base: addr if memory, offset if reg relative. */
966 memranges
->list
[memranges
->next_memrange
].start
= base
;
967 /* len: we actually save end (base + len) for convenience */
968 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
969 memranges
->next_memrange
++;
970 if (memranges
->next_memrange
>= memranges
->listsize
)
972 memranges
->listsize
*= 2;
973 memranges
->list
= xrealloc (memranges
->list
,
974 memranges
->listsize
);
977 if (type
!= memrange_absolute
) /* Better collect the base register! */
978 add_register (memranges
, type
);
981 /* Add a symbol to a collection list. */
983 collect_symbol (struct collection_list
*collect
,
985 struct gdbarch
*gdbarch
,
986 long frame_regno
, long frame_offset
,
992 bfd_signed_vma offset
;
993 int treat_as_expr
= 0;
995 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
996 switch (SYMBOL_CLASS (sym
))
999 printf_filtered ("%s: don't know symbol class %d\n",
1000 SYMBOL_PRINT_NAME (sym
),
1001 SYMBOL_CLASS (sym
));
1004 printf_filtered ("constant %s (value %s) will not be collected.\n",
1005 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1008 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1013 sprintf_vma (tmp
, offset
);
1014 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1015 SYMBOL_PRINT_NAME (sym
), len
,
1018 /* A struct may be a C++ class with static fields, go to general
1019 expression handling. */
1020 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1023 add_memrange (collect
, memrange_absolute
, offset
, len
);
1026 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1028 printf_filtered ("LOC_REG[parm] %s: ",
1029 SYMBOL_PRINT_NAME (sym
));
1030 add_register (collect
, reg
);
1031 /* Check for doubles stored in two registers. */
1032 /* FIXME: how about larger types stored in 3 or more regs? */
1033 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1034 len
> register_size (gdbarch
, reg
))
1035 add_register (collect
, reg
+ 1);
1038 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1039 printf_filtered (" (will not collect %s)\n",
1040 SYMBOL_PRINT_NAME (sym
));
1044 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1047 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1048 SYMBOL_PRINT_NAME (sym
), len
);
1049 printf_vma (offset
);
1050 printf_filtered (" from frame ptr reg %d\n", reg
);
1052 add_memrange (collect
, reg
, offset
, len
);
1054 case LOC_REGPARM_ADDR
:
1055 reg
= SYMBOL_VALUE (sym
);
1059 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1060 SYMBOL_PRINT_NAME (sym
), len
);
1061 printf_vma (offset
);
1062 printf_filtered (" from reg %d\n", reg
);
1064 add_memrange (collect
, reg
, offset
, len
);
1068 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1071 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1072 SYMBOL_PRINT_NAME (sym
), len
);
1073 printf_vma (offset
);
1074 printf_filtered (" from frame ptr reg %d\n", reg
);
1076 add_memrange (collect
, reg
, offset
, len
);
1079 case LOC_UNRESOLVED
:
1083 case LOC_OPTIMIZED_OUT
:
1084 printf_filtered ("%s has been optimized out of existence.\n",
1085 SYMBOL_PRINT_NAME (sym
));
1093 /* Expressions are the most general case. */
1096 struct agent_expr
*aexpr
;
1097 struct cleanup
*old_chain1
= NULL
;
1099 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1101 /* It can happen that the symbol is recorded as a computed
1102 location, but it's been optimized away and doesn't actually
1103 have a location expression. */
1106 printf_filtered ("%s has been optimized out of existence.\n",
1107 SYMBOL_PRINT_NAME (sym
));
1111 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1115 report_agent_reqs_errors (aexpr
);
1117 discard_cleanups (old_chain1
);
1118 add_aexpr (collect
, aexpr
);
1120 /* Take care of the registers. */
1121 if (aexpr
->reg_mask_len
> 0)
1125 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1127 QUIT
; /* Allow user to bail out with ^C. */
1128 if (aexpr
->reg_mask
[ndx1
] != 0)
1130 /* Assume chars have 8 bits. */
1131 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1132 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1133 /* It's used -- record it. */
1134 add_register (collect
, ndx1
* 8 + ndx2
);
1141 /* Data to be passed around in the calls to the locals and args
1144 struct add_local_symbols_data
1146 struct collection_list
*collect
;
1147 struct gdbarch
*gdbarch
;
1155 /* The callback for the locals and args iterators. */
1158 do_collect_symbol (const char *print_name
,
1162 struct add_local_symbols_data
*p
= cb_data
;
1164 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1165 p
->frame_offset
, p
->pc
, p
->trace_string
);
1169 /* Add all locals (or args) symbols to collection list. */
1171 add_local_symbols (struct collection_list
*collect
,
1172 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1173 long frame_regno
, long frame_offset
, int type
,
1176 struct block
*block
;
1177 struct add_local_symbols_data cb_data
;
1179 cb_data
.collect
= collect
;
1180 cb_data
.gdbarch
= gdbarch
;
1182 cb_data
.frame_regno
= frame_regno
;
1183 cb_data
.frame_offset
= frame_offset
;
1185 cb_data
.trace_string
= trace_string
;
1189 block
= block_for_pc (pc
);
1192 warning (_("Can't collect locals; "
1193 "no symbol table info available.\n"));
1197 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1198 if (cb_data
.count
== 0)
1199 warning (_("No locals found in scope."));
1203 pc
= get_pc_function_start (pc
);
1204 block
= block_for_pc (pc
);
1207 warning (_("Can't collect args; no symbol table info available."));
1211 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1212 if (cb_data
.count
== 0)
1213 warning (_("No args found in scope."));
1218 add_static_trace_data (struct collection_list
*collection
)
1221 printf_filtered ("collect static trace data\n");
1222 collection
->strace_data
= 1;
1225 /* worker function */
1227 clear_collection_list (struct collection_list
*list
)
1231 list
->next_memrange
= 0;
1232 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1234 free_agent_expr (list
->aexpr_list
[ndx
]);
1235 list
->aexpr_list
[ndx
] = NULL
;
1237 list
->next_aexpr_elt
= 0;
1238 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1239 list
->strace_data
= 0;
1242 /* Reduce a collection list to string form (for gdb protocol). */
1244 stringify_collection_list (struct collection_list
*list
, char *string
)
1246 char temp_buf
[2048];
1250 char *(*str_list
)[];
1254 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1255 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1257 if (list
->strace_data
)
1260 printf_filtered ("\nCollecting static trace data\n");
1263 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1267 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1268 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1270 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1273 printf_filtered ("\nCollecting registers (mask): 0x");
1278 QUIT
; /* Allow user to bail out with ^C. */
1280 printf_filtered ("%02X", list
->regs_mask
[i
]);
1281 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1284 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1288 printf_filtered ("\n");
1289 if (list
->next_memrange
> 0 && info_verbose
)
1290 printf_filtered ("Collecting memranges: \n");
1291 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1293 QUIT
; /* Allow user to bail out with ^C. */
1294 sprintf_vma (tmp2
, list
->list
[i
].start
);
1297 printf_filtered ("(%d, %s, %ld)\n",
1300 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1302 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1304 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1311 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1313 /* The "%X" conversion specifier expects an unsigned argument,
1314 so passing -1 (memrange_absolute) to it directly gives you
1315 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1317 if (list
->list
[i
].type
== memrange_absolute
)
1318 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1320 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1323 count
+= strlen (end
);
1324 end
= temp_buf
+ count
;
1327 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1329 QUIT
; /* Allow user to bail out with ^C. */
1330 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1332 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1337 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1338 end
+= 10; /* 'X' + 8 hex digits + ',' */
1341 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1342 end
, list
->aexpr_list
[i
]->len
);
1343 count
+= 2 * list
->aexpr_list
[i
]->len
;
1348 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1353 (*str_list
)[ndx
] = NULL
;
1366 encode_actions_1 (struct command_line
*action
,
1367 struct breakpoint
*t
,
1368 struct bp_location
*tloc
,
1370 LONGEST frame_offset
,
1371 struct collection_list
*collect
,
1372 struct collection_list
*stepping_list
)
1374 const char *action_exp
;
1375 struct expression
*exp
= NULL
;
1377 struct value
*tempval
;
1378 struct cmd_list_element
*cmd
;
1379 struct agent_expr
*aexpr
;
1381 for (; action
; action
= action
->next
)
1383 QUIT
; /* Allow user to bail out with ^C. */
1384 action_exp
= action
->line
;
1385 action_exp
= skip_spaces_const (action_exp
);
1387 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1389 error (_("Bad action list item: %s"), action_exp
);
1391 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1393 int trace_string
= 0;
1395 if (*action_exp
== '/')
1396 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1399 { /* Repeat over a comma-separated list. */
1400 QUIT
; /* Allow user to bail out with ^C. */
1401 action_exp
= skip_spaces_const (action_exp
);
1403 if (0 == strncasecmp ("$reg", action_exp
, 4))
1405 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1406 add_register (collect
, i
);
1407 action_exp
= strchr (action_exp
, ','); /* more? */
1409 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1411 add_local_symbols (collect
,
1418 action_exp
= strchr (action_exp
, ','); /* more? */
1420 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1422 add_local_symbols (collect
,
1429 action_exp
= strchr (action_exp
, ','); /* more? */
1431 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1433 struct cleanup
*old_chain1
= NULL
;
1435 aexpr
= gen_trace_for_return_address (tloc
->address
,
1439 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1442 report_agent_reqs_errors (aexpr
);
1444 discard_cleanups (old_chain1
);
1445 add_aexpr (collect
, aexpr
);
1447 /* take care of the registers */
1448 if (aexpr
->reg_mask_len
> 0)
1452 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1454 QUIT
; /* allow user to bail out with ^C */
1455 if (aexpr
->reg_mask
[ndx1
] != 0)
1457 /* assume chars have 8 bits */
1458 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1459 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1460 /* it's used -- record it */
1461 add_register (collect
,
1467 action_exp
= strchr (action_exp
, ','); /* more? */
1469 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1471 add_static_trace_data (collect
);
1472 action_exp
= strchr (action_exp
, ','); /* more? */
1477 struct cleanup
*old_chain
= NULL
;
1478 struct cleanup
*old_chain1
= NULL
;
1480 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1481 block_for_pc (tloc
->address
), 1);
1482 old_chain
= make_cleanup (free_current_contents
, &exp
);
1484 switch (exp
->elts
[0].opcode
)
1488 const char *name
= &exp
->elts
[2].string
;
1490 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1491 name
, strlen (name
));
1493 internal_error (__FILE__
, __LINE__
,
1494 _("Register $%s not available"),
1497 printf_filtered ("OP_REGISTER: ");
1498 add_register (collect
, i
);
1503 /* Safe because we know it's a simple expression. */
1504 tempval
= evaluate_expression (exp
);
1505 addr
= value_address (tempval
);
1506 /* Initialize the TYPE_LENGTH if it is a typedef. */
1507 check_typedef (exp
->elts
[1].type
);
1508 add_memrange (collect
, memrange_absolute
, addr
,
1509 TYPE_LENGTH (exp
->elts
[1].type
));
1513 collect_symbol (collect
,
1514 exp
->elts
[2].symbol
,
1522 default: /* Full-fledged expression. */
1523 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1526 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1530 report_agent_reqs_errors (aexpr
);
1532 discard_cleanups (old_chain1
);
1533 add_aexpr (collect
, aexpr
);
1535 /* Take care of the registers. */
1536 if (aexpr
->reg_mask_len
> 0)
1541 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1543 QUIT
; /* Allow user to bail out with ^C. */
1544 if (aexpr
->reg_mask
[ndx1
] != 0)
1546 /* Assume chars have 8 bits. */
1547 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1548 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1549 /* It's used -- record it. */
1550 add_register (collect
,
1557 do_cleanups (old_chain
);
1560 while (action_exp
&& *action_exp
++ == ',');
1562 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1565 { /* Repeat over a comma-separated list. */
1566 QUIT
; /* Allow user to bail out with ^C. */
1567 action_exp
= skip_spaces_const (action_exp
);
1570 struct cleanup
*old_chain
= NULL
;
1571 struct cleanup
*old_chain1
= NULL
;
1573 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1574 block_for_pc (tloc
->address
), 1);
1575 old_chain
= make_cleanup (free_current_contents
, &exp
);
1577 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1578 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1581 report_agent_reqs_errors (aexpr
);
1583 discard_cleanups (old_chain1
);
1584 /* Even though we're not officially collecting, add
1585 to the collect list anyway. */
1586 add_aexpr (collect
, aexpr
);
1588 do_cleanups (old_chain
);
1591 while (action_exp
&& *action_exp
++ == ',');
1593 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1595 /* We check against nested while-stepping when setting
1596 breakpoint action, so no way to run into nested
1598 gdb_assert (stepping_list
);
1600 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1601 frame_offset
, stepping_list
, NULL
);
1604 error (_("Invalid tracepoint command '%s'"), action
->line
);
1608 /* Render all actions into gdb protocol. */
1611 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1612 char ***tdp_actions
, char ***stepping_actions
)
1614 static char tdp_buff
[2048], step_buff
[2048];
1615 char *default_collect_line
= NULL
;
1616 struct command_line
*actions
;
1617 struct command_line
*default_collect_action
= NULL
;
1619 LONGEST frame_offset
;
1620 struct cleanup
*back_to
;
1622 back_to
= make_cleanup (null_cleanup
, NULL
);
1624 clear_collection_list (&tracepoint_list
);
1625 clear_collection_list (&stepping_list
);
1627 *tdp_actions
= NULL
;
1628 *stepping_actions
= NULL
;
1630 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1631 tloc
->address
, &frame_reg
, &frame_offset
);
1633 actions
= breakpoint_commands (t
);
1635 /* If there are default expressions to collect, make up a collect
1636 action and prepend to the action list to encode. Note that since
1637 validation is per-tracepoint (local var "xyz" might be valid for
1638 one tracepoint and not another, etc), we make up the action on
1639 the fly, and don't cache it. */
1640 if (*default_collect
)
1642 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1643 make_cleanup (xfree
, default_collect_line
);
1645 validate_actionline (default_collect_line
, t
);
1647 default_collect_action
= xmalloc (sizeof (struct command_line
));
1648 make_cleanup (xfree
, default_collect_action
);
1649 default_collect_action
->next
= actions
;
1650 default_collect_action
->line
= default_collect_line
;
1651 actions
= default_collect_action
;
1653 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1654 &tracepoint_list
, &stepping_list
);
1656 memrange_sortmerge (&tracepoint_list
);
1657 memrange_sortmerge (&stepping_list
);
1659 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1661 *stepping_actions
= stringify_collection_list (&stepping_list
,
1664 do_cleanups (back_to
);
1668 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1670 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1672 collect
->aexpr_list
=
1673 xrealloc (collect
->aexpr_list
,
1674 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1675 collect
->aexpr_listsize
*= 2;
1677 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1678 collect
->next_aexpr_elt
++;
1682 process_tracepoint_on_disconnect (void)
1684 VEC(breakpoint_p
) *tp_vec
= NULL
;
1686 struct breakpoint
*b
;
1687 int has_pending_p
= 0;
1689 /* Check whether we still have pending tracepoint. If we have, warn the
1690 user that pending tracepoint will no longer work. */
1691 tp_vec
= all_tracepoints ();
1692 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1701 struct bp_location
*loc1
;
1703 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1705 if (loc1
->shlib_disabled
)
1716 VEC_free (breakpoint_p
, tp_vec
);
1719 warning (_("Pending tracepoints will not be resolved while"
1720 " GDB is disconnected\n"));
1725 start_tracing (char *notes
)
1727 VEC(breakpoint_p
) *tp_vec
= NULL
;
1729 struct breakpoint
*b
;
1730 struct trace_state_variable
*tsv
;
1731 int any_enabled
= 0, num_to_download
= 0;
1734 tp_vec
= all_tracepoints ();
1736 /* No point in tracing without any tracepoints... */
1737 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1739 VEC_free (breakpoint_p
, tp_vec
);
1740 error (_("No tracepoints defined, not starting trace"));
1743 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1745 struct tracepoint
*t
= (struct tracepoint
*) b
;
1746 struct bp_location
*loc
;
1748 if (b
->enable_state
== bp_enabled
)
1751 if ((b
->type
== bp_fast_tracepoint
1752 ? may_insert_fast_tracepoints
1753 : may_insert_tracepoints
))
1756 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1757 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1762 if (target_supports_enable_disable_tracepoint ())
1763 warning (_("No tracepoints enabled"));
1766 /* No point in tracing with only disabled tracepoints that
1767 cannot be re-enabled. */
1768 VEC_free (breakpoint_p
, tp_vec
);
1769 error (_("No tracepoints enabled, not starting trace"));
1773 if (num_to_download
<= 0)
1775 VEC_free (breakpoint_p
, tp_vec
);
1776 error (_("No tracepoints that may be downloaded, not starting trace"));
1779 target_trace_init ();
1781 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1783 struct tracepoint
*t
= (struct tracepoint
*) b
;
1784 struct bp_location
*loc
;
1785 int bp_location_downloaded
= 0;
1787 /* Clear `inserted' flag. */
1788 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1791 if ((b
->type
== bp_fast_tracepoint
1792 ? !may_insert_fast_tracepoints
1793 : !may_insert_tracepoints
))
1796 t
->number_on_target
= 0;
1798 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1800 /* Since tracepoint locations are never duplicated, `inserted'
1801 flag should be zero. */
1802 gdb_assert (!loc
->inserted
);
1804 target_download_tracepoint (loc
);
1807 bp_location_downloaded
= 1;
1810 t
->number_on_target
= b
->number
;
1812 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1813 if (loc
->probe
!= NULL
)
1814 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1816 if (bp_location_downloaded
)
1817 observer_notify_breakpoint_modified (b
);
1819 VEC_free (breakpoint_p
, tp_vec
);
1821 /* Send down all the trace state variables too. */
1822 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1824 target_download_trace_state_variable (tsv
);
1827 /* Tell target to treat text-like sections as transparent. */
1828 target_trace_set_readonly_regions ();
1829 /* Set some mode flags. */
1830 target_set_disconnected_tracing (disconnected_tracing
);
1831 target_set_circular_trace_buffer (circular_trace_buffer
);
1832 target_set_trace_buffer_size (trace_buffer_size
);
1835 notes
= trace_notes
;
1836 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1838 if (!ret
&& (trace_user
|| notes
))
1839 warning (_("Target does not support trace user/notes, info ignored"));
1841 /* Now insert traps and begin collecting data. */
1842 target_trace_start ();
1844 /* Reset our local state. */
1845 set_traceframe_num (-1);
1846 set_tracepoint_num (-1);
1847 set_traceframe_context (NULL
);
1848 current_trace_status()->running
= 1;
1849 clear_traceframe_info ();
1852 /* The tstart command requests the target to start a new trace run.
1853 The command passes any arguments it has to the target verbatim, as
1854 an optional "trace note". This is useful as for instance a warning
1855 to other users if the trace runs disconnected, and you don't want
1856 anybody else messing with the target. */
1859 trace_start_command (char *args
, int from_tty
)
1861 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1863 if (current_trace_status ()->running
)
1866 && !query (_("A trace is running already. Start a new run? ")))
1867 error (_("New trace run not started."));
1870 start_tracing (args
);
1873 /* The tstop command stops the tracing run. The command passes any
1874 supplied arguments to the target verbatim as a "stop note"; if the
1875 target supports trace notes, then it will be reported back as part
1876 of the trace run's status. */
1879 trace_stop_command (char *args
, int from_tty
)
1881 if (!current_trace_status ()->running
)
1882 error (_("Trace is not running."));
1884 stop_tracing (args
);
1888 stop_tracing (char *note
)
1891 VEC(breakpoint_p
) *tp_vec
= NULL
;
1893 struct breakpoint
*t
;
1895 target_trace_stop ();
1897 tp_vec
= all_tracepoints ();
1898 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1900 struct bp_location
*loc
;
1902 if ((t
->type
== bp_fast_tracepoint
1903 ? !may_insert_fast_tracepoints
1904 : !may_insert_tracepoints
))
1907 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1909 /* GDB can be totally absent in some disconnected trace scenarios,
1910 but we don't really care if this semaphore goes out of sync.
1911 That's why we are decrementing it here, but not taking care
1913 if (loc
->probe
!= NULL
)
1914 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1918 VEC_free (breakpoint_p
, tp_vec
);
1921 note
= trace_stop_notes
;
1922 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1925 warning (_("Target does not support trace notes, note ignored"));
1927 /* Should change in response to reply? */
1928 current_trace_status ()->running
= 0;
1931 /* tstatus command */
1933 trace_status_command (char *args
, int from_tty
)
1935 struct trace_status
*ts
= current_trace_status ();
1937 VEC(breakpoint_p
) *tp_vec
= NULL
;
1938 struct breakpoint
*t
;
1940 status
= target_get_trace_status (ts
);
1944 if (ts
->filename
!= NULL
)
1945 printf_filtered (_("Using a trace file.\n"));
1948 printf_filtered (_("Trace can not be run on this target.\n"));
1953 if (!ts
->running_known
)
1955 printf_filtered (_("Run/stop status is unknown.\n"));
1957 else if (ts
->running
)
1959 printf_filtered (_("Trace is running on the target.\n"));
1963 switch (ts
->stop_reason
)
1965 case trace_never_run
:
1966 printf_filtered (_("No trace has been run on the target.\n"));
1970 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1973 printf_filtered (_("Trace stopped by a tstop command.\n"));
1975 case trace_buffer_full
:
1976 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1978 case trace_disconnected
:
1979 printf_filtered (_("Trace stopped because of disconnection.\n"));
1981 case tracepoint_passcount
:
1982 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1983 ts
->stopping_tracepoint
);
1985 case tracepoint_error
:
1986 if (ts
->stopping_tracepoint
)
1987 printf_filtered (_("Trace stopped by an "
1988 "error (%s, tracepoint %d).\n"),
1989 ts
->stop_desc
, ts
->stopping_tracepoint
);
1991 printf_filtered (_("Trace stopped by an error (%s).\n"),
1994 case trace_stop_reason_unknown
:
1995 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1998 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2004 if (ts
->traceframes_created
>= 0
2005 && ts
->traceframe_count
!= ts
->traceframes_created
)
2007 printf_filtered (_("Buffer contains %d trace "
2008 "frames (of %d created total).\n"),
2009 ts
->traceframe_count
, ts
->traceframes_created
);
2011 else if (ts
->traceframe_count
>= 0)
2013 printf_filtered (_("Collected %d trace frames.\n"),
2014 ts
->traceframe_count
);
2017 if (ts
->buffer_free
>= 0)
2019 if (ts
->buffer_size
>= 0)
2021 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2022 ts
->buffer_free
, ts
->buffer_size
);
2023 if (ts
->buffer_size
> 0)
2024 printf_filtered (_(" (%d%% full)"),
2025 ((int) ((((long long) (ts
->buffer_size
2026 - ts
->buffer_free
)) * 100)
2027 / ts
->buffer_size
)));
2028 printf_filtered (_(".\n"));
2031 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2035 if (ts
->disconnected_tracing
)
2036 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2038 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2040 if (ts
->circular_buffer
)
2041 printf_filtered (_("Trace buffer is circular.\n"));
2043 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2044 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2046 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2047 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2049 /* Now report on what we're doing with tfind. */
2050 if (traceframe_number
>= 0)
2051 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2052 traceframe_number
, tracepoint_number
);
2054 printf_filtered (_("Not looking at any trace frame.\n"));
2056 /* Report start/stop times if supplied. */
2061 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2063 /* Reporting a run time is more readable than two long numbers. */
2064 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2065 (long int) ts
->start_time
/ 1000000,
2066 (long int) ts
->start_time
% 1000000,
2067 (long int) run_time
/ 1000000,
2068 (long int) run_time
% 1000000);
2071 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2072 (long int) ts
->start_time
/ 1000000,
2073 (long int) ts
->start_time
% 1000000);
2075 else if (ts
->stop_time
)
2076 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2077 (long int) ts
->stop_time
/ 1000000,
2078 (long int) ts
->stop_time
% 1000000);
2080 /* Now report any per-tracepoint status available. */
2081 tp_vec
= all_tracepoints ();
2083 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2084 target_get_tracepoint_status (t
, NULL
);
2086 VEC_free (breakpoint_p
, tp_vec
);
2089 /* Report the trace status to uiout, in a way suitable for MI, and not
2090 suitable for CLI. If ON_STOP is true, suppress a few fields that
2091 are not meaningful in the -trace-stop response.
2093 The implementation is essentially parallel to trace_status_command, but
2094 merging them will result in unreadable code. */
2096 trace_status_mi (int on_stop
)
2098 struct ui_out
*uiout
= current_uiout
;
2099 struct trace_status
*ts
= current_trace_status ();
2102 status
= target_get_trace_status (ts
);
2104 if (status
== -1 && ts
->filename
== NULL
)
2106 ui_out_field_string (uiout
, "supported", "0");
2110 if (ts
->filename
!= NULL
)
2111 ui_out_field_string (uiout
, "supported", "file");
2113 ui_out_field_string (uiout
, "supported", "1");
2115 if (ts
->filename
!= NULL
)
2116 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2118 gdb_assert (ts
->running_known
);
2122 ui_out_field_string (uiout
, "running", "1");
2124 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2125 Given that the frontend gets the status either on -trace-stop, or from
2126 -trace-status after re-connection, it does not seem like this
2127 information is necessary for anything. It is not necessary for either
2128 figuring the vital state of the target nor for navigation of trace
2129 frames. If the frontend wants to show the current state is some
2130 configure dialog, it can request the value when such dialog is
2131 invoked by the user. */
2135 char *stop_reason
= NULL
;
2136 int stopping_tracepoint
= -1;
2139 ui_out_field_string (uiout
, "running", "0");
2141 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2143 switch (ts
->stop_reason
)
2146 stop_reason
= "request";
2148 case trace_buffer_full
:
2149 stop_reason
= "overflow";
2151 case trace_disconnected
:
2152 stop_reason
= "disconnection";
2154 case tracepoint_passcount
:
2155 stop_reason
= "passcount";
2156 stopping_tracepoint
= ts
->stopping_tracepoint
;
2158 case tracepoint_error
:
2159 stop_reason
= "error";
2160 stopping_tracepoint
= ts
->stopping_tracepoint
;
2166 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2167 if (stopping_tracepoint
!= -1)
2168 ui_out_field_int (uiout
, "stopping-tracepoint",
2169 stopping_tracepoint
);
2170 if (ts
->stop_reason
== tracepoint_error
)
2171 ui_out_field_string (uiout
, "error-description",
2177 if (ts
->traceframe_count
!= -1)
2178 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2179 if (ts
->traceframes_created
!= -1)
2180 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2181 if (ts
->buffer_size
!= -1)
2182 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2183 if (ts
->buffer_free
!= -1)
2184 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2186 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2187 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2189 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2190 ui_out_field_string (uiout
, "notes", ts
->notes
);
2195 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2196 (long int) ts
->start_time
/ 1000000,
2197 (long int) ts
->start_time
% 1000000);
2198 ui_out_field_string (uiout
, "start-time", buf
);
2199 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2200 (long int) ts
->stop_time
/ 1000000,
2201 (long int) ts
->stop_time
% 1000000);
2202 ui_out_field_string (uiout
, "stop-time", buf
);
2206 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2207 user if she really wants to detach. */
2210 query_if_trace_running (int from_tty
)
2215 /* It can happen that the target that was tracing went away on its
2216 own, and we didn't notice. Get a status update, and if the
2217 current target doesn't even do tracing, then assume it's not
2219 if (target_get_trace_status (current_trace_status ()) < 0)
2220 current_trace_status ()->running
= 0;
2222 /* If running interactively, give the user the option to cancel and
2223 then decide what to do differently with the run. Scripts are
2224 just going to disconnect and let the target deal with it,
2225 according to how it's been instructed previously via
2226 disconnected-tracing. */
2227 if (current_trace_status ()->running
)
2229 process_tracepoint_on_disconnect ();
2231 if (current_trace_status ()->disconnected_tracing
)
2233 if (!query (_("Trace is running and will "
2234 "continue after detach; detach anyway? ")))
2235 error (_("Not confirmed."));
2239 if (!query (_("Trace is running but will "
2240 "stop on detach; detach anyway? ")))
2241 error (_("Not confirmed."));
2246 /* This function handles the details of what to do about an ongoing
2247 tracing run if the user has asked to detach or otherwise disconnect
2251 disconnect_tracing (void)
2253 /* Also we want to be out of tfind mode, otherwise things can get
2254 confusing upon reconnection. Just use these calls instead of
2255 full tfind_1 behavior because we're in the middle of detaching,
2256 and there's no point to updating current stack frame etc. */
2257 set_current_traceframe (-1);
2258 set_tracepoint_num (-1);
2259 set_traceframe_context (NULL
);
2262 /* Worker function for the various flavors of the tfind command. */
2264 tfind_1 (enum trace_find_type type
, int num
,
2265 CORE_ADDR addr1
, CORE_ADDR addr2
,
2268 int target_frameno
= -1, target_tracept
= -1;
2269 struct frame_id old_frame_id
= null_frame_id
;
2270 struct tracepoint
*tp
;
2271 struct ui_out
*uiout
= current_uiout
;
2273 /* Only try to get the current stack frame if we have a chance of
2274 succeeding. In particular, if we're trying to get a first trace
2275 frame while all threads are running, it's not going to succeed,
2276 so leave it with a default value and let the frame comparison
2277 below (correctly) decide to print out the source location of the
2279 if (!(type
== tfind_number
&& num
== -1)
2280 && (has_stack_frames () || traceframe_number
>= 0))
2281 old_frame_id
= get_frame_id (get_current_frame ());
2283 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2286 if (type
== tfind_number
2288 && target_frameno
== -1)
2290 /* We told the target to get out of tfind mode, and it did. */
2292 else if (target_frameno
== -1)
2294 /* A request for a non-existent trace frame has failed.
2295 Our response will be different, depending on FROM_TTY:
2297 If FROM_TTY is true, meaning that this command was
2298 typed interactively by the user, then give an error
2299 and DO NOT change the state of traceframe_number etc.
2301 However if FROM_TTY is false, meaning that we're either
2302 in a script, a loop, or a user-defined command, then
2303 DON'T give an error, but DO change the state of
2304 traceframe_number etc. to invalid.
2306 The rationalle is that if you typed the command, you
2307 might just have committed a typo or something, and you'd
2308 like to NOT lose your current debugging state. However
2309 if you're in a user-defined command or especially in a
2310 loop, then you need a way to detect that the command
2311 failed WITHOUT aborting. This allows you to write
2312 scripts that search thru the trace buffer until the end,
2313 and then continue on to do something else. */
2316 error (_("Target failed to find requested trace frame."));
2320 printf_filtered ("End of trace buffer.\n");
2321 #if 0 /* dubious now? */
2322 /* The following will not recurse, since it's
2324 trace_find_command ("-1", from_tty
);
2329 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2331 reinit_frame_cache ();
2332 target_dcache_invalidate ();
2334 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2336 if (target_frameno
!= get_traceframe_number ())
2337 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2339 set_current_traceframe (target_frameno
);
2341 if (target_frameno
== -1)
2342 set_traceframe_context (NULL
);
2344 set_traceframe_context (get_current_frame ());
2346 if (traceframe_number
>= 0)
2348 /* Use different branches for MI and CLI to make CLI messages
2350 if (ui_out_is_mi_like_p (uiout
))
2352 ui_out_field_string (uiout
, "found", "1");
2353 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2354 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2358 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2359 traceframe_number
, tracepoint_number
);
2364 if (ui_out_is_mi_like_p (uiout
))
2365 ui_out_field_string (uiout
, "found", "0");
2366 else if (type
== tfind_number
&& num
== -1)
2367 printf_unfiltered (_("No longer looking at any trace frame\n"));
2368 else /* This case may never occur, check. */
2369 printf_unfiltered (_("No trace frame found\n"));
2372 /* If we're in nonstop mode and getting out of looking at trace
2373 frames, there won't be any current frame to go back to and
2376 && (has_stack_frames () || traceframe_number
>= 0))
2378 enum print_what print_what
;
2380 /* NOTE: in imitation of the step command, try to determine
2381 whether we have made a transition from one function to
2382 another. If so, we'll print the "stack frame" (ie. the new
2383 function and it's arguments) -- otherwise we'll just show the
2386 if (frame_id_eq (old_frame_id
,
2387 get_frame_id (get_current_frame ())))
2388 print_what
= SRC_LINE
;
2390 print_what
= SRC_AND_LOC
;
2392 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2397 /* trace_find_command takes a trace frame number n,
2398 sends "QTFrame:<n>" to the target,
2399 and accepts a reply that may contain several optional pieces
2400 of information: a frame number, a tracepoint number, and an
2401 indication of whether this is a trap frame or a stepping frame.
2403 The minimal response is just "OK" (which indicates that the
2404 target does not give us a frame number or a tracepoint number).
2405 Instead of that, the target may send us a string containing
2407 F<hexnum> (gives the selected frame number)
2408 T<hexnum> (gives the selected tracepoint number)
2413 trace_find_command (char *args
, int from_tty
)
2414 { /* This should only be called with a numeric argument. */
2417 if (current_trace_status ()->running
2418 && current_trace_status ()->filename
== NULL
)
2419 error (_("May not look at trace frames while trace is running."));
2421 if (args
== 0 || *args
== 0)
2422 { /* TFIND with no args means find NEXT trace frame. */
2423 if (traceframe_number
== -1)
2424 frameno
= 0; /* "next" is first one. */
2426 frameno
= traceframe_number
+ 1;
2428 else if (0 == strcmp (args
, "-"))
2430 if (traceframe_number
== -1)
2431 error (_("not debugging trace buffer"));
2432 else if (from_tty
&& traceframe_number
== 0)
2433 error (_("already at start of trace buffer"));
2435 frameno
= traceframe_number
- 1;
2437 /* A hack to work around eval's need for fp to have been collected. */
2438 else if (0 == strcmp (args
, "-1"))
2441 frameno
= parse_and_eval_long (args
);
2444 error (_("invalid input (%d is less than zero)"), frameno
);
2446 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2451 trace_find_end_command (char *args
, int from_tty
)
2453 trace_find_command ("-1", from_tty
);
2458 trace_find_start_command (char *args
, int from_tty
)
2460 trace_find_command ("0", from_tty
);
2463 /* tfind pc command */
2465 trace_find_pc_command (char *args
, int from_tty
)
2469 if (current_trace_status ()->running
2470 && current_trace_status ()->filename
== NULL
)
2471 error (_("May not look at trace frames while trace is running."));
2473 if (args
== 0 || *args
== 0)
2474 pc
= regcache_read_pc (get_current_regcache ());
2476 pc
= parse_and_eval_address (args
);
2478 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2481 /* tfind tracepoint command */
2483 trace_find_tracepoint_command (char *args
, int from_tty
)
2486 struct tracepoint
*tp
;
2488 if (current_trace_status ()->running
2489 && current_trace_status ()->filename
== NULL
)
2490 error (_("May not look at trace frames while trace is running."));
2492 if (args
== 0 || *args
== 0)
2494 if (tracepoint_number
== -1)
2495 error (_("No current tracepoint -- please supply an argument."));
2497 tdp
= tracepoint_number
; /* Default is current TDP. */
2500 tdp
= parse_and_eval_long (args
);
2502 /* If we have the tracepoint on hand, use the number that the
2503 target knows about (which may be different if we disconnected
2504 and reconnected). */
2505 tp
= get_tracepoint (tdp
);
2507 tdp
= tp
->number_on_target
;
2509 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2512 /* TFIND LINE command:
2514 This command will take a sourceline for argument, just like BREAK
2515 or TRACE (ie. anything that "decode_line_1" can handle).
2517 With no argument, this command will find the next trace frame
2518 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2521 trace_find_line_command (char *args
, int from_tty
)
2523 static CORE_ADDR start_pc
, end_pc
;
2524 struct symtabs_and_lines sals
;
2525 struct symtab_and_line sal
;
2526 struct cleanup
*old_chain
;
2528 if (current_trace_status ()->running
2529 && current_trace_status ()->filename
== NULL
)
2530 error (_("May not look at trace frames while trace is running."));
2532 if (args
== 0 || *args
== 0)
2534 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2536 sals
.sals
= (struct symtab_and_line
*)
2537 xmalloc (sizeof (struct symtab_and_line
));
2542 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2546 old_chain
= make_cleanup (xfree
, sals
.sals
);
2547 if (sal
.symtab
== 0)
2548 error (_("No line number information available."));
2550 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2552 if (start_pc
== end_pc
)
2554 printf_filtered ("Line %d of \"%s\"",
2556 symtab_to_filename_for_display (sal
.symtab
));
2558 printf_filtered (" is at address ");
2559 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2561 printf_filtered (" but contains no code.\n");
2562 sal
= find_pc_line (start_pc
, 0);
2564 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2565 && start_pc
!= end_pc
)
2566 printf_filtered ("Attempting to find line %d instead.\n",
2569 error (_("Cannot find a good line."));
2573 /* Is there any case in which we get here, and have an address
2574 which the user would want to see? If we have debugging
2575 symbols and no line numbers? */
2576 error (_("Line number %d is out of range for \"%s\"."),
2577 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2579 /* Find within range of stated line. */
2581 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2583 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2584 do_cleanups (old_chain
);
2587 /* tfind range command */
2589 trace_find_range_command (char *args
, int from_tty
)
2591 static CORE_ADDR start
, stop
;
2594 if (current_trace_status ()->running
2595 && current_trace_status ()->filename
== NULL
)
2596 error (_("May not look at trace frames while trace is running."));
2598 if (args
== 0 || *args
== 0)
2599 { /* XXX FIXME: what should default behavior be? */
2600 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2604 if (0 != (tmp
= strchr (args
, ',')))
2606 *tmp
++ = '\0'; /* Terminate start address. */
2607 tmp
= skip_spaces (tmp
);
2608 start
= parse_and_eval_address (args
);
2609 stop
= parse_and_eval_address (tmp
);
2612 { /* No explicit end address? */
2613 start
= parse_and_eval_address (args
);
2614 stop
= start
+ 1; /* ??? */
2617 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2620 /* tfind outside command */
2622 trace_find_outside_command (char *args
, int from_tty
)
2624 CORE_ADDR start
, stop
;
2627 if (current_trace_status ()->running
2628 && current_trace_status ()->filename
== NULL
)
2629 error (_("May not look at trace frames while trace is running."));
2631 if (args
== 0 || *args
== 0)
2632 { /* XXX FIXME: what should default behavior be? */
2633 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2637 if (0 != (tmp
= strchr (args
, ',')))
2639 *tmp
++ = '\0'; /* Terminate start address. */
2640 tmp
= skip_spaces (tmp
);
2641 start
= parse_and_eval_address (args
);
2642 stop
= parse_and_eval_address (tmp
);
2645 { /* No explicit end address? */
2646 start
= parse_and_eval_address (args
);
2647 stop
= start
+ 1; /* ??? */
2650 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2653 /* info scope command: list the locals for a scope. */
2655 scope_info (char *args
, int from_tty
)
2657 struct symtabs_and_lines sals
;
2659 struct minimal_symbol
*msym
;
2660 struct block
*block
;
2661 const char *symname
;
2662 char *save_args
= args
;
2663 struct block_iterator iter
;
2665 struct gdbarch
*gdbarch
;
2668 if (args
== 0 || *args
== 0)
2669 error (_("requires an argument (function, "
2670 "line or *addr) to define a scope"));
2672 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2673 if (sals
.nelts
== 0)
2674 return; /* Presumably decode_line_1 has already warned. */
2676 /* Resolve line numbers to PC. */
2677 resolve_sal_pc (&sals
.sals
[0]);
2678 block
= block_for_pc (sals
.sals
[0].pc
);
2682 QUIT
; /* Allow user to bail out with ^C. */
2683 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2685 QUIT
; /* Allow user to bail out with ^C. */
2687 printf_filtered ("Scope for %s:\n", save_args
);
2690 symname
= SYMBOL_PRINT_NAME (sym
);
2691 if (symname
== NULL
|| *symname
== '\0')
2692 continue; /* Probably botched, certainly useless. */
2694 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2696 printf_filtered ("Symbol %s is ", symname
);
2698 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2699 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2700 BLOCK_START (block
),
2704 switch (SYMBOL_CLASS (sym
))
2707 case LOC_UNDEF
: /* Messed up symbol? */
2708 printf_filtered ("a bogus symbol, class %d.\n",
2709 SYMBOL_CLASS (sym
));
2710 count
--; /* Don't count this one. */
2713 printf_filtered ("a constant with value %s (%s)",
2714 plongest (SYMBOL_VALUE (sym
)),
2715 hex_string (SYMBOL_VALUE (sym
)));
2717 case LOC_CONST_BYTES
:
2718 printf_filtered ("constant bytes: ");
2719 if (SYMBOL_TYPE (sym
))
2720 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2721 fprintf_filtered (gdb_stdout
, " %02x",
2722 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2725 printf_filtered ("in static storage at address ");
2726 printf_filtered ("%s", paddress (gdbarch
,
2727 SYMBOL_VALUE_ADDRESS (sym
)));
2730 /* GDBARCH is the architecture associated with the objfile
2731 the symbol is defined in; the target architecture may be
2732 different, and may provide additional registers. However,
2733 we do not know the target architecture at this point.
2734 We assume the objfile architecture will contain all the
2735 standard registers that occur in debug info in that
2737 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2740 if (SYMBOL_IS_ARGUMENT (sym
))
2741 printf_filtered ("an argument in register $%s",
2742 gdbarch_register_name (gdbarch
, regno
));
2744 printf_filtered ("a local variable in register $%s",
2745 gdbarch_register_name (gdbarch
, regno
));
2748 printf_filtered ("an argument at stack/frame offset %s",
2749 plongest (SYMBOL_VALUE (sym
)));
2752 printf_filtered ("a local variable at frame offset %s",
2753 plongest (SYMBOL_VALUE (sym
)));
2756 printf_filtered ("a reference argument at offset %s",
2757 plongest (SYMBOL_VALUE (sym
)));
2759 case LOC_REGPARM_ADDR
:
2760 /* Note comment at LOC_REGISTER. */
2761 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2763 printf_filtered ("the address of an argument, in register $%s",
2764 gdbarch_register_name (gdbarch
, regno
));
2767 printf_filtered ("a typedef.\n");
2770 printf_filtered ("a label at address ");
2771 printf_filtered ("%s", paddress (gdbarch
,
2772 SYMBOL_VALUE_ADDRESS (sym
)));
2775 printf_filtered ("a function at address ");
2776 printf_filtered ("%s",
2777 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2779 case LOC_UNRESOLVED
:
2780 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2783 printf_filtered ("Unresolved Static");
2786 printf_filtered ("static storage at address ");
2787 printf_filtered ("%s",
2789 SYMBOL_VALUE_ADDRESS (msym
)));
2792 case LOC_OPTIMIZED_OUT
:
2793 printf_filtered ("optimized out.\n");
2796 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2799 if (SYMBOL_TYPE (sym
))
2800 printf_filtered (", length %d.\n",
2801 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2803 if (BLOCK_FUNCTION (block
))
2806 block
= BLOCK_SUPERBLOCK (block
);
2809 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2813 /* Helper for trace_dump_command. Dump the action list starting at
2814 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2815 actions of the body of a while-stepping action. STEPPING_FRAME is
2816 set if the current traceframe was determined to be a while-stepping
2820 trace_dump_actions (struct command_line
*action
,
2821 int stepping_actions
, int stepping_frame
,
2824 const char *action_exp
, *next_comma
;
2826 for (; action
!= NULL
; action
= action
->next
)
2828 struct cmd_list_element
*cmd
;
2830 QUIT
; /* Allow user to bail out with ^C. */
2831 action_exp
= action
->line
;
2832 action_exp
= skip_spaces_const (action_exp
);
2834 /* The collection actions to be done while stepping are
2835 bracketed by the commands "while-stepping" and "end". */
2837 if (*action_exp
== '#') /* comment line */
2840 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2842 error (_("Bad action list item: %s"), action_exp
);
2844 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2848 for (i
= 0; i
< action
->body_count
; ++i
)
2849 trace_dump_actions (action
->body_list
[i
],
2850 1, stepping_frame
, from_tty
);
2852 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2854 /* Display the collected data.
2855 For the trap frame, display only what was collected at
2856 the trap. Likewise for stepping frames, display only
2857 what was collected while stepping. This means that the
2858 two boolean variables, STEPPING_FRAME and
2859 STEPPING_ACTIONS should be equal. */
2860 if (stepping_frame
== stepping_actions
)
2863 struct cleanup
*old_chain
2864 = make_cleanup (free_current_contents
, &cmd
);
2865 int trace_string
= 0;
2867 if (*action_exp
== '/')
2868 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2871 { /* Repeat over a comma-separated list. */
2872 QUIT
; /* Allow user to bail out with ^C. */
2873 if (*action_exp
== ',')
2875 action_exp
= skip_spaces_const (action_exp
);
2877 next_comma
= strchr (action_exp
, ',');
2879 if (0 == strncasecmp (action_exp
, "$reg", 4))
2880 registers_info (NULL
, from_tty
);
2881 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2883 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2884 locals_info (NULL
, from_tty
);
2885 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2886 args_info (NULL
, from_tty
);
2889 if (next_comma
!= NULL
)
2891 size_t len
= next_comma
- action_exp
;
2893 cmd
= xrealloc (cmd
, len
+ 1);
2894 memcpy (cmd
, action_exp
, len
);
2899 size_t len
= strlen (action_exp
);
2901 cmd
= xrealloc (cmd
, len
+ 1);
2902 memcpy (cmd
, action_exp
, len
+ 1);
2905 printf_filtered ("%s = ", cmd
);
2906 output_command_const (cmd
, from_tty
);
2907 printf_filtered ("\n");
2909 action_exp
= next_comma
;
2911 while (action_exp
&& *action_exp
== ',');
2913 do_cleanups (old_chain
);
2919 /* The tdump command. */
2922 trace_dump_command (char *args
, int from_tty
)
2924 struct regcache
*regcache
;
2925 struct tracepoint
*t
;
2926 int stepping_frame
= 0;
2927 struct bp_location
*loc
;
2928 char *default_collect_line
= NULL
;
2929 struct command_line
*actions
, *default_collect_action
= NULL
;
2930 struct cleanup
*old_chain
= NULL
;
2932 if (tracepoint_number
== -1)
2934 warning (_("No current trace frame."));
2938 t
= get_tracepoint (tracepoint_number
);
2941 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2944 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2945 tracepoint_number
, traceframe_number
);
2947 /* The current frame is a trap frame if the frame PC is equal
2948 to the tracepoint PC. If not, then the current frame was
2949 collected during single-stepping. */
2951 regcache
= get_current_regcache ();
2953 /* If the traceframe's address matches any of the tracepoint's
2954 locations, assume it is a direct hit rather than a while-stepping
2955 frame. (FIXME this is not reliable, should record each frame's
2958 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2959 if (loc
->address
== regcache_read_pc (regcache
))
2962 actions
= breakpoint_commands (&t
->base
);
2964 /* If there is a default-collect list, make up a collect command,
2965 prepend to the tracepoint's commands, and pass the whole mess to
2966 the trace dump scanner. We need to validate because
2967 default-collect might have been junked since the trace run. */
2968 if (*default_collect
)
2970 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2971 old_chain
= make_cleanup (xfree
, default_collect_line
);
2972 validate_actionline (default_collect_line
, &t
->base
);
2973 default_collect_action
= xmalloc (sizeof (struct command_line
));
2974 make_cleanup (xfree
, default_collect_action
);
2975 default_collect_action
->next
= actions
;
2976 default_collect_action
->line
= default_collect_line
;
2977 actions
= default_collect_action
;
2980 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2982 if (*default_collect
)
2983 do_cleanups (old_chain
);
2986 /* Encode a piece of a tracepoint's source-level definition in a form
2987 that is suitable for both protocol and saving in files. */
2988 /* This version does not do multiple encodes for long strings; it should
2989 return an offset to the next piece to encode. FIXME */
2992 encode_source_string (int tpnum
, ULONGEST addr
,
2993 char *srctype
, char *src
, char *buf
, int buf_size
)
2995 if (80 + strlen (srctype
) > buf_size
)
2996 error (_("Buffer too small for source encoding"));
2997 sprintf (buf
, "%x:%s:%s:%x:%x:",
2998 tpnum
, phex_nz (addr
, sizeof (addr
)),
2999 srctype
, 0, (int) strlen (src
));
3000 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3001 error (_("Source string too long for buffer"));
3002 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3006 /* Free trace file writer. */
3009 trace_file_writer_xfree (void *arg
)
3011 struct trace_file_writer
*writer
= arg
;
3013 writer
->ops
->dtor (writer
);
3017 /* TFILE trace writer. */
3019 struct tfile_trace_file_writer
3021 struct trace_file_writer base
;
3023 /* File pointer to tfile trace file. */
3025 /* Path name of the tfile trace file. */
3029 /* This is the implementation of trace_file_write_ops method
3030 target_save. We just call the generic target
3031 target_save_trace_data to do target-side saving. */
3034 tfile_target_save (struct trace_file_writer
*self
,
3035 const char *filename
)
3037 int err
= target_save_trace_data (filename
);
3042 /* This is the implementation of trace_file_write_ops method
3046 tfile_dtor (struct trace_file_writer
*self
)
3048 struct tfile_trace_file_writer
*writer
3049 = (struct tfile_trace_file_writer
*) self
;
3051 xfree (writer
->pathname
);
3053 if (writer
->fp
!= NULL
)
3054 fclose (writer
->fp
);
3057 /* This is the implementation of trace_file_write_ops method
3058 start. It creates the trace file FILENAME and registers some
3062 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3064 struct tfile_trace_file_writer
*writer
3065 = (struct tfile_trace_file_writer
*) self
;
3067 writer
->pathname
= tilde_expand (filename
);
3068 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3069 if (writer
->fp
== NULL
)
3070 error (_("Unable to open file '%s' for saving trace data (%s)"),
3071 filename
, safe_strerror (errno
));
3074 /* This is the implementation of trace_file_write_ops method
3075 write_header. Write the TFILE header. */
3078 tfile_write_header (struct trace_file_writer
*self
)
3080 struct tfile_trace_file_writer
*writer
3081 = (struct tfile_trace_file_writer
*) self
;
3084 /* Write a file header, with a high-bit-set char to indicate a
3085 binary file, plus a hint as what this file is, and a version
3086 number in case of future needs. */
3087 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3089 perror_with_name (writer
->pathname
);
3092 /* This is the implementation of trace_file_write_ops method
3093 write_regblock_type. Write the size of register block. */
3096 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3098 struct tfile_trace_file_writer
*writer
3099 = (struct tfile_trace_file_writer
*) self
;
3101 fprintf (writer
->fp
, "R %x\n", size
);
3104 /* This is the implementation of trace_file_write_ops method
3108 tfile_write_status (struct trace_file_writer
*self
,
3109 struct trace_status
*ts
)
3111 struct tfile_trace_file_writer
*writer
3112 = (struct tfile_trace_file_writer
*) self
;
3114 fprintf (writer
->fp
, "status %c;%s",
3115 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3116 if (ts
->stop_reason
== tracepoint_error
3117 || ts
->stop_reason
== tstop_command
)
3119 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3121 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3122 fprintf (writer
->fp
, ":%s", buf
);
3124 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3125 if (ts
->traceframe_count
>= 0)
3126 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3127 if (ts
->traceframes_created
>= 0)
3128 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3129 if (ts
->buffer_free
>= 0)
3130 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3131 if (ts
->buffer_size
>= 0)
3132 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3133 if (ts
->disconnected_tracing
)
3134 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3135 if (ts
->circular_buffer
)
3136 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3137 if (ts
->notes
!= NULL
)
3139 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3141 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3142 fprintf (writer
->fp
, ";notes:%s", buf
);
3144 if (ts
->user_name
!= NULL
)
3146 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3148 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3149 fprintf (writer
->fp
, ";username:%s", buf
);
3151 fprintf (writer
->fp
, "\n");
3154 /* This is the implementation of trace_file_write_ops method
3155 write_uploaded_tsv. */
3158 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3159 struct uploaded_tsv
*utsv
)
3162 struct tfile_trace_file_writer
*writer
3163 = (struct tfile_trace_file_writer
*) self
;
3167 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3168 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3171 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3172 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3173 utsv
->builtin
, buf
);
3179 #define MAX_TRACE_UPLOAD 2000
3181 /* This is the implementation of trace_file_write_ops method
3182 write_uploaded_tp. */
3185 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3186 struct uploaded_tp
*utp
)
3188 struct tfile_trace_file_writer
*writer
3189 = (struct tfile_trace_file_writer
*) self
;
3192 char buf
[MAX_TRACE_UPLOAD
];
3194 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3195 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3196 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3197 if (utp
->type
== bp_fast_tracepoint
)
3198 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3200 fprintf (writer
->fp
,
3201 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3203 fprintf (writer
->fp
, "\n");
3204 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3205 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3206 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3207 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3208 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3209 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3212 encode_source_string (utp
->number
, utp
->addr
,
3213 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3214 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3216 if (utp
->cond_string
)
3218 encode_source_string (utp
->number
, utp
->addr
,
3219 "cond", utp
->cond_string
,
3220 buf
, MAX_TRACE_UPLOAD
);
3221 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3223 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3225 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3226 buf
, MAX_TRACE_UPLOAD
);
3227 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3229 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3230 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3232 phex_nz (utp
->traceframe_usage
,
3233 sizeof (utp
->traceframe_usage
)));
3236 /* This is the implementation of trace_file_write_ops method
3237 write_definition_end. */
3240 tfile_write_definition_end (struct trace_file_writer
*self
)
3242 struct tfile_trace_file_writer
*writer
3243 = (struct tfile_trace_file_writer
*) self
;
3245 fprintf (writer
->fp
, "\n");
3248 /* This is the implementation of trace_file_write_ops method
3252 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3255 struct tfile_trace_file_writer
*writer
3256 = (struct tfile_trace_file_writer
*) self
;
3258 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3259 perror_with_name (writer
->pathname
);
3262 /* This is the implementation of trace_file_write_ops method
3266 tfile_end (struct trace_file_writer
*self
)
3268 struct tfile_trace_file_writer
*writer
3269 = (struct tfile_trace_file_writer
*) self
;
3270 uint32_t gotten
= 0;
3272 /* Mark the end of trace data. */
3273 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3274 perror_with_name (writer
->pathname
);
3277 /* Operations to write trace buffers into TFILE format. */
3279 static const struct trace_file_write_ops tfile_write_ops
=
3285 tfile_write_regblock_type
,
3287 tfile_write_uploaded_tsv
,
3288 tfile_write_uploaded_tp
,
3289 tfile_write_definition_end
,
3290 tfile_write_raw_data
,
3295 /* Helper macros. */
3297 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3298 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3299 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3300 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3302 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3303 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3305 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3306 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
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
];
3324 #define MAX_TRACE_UPLOAD 2000
3326 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3328 /* If the target is to save the data to a file on its own, then just
3329 send the command and be done with it. */
3330 if (target_does_save
)
3332 if (!writer
->ops
->target_save (writer
, filename
))
3333 error (_("Target failed to save trace data to '%s'."),
3338 /* Get the trace status first before opening the file, so if the
3339 target is losing, we can get out without touching files. */
3340 status
= target_get_trace_status (ts
);
3342 writer
->ops
->start (writer
, filename
);
3344 writer
->ops
->write_header (writer
);
3346 /* Write descriptive info. */
3348 /* Write out the size of a register block. */
3349 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3351 /* Write out status of the tracing run (aka "tstatus" info). */
3352 writer
->ops
->write_status (writer
, ts
);
3354 /* Note that we want to upload tracepoints and save those, rather
3355 than simply writing out the local ones, because the user may have
3356 changed tracepoints in GDB in preparation for a future tracing
3357 run, or maybe just mass-deleted all types of breakpoints as part
3358 of cleaning up. So as not to contaminate the session, leave the
3359 data in its uploaded form, don't make into real tracepoints. */
3361 /* Get trace state variables first, they may be checked when parsing
3362 uploaded commands. */
3364 target_upload_trace_state_variables (&uploaded_tsvs
);
3366 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3367 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3369 free_uploaded_tsvs (&uploaded_tsvs
);
3371 target_upload_tracepoints (&uploaded_tps
);
3373 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3374 target_get_tracepoint_status (NULL
, utp
);
3376 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3377 writer
->ops
->write_uploaded_tp (writer
, utp
);
3379 free_uploaded_tps (&uploaded_tps
);
3381 /* Mark the end of the definition section. */
3382 writer
->ops
->write_definition_end (writer
);
3384 /* Get and write the trace data proper. */
3389 /* The writer supports writing the contents of trace buffer
3390 directly to trace file. Don't parse the contents of trace
3392 if (writer
->ops
->write_trace_buffer
!= NULL
)
3394 /* We ask for big blocks, in the hopes of efficiency, but
3395 will take less if the target has packet size limitations
3397 gotten
= target_get_raw_trace_data (buf
, offset
,
3400 error (_("Failure to get requested trace buffer data"));
3401 /* No more data is forthcoming, we're done. */
3405 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3413 /* Parse the trace buffers according to how data are stored
3414 in trace buffer in GDBserver. */
3416 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3421 /* Read the first six bytes in, which is the tracepoint
3422 number and trace frame size. */
3424 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3426 tf_size
= (uint32_t)
3427 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3429 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3438 for (block
= 0; block
< tf_size
; )
3440 gdb_byte block_type
;
3442 /* We'll fetch one block each time, in order to
3443 handle the extremely large 'M' block. We first
3444 fetch one byte to get the type of the block. */
3445 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3447 error (_("Failure to get requested trace buffer data"));
3453 block_type
= buf
[0];
3458 = target_get_raw_trace_data (buf
, offset
,
3459 trace_regblock_size
);
3460 if (gotten
< trace_regblock_size
)
3461 error (_("Failure to get requested trace"
3464 TRACE_WRITE_R_BLOCK (writer
, buf
,
3465 trace_regblock_size
);
3469 unsigned short mlen
;
3474 t
= target_get_raw_trace_data (buf
,offset
, 10);
3476 error (_("Failure to get requested trace"
3484 extract_unsigned_integer (buf
, 8,
3486 mlen
= (unsigned short)
3487 extract_unsigned_integer (&buf
[8], 2,
3490 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3493 /* The memory contents in 'M' block may be
3494 very large. Fetch the data from the target
3495 and write them into file one by one. */
3496 for (j
= 0; j
< mlen
; )
3498 unsigned int read_length
;
3500 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3501 read_length
= MAX_TRACE_UPLOAD
;
3503 read_length
= mlen
- j
;
3505 t
= target_get_raw_trace_data (buf
,
3508 if (t
< read_length
)
3509 error (_("Failure to get requested"
3510 " trace buffer data"));
3512 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3516 gotten
+= read_length
;
3527 = target_get_raw_trace_data (buf
, offset
,
3530 error (_("Failure to get requested"
3531 " trace buffer data"));
3533 vnum
= (int) extract_signed_integer (buf
,
3537 = extract_signed_integer (&buf
[4], 8,
3540 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3544 error (_("Unknown block type '%c' (0x%x) in"
3546 block_type
, block_type
);
3556 writer
->ops
->frame_ops
->end (writer
);
3560 writer
->ops
->end (writer
);
3563 /* Return a trace writer for TFILE format. */
3565 static struct trace_file_writer
*
3566 tfile_trace_file_writer_new (void)
3568 struct tfile_trace_file_writer
*writer
3569 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3571 writer
->base
.ops
= &tfile_write_ops
;
3573 writer
->pathname
= NULL
;
3575 return (struct trace_file_writer
*) writer
;
3579 trace_save_command (char *args
, int from_tty
)
3581 int target_does_save
= 0;
3583 char *filename
= NULL
;
3584 struct cleanup
*back_to
;
3585 int generate_ctf
= 0;
3586 struct trace_file_writer
*writer
= NULL
;
3589 error_no_arg (_("file in which to save trace data"));
3591 argv
= gdb_buildargv (args
);
3592 back_to
= make_cleanup_freeargv (argv
);
3594 for (; *argv
; ++argv
)
3596 if (strcmp (*argv
, "-r") == 0)
3597 target_does_save
= 1;
3598 if (strcmp (*argv
, "-ctf") == 0)
3600 else if (**argv
== '-')
3601 error (_("unknown option `%s'"), *argv
);
3607 error_no_arg (_("file in which to save trace data"));
3610 writer
= ctf_trace_file_writer_new ();
3612 writer
= tfile_trace_file_writer_new ();
3614 make_cleanup (trace_file_writer_xfree
, writer
);
3616 trace_save (filename
, writer
, target_does_save
);
3619 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3620 generate_ctf
? "directory" : "file", filename
);
3622 do_cleanups (back_to
);
3625 /* Save the trace data to file FILENAME of tfile format. */
3628 trace_save_tfile (const char *filename
, int target_does_save
)
3630 struct trace_file_writer
*writer
;
3631 struct cleanup
*back_to
;
3633 writer
= tfile_trace_file_writer_new ();
3634 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3635 trace_save (filename
, writer
, target_does_save
);
3636 do_cleanups (back_to
);
3639 /* Save the trace data to dir DIRNAME of ctf format. */
3642 trace_save_ctf (const char *dirname
, int target_does_save
)
3644 struct trace_file_writer
*writer
;
3645 struct cleanup
*back_to
;
3647 writer
= ctf_trace_file_writer_new ();
3648 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3650 trace_save (dirname
, writer
, target_does_save
);
3651 do_cleanups (back_to
);
3654 /* Tell the target what to do with an ongoing tracing run if GDB
3655 disconnects for some reason. */
3658 set_disconnected_tracing (char *args
, int from_tty
,
3659 struct cmd_list_element
*c
)
3661 target_set_disconnected_tracing (disconnected_tracing
);
3665 set_circular_trace_buffer (char *args
, int from_tty
,
3666 struct cmd_list_element
*c
)
3668 target_set_circular_trace_buffer (circular_trace_buffer
);
3672 set_trace_buffer_size (char *args
, int from_tty
,
3673 struct cmd_list_element
*c
)
3675 target_set_trace_buffer_size (trace_buffer_size
);
3679 set_trace_user (char *args
, int from_tty
,
3680 struct cmd_list_element
*c
)
3684 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3687 warning (_("Target does not support trace notes, user ignored"));
3691 set_trace_notes (char *args
, int from_tty
,
3692 struct cmd_list_element
*c
)
3696 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3699 warning (_("Target does not support trace notes, note ignored"));
3703 set_trace_stop_notes (char *args
, int from_tty
,
3704 struct cmd_list_element
*c
)
3708 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3711 warning (_("Target does not support trace notes, stop note ignored"));
3714 /* Convert the memory pointed to by mem into hex, placing result in buf.
3715 * Return a pointer to the last char put in buf (null)
3716 * "stolen" from sparc-stub.c
3719 static const char hexchars
[] = "0123456789abcdef";
3722 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3730 *buf
++ = hexchars
[ch
>> 4];
3731 *buf
++ = hexchars
[ch
& 0xf];
3740 get_traceframe_number (void)
3742 return traceframe_number
;
3746 get_tracepoint_number (void)
3748 return tracepoint_number
;
3751 /* Make the traceframe NUM be the current trace frame. Does nothing
3752 if NUM is already current. */
3755 set_current_traceframe (int num
)
3759 if (traceframe_number
== num
)
3761 /* Nothing to do. */
3765 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3768 warning (_("could not change traceframe"));
3770 set_traceframe_num (newnum
);
3772 /* Changing the traceframe changes our view of registers and of the
3774 registers_changed ();
3776 clear_traceframe_info ();
3779 /* Make the traceframe NUM be the current trace frame, and do nothing
3783 set_traceframe_number (int num
)
3785 traceframe_number
= num
;
3788 /* A cleanup used when switching away and back from tfind mode. */
3790 struct current_traceframe_cleanup
3792 /* The traceframe we were inspecting. */
3793 int traceframe_number
;
3797 do_restore_current_traceframe_cleanup (void *arg
)
3799 struct current_traceframe_cleanup
*old
= arg
;
3801 set_current_traceframe (old
->traceframe_number
);
3805 restore_current_traceframe_cleanup_dtor (void *arg
)
3807 struct current_traceframe_cleanup
*old
= arg
;
3813 make_cleanup_restore_current_traceframe (void)
3815 struct current_traceframe_cleanup
*old
;
3817 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3818 old
->traceframe_number
= traceframe_number
;
3820 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3821 restore_current_traceframe_cleanup_dtor
);
3825 make_cleanup_restore_traceframe_number (void)
3827 return make_cleanup_restore_integer (&traceframe_number
);
3830 /* Given a number and address, return an uploaded tracepoint with that
3831 number, creating if necessary. */
3833 struct uploaded_tp
*
3834 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3836 struct uploaded_tp
*utp
;
3838 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3839 if (utp
->number
== num
&& utp
->addr
== addr
)
3841 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3842 memset (utp
, 0, sizeof (struct uploaded_tp
));
3845 utp
->actions
= NULL
;
3846 utp
->step_actions
= NULL
;
3847 utp
->cmd_strings
= NULL
;
3854 free_uploaded_tps (struct uploaded_tp
**utpp
)
3856 struct uploaded_tp
*next_one
;
3860 next_one
= (*utpp
)->next
;
3866 /* Given a number and address, return an uploaded tracepoint with that
3867 number, creating if necessary. */
3869 struct uploaded_tsv
*
3870 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3872 struct uploaded_tsv
*utsv
;
3874 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3875 if (utsv
->number
== num
)
3877 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3878 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3880 utsv
->next
= *utsvp
;
3886 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3888 struct uploaded_tsv
*next_one
;
3892 next_one
= (*utsvp
)->next
;
3898 /* FIXME this function is heuristic and will miss the cases where the
3899 conditional is semantically identical but differs in whitespace,
3900 such as "x == 0" vs "x==0". */
3903 cond_string_is_same (char *str1
, char *str2
)
3905 if (str1
== NULL
|| str2
== NULL
)
3906 return (str1
== str2
);
3908 return (strcmp (str1
, str2
) == 0);
3911 /* Look for an existing tracepoint that seems similar enough to the
3912 uploaded one. Enablement isn't compared, because the user can
3913 toggle that freely, and may have done so in anticipation of the
3914 next trace run. Return the location of matched tracepoint. */
3916 static struct bp_location
*
3917 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3919 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3921 struct breakpoint
*b
;
3922 struct bp_location
*loc
;
3924 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3926 struct tracepoint
*t
= (struct tracepoint
*) b
;
3928 if (b
->type
== utp
->type
3929 && t
->step_count
== utp
->step
3930 && t
->pass_count
== utp
->pass
3931 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3932 /* FIXME also test actions. */
3935 /* Scan the locations for an address match. */
3936 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3938 if (loc
->address
== utp
->addr
)
3946 /* Given a list of tracepoints uploaded from a target, attempt to
3947 match them up with existing tracepoints, and create new ones if not
3951 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3953 struct uploaded_tp
*utp
;
3954 /* A set of tracepoints which are modified. */
3955 VEC(breakpoint_p
) *modified_tp
= NULL
;
3957 struct breakpoint
*b
;
3959 /* Look for GDB tracepoints that match up with our uploaded versions. */
3960 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3962 struct bp_location
*loc
;
3963 struct tracepoint
*t
;
3965 loc
= find_matching_tracepoint_location (utp
);
3970 /* Mark this location as already inserted. */
3972 t
= (struct tracepoint
*) loc
->owner
;
3973 printf_filtered (_("Assuming tracepoint %d is same "
3974 "as target's tracepoint %d at %s.\n"),
3975 loc
->owner
->number
, utp
->number
,
3976 paddress (loc
->gdbarch
, utp
->addr
));
3978 /* The tracepoint LOC->owner was modified (the location LOC
3979 was marked as inserted in the target). Save it in
3980 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3981 observers will be notified later once for each tracepoint
3982 saved in MODIFIED_TP. */
3984 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3986 if (b
== loc
->owner
)
3992 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3996 t
= create_tracepoint_from_upload (utp
);
3998 printf_filtered (_("Created tracepoint %d for "
3999 "target's tracepoint %d at %s.\n"),
4000 t
->base
.number
, utp
->number
,
4001 paddress (get_current_arch (), utp
->addr
));
4003 printf_filtered (_("Failed to create tracepoint for target's "
4004 "tracepoint %d at %s, skipping it.\n"),
4006 paddress (get_current_arch (), utp
->addr
));
4008 /* Whether found or created, record the number used by the
4009 target, to help with mapping target tracepoints back to their
4010 counterparts here. */
4012 t
->number_on_target
= utp
->number
;
4015 /* Notify 'breakpoint-modified' observer that at least one of B's
4016 locations was changed. */
4017 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4018 observer_notify_breakpoint_modified (b
);
4020 VEC_free (breakpoint_p
, modified_tp
);
4021 free_uploaded_tps (uploaded_tps
);
4024 /* Trace state variables don't have much to identify them beyond their
4025 name, so just use that to detect matches. */
4027 static struct trace_state_variable
*
4028 find_matching_tsv (struct uploaded_tsv
*utsv
)
4033 return find_trace_state_variable (utsv
->name
);
4036 static struct trace_state_variable
*
4037 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4039 const char *namebase
;
4042 struct trace_state_variable
*tsv
;
4043 struct cleanup
*old_chain
;
4047 namebase
= utsv
->name
;
4048 buf
= xstrprintf ("%s", namebase
);
4053 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4056 /* Fish for a name that is not in use. */
4057 /* (should check against all internal vars?) */
4058 while (find_trace_state_variable (buf
))
4061 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4064 old_chain
= make_cleanup (xfree
, buf
);
4066 /* We have an available name, create the variable. */
4067 tsv
= create_trace_state_variable (buf
);
4068 tsv
->initial_value
= utsv
->initial_value
;
4069 tsv
->builtin
= utsv
->builtin
;
4071 observer_notify_tsv_created (tsv
);
4073 do_cleanups (old_chain
);
4078 /* Given a list of uploaded trace state variables, try to match them
4079 up with existing variables, or create additional ones. */
4082 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4085 struct uploaded_tsv
*utsv
;
4086 struct trace_state_variable
*tsv
;
4089 /* Most likely some numbers will have to be reassigned as part of
4090 the merge, so clear them all in anticipation. */
4091 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4094 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4096 tsv
= find_matching_tsv (utsv
);
4100 printf_filtered (_("Assuming trace state variable $%s "
4101 "is same as target's variable %d.\n"),
4102 tsv
->name
, utsv
->number
);
4106 tsv
= create_tsv_from_upload (utsv
);
4108 printf_filtered (_("Created trace state variable "
4109 "$%s for target's variable %d.\n"),
4110 tsv
->name
, utsv
->number
);
4112 /* Give precedence to numberings that come from the target. */
4114 tsv
->number
= utsv
->number
;
4117 /* Renumber everything that didn't get a target-assigned number. */
4119 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4120 if (tsv
->number
> highest
)
4121 highest
= tsv
->number
;
4124 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4125 if (tsv
->number
== 0)
4126 tsv
->number
= highest
++;
4128 free_uploaded_tsvs (uploaded_tsvs
);
4131 /* target tfile command */
4133 static struct target_ops tfile_ops
;
4135 /* Fill in tfile_ops with its defined operations and properties. */
4137 #define TRACE_HEADER_SIZE 8
4139 static char *trace_filename
;
4140 static int trace_fd
= -1;
4141 static off_t trace_frames_offset
;
4142 static off_t cur_offset
;
4143 static int cur_data_size
;
4144 int trace_regblock_size
;
4146 static void tfile_interp_line (char *line
,
4147 struct uploaded_tp
**utpp
,
4148 struct uploaded_tsv
**utsvp
);
4150 /* Read SIZE bytes into READBUF from the trace frame, starting at
4151 TRACE_FD's current position. Note that this call `read'
4152 underneath, hence it advances the file's seek position. Throws an
4153 error if the `read' syscall fails, or less than SIZE bytes are
4157 tfile_read (gdb_byte
*readbuf
, int size
)
4161 gotten
= read (trace_fd
, readbuf
, size
);
4163 perror_with_name (trace_filename
);
4164 else if (gotten
< size
)
4165 error (_("Premature end of file while reading trace file"));
4169 tfile_open (char *filename
, int from_tty
)
4171 volatile struct gdb_exception ex
;
4173 struct cleanup
*old_chain
;
4176 char header
[TRACE_HEADER_SIZE
];
4177 char linebuf
[1000]; /* Should be max remote packet size or so. */
4180 struct trace_status
*ts
;
4181 struct uploaded_tp
*uploaded_tps
= NULL
;
4182 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4184 target_preopen (from_tty
);
4186 error (_("No trace file specified."));
4188 filename
= tilde_expand (filename
);
4189 if (!IS_ABSOLUTE_PATH(filename
))
4191 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4196 old_chain
= make_cleanup (xfree
, filename
);
4198 flags
= O_BINARY
| O_LARGEFILE
;
4200 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4201 if (scratch_chan
< 0)
4202 perror_with_name (filename
);
4204 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4206 discard_cleanups (old_chain
); /* Don't free filename any more. */
4207 unpush_target (&tfile_ops
);
4209 trace_filename
= xstrdup (filename
);
4210 trace_fd
= scratch_chan
;
4213 /* Read the file header and test for validity. */
4214 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4216 bytes
+= TRACE_HEADER_SIZE
;
4217 if (!(header
[0] == 0x7f
4218 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4219 error (_("File is not a valid trace file."));
4221 push_target (&tfile_ops
);
4223 trace_regblock_size
= 0;
4224 ts
= current_trace_status ();
4225 /* We know we're working with a file. Record its name. */
4226 ts
->filename
= trace_filename
;
4227 /* Set defaults in case there is no status line. */
4228 ts
->running_known
= 0;
4229 ts
->stop_reason
= trace_stop_reason_unknown
;
4230 ts
->traceframe_count
= -1;
4231 ts
->buffer_free
= 0;
4232 ts
->disconnected_tracing
= 0;
4233 ts
->circular_buffer
= 0;
4235 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4237 /* Read through a section of newline-terminated lines that
4238 define things like tracepoints. */
4242 tfile_read (&byte
, 1);
4247 /* Empty line marks end of the definition section. */
4252 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4255 linebuf
[i
++] = byte
;
4257 error (_("Excessively long lines in trace file"));
4260 /* Record the starting offset of the binary trace data. */
4261 trace_frames_offset
= bytes
;
4263 /* If we don't have a blocksize, we can't interpret the
4265 if (trace_regblock_size
== 0)
4266 error (_("No register block size recorded in trace file"));
4270 /* Pop the partially set up target. */
4272 throw_exception (ex
);
4275 if (ts
->traceframe_count
<= 0)
4276 warning (_("No traceframes present in this file."));
4278 /* Add the file's tracepoints and variables into the current mix. */
4280 /* Get trace state variables first, they may be checked when parsing
4281 uploaded commands. */
4282 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4284 merge_uploaded_tracepoints (&uploaded_tps
);
4287 /* Interpret the given line from the definitions part of the trace
4291 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4292 struct uploaded_tsv
**utsvp
)
4296 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4299 trace_regblock_size
= strtol (p
, &p
, 16);
4301 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4303 p
+= strlen ("status ");
4304 parse_trace_status (p
, current_trace_status ());
4306 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4308 p
+= strlen ("tp ");
4309 parse_tracepoint_definition (p
, utpp
);
4311 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4313 p
+= strlen ("tsv ");
4314 parse_tsv_definition (p
, utsvp
);
4317 warning (_("Ignoring trace file definition \"%s\""), line
);
4320 /* Parse the part of trace status syntax that is shared between
4321 the remote protocol and the trace file reader. */
4324 parse_trace_status (char *line
, struct trace_status
*ts
)
4326 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4330 ts
->running_known
= 1;
4331 ts
->running
= (*p
++ == '1');
4332 ts
->stop_reason
= trace_stop_reason_unknown
;
4333 xfree (ts
->stop_desc
);
4334 ts
->stop_desc
= NULL
;
4335 ts
->traceframe_count
= -1;
4336 ts
->traceframes_created
= -1;
4337 ts
->buffer_free
= -1;
4338 ts
->buffer_size
= -1;
4339 ts
->disconnected_tracing
= 0;
4340 ts
->circular_buffer
= 0;
4341 xfree (ts
->user_name
);
4342 ts
->user_name
= NULL
;
4345 ts
->start_time
= ts
->stop_time
= 0;
4349 p1
= strchr (p
, ':');
4351 error (_("Malformed trace status, at %s\n\
4352 Status line: '%s'\n"), p
, line
);
4353 p3
= strchr (p
, ';');
4355 p3
= p
+ strlen (p
);
4356 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4358 p
= unpack_varlen_hex (++p1
, &val
);
4359 ts
->stop_reason
= trace_buffer_full
;
4361 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4363 p
= unpack_varlen_hex (++p1
, &val
);
4364 ts
->stop_reason
= trace_never_run
;
4366 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4369 p
= unpack_varlen_hex (++p1
, &val
);
4370 ts
->stop_reason
= tracepoint_passcount
;
4371 ts
->stopping_tracepoint
= val
;
4373 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4375 p2
= strchr (++p1
, ':');
4383 ts
->stop_desc
= xmalloc (strlen (line
));
4384 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4385 ts
->stop_desc
[end
] = '\0';
4388 ts
->stop_desc
= xstrdup ("");
4390 p
= unpack_varlen_hex (++p2
, &val
);
4391 ts
->stop_reason
= tstop_command
;
4393 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4395 p
= unpack_varlen_hex (++p1
, &val
);
4396 ts
->stop_reason
= trace_disconnected
;
4398 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4400 p2
= strchr (++p1
, ':');
4403 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4404 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4405 ts
->stop_desc
[end
] = '\0';
4408 ts
->stop_desc
= xstrdup ("");
4410 p
= unpack_varlen_hex (++p2
, &val
);
4411 ts
->stopping_tracepoint
= val
;
4412 ts
->stop_reason
= tracepoint_error
;
4414 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4416 p
= unpack_varlen_hex (++p1
, &val
);
4417 ts
->traceframe_count
= val
;
4419 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4421 p
= unpack_varlen_hex (++p1
, &val
);
4422 ts
->traceframes_created
= val
;
4424 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4426 p
= unpack_varlen_hex (++p1
, &val
);
4427 ts
->buffer_free
= val
;
4429 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4431 p
= unpack_varlen_hex (++p1
, &val
);
4432 ts
->buffer_size
= val
;
4434 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4436 p
= unpack_varlen_hex (++p1
, &val
);
4437 ts
->disconnected_tracing
= val
;
4439 else if (strncmp (p
, "circular", p1
- p
) == 0)
4441 p
= unpack_varlen_hex (++p1
, &val
);
4442 ts
->circular_buffer
= val
;
4444 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4446 p
= unpack_varlen_hex (++p1
, &val
);
4447 ts
->start_time
= val
;
4449 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4451 p
= unpack_varlen_hex (++p1
, &val
);
4452 ts
->stop_time
= val
;
4454 else if (strncmp (p
, "username", p1
- p
) == 0)
4457 ts
->user_name
= xmalloc (strlen (p
) / 2);
4458 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4459 ts
->user_name
[end
] = '\0';
4462 else if (strncmp (p
, "notes", p1
- p
) == 0)
4465 ts
->notes
= xmalloc (strlen (p
) / 2);
4466 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4467 ts
->notes
[end
] = '\0';
4472 /* Silently skip unknown optional info. */
4473 p_temp
= strchr (p1
+ 1, ';');
4477 /* Must be at the end. */
4484 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4485 struct uploaded_tp
*utp
)
4488 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4490 p
= unpack_varlen_hex (p
, &uval
);
4492 tp
->base
.hit_count
+= uval
;
4494 utp
->hit_count
+= uval
;
4495 p
= unpack_varlen_hex (p
+ 1, &uval
);
4497 tp
->traceframe_usage
+= uval
;
4499 utp
->traceframe_usage
+= uval
;
4500 /* Ignore any extra, allowing for future extensions. */
4503 /* Given a line of text defining a part of a tracepoint, parse it into
4504 an "uploaded tracepoint". */
4507 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4511 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4514 char *cond
, *srctype
, *buf
;
4515 struct uploaded_tp
*utp
= NULL
;
4518 /* Both tracepoint and action definitions start with the same number
4519 and address sequence. */
4521 p
= unpack_varlen_hex (p
, &num
);
4522 p
++; /* skip a colon */
4523 p
= unpack_varlen_hex (p
, &addr
);
4524 p
++; /* skip a colon */
4527 enabled
= (*p
++ == 'E');
4528 p
++; /* skip a colon */
4529 p
= unpack_varlen_hex (p
, &step
);
4530 p
++; /* skip a colon */
4531 p
= unpack_varlen_hex (p
, &pass
);
4532 type
= bp_tracepoint
;
4534 /* Thumb through optional fields. */
4537 p
++; /* skip a colon */
4540 type
= bp_fast_tracepoint
;
4542 p
= unpack_varlen_hex (p
, &orig_size
);
4546 type
= bp_static_tracepoint
;
4552 p
= unpack_varlen_hex (p
, &xlen
);
4553 p
++; /* skip a comma */
4554 cond
= (char *) xmalloc (2 * xlen
+ 1);
4555 strncpy (cond
, p
, 2 * xlen
);
4556 cond
[2 * xlen
] = '\0';
4560 warning (_("Unrecognized char '%c' in tracepoint "
4561 "definition, skipping rest"), *p
);
4563 utp
= get_uploaded_tp (num
, addr
, utpp
);
4565 utp
->enabled
= enabled
;
4570 else if (piece
== 'A')
4572 utp
= get_uploaded_tp (num
, addr
, utpp
);
4573 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4575 else if (piece
== 'S')
4577 utp
= get_uploaded_tp (num
, addr
, utpp
);
4578 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4580 else if (piece
== 'Z')
4582 /* Parse a chunk of source form definition. */
4583 utp
= get_uploaded_tp (num
, addr
, utpp
);
4585 p
= strchr (p
, ':');
4586 p
++; /* skip a colon */
4587 p
= unpack_varlen_hex (p
, &start
);
4588 p
++; /* skip a colon */
4589 p
= unpack_varlen_hex (p
, &xlen
);
4590 p
++; /* skip a colon */
4592 buf
= alloca (strlen (line
));
4594 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4597 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4598 utp
->at_string
= xstrdup (buf
);
4599 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4600 utp
->cond_string
= xstrdup (buf
);
4601 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4602 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4604 else if (piece
== 'V')
4606 utp
= get_uploaded_tp (num
, addr
, utpp
);
4608 parse_tracepoint_status (p
, NULL
, utp
);
4612 /* Don't error out, the target might be sending us optional
4613 info that we don't care about. */
4614 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4618 /* Convert a textual description of a trace state variable into an
4622 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4625 ULONGEST num
, initval
, builtin
;
4627 struct uploaded_tsv
*utsv
= NULL
;
4629 buf
= alloca (strlen (line
));
4632 p
= unpack_varlen_hex (p
, &num
);
4633 p
++; /* skip a colon */
4634 p
= unpack_varlen_hex (p
, &initval
);
4635 p
++; /* skip a colon */
4636 p
= unpack_varlen_hex (p
, &builtin
);
4637 p
++; /* skip a colon */
4638 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4641 utsv
= get_uploaded_tsv (num
, utsvp
);
4642 utsv
->initial_value
= initval
;
4643 utsv
->builtin
= builtin
;
4644 utsv
->name
= xstrdup (buf
);
4647 /* Close the trace file and generally clean up. */
4659 xfree (trace_filename
);
4660 trace_filename
= NULL
;
4664 tfile_files_info (struct target_ops
*t
)
4666 printf_filtered ("\t`%s'\n", trace_filename
);
4669 /* The trace status for a file is that tracing can never be run. */
4672 tfile_get_trace_status (struct trace_status
*ts
)
4674 /* Other bits of trace status were collected as part of opening the
4675 trace files, so nothing to do here. */
4681 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4683 /* Other bits of trace status were collected as part of opening the
4684 trace files, so nothing to do here. */
4687 /* Given the position of a traceframe in the file, figure out what
4688 address the frame was collected at. This would normally be the
4689 value of a collected PC register, but if not available, we
4693 tfile_get_traceframe_address (off_t tframe_offset
)
4697 struct tracepoint
*tp
;
4698 off_t saved_offset
= cur_offset
;
4700 /* FIXME dig pc out of collected registers. */
4702 /* Fall back to using tracepoint address. */
4703 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4704 tfile_read ((gdb_byte
*) &tpnum
, 2);
4705 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4707 (target_gdbarch ()));
4709 tp
= get_tracepoint_by_number_on_target (tpnum
);
4710 /* FIXME this is a poor heuristic if multiple locations. */
4711 if (tp
&& tp
->base
.loc
)
4712 addr
= tp
->base
.loc
->address
;
4714 /* Restore our seek position. */
4715 cur_offset
= saved_offset
;
4716 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4720 /* Given a type of search and some parameters, scan the collection of
4721 traceframes in the file looking for a match. When found, return
4722 both the traceframe and tracepoint number, otherwise -1 for
4726 tfile_trace_find (enum trace_find_type type
, int num
,
4727 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4730 int tfnum
= 0, found
= 0;
4731 unsigned int data_size
;
4732 struct tracepoint
*tp
;
4733 off_t offset
, tframe_offset
;
4743 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4744 offset
= trace_frames_offset
;
4747 tframe_offset
= offset
;
4748 tfile_read ((gdb_byte
*) &tpnum
, 2);
4749 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4751 (target_gdbarch ()));
4755 tfile_read ((gdb_byte
*) &data_size
, 4);
4756 data_size
= (unsigned int) extract_unsigned_integer
4757 ((gdb_byte
*) &data_size
, 4,
4758 gdbarch_byte_order (target_gdbarch ()));
4761 if (type
== tfind_number
)
4763 /* Looking for a specific trace frame. */
4769 /* Start from the _next_ trace frame. */
4770 if (tfnum
> traceframe_number
)
4775 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4776 if (tfaddr
== addr1
)
4780 tp
= get_tracepoint (num
);
4781 if (tp
&& tpnum
== tp
->number_on_target
)
4785 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4786 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4790 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4791 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4795 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4804 cur_offset
= offset
;
4805 cur_data_size
= data_size
;
4809 /* Skip past the traceframe's data. */
4810 lseek (trace_fd
, data_size
, SEEK_CUR
);
4811 offset
+= data_size
;
4812 /* Update our own count of traceframes. */
4815 /* Did not find what we were looking for. */
4821 /* Prototype of the callback passed to tframe_walk_blocks. */
4822 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4824 /* Callback for traceframe_walk_blocks, used to find a given block
4825 type in a traceframe. */
4828 match_blocktype (char blocktype
, void *data
)
4830 char *wantedp
= data
;
4832 if (*wantedp
== blocktype
)
4838 /* Walk over all traceframe block starting at POS offset from
4839 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4840 unmodified. If CALLBACK returns true, this returns the position in
4841 the traceframe where the block is found, relative to the start of
4842 the traceframe (cur_offset). Returns -1 if no callback call
4843 returned true, indicating that all blocks have been walked. */
4846 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4847 int pos
, void *data
)
4849 /* Iterate through a traceframe's blocks, looking for a block of the
4852 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4853 while (pos
< cur_data_size
)
4855 unsigned short mlen
;
4858 tfile_read ((gdb_byte
*) &block_type
, 1);
4862 if ((*callback
) (block_type
, data
))
4868 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4869 pos
+= trace_regblock_size
;
4872 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4873 tfile_read ((gdb_byte
*) &mlen
, 2);
4874 mlen
= (unsigned short)
4875 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4877 (target_gdbarch ()));
4878 lseek (trace_fd
, mlen
, SEEK_CUR
);
4879 pos
+= (8 + 2 + mlen
);
4882 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4886 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4887 block_type
, block_type
);
4895 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4896 position offset of a block of type TYPE_WANTED in the current trace
4897 frame, starting at POS. Returns -1 if no such block was found. */
4900 traceframe_find_block_type (char type_wanted
, int pos
)
4902 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4905 /* Look for a block of saved registers in the traceframe, and get the
4906 requested register from it. */
4909 tfile_fetch_registers (struct target_ops
*ops
,
4910 struct regcache
*regcache
, int regno
)
4912 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4913 int offset
, regn
, regsize
, pc_regno
;
4916 /* An uninitialized reg size says we're not going to be
4917 successful at getting register blocks. */
4918 if (!trace_regblock_size
)
4921 regs
= alloca (trace_regblock_size
);
4923 if (traceframe_find_block_type ('R', 0) >= 0)
4925 tfile_read (regs
, trace_regblock_size
);
4927 /* Assume the block is laid out in GDB register number order,
4928 each register with the size that it has in GDB. */
4930 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4932 regsize
= register_size (gdbarch
, regn
);
4933 /* Make sure we stay within block bounds. */
4934 if (offset
+ regsize
>= trace_regblock_size
)
4936 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4940 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4943 else if (regno
== -1)
4945 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4953 /* We get here if no register data has been found. Mark registers
4955 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4956 regcache_raw_supply (regcache
, regn
, NULL
);
4958 /* We can often usefully guess that the PC is going to be the same
4959 as the address of the tracepoint. */
4960 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4961 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4963 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4965 if (tp
&& tp
->base
.loc
)
4967 /* But don't try to guess if tracepoint is multi-location... */
4968 if (tp
->base
.loc
->next
)
4970 warning (_("Tracepoint %d has multiple "
4971 "locations, cannot infer $pc"),
4975 /* ... or does while-stepping. */
4976 if (tp
->step_count
> 0)
4978 warning (_("Tracepoint %d does while-stepping, "
4979 "cannot infer $pc"),
4984 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4985 gdbarch_byte_order (gdbarch
),
4986 tp
->base
.loc
->address
);
4987 regcache_raw_supply (regcache
, pc_regno
, regs
);
4993 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4994 const char *annex
, gdb_byte
*readbuf
,
4995 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4997 /* We're only doing regular memory for now. */
4998 if (object
!= TARGET_OBJECT_MEMORY
)
5001 if (readbuf
== NULL
)
5002 error (_("tfile_xfer_partial: trace file is read-only"));
5004 if (traceframe_number
!= -1)
5008 /* Iterate through the traceframe's blocks, looking for
5010 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5012 ULONGEST maddr
, amt
;
5013 unsigned short mlen
;
5014 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5016 tfile_read ((gdb_byte
*) &maddr
, 8);
5017 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5019 tfile_read ((gdb_byte
*) &mlen
, 2);
5020 mlen
= (unsigned short)
5021 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5023 /* If the block includes the first part of the desired
5024 range, return as much it has; GDB will re-request the
5025 remainder, which might be in a different block of this
5027 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5029 amt
= (maddr
+ mlen
) - offset
;
5033 if (maddr
!= offset
)
5034 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5035 tfile_read (readbuf
, amt
);
5039 /* Skip over this block. */
5040 pos
+= (8 + 2 + mlen
);
5044 /* It's unduly pedantic to refuse to look at the executable for
5045 read-only pieces; so do the equivalent of readonly regions aka
5047 /* FIXME account for relocation at some point. */
5054 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5056 if ((s
->flags
& SEC_LOAD
) == 0
5057 || (s
->flags
& SEC_READONLY
) == 0)
5061 size
= bfd_get_section_size (s
);
5062 if (vma
<= offset
&& offset
< (vma
+ size
))
5066 amt
= (vma
+ size
) - offset
;
5070 amt
= bfd_get_section_contents (exec_bfd
, s
,
5071 readbuf
, offset
- vma
, amt
);
5077 /* Indicate failure to find the requested memory block. */
5081 /* Iterate through the blocks of a trace frame, looking for a 'V'
5082 block with a matching tsv number. */
5085 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5090 /* Iterate over blocks in current frame and find the last 'V'
5091 block in which tsv number is TSVNUM. In one trace frame, there
5092 may be multiple 'V' blocks created for a given trace variable,
5093 and the last matched 'V' block contains the updated value. */
5095 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5099 tfile_read ((gdb_byte
*) &vnum
, 4);
5100 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5102 (target_gdbarch ()));
5105 tfile_read ((gdb_byte
*) val
, 8);
5106 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5108 (target_gdbarch ()));
5118 tfile_has_all_memory (struct target_ops
*ops
)
5124 tfile_has_memory (struct target_ops
*ops
)
5130 tfile_has_stack (struct target_ops
*ops
)
5132 return traceframe_number
!= -1;
5136 tfile_has_registers (struct target_ops
*ops
)
5138 return traceframe_number
!= -1;
5141 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5142 object for the tfile target's current traceframe. */
5145 build_traceframe_info (char blocktype
, void *data
)
5147 struct traceframe_info
*info
= data
;
5153 struct mem_range
*r
;
5155 unsigned short mlen
;
5157 tfile_read ((gdb_byte
*) &maddr
, 8);
5158 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5160 (target_gdbarch ()));
5161 tfile_read ((gdb_byte
*) &mlen
, 2);
5162 mlen
= (unsigned short)
5163 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5164 2, gdbarch_byte_order
5165 (target_gdbarch ()));
5167 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5180 warning (_("Unhandled trace block type (%d) '%c ' "
5181 "while building trace frame info."),
5182 blocktype
, blocktype
);
5189 static struct traceframe_info
*
5190 tfile_traceframe_info (void)
5192 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5194 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5199 init_tfile_ops (void)
5201 tfile_ops
.to_shortname
= "tfile";
5202 tfile_ops
.to_longname
= "Local trace dump file";
5204 = "Use a trace file as a target. Specify the filename of the trace file.";
5205 tfile_ops
.to_open
= tfile_open
;
5206 tfile_ops
.to_close
= tfile_close
;
5207 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5208 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5209 tfile_ops
.to_files_info
= tfile_files_info
;
5210 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5211 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5212 tfile_ops
.to_trace_find
= tfile_trace_find
;
5213 tfile_ops
.to_get_trace_state_variable_value
5214 = tfile_get_trace_state_variable_value
;
5215 tfile_ops
.to_stratum
= process_stratum
;
5216 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5217 tfile_ops
.to_has_memory
= tfile_has_memory
;
5218 tfile_ops
.to_has_stack
= tfile_has_stack
;
5219 tfile_ops
.to_has_registers
= tfile_has_registers
;
5220 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5221 tfile_ops
.to_magic
= OPS_MAGIC
;
5225 free_current_marker (void *arg
)
5227 struct static_tracepoint_marker
**marker_p
= arg
;
5229 if (*marker_p
!= NULL
)
5231 release_static_tracepoint_marker (*marker_p
);
5238 /* Given a line of text defining a static tracepoint marker, parse it
5239 into a "static tracepoint marker" object. Throws an error is
5240 parsing fails. If PP is non-null, it points to one past the end of
5241 the parsed marker definition. */
5244 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5245 struct static_tracepoint_marker
*marker
)
5252 p
= unpack_varlen_hex (p
, &addr
);
5253 p
++; /* skip a colon */
5255 marker
->gdbarch
= target_gdbarch ();
5256 marker
->address
= (CORE_ADDR
) addr
;
5258 endp
= strchr (p
, ':');
5260 error (_("bad marker definition: %s"), line
);
5262 marker
->str_id
= xmalloc (endp
- p
+ 1);
5263 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5264 marker
->str_id
[end
] = '\0';
5267 p
++; /* skip a colon */
5269 marker
->extra
= xmalloc (strlen (p
) + 1);
5270 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5271 marker
->extra
[end
] = '\0';
5277 /* Release a static tracepoint marker's contents. Note that the
5278 object itself isn't released here. There objects are usually on
5282 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5284 xfree (marker
->str_id
);
5285 marker
->str_id
= NULL
;
5288 /* Print MARKER to gdb_stdout. */
5291 print_one_static_tracepoint_marker (int count
,
5292 struct static_tracepoint_marker
*marker
)
5294 struct command_line
*l
;
5297 char wrap_indent
[80];
5298 char extra_field_indent
[80];
5299 struct ui_out
*uiout
= current_uiout
;
5300 struct cleanup
*bkpt_chain
;
5301 VEC(breakpoint_p
) *tracepoints
;
5303 struct symtab_and_line sal
;
5307 sal
.pc
= marker
->address
;
5309 tracepoints
= static_tracepoints_here (marker
->address
);
5311 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5313 /* A counter field to help readability. This is not a stable
5315 ui_out_field_int (uiout
, "count", count
);
5317 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5319 ui_out_field_fmt (uiout
, "enabled", "%c",
5320 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5321 ui_out_spaces (uiout
, 2);
5323 strcpy (wrap_indent
, " ");
5325 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5326 strcat (wrap_indent
, " ");
5328 strcat (wrap_indent
, " ");
5330 strcpy (extra_field_indent
, " ");
5332 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5334 sal
= find_pc_line (marker
->address
, 0);
5335 sym
= find_pc_sect_function (marker
->address
, NULL
);
5338 ui_out_text (uiout
, "in ");
5339 ui_out_field_string (uiout
, "func",
5340 SYMBOL_PRINT_NAME (sym
));
5341 ui_out_wrap_hint (uiout
, wrap_indent
);
5342 ui_out_text (uiout
, " at ");
5345 ui_out_field_skip (uiout
, "func");
5347 if (sal
.symtab
!= NULL
)
5349 ui_out_field_string (uiout
, "file",
5350 symtab_to_filename_for_display (sal
.symtab
));
5351 ui_out_text (uiout
, ":");
5353 if (ui_out_is_mi_like_p (uiout
))
5355 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5357 ui_out_field_string (uiout
, "fullname", fullname
);
5360 ui_out_field_skip (uiout
, "fullname");
5362 ui_out_field_int (uiout
, "line", sal
.line
);
5366 ui_out_field_skip (uiout
, "fullname");
5367 ui_out_field_skip (uiout
, "line");
5370 ui_out_text (uiout
, "\n");
5371 ui_out_text (uiout
, extra_field_indent
);
5372 ui_out_text (uiout
, _("Data: \""));
5373 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5374 ui_out_text (uiout
, "\"\n");
5376 if (!VEC_empty (breakpoint_p
, tracepoints
))
5378 struct cleanup
*cleanup_chain
;
5380 struct breakpoint
*b
;
5382 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5385 ui_out_text (uiout
, extra_field_indent
);
5386 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5387 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5390 ui_out_text (uiout
, ", ");
5391 ui_out_text (uiout
, "#");
5392 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5395 do_cleanups (cleanup_chain
);
5397 if (ui_out_is_mi_like_p (uiout
))
5398 ui_out_field_int (uiout
, "number-of-tracepoints",
5399 VEC_length(breakpoint_p
, tracepoints
));
5401 ui_out_text (uiout
, "\n");
5403 VEC_free (breakpoint_p
, tracepoints
);
5405 do_cleanups (bkpt_chain
);
5409 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5411 VEC(static_tracepoint_marker_p
) *markers
;
5412 struct cleanup
*old_chain
;
5413 struct static_tracepoint_marker
*marker
;
5414 struct ui_out
*uiout
= current_uiout
;
5417 /* We don't have to check target_can_use_agent and agent's capability on
5418 static tracepoint here, in order to be compatible with older GDBserver.
5419 We don't check USE_AGENT is true or not, because static tracepoints
5420 don't work without in-process agent, so we don't bother users to type
5421 `set agent on' when to use static tracepoint. */
5424 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5425 "StaticTracepointMarkersTable");
5427 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5429 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5431 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5432 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5433 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5435 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5436 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5438 ui_out_table_body (uiout
);
5440 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5441 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5444 VEC_iterate (static_tracepoint_marker_p
,
5445 markers
, i
, marker
);
5448 print_one_static_tracepoint_marker (i
+ 1, marker
);
5449 release_static_tracepoint_marker (marker
);
5452 do_cleanups (old_chain
);
5455 /* The $_sdata convenience variable is a bit special. We don't know
5456 for sure type of the value until we actually have a chance to fetch
5457 the data --- the size of the object depends on what has been
5458 collected. We solve this by making $_sdata be an internalvar that
5459 creates a new value on access. */
5461 /* Return a new value with the correct type for the sdata object of
5462 the current trace frame. Return a void value if there's no object
5465 static struct value
*
5466 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5472 /* We need to read the whole object before we know its size. */
5473 size
= target_read_alloc (¤t_target
,
5474 TARGET_OBJECT_STATIC_TRACE_DATA
,
5481 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5483 v
= allocate_value (type
);
5484 memcpy (value_contents_raw (v
), buf
, size
);
5489 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5492 #if !defined(HAVE_LIBEXPAT)
5494 struct traceframe_info
*
5495 parse_traceframe_info (const char *tframe_info
)
5497 static int have_warned
;
5502 warning (_("Can not parse XML trace frame info; XML support "
5503 "was disabled at compile time"));
5509 #else /* HAVE_LIBEXPAT */
5511 #include "xml-support.h"
5513 /* Handle the start of a <memory> element. */
5516 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5517 const struct gdb_xml_element
*element
,
5518 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5520 struct traceframe_info
*info
= user_data
;
5521 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5522 ULONGEST
*start_p
, *length_p
;
5524 start_p
= xml_find_attribute (attributes
, "start")->value
;
5525 length_p
= xml_find_attribute (attributes
, "length")->value
;
5527 r
->start
= *start_p
;
5528 r
->length
= *length_p
;
5531 /* Discard the constructed trace frame info (if an error occurs). */
5534 free_result (void *p
)
5536 struct traceframe_info
*result
= p
;
5538 free_traceframe_info (result
);
5541 /* The allowed elements and attributes for an XML memory map. */
5543 static const struct gdb_xml_attribute memory_attributes
[] = {
5544 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5545 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5546 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5549 static const struct gdb_xml_element traceframe_info_children
[] = {
5550 { "memory", memory_attributes
, NULL
,
5551 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5552 traceframe_info_start_memory
, NULL
},
5553 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5556 static const struct gdb_xml_element traceframe_info_elements
[] = {
5557 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5559 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5562 /* Parse a traceframe-info XML document. */
5564 struct traceframe_info
*
5565 parse_traceframe_info (const char *tframe_info
)
5567 struct traceframe_info
*result
;
5568 struct cleanup
*back_to
;
5570 result
= XCNEW (struct traceframe_info
);
5571 back_to
= make_cleanup (free_result
, result
);
5573 if (gdb_xml_parse_quick (_("trace frame info"),
5574 "traceframe-info.dtd", traceframe_info_elements
,
5575 tframe_info
, result
) == 0)
5577 /* Parsed successfully, keep the result. */
5578 discard_cleanups (back_to
);
5583 do_cleanups (back_to
);
5587 #endif /* HAVE_LIBEXPAT */
5589 /* Returns the traceframe_info object for the current traceframe.
5590 This is where we avoid re-fetching the object from the target if we
5591 already have it cached. */
5593 static struct traceframe_info
*
5594 get_traceframe_info (void)
5596 if (traceframe_info
== NULL
)
5597 traceframe_info
= target_traceframe_info ();
5599 return traceframe_info
;
5602 /* If the target supports the query, return in RESULT the set of
5603 collected memory in the current traceframe, found within the LEN
5604 bytes range starting at MEMADDR. Returns true if the target
5605 supports the query, otherwise returns false, and RESULT is left
5609 traceframe_available_memory (VEC(mem_range_s
) **result
,
5610 CORE_ADDR memaddr
, ULONGEST len
)
5612 struct traceframe_info
*info
= get_traceframe_info ();
5616 struct mem_range
*r
;
5621 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5622 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5624 ULONGEST lo1
, hi1
, lo2
, hi2
;
5625 struct mem_range
*nr
;
5628 hi1
= memaddr
+ len
;
5631 hi2
= r
->start
+ r
->length
;
5633 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5635 nr
->start
= max (lo1
, lo2
);
5636 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5639 normalize_mem_ranges (*result
);
5646 /* Implementation of `sdata' variable. */
5648 static const struct internalvar_funcs sdata_funcs
=
5655 /* module initialization */
5657 _initialize_tracepoint (void)
5659 struct cmd_list_element
*c
;
5661 /* Explicitly create without lookup, since that tries to create a
5662 value with a void typed value, and when we get here, gdbarch
5663 isn't initialized yet. At this point, we're quite sure there
5664 isn't another convenience variable of the same name. */
5665 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5667 traceframe_number
= -1;
5668 tracepoint_number
= -1;
5670 if (tracepoint_list
.list
== NULL
)
5672 tracepoint_list
.listsize
= 128;
5673 tracepoint_list
.list
= xmalloc
5674 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5676 if (tracepoint_list
.aexpr_list
== NULL
)
5678 tracepoint_list
.aexpr_listsize
= 128;
5679 tracepoint_list
.aexpr_list
= xmalloc
5680 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5683 if (stepping_list
.list
== NULL
)
5685 stepping_list
.listsize
= 128;
5686 stepping_list
.list
= xmalloc
5687 (stepping_list
.listsize
* sizeof (struct memrange
));
5690 if (stepping_list
.aexpr_list
== NULL
)
5692 stepping_list
.aexpr_listsize
= 128;
5693 stepping_list
.aexpr_list
= xmalloc
5694 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5697 add_info ("scope", scope_info
,
5698 _("List the variables local to a scope"));
5700 add_cmd ("tracepoints", class_trace
, NULL
,
5701 _("Tracing of program execution without stopping the program."),
5704 add_com ("tdump", class_trace
, trace_dump_command
,
5705 _("Print everything collected at the current tracepoint."));
5707 add_com ("tsave", class_trace
, trace_save_command
, _("\
5708 Save the trace data to a file.\n\
5709 Use the '-ctf' option to save the data to CTF format.\n\
5710 Use the '-r' option to direct the target to save directly to the file,\n\
5711 using its own filesystem."));
5713 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5714 Define a trace state variable.\n\
5715 Argument is a $-prefixed name, optionally followed\n\
5716 by '=' and an expression that sets the initial value\n\
5717 at the start of tracing."));
5718 set_cmd_completer (c
, expression_completer
);
5720 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5721 Delete one or more trace state variables.\n\
5722 Arguments are the names of the variables to delete.\n\
5723 If no arguments are supplied, delete all variables."), &deletelist
);
5724 /* FIXME add a trace variable completer. */
5726 add_info ("tvariables", tvariables_info
, _("\
5727 Status of trace state variables and their values.\n\
5730 add_info ("static-tracepoint-markers",
5731 info_static_tracepoint_markers_command
, _("\
5732 List target static tracepoints markers.\n\
5735 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5736 Select a trace frame;\n\
5737 No argument means forward by one frame; '-' means backward by one frame."),
5738 &tfindlist
, "tfind ", 1, &cmdlist
);
5740 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5741 Select a trace frame whose PC is outside the given range (exclusive).\n\
5742 Usage: tfind outside addr1, addr2"),
5745 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5746 Select a trace frame whose PC is in the given range (inclusive).\n\
5747 Usage: tfind range addr1,addr2"),
5750 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5751 Select a trace frame by source line.\n\
5752 Argument can be a line number (with optional source file),\n\
5753 a function name, or '*' followed by an address.\n\
5754 Default argument is 'the next source line that was traced'."),
5757 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5758 Select a trace frame by tracepoint number.\n\
5759 Default is the tracepoint for the current trace frame."),
5762 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5763 Select a trace frame by PC.\n\
5764 Default is the current PC, or the PC of the current trace frame."),
5767 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5768 De-select any trace frame and resume 'live' debugging."),
5771 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5773 add_cmd ("start", class_trace
, trace_find_start_command
,
5774 _("Select the first trace frame in the trace buffer."),
5777 add_com ("tstatus", class_trace
, trace_status_command
,
5778 _("Display the status of the current trace data collection."));
5780 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5781 Stop trace data collection.\n\
5782 Usage: tstop [ <notes> ... ]\n\
5783 Any arguments supplied are recorded with the trace as a stop reason and\n\
5784 reported by tstatus (if the target supports trace notes)."));
5786 add_com ("tstart", class_trace
, trace_start_command
, _("\
5787 Start trace data collection.\n\
5788 Usage: tstart [ <notes> ... ]\n\
5789 Any arguments supplied are recorded with the trace as a note and\n\
5790 reported by tstatus (if the target supports trace notes)."));
5792 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5793 Ends a list of commands or actions.\n\
5794 Several GDB commands allow you to enter a list of commands or actions.\n\
5795 Entering \"end\" on a line by itself is the normal way to terminate\n\
5797 Note: the \"end\" command cannot be used at the gdb prompt."));
5799 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5800 Specify single-stepping behavior at a tracepoint.\n\
5801 Argument is number of instructions to trace in single-step mode\n\
5802 following the tracepoint. This command is normally followed by\n\
5803 one or more \"collect\" commands, to specify what to collect\n\
5804 while single-stepping.\n\n\
5805 Note: this command can only be used in a tracepoint \"actions\" list."));
5807 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5808 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5810 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5811 Specify one or more data items to be collected at a tracepoint.\n\
5812 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5813 collect all data (variables, registers) referenced by that expression.\n\
5814 Also accepts the following special arguments:\n\
5815 $regs -- all registers.\n\
5816 $args -- all function arguments.\n\
5817 $locals -- all variables local to the block/function scope.\n\
5818 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5819 Note: this command can only be used in a tracepoint \"actions\" list."));
5821 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5822 Specify one or more expressions to be evaluated at a tracepoint.\n\
5823 Accepts a comma-separated list of (one or more) expressions.\n\
5824 The result of each evaluation will be discarded.\n\
5825 Note: this command can only be used in a tracepoint \"actions\" list."));
5827 add_com ("actions", class_trace
, trace_actions_command
, _("\
5828 Specify the actions to be taken at a tracepoint.\n\
5829 Tracepoint actions may include collecting of specified data,\n\
5830 single-stepping, or enabling/disabling other tracepoints,\n\
5831 depending on target's capabilities."));
5833 default_collect
= xstrdup ("");
5834 add_setshow_string_cmd ("default-collect", class_trace
,
5835 &default_collect
, _("\
5836 Set the list of expressions to collect by default"), _("\
5837 Show the list of expressions to collect by default"), NULL
,
5839 &setlist
, &showlist
);
5841 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5842 &disconnected_tracing
, _("\
5843 Set whether tracing continues after GDB disconnects."), _("\
5844 Show whether tracing continues after GDB disconnects."), _("\
5845 Use this to continue a tracing run even if GDB disconnects\n\
5846 or detaches from the target. You can reconnect later and look at\n\
5847 trace data collected in the meantime."),
5848 set_disconnected_tracing
,
5853 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5854 &circular_trace_buffer
, _("\
5855 Set target's use of circular trace buffer."), _("\
5856 Show target's use of circular trace buffer."), _("\
5857 Use this to make the trace buffer into a circular buffer,\n\
5858 which will discard traceframes (oldest first) instead of filling\n\
5859 up and stopping the trace run."),
5860 set_circular_trace_buffer
,
5865 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5866 &trace_buffer_size
, _("\
5867 Set requested size of trace buffer."), _("\
5868 Show requested size of trace buffer."), _("\
5869 Use this to choose a size for the trace buffer. Some targets\n\
5870 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5871 disables any attempt to set the buffer size and lets the target choose."),
5872 set_trace_buffer_size
, NULL
,
5873 &setlist
, &showlist
);
5875 add_setshow_string_cmd ("trace-user", class_trace
,
5877 Set the user name to use for current and future trace runs"), _("\
5878 Show the user name to use for current and future trace runs"), NULL
,
5879 set_trace_user
, NULL
,
5880 &setlist
, &showlist
);
5882 add_setshow_string_cmd ("trace-notes", class_trace
,
5884 Set notes string to use for current and future trace runs"), _("\
5885 Show the notes string to use for current and future trace runs"), NULL
,
5886 set_trace_notes
, NULL
,
5887 &setlist
, &showlist
);
5889 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5890 &trace_stop_notes
, _("\
5891 Set notes string to use for future tstop commands"), _("\
5892 Show the notes string to use for future tstop commands"), NULL
,
5893 set_trace_stop_notes
, NULL
,
5894 &setlist
, &showlist
);
5898 add_target_with_completer (&tfile_ops
, filename_completer
);