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"
58 /* readline include files */
59 #include "readline/readline.h"
60 #include "readline/history.h"
62 /* readline defines this. */
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
88 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
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 /* An object describing the contents of a traceframe. */
131 struct traceframe_info
133 /* Collected memory. */
134 VEC(mem_range_s
) *memory
;
137 static VEC(tsv_s
) *tvariables
;
139 /* The next integer to assign to a variable. */
141 static int next_tsv_number
= 1;
143 /* Number of last traceframe collected. */
144 static int traceframe_number
;
146 /* Tracepoint for last traceframe collected. */
147 static int tracepoint_number
;
149 /* Symbol for function for last traceframe collected. */
150 static struct symbol
*traceframe_fun
;
152 /* Symtab and line for last traceframe collected. */
153 static struct symtab_and_line traceframe_sal
;
155 /* The traceframe info of the current traceframe. NULL if we haven't
156 yet attempted to fetch it, or if the target does not support
157 fetching this object, or if we're not inspecting a traceframe
159 static struct traceframe_info
*traceframe_info
;
161 /* Tracing command lists. */
162 static struct cmd_list_element
*tfindlist
;
164 /* List of expressions to collect by default at each tracepoint hit. */
165 char *default_collect
= "";
167 static int disconnected_tracing
;
169 /* This variable controls whether we ask the target for a linear or
170 circular trace buffer. */
172 static int circular_trace_buffer
;
174 /* This variable is the requested trace buffer size, or -1 to indicate
175 that we don't care and leave it up to the target to set a size. */
177 static int trace_buffer_size
= -1;
179 /* Textual notes applying to the current and/or future trace runs. */
181 char *trace_user
= NULL
;
183 /* Textual notes applying to the current and/or future trace runs. */
185 char *trace_notes
= NULL
;
187 /* Textual notes applying to the stopping of a trace. */
189 char *trace_stop_notes
= NULL
;
191 /* ======= Important command functions: ======= */
192 static void trace_actions_command (char *, int);
193 static void trace_start_command (char *, int);
194 static void trace_stop_command (char *, int);
195 static void trace_status_command (char *, int);
196 static void trace_find_command (char *, int);
197 static void trace_find_pc_command (char *, int);
198 static void trace_find_tracepoint_command (char *, int);
199 static void trace_find_line_command (char *, int);
200 static void trace_find_range_command (char *, int);
201 static void trace_find_outside_command (char *, int);
202 static void trace_dump_command (char *, int);
204 /* support routines */
206 struct collection_list
;
207 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
208 static char *mem2hex (gdb_byte
*, char *, int);
209 static void add_register (struct collection_list
*collection
,
212 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
213 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
216 extern void _initialize_tracepoint (void);
218 static struct trace_status trace_status
;
220 char *stop_reason_names
[] = {
230 struct trace_status
*
231 current_trace_status (void)
233 return &trace_status
;
239 free_traceframe_info (struct traceframe_info
*info
)
243 VEC_free (mem_range_s
, info
->memory
);
249 /* Free and clear the traceframe info cache of the current
253 clear_traceframe_info (void)
255 free_traceframe_info (traceframe_info
);
256 traceframe_info
= NULL
;
259 /* Set traceframe number to NUM. */
261 set_traceframe_num (int num
)
263 traceframe_number
= num
;
264 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
267 /* Set tracepoint number to NUM. */
269 set_tracepoint_num (int num
)
271 tracepoint_number
= num
;
272 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
275 /* Set externally visible debug variables for querying/printing
276 the traceframe context (line, function, file). */
279 set_traceframe_context (struct frame_info
*trace_frame
)
283 /* Save as globals for internal use. */
284 if (trace_frame
!= NULL
285 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
287 traceframe_sal
= find_pc_line (trace_pc
, 0);
288 traceframe_fun
= find_pc_function (trace_pc
);
290 /* Save linenumber as "$trace_line", a debugger variable visible to
292 set_internalvar_integer (lookup_internalvar ("trace_line"),
293 traceframe_sal
.line
);
297 init_sal (&traceframe_sal
);
298 traceframe_fun
= NULL
;
299 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
302 /* Save func name as "$trace_func", a debugger variable visible to
304 if (traceframe_fun
== NULL
305 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
306 clear_internalvar (lookup_internalvar ("trace_func"));
308 set_internalvar_string (lookup_internalvar ("trace_func"),
309 SYMBOL_LINKAGE_NAME (traceframe_fun
));
311 /* Save file name as "$trace_file", a debugger variable visible to
313 if (traceframe_sal
.symtab
== NULL
)
314 clear_internalvar (lookup_internalvar ("trace_file"));
316 set_internalvar_string (lookup_internalvar ("trace_file"),
317 symtab_to_filename_for_display (traceframe_sal
.symtab
));
320 /* Create a new trace state variable with the given name. */
322 struct trace_state_variable
*
323 create_trace_state_variable (const char *name
)
325 struct trace_state_variable tsv
;
327 memset (&tsv
, 0, sizeof (tsv
));
328 tsv
.name
= xstrdup (name
);
329 tsv
.number
= next_tsv_number
++;
330 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
333 /* Look for a trace state variable of the given name. */
335 struct trace_state_variable
*
336 find_trace_state_variable (const char *name
)
338 struct trace_state_variable
*tsv
;
341 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
342 if (strcmp (name
, tsv
->name
) == 0)
349 delete_trace_state_variable (const char *name
)
351 struct trace_state_variable
*tsv
;
354 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
355 if (strcmp (name
, tsv
->name
) == 0)
357 observer_notify_tsv_deleted (tsv
);
359 xfree ((void *)tsv
->name
);
360 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
365 warning (_("No trace variable named \"$%s\", not deleting"), name
);
368 /* Throws an error if NAME is not valid syntax for a trace state
372 validate_trace_state_variable_name (const char *name
)
377 error (_("Must supply a non-empty variable name"));
379 /* All digits in the name is reserved for value history
381 for (p
= name
; isdigit (*p
); p
++)
384 error (_("$%s is not a valid trace state variable name"), name
);
386 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
389 error (_("$%s is not a valid trace state variable name"), name
);
392 /* The 'tvariable' command collects a name and optional expression to
393 evaluate into an initial value. */
396 trace_variable_command (char *args
, int from_tty
)
398 struct cleanup
*old_chain
;
400 struct trace_state_variable
*tsv
;
404 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
406 /* Only allow two syntaxes; "$name" and "$name=value". */
407 p
= skip_spaces (args
);
410 error (_("Name of trace variable should start with '$'"));
413 while (isalnum (*p
) || *p
== '_')
415 name
= savestring (name
, p
- name
);
416 old_chain
= make_cleanup (xfree
, name
);
419 if (*p
!= '=' && *p
!= '\0')
420 error (_("Syntax must be $NAME [ = EXPR ]"));
422 validate_trace_state_variable_name (name
);
425 initval
= value_as_long (parse_and_eval (++p
));
427 /* If the variable already exists, just change its initial value. */
428 tsv
= find_trace_state_variable (name
);
431 if (tsv
->initial_value
!= initval
)
433 tsv
->initial_value
= initval
;
434 observer_notify_tsv_modified (tsv
);
436 printf_filtered (_("Trace state variable $%s "
437 "now has initial value %s.\n"),
438 tsv
->name
, plongest (tsv
->initial_value
));
439 do_cleanups (old_chain
);
443 /* Create a new variable. */
444 tsv
= create_trace_state_variable (name
);
445 tsv
->initial_value
= initval
;
447 observer_notify_tsv_created (tsv
);
449 printf_filtered (_("Trace state variable $%s "
450 "created, with initial value %s.\n"),
451 tsv
->name
, plongest (tsv
->initial_value
));
453 do_cleanups (old_chain
);
457 delete_trace_variable_command (char *args
, int from_tty
)
461 struct cleanup
*back_to
;
465 if (query (_("Delete all trace state variables? ")))
466 VEC_free (tsv_s
, tvariables
);
468 observer_notify_tsv_deleted (NULL
);
472 argv
= gdb_buildargv (args
);
473 back_to
= make_cleanup_freeargv (argv
);
475 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
477 if (*argv
[ix
] == '$')
478 delete_trace_state_variable (argv
[ix
] + 1);
480 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
483 do_cleanups (back_to
);
489 tvariables_info_1 (void)
491 struct trace_state_variable
*tsv
;
494 struct cleanup
*back_to
;
495 struct ui_out
*uiout
= current_uiout
;
497 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
499 printf_filtered (_("No trace state variables.\n"));
503 /* Try to acquire values from the target. */
504 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
505 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
508 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
509 count
, "trace-variables");
510 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
511 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
512 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
514 ui_out_table_body (uiout
);
516 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
518 struct cleanup
*back_to2
;
522 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
524 name
= concat ("$", tsv
->name
, (char *) NULL
);
525 make_cleanup (xfree
, name
);
526 ui_out_field_string (uiout
, "name", name
);
527 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
529 if (tsv
->value_known
)
530 c
= plongest (tsv
->value
);
531 else if (ui_out_is_mi_like_p (uiout
))
532 /* For MI, we prefer not to use magic string constants, but rather
533 omit the field completely. The difference between unknown and
534 undefined does not seem important enough to represent. */
536 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
537 /* The value is/was defined, but we don't have it. */
540 /* It is not meaningful to ask about the value. */
543 ui_out_field_string (uiout
, "current", c
);
544 ui_out_text (uiout
, "\n");
546 do_cleanups (back_to2
);
549 do_cleanups (back_to
);
552 /* List all the trace state variables. */
555 tvariables_info (char *args
, int from_tty
)
557 tvariables_info_1 ();
560 /* Stash definitions of tsvs into the given file. */
563 save_trace_state_variables (struct ui_file
*fp
)
565 struct trace_state_variable
*tsv
;
568 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
570 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
571 if (tsv
->initial_value
)
572 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
573 fprintf_unfiltered (fp
, "\n");
577 /* ACTIONS functions: */
579 /* The three functions:
580 collect_pseudocommand,
581 while_stepping_pseudocommand, and
582 end_actions_pseudocommand
583 are placeholders for "commands" that are actually ONLY to be used
584 within a tracepoint action list. If the actual function is ever called,
585 it means that somebody issued the "command" at the top level,
586 which is always an error. */
589 end_actions_pseudocommand (char *args
, int from_tty
)
591 error (_("This command cannot be used at the top level."));
595 while_stepping_pseudocommand (char *args
, int from_tty
)
597 error (_("This command can only be used in a tracepoint actions list."));
601 collect_pseudocommand (char *args
, int from_tty
)
603 error (_("This command can only be used in a tracepoint actions list."));
607 teval_pseudocommand (char *args
, int from_tty
)
609 error (_("This command can only be used in a tracepoint actions list."));
612 /* Parse any collection options, such as /s for strings. */
615 decode_agent_options (const char *exp
)
617 struct value_print_options opts
;
622 /* Call this to borrow the print elements default for collection
624 get_user_print_options (&opts
);
629 if (target_supports_string_tracing ())
631 /* Allow an optional decimal number giving an explicit maximum
632 string length, defaulting it to the "print elements" value;
633 so "collect/s80 mystr" gets at most 80 bytes of string. */
634 trace_string_kludge
= opts
.print_max
;
636 if (*exp
>= '0' && *exp
<= '9')
637 trace_string_kludge
= atoi (exp
);
638 while (*exp
>= '0' && *exp
<= '9')
642 error (_("Target does not support \"/s\" option for string tracing."));
645 error (_("Undefined collection format \"%c\"."), *exp
);
647 exp
= skip_spaces_const (exp
);
652 /* Enter a list of actions for a tracepoint. */
654 trace_actions_command (char *args
, int from_tty
)
656 struct tracepoint
*t
;
657 struct command_line
*l
;
659 t
= get_tracepoint_by_number (&args
, NULL
, 1);
663 xstrprintf ("Enter actions for tracepoint %d, one per line.",
665 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
667 l
= read_command_lines (tmpbuf
, from_tty
, 1,
668 check_tracepoint_command
, t
);
669 do_cleanups (cleanups
);
670 breakpoint_set_commands (&t
->base
, l
);
672 /* else just return */
675 /* Report the results of checking the agent expression, as errors or
679 report_agent_reqs_errors (struct agent_expr
*aexpr
)
681 /* All of the "flaws" are serious bytecode generation issues that
682 should never occur. */
683 if (aexpr
->flaw
!= agent_flaw_none
)
684 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
686 /* If analysis shows a stack underflow, GDB must have done something
687 badly wrong in its bytecode generation. */
688 if (aexpr
->min_height
< 0)
689 internal_error (__FILE__
, __LINE__
,
690 _("expression has min height < 0"));
692 /* Issue this error if the stack is predicted to get too deep. The
693 limit is rather arbitrary; a better scheme might be for the
694 target to report how much stack it will have available. The
695 depth roughly corresponds to parenthesization, so a limit of 20
696 amounts to 20 levels of expression nesting, which is actually
697 a pretty big hairy expression. */
698 if (aexpr
->max_height
> 20)
699 error (_("Expression is too complicated."));
702 /* worker function */
704 validate_actionline (const char *line
, struct breakpoint
*b
)
706 struct cmd_list_element
*c
;
707 struct expression
*exp
= NULL
;
708 struct cleanup
*old_chain
= NULL
;
711 struct bp_location
*loc
;
712 struct agent_expr
*aexpr
;
713 struct tracepoint
*t
= (struct tracepoint
*) b
;
715 /* If EOF is typed, *line is NULL. */
719 p
= skip_spaces_const (line
);
721 /* Symbol lookup etc. */
722 if (*p
== '\0') /* empty line: just prompt for another line. */
725 if (*p
== '#') /* comment line */
728 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
730 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
732 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
734 trace_string_kludge
= 0;
736 p
= decode_agent_options (p
);
739 { /* Repeat over a comma-separated list. */
740 QUIT
; /* Allow user to bail out with ^C. */
741 p
= skip_spaces_const (p
);
743 if (*p
== '$') /* Look for special pseudo-symbols. */
745 if (0 == strncasecmp ("reg", p
+ 1, 3)
746 || 0 == strncasecmp ("arg", p
+ 1, 3)
747 || 0 == strncasecmp ("loc", p
+ 1, 3)
748 || 0 == strncasecmp ("_ret", p
+ 1, 4)
749 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
754 /* else fall thru, treat p as an expression and parse it! */
757 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
760 exp
= parse_exp_1 (&p
, loc
->address
,
761 block_for_pc (loc
->address
), 1);
762 old_chain
= make_cleanup (free_current_contents
, &exp
);
764 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
766 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
768 error (_("constant `%s' (value %s) "
769 "will not be collected."),
770 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
771 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
773 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
774 == LOC_OPTIMIZED_OUT
)
776 error (_("`%s' is optimized away "
777 "and cannot be collected."),
778 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
782 /* We have something to collect, make sure that the expr to
783 bytecode translator can handle it and that it's not too
785 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
786 make_cleanup_free_agent_expr (aexpr
);
788 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
789 error (_("Expression is too complicated."));
793 report_agent_reqs_errors (aexpr
);
795 do_cleanups (old_chain
);
798 while (p
&& *p
++ == ',');
801 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
804 { /* Repeat over a comma-separated list. */
805 QUIT
; /* Allow user to bail out with ^C. */
806 p
= skip_spaces_const (p
);
809 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
813 /* Only expressions are allowed for this action. */
814 exp
= parse_exp_1 (&p
, loc
->address
,
815 block_for_pc (loc
->address
), 1);
816 old_chain
= make_cleanup (free_current_contents
, &exp
);
818 /* We have something to evaluate, make sure that the expr to
819 bytecode translator can handle it and that it's not too
821 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
822 make_cleanup_free_agent_expr (aexpr
);
824 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
825 error (_("Expression is too complicated."));
828 report_agent_reqs_errors (aexpr
);
830 do_cleanups (old_chain
);
833 while (p
&& *p
++ == ',');
836 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
840 p
= skip_spaces_const (p
);
841 t
->step_count
= strtol (p
, &endp
, 0);
842 if (endp
== p
|| t
->step_count
== 0)
843 error (_("while-stepping step count `%s' is malformed."), line
);
847 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
851 error (_("`%s' is not a supported tracepoint action."), line
);
855 memrange_absolute
= -1
860 int type
; /* memrange_absolute for absolute memory range,
861 else basereg number. */
862 bfd_signed_vma start
;
866 struct collection_list
868 unsigned char regs_mask
[32]; /* room for up to 256 regs */
871 struct memrange
*list
;
872 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
874 struct agent_expr
**aexpr_list
;
876 /* True is the user requested a collection of "$_sdata", "static
880 tracepoint_list
, stepping_list
;
882 /* MEMRANGE functions: */
884 static int memrange_cmp (const void *, const void *);
886 /* Compare memranges for qsort. */
888 memrange_cmp (const void *va
, const void *vb
)
890 const struct memrange
*a
= va
, *b
= vb
;
892 if (a
->type
< b
->type
)
894 if (a
->type
> b
->type
)
896 if (a
->type
== memrange_absolute
)
898 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
900 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
905 if (a
->start
< b
->start
)
907 if (a
->start
> b
->start
)
913 /* Sort the memrange list using qsort, and merge adjacent memranges. */
915 memrange_sortmerge (struct collection_list
*memranges
)
919 qsort (memranges
->list
, memranges
->next_memrange
,
920 sizeof (struct memrange
), memrange_cmp
);
921 if (memranges
->next_memrange
> 0)
923 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
925 /* If memrange b overlaps or is adjacent to memrange a,
927 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
928 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
930 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
931 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
932 continue; /* next b, same a */
936 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
937 sizeof (struct memrange
));
939 memranges
->next_memrange
= a
+ 1;
943 /* Add a register to a collection list. */
945 add_register (struct collection_list
*collection
, unsigned int regno
)
948 printf_filtered ("collect register %d\n", regno
);
949 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
950 error (_("Internal: register number %d too large for tracepoint"),
952 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
955 /* Add a memrange to a collection list. */
957 add_memrange (struct collection_list
*memranges
,
958 int type
, bfd_signed_vma base
,
963 printf_filtered ("(%d,", type
);
965 printf_filtered (",%ld)\n", len
);
968 /* type: memrange_absolute == memory, other n == basereg */
969 memranges
->list
[memranges
->next_memrange
].type
= type
;
970 /* base: addr if memory, offset if reg relative. */
971 memranges
->list
[memranges
->next_memrange
].start
= base
;
972 /* len: we actually save end (base + len) for convenience */
973 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
974 memranges
->next_memrange
++;
975 if (memranges
->next_memrange
>= memranges
->listsize
)
977 memranges
->listsize
*= 2;
978 memranges
->list
= xrealloc (memranges
->list
,
979 memranges
->listsize
);
982 if (type
!= memrange_absolute
) /* Better collect the base register! */
983 add_register (memranges
, type
);
986 /* Add a symbol to a collection list. */
988 collect_symbol (struct collection_list
*collect
,
990 struct gdbarch
*gdbarch
,
991 long frame_regno
, long frame_offset
,
996 bfd_signed_vma offset
;
997 int treat_as_expr
= 0;
999 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1000 switch (SYMBOL_CLASS (sym
))
1003 printf_filtered ("%s: don't know symbol class %d\n",
1004 SYMBOL_PRINT_NAME (sym
),
1005 SYMBOL_CLASS (sym
));
1008 printf_filtered ("constant %s (value %s) will not be collected.\n",
1009 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1012 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1017 sprintf_vma (tmp
, offset
);
1018 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1019 SYMBOL_PRINT_NAME (sym
), len
,
1022 /* A struct may be a C++ class with static fields, go to general
1023 expression handling. */
1024 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1027 add_memrange (collect
, memrange_absolute
, offset
, len
);
1030 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1032 printf_filtered ("LOC_REG[parm] %s: ",
1033 SYMBOL_PRINT_NAME (sym
));
1034 add_register (collect
, reg
);
1035 /* Check for doubles stored in two registers. */
1036 /* FIXME: how about larger types stored in 3 or more regs? */
1037 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1038 len
> register_size (gdbarch
, reg
))
1039 add_register (collect
, reg
+ 1);
1042 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1043 printf_filtered (" (will not collect %s)\n",
1044 SYMBOL_PRINT_NAME (sym
));
1048 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1051 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1052 SYMBOL_PRINT_NAME (sym
), len
);
1053 printf_vma (offset
);
1054 printf_filtered (" from frame ptr reg %d\n", reg
);
1056 add_memrange (collect
, reg
, offset
, len
);
1058 case LOC_REGPARM_ADDR
:
1059 reg
= SYMBOL_VALUE (sym
);
1063 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1064 SYMBOL_PRINT_NAME (sym
), len
);
1065 printf_vma (offset
);
1066 printf_filtered (" from reg %d\n", reg
);
1068 add_memrange (collect
, reg
, offset
, len
);
1072 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1075 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1076 SYMBOL_PRINT_NAME (sym
), len
);
1077 printf_vma (offset
);
1078 printf_filtered (" from frame ptr reg %d\n", reg
);
1080 add_memrange (collect
, reg
, offset
, len
);
1083 case LOC_UNRESOLVED
:
1087 case LOC_OPTIMIZED_OUT
:
1088 printf_filtered ("%s has been optimized out of existence.\n",
1089 SYMBOL_PRINT_NAME (sym
));
1097 /* Expressions are the most general case. */
1100 struct agent_expr
*aexpr
;
1101 struct cleanup
*old_chain1
= NULL
;
1103 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1105 /* It can happen that the symbol is recorded as a computed
1106 location, but it's been optimized away and doesn't actually
1107 have a location expression. */
1110 printf_filtered ("%s has been optimized out of existence.\n",
1111 SYMBOL_PRINT_NAME (sym
));
1115 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1119 report_agent_reqs_errors (aexpr
);
1121 discard_cleanups (old_chain1
);
1122 add_aexpr (collect
, aexpr
);
1124 /* Take care of the registers. */
1125 if (aexpr
->reg_mask_len
> 0)
1129 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1131 QUIT
; /* Allow user to bail out with ^C. */
1132 if (aexpr
->reg_mask
[ndx1
] != 0)
1134 /* Assume chars have 8 bits. */
1135 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1136 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1137 /* It's used -- record it. */
1138 add_register (collect
, ndx1
* 8 + ndx2
);
1145 /* Data to be passed around in the calls to the locals and args
1148 struct add_local_symbols_data
1150 struct collection_list
*collect
;
1151 struct gdbarch
*gdbarch
;
1158 /* The callback for the locals and args iterators. */
1161 do_collect_symbol (const char *print_name
,
1165 struct add_local_symbols_data
*p
= cb_data
;
1167 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1168 p
->frame_offset
, p
->pc
);
1172 /* Add all locals (or args) symbols to collection list. */
1174 add_local_symbols (struct collection_list
*collect
,
1175 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1176 long frame_regno
, long frame_offset
, int type
)
1178 struct block
*block
;
1179 struct add_local_symbols_data cb_data
;
1181 cb_data
.collect
= collect
;
1182 cb_data
.gdbarch
= gdbarch
;
1184 cb_data
.frame_regno
= frame_regno
;
1185 cb_data
.frame_offset
= frame_offset
;
1190 block
= block_for_pc (pc
);
1193 warning (_("Can't collect locals; "
1194 "no symbol table info available.\n"));
1198 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1199 if (cb_data
.count
== 0)
1200 warning (_("No locals found in scope."));
1204 pc
= get_pc_function_start (pc
);
1205 block
= block_for_pc (pc
);
1208 warning (_("Can't collect args; no symbol table info available."));
1212 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1213 if (cb_data
.count
== 0)
1214 warning (_("No args found in scope."));
1219 add_static_trace_data (struct collection_list
*collection
)
1222 printf_filtered ("collect static trace data\n");
1223 collection
->strace_data
= 1;
1226 /* worker function */
1228 clear_collection_list (struct collection_list
*list
)
1232 list
->next_memrange
= 0;
1233 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1235 free_agent_expr (list
->aexpr_list
[ndx
]);
1236 list
->aexpr_list
[ndx
] = NULL
;
1238 list
->next_aexpr_elt
= 0;
1239 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1240 list
->strace_data
= 0;
1243 /* Reduce a collection list to string form (for gdb protocol). */
1245 stringify_collection_list (struct collection_list
*list
, char *string
)
1247 char temp_buf
[2048];
1251 char *(*str_list
)[];
1255 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1256 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1258 if (list
->strace_data
)
1261 printf_filtered ("\nCollecting static trace data\n");
1264 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1268 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1269 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1271 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1274 printf_filtered ("\nCollecting registers (mask): 0x");
1279 QUIT
; /* Allow user to bail out with ^C. */
1281 printf_filtered ("%02X", list
->regs_mask
[i
]);
1282 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1285 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1289 printf_filtered ("\n");
1290 if (list
->next_memrange
> 0 && info_verbose
)
1291 printf_filtered ("Collecting memranges: \n");
1292 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1294 QUIT
; /* Allow user to bail out with ^C. */
1295 sprintf_vma (tmp2
, list
->list
[i
].start
);
1298 printf_filtered ("(%d, %s, %ld)\n",
1301 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1303 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1305 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1312 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1314 /* The "%X" conversion specifier expects an unsigned argument,
1315 so passing -1 (memrange_absolute) to it directly gives you
1316 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1318 if (list
->list
[i
].type
== memrange_absolute
)
1319 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1321 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1324 count
+= strlen (end
);
1325 end
= temp_buf
+ count
;
1328 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1330 QUIT
; /* Allow user to bail out with ^C. */
1331 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1333 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1338 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1339 end
+= 10; /* 'X' + 8 hex digits + ',' */
1342 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1343 end
, list
->aexpr_list
[i
]->len
);
1344 count
+= 2 * list
->aexpr_list
[i
]->len
;
1349 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1354 (*str_list
)[ndx
] = NULL
;
1367 encode_actions_1 (struct command_line
*action
,
1368 struct breakpoint
*t
,
1369 struct bp_location
*tloc
,
1371 LONGEST frame_offset
,
1372 struct collection_list
*collect
,
1373 struct collection_list
*stepping_list
)
1375 const char *action_exp
;
1376 struct expression
*exp
= NULL
;
1378 struct value
*tempval
;
1379 struct cmd_list_element
*cmd
;
1380 struct agent_expr
*aexpr
;
1382 for (; action
; action
= action
->next
)
1384 QUIT
; /* Allow user to bail out with ^C. */
1385 action_exp
= action
->line
;
1386 action_exp
= skip_spaces_const (action_exp
);
1388 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1390 error (_("Bad action list item: %s"), action_exp
);
1392 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1394 trace_string_kludge
= 0;
1395 if (*action_exp
== '/')
1396 action_exp
= decode_agent_options (action_exp
);
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
,
1417 action_exp
= strchr (action_exp
, ','); /* more? */
1419 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1421 add_local_symbols (collect
,
1427 action_exp
= strchr (action_exp
, ','); /* more? */
1429 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1431 struct cleanup
*old_chain1
= NULL
;
1433 aexpr
= gen_trace_for_return_address (tloc
->address
,
1436 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1439 report_agent_reqs_errors (aexpr
);
1441 discard_cleanups (old_chain1
);
1442 add_aexpr (collect
, aexpr
);
1444 /* take care of the registers */
1445 if (aexpr
->reg_mask_len
> 0)
1449 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1451 QUIT
; /* allow user to bail out with ^C */
1452 if (aexpr
->reg_mask
[ndx1
] != 0)
1454 /* assume chars have 8 bits */
1455 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1456 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1457 /* it's used -- record it */
1458 add_register (collect
,
1464 action_exp
= strchr (action_exp
, ','); /* more? */
1466 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1468 add_static_trace_data (collect
);
1469 action_exp
= strchr (action_exp
, ','); /* more? */
1474 struct cleanup
*old_chain
= NULL
;
1475 struct cleanup
*old_chain1
= NULL
;
1477 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1478 block_for_pc (tloc
->address
), 1);
1479 old_chain
= make_cleanup (free_current_contents
, &exp
);
1481 switch (exp
->elts
[0].opcode
)
1485 const char *name
= &exp
->elts
[2].string
;
1487 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1488 name
, strlen (name
));
1490 internal_error (__FILE__
, __LINE__
,
1491 _("Register $%s not available"),
1494 printf_filtered ("OP_REGISTER: ");
1495 add_register (collect
, i
);
1500 /* Safe because we know it's a simple expression. */
1501 tempval
= evaluate_expression (exp
);
1502 addr
= value_address (tempval
);
1503 /* Initialize the TYPE_LENGTH if it is a typedef. */
1504 check_typedef (exp
->elts
[1].type
);
1505 add_memrange (collect
, memrange_absolute
, addr
,
1506 TYPE_LENGTH (exp
->elts
[1].type
));
1510 collect_symbol (collect
,
1511 exp
->elts
[2].symbol
,
1518 default: /* Full-fledged expression. */
1519 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1521 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1525 report_agent_reqs_errors (aexpr
);
1527 discard_cleanups (old_chain1
);
1528 add_aexpr (collect
, aexpr
);
1530 /* Take care of the registers. */
1531 if (aexpr
->reg_mask_len
> 0)
1536 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1538 QUIT
; /* Allow user to bail out with ^C. */
1539 if (aexpr
->reg_mask
[ndx1
] != 0)
1541 /* Assume chars have 8 bits. */
1542 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1543 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1544 /* It's used -- record it. */
1545 add_register (collect
,
1552 do_cleanups (old_chain
);
1555 while (action_exp
&& *action_exp
++ == ',');
1557 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1560 { /* Repeat over a comma-separated list. */
1561 QUIT
; /* Allow user to bail out with ^C. */
1562 action_exp
= skip_spaces_const (action_exp
);
1565 struct cleanup
*old_chain
= NULL
;
1566 struct cleanup
*old_chain1
= NULL
;
1568 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1569 block_for_pc (tloc
->address
), 1);
1570 old_chain
= make_cleanup (free_current_contents
, &exp
);
1572 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1573 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1576 report_agent_reqs_errors (aexpr
);
1578 discard_cleanups (old_chain1
);
1579 /* Even though we're not officially collecting, add
1580 to the collect list anyway. */
1581 add_aexpr (collect
, aexpr
);
1583 do_cleanups (old_chain
);
1586 while (action_exp
&& *action_exp
++ == ',');
1588 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1590 /* We check against nested while-stepping when setting
1591 breakpoint action, so no way to run into nested
1593 gdb_assert (stepping_list
);
1595 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1596 frame_offset
, stepping_list
, NULL
);
1599 error (_("Invalid tracepoint command '%s'"), action
->line
);
1603 /* Render all actions into gdb protocol. */
1606 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1607 char ***tdp_actions
, char ***stepping_actions
)
1609 static char tdp_buff
[2048], step_buff
[2048];
1610 char *default_collect_line
= NULL
;
1611 struct command_line
*actions
;
1612 struct command_line
*default_collect_action
= NULL
;
1614 LONGEST frame_offset
;
1615 struct cleanup
*back_to
;
1617 back_to
= make_cleanup (null_cleanup
, NULL
);
1619 clear_collection_list (&tracepoint_list
);
1620 clear_collection_list (&stepping_list
);
1622 *tdp_actions
= NULL
;
1623 *stepping_actions
= NULL
;
1625 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1626 tloc
->address
, &frame_reg
, &frame_offset
);
1628 actions
= breakpoint_commands (t
);
1630 /* If there are default expressions to collect, make up a collect
1631 action and prepend to the action list to encode. Note that since
1632 validation is per-tracepoint (local var "xyz" might be valid for
1633 one tracepoint and not another, etc), we make up the action on
1634 the fly, and don't cache it. */
1635 if (*default_collect
)
1637 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1638 make_cleanup (xfree
, default_collect_line
);
1640 validate_actionline (default_collect_line
, t
);
1642 default_collect_action
= xmalloc (sizeof (struct command_line
));
1643 make_cleanup (xfree
, default_collect_action
);
1644 default_collect_action
->next
= actions
;
1645 default_collect_action
->line
= default_collect_line
;
1646 actions
= default_collect_action
;
1648 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1649 &tracepoint_list
, &stepping_list
);
1651 memrange_sortmerge (&tracepoint_list
);
1652 memrange_sortmerge (&stepping_list
);
1654 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1656 *stepping_actions
= stringify_collection_list (&stepping_list
,
1659 do_cleanups (back_to
);
1663 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1665 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1667 collect
->aexpr_list
=
1668 xrealloc (collect
->aexpr_list
,
1669 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1670 collect
->aexpr_listsize
*= 2;
1672 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1673 collect
->next_aexpr_elt
++;
1677 process_tracepoint_on_disconnect (void)
1679 VEC(breakpoint_p
) *tp_vec
= NULL
;
1681 struct breakpoint
*b
;
1682 int has_pending_p
= 0;
1684 /* Check whether we still have pending tracepoint. If we have, warn the
1685 user that pending tracepoint will no longer work. */
1686 tp_vec
= all_tracepoints ();
1687 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1696 struct bp_location
*loc1
;
1698 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1700 if (loc1
->shlib_disabled
)
1711 VEC_free (breakpoint_p
, tp_vec
);
1714 warning (_("Pending tracepoints will not be resolved while"
1715 " GDB is disconnected\n"));
1720 start_tracing (char *notes
)
1722 VEC(breakpoint_p
) *tp_vec
= NULL
;
1724 struct breakpoint
*b
;
1725 struct trace_state_variable
*tsv
;
1726 int any_enabled
= 0, num_to_download
= 0;
1729 tp_vec
= all_tracepoints ();
1731 /* No point in tracing without any tracepoints... */
1732 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1734 VEC_free (breakpoint_p
, tp_vec
);
1735 error (_("No tracepoints defined, not starting trace"));
1738 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1740 struct tracepoint
*t
= (struct tracepoint
*) b
;
1741 struct bp_location
*loc
;
1743 if (b
->enable_state
== bp_enabled
)
1746 if ((b
->type
== bp_fast_tracepoint
1747 ? may_insert_fast_tracepoints
1748 : may_insert_tracepoints
))
1751 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1752 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1757 if (target_supports_enable_disable_tracepoint ())
1758 warning (_("No tracepoints enabled"));
1761 /* No point in tracing with only disabled tracepoints that
1762 cannot be re-enabled. */
1763 VEC_free (breakpoint_p
, tp_vec
);
1764 error (_("No tracepoints enabled, not starting trace"));
1768 if (num_to_download
<= 0)
1770 VEC_free (breakpoint_p
, tp_vec
);
1771 error (_("No tracepoints that may be downloaded, not starting trace"));
1774 target_trace_init ();
1776 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1778 struct tracepoint
*t
= (struct tracepoint
*) b
;
1779 struct bp_location
*loc
;
1780 int bp_location_downloaded
= 0;
1782 /* Clear `inserted' flag. */
1783 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1786 if ((b
->type
== bp_fast_tracepoint
1787 ? !may_insert_fast_tracepoints
1788 : !may_insert_tracepoints
))
1791 t
->number_on_target
= 0;
1793 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1795 /* Since tracepoint locations are never duplicated, `inserted'
1796 flag should be zero. */
1797 gdb_assert (!loc
->inserted
);
1799 target_download_tracepoint (loc
);
1802 bp_location_downloaded
= 1;
1805 t
->number_on_target
= b
->number
;
1807 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1808 if (loc
->probe
!= NULL
)
1809 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1811 if (bp_location_downloaded
)
1812 observer_notify_breakpoint_modified (b
);
1814 VEC_free (breakpoint_p
, tp_vec
);
1816 /* Send down all the trace state variables too. */
1817 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1819 target_download_trace_state_variable (tsv
);
1822 /* Tell target to treat text-like sections as transparent. */
1823 target_trace_set_readonly_regions ();
1824 /* Set some mode flags. */
1825 target_set_disconnected_tracing (disconnected_tracing
);
1826 target_set_circular_trace_buffer (circular_trace_buffer
);
1827 target_set_trace_buffer_size (trace_buffer_size
);
1830 notes
= trace_notes
;
1831 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1833 if (!ret
&& (trace_user
|| notes
))
1834 warning (_("Target does not support trace user/notes, info ignored"));
1836 /* Now insert traps and begin collecting data. */
1837 target_trace_start ();
1839 /* Reset our local state. */
1840 set_traceframe_num (-1);
1841 set_tracepoint_num (-1);
1842 set_traceframe_context (NULL
);
1843 current_trace_status()->running
= 1;
1844 clear_traceframe_info ();
1847 /* The tstart command requests the target to start a new trace run.
1848 The command passes any arguments it has to the target verbatim, as
1849 an optional "trace note". This is useful as for instance a warning
1850 to other users if the trace runs disconnected, and you don't want
1851 anybody else messing with the target. */
1854 trace_start_command (char *args
, int from_tty
)
1856 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1858 if (current_trace_status ()->running
)
1861 && !query (_("A trace is running already. Start a new run? ")))
1862 error (_("New trace run not started."));
1865 start_tracing (args
);
1868 /* The tstop command stops the tracing run. The command passes any
1869 supplied arguments to the target verbatim as a "stop note"; if the
1870 target supports trace notes, then it will be reported back as part
1871 of the trace run's status. */
1874 trace_stop_command (char *args
, int from_tty
)
1876 if (!current_trace_status ()->running
)
1877 error (_("Trace is not running."));
1879 stop_tracing (args
);
1883 stop_tracing (char *note
)
1886 VEC(breakpoint_p
) *tp_vec
= NULL
;
1888 struct breakpoint
*t
;
1890 target_trace_stop ();
1892 tp_vec
= all_tracepoints ();
1893 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1895 struct bp_location
*loc
;
1897 if ((t
->type
== bp_fast_tracepoint
1898 ? !may_insert_fast_tracepoints
1899 : !may_insert_tracepoints
))
1902 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1904 /* GDB can be totally absent in some disconnected trace scenarios,
1905 but we don't really care if this semaphore goes out of sync.
1906 That's why we are decrementing it here, but not taking care
1908 if (loc
->probe
!= NULL
)
1909 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1913 VEC_free (breakpoint_p
, tp_vec
);
1916 note
= trace_stop_notes
;
1917 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1920 warning (_("Target does not support trace notes, note ignored"));
1922 /* Should change in response to reply? */
1923 current_trace_status ()->running
= 0;
1926 /* tstatus command */
1928 trace_status_command (char *args
, int from_tty
)
1930 struct trace_status
*ts
= current_trace_status ();
1932 VEC(breakpoint_p
) *tp_vec
= NULL
;
1933 struct breakpoint
*t
;
1935 status
= target_get_trace_status (ts
);
1939 if (ts
->filename
!= NULL
)
1940 printf_filtered (_("Using a trace file.\n"));
1943 printf_filtered (_("Trace can not be run on this target.\n"));
1948 if (!ts
->running_known
)
1950 printf_filtered (_("Run/stop status is unknown.\n"));
1952 else if (ts
->running
)
1954 printf_filtered (_("Trace is running on the target.\n"));
1958 switch (ts
->stop_reason
)
1960 case trace_never_run
:
1961 printf_filtered (_("No trace has been run on the target.\n"));
1965 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1968 printf_filtered (_("Trace stopped by a tstop command.\n"));
1970 case trace_buffer_full
:
1971 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1973 case trace_disconnected
:
1974 printf_filtered (_("Trace stopped because of disconnection.\n"));
1976 case tracepoint_passcount
:
1977 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1978 ts
->stopping_tracepoint
);
1980 case tracepoint_error
:
1981 if (ts
->stopping_tracepoint
)
1982 printf_filtered (_("Trace stopped by an "
1983 "error (%s, tracepoint %d).\n"),
1984 ts
->stop_desc
, ts
->stopping_tracepoint
);
1986 printf_filtered (_("Trace stopped by an error (%s).\n"),
1989 case trace_stop_reason_unknown
:
1990 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1993 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1999 if (ts
->traceframes_created
>= 0
2000 && ts
->traceframe_count
!= ts
->traceframes_created
)
2002 printf_filtered (_("Buffer contains %d trace "
2003 "frames (of %d created total).\n"),
2004 ts
->traceframe_count
, ts
->traceframes_created
);
2006 else if (ts
->traceframe_count
>= 0)
2008 printf_filtered (_("Collected %d trace frames.\n"),
2009 ts
->traceframe_count
);
2012 if (ts
->buffer_free
>= 0)
2014 if (ts
->buffer_size
>= 0)
2016 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2017 ts
->buffer_free
, ts
->buffer_size
);
2018 if (ts
->buffer_size
> 0)
2019 printf_filtered (_(" (%d%% full)"),
2020 ((int) ((((long long) (ts
->buffer_size
2021 - ts
->buffer_free
)) * 100)
2022 / ts
->buffer_size
)));
2023 printf_filtered (_(".\n"));
2026 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2030 if (ts
->disconnected_tracing
)
2031 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2033 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2035 if (ts
->circular_buffer
)
2036 printf_filtered (_("Trace buffer is circular.\n"));
2038 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2039 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2041 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2042 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2044 /* Now report on what we're doing with tfind. */
2045 if (traceframe_number
>= 0)
2046 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2047 traceframe_number
, tracepoint_number
);
2049 printf_filtered (_("Not looking at any trace frame.\n"));
2051 /* Report start/stop times if supplied. */
2056 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2058 /* Reporting a run time is more readable than two long numbers. */
2059 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2060 (long int) ts
->start_time
/ 1000000,
2061 (long int) ts
->start_time
% 1000000,
2062 (long int) run_time
/ 1000000,
2063 (long int) run_time
% 1000000);
2066 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2067 (long int) ts
->start_time
/ 1000000,
2068 (long int) ts
->start_time
% 1000000);
2070 else if (ts
->stop_time
)
2071 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2072 (long int) ts
->stop_time
/ 1000000,
2073 (long int) ts
->stop_time
% 1000000);
2075 /* Now report any per-tracepoint status available. */
2076 tp_vec
= all_tracepoints ();
2078 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2079 target_get_tracepoint_status (t
, NULL
);
2081 VEC_free (breakpoint_p
, tp_vec
);
2084 /* Report the trace status to uiout, in a way suitable for MI, and not
2085 suitable for CLI. If ON_STOP is true, suppress a few fields that
2086 are not meaningful in the -trace-stop response.
2088 The implementation is essentially parallel to trace_status_command, but
2089 merging them will result in unreadable code. */
2091 trace_status_mi (int on_stop
)
2093 struct ui_out
*uiout
= current_uiout
;
2094 struct trace_status
*ts
= current_trace_status ();
2097 status
= target_get_trace_status (ts
);
2099 if (status
== -1 && ts
->filename
== NULL
)
2101 ui_out_field_string (uiout
, "supported", "0");
2105 if (ts
->filename
!= NULL
)
2106 ui_out_field_string (uiout
, "supported", "file");
2108 ui_out_field_string (uiout
, "supported", "1");
2110 if (ts
->filename
!= NULL
)
2111 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2113 gdb_assert (ts
->running_known
);
2117 ui_out_field_string (uiout
, "running", "1");
2119 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2120 Given that the frontend gets the status either on -trace-stop, or from
2121 -trace-status after re-connection, it does not seem like this
2122 information is necessary for anything. It is not necessary for either
2123 figuring the vital state of the target nor for navigation of trace
2124 frames. If the frontend wants to show the current state is some
2125 configure dialog, it can request the value when such dialog is
2126 invoked by the user. */
2130 char *stop_reason
= NULL
;
2131 int stopping_tracepoint
= -1;
2134 ui_out_field_string (uiout
, "running", "0");
2136 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2138 switch (ts
->stop_reason
)
2141 stop_reason
= "request";
2143 case trace_buffer_full
:
2144 stop_reason
= "overflow";
2146 case trace_disconnected
:
2147 stop_reason
= "disconnection";
2149 case tracepoint_passcount
:
2150 stop_reason
= "passcount";
2151 stopping_tracepoint
= ts
->stopping_tracepoint
;
2153 case tracepoint_error
:
2154 stop_reason
= "error";
2155 stopping_tracepoint
= ts
->stopping_tracepoint
;
2161 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2162 if (stopping_tracepoint
!= -1)
2163 ui_out_field_int (uiout
, "stopping-tracepoint",
2164 stopping_tracepoint
);
2165 if (ts
->stop_reason
== tracepoint_error
)
2166 ui_out_field_string (uiout
, "error-description",
2172 if (ts
->traceframe_count
!= -1)
2173 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2174 if (ts
->traceframes_created
!= -1)
2175 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2176 if (ts
->buffer_size
!= -1)
2177 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2178 if (ts
->buffer_free
!= -1)
2179 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2181 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2182 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2184 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2185 ui_out_field_string (uiout
, "notes", ts
->notes
);
2190 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2191 (long int) ts
->start_time
/ 1000000,
2192 (long int) ts
->start_time
% 1000000);
2193 ui_out_field_string (uiout
, "start-time", buf
);
2194 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2195 (long int) ts
->stop_time
/ 1000000,
2196 (long int) ts
->stop_time
% 1000000);
2197 ui_out_field_string (uiout
, "stop-time", buf
);
2201 /* This function handles the details of what to do about an ongoing
2202 tracing run if the user has asked to detach or otherwise disconnect
2205 disconnect_tracing (int from_tty
)
2207 /* It can happen that the target that was tracing went away on its
2208 own, and we didn't notice. Get a status update, and if the
2209 current target doesn't even do tracing, then assume it's not
2211 if (target_get_trace_status (current_trace_status ()) < 0)
2212 current_trace_status ()->running
= 0;
2214 /* If running interactively, give the user the option to cancel and
2215 then decide what to do differently with the run. Scripts are
2216 just going to disconnect and let the target deal with it,
2217 according to how it's been instructed previously via
2218 disconnected-tracing. */
2219 if (current_trace_status ()->running
&& from_tty
)
2221 process_tracepoint_on_disconnect ();
2223 if (current_trace_status ()->disconnected_tracing
)
2225 if (!query (_("Trace is running and will "
2226 "continue after detach; detach anyway? ")))
2227 error (_("Not confirmed."));
2231 if (!query (_("Trace is running but will "
2232 "stop on detach; detach anyway? ")))
2233 error (_("Not confirmed."));
2237 /* Also we want to be out of tfind mode, otherwise things can get
2238 confusing upon reconnection. Just use these calls instead of
2239 full tfind_1 behavior because we're in the middle of detaching,
2240 and there's no point to updating current stack frame etc. */
2241 set_current_traceframe (-1);
2242 set_tracepoint_num (-1);
2243 set_traceframe_context (NULL
);
2246 /* Worker function for the various flavors of the tfind command. */
2248 tfind_1 (enum trace_find_type type
, int num
,
2249 ULONGEST addr1
, ULONGEST addr2
,
2252 int target_frameno
= -1, target_tracept
= -1;
2253 struct frame_id old_frame_id
= null_frame_id
;
2254 struct tracepoint
*tp
;
2255 struct ui_out
*uiout
= current_uiout
;
2257 /* Only try to get the current stack frame if we have a chance of
2258 succeeding. In particular, if we're trying to get a first trace
2259 frame while all threads are running, it's not going to succeed,
2260 so leave it with a default value and let the frame comparison
2261 below (correctly) decide to print out the source location of the
2263 if (!(type
== tfind_number
&& num
== -1)
2264 && (has_stack_frames () || traceframe_number
>= 0))
2265 old_frame_id
= get_frame_id (get_current_frame ());
2267 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2270 if (type
== tfind_number
2272 && target_frameno
== -1)
2274 /* We told the target to get out of tfind mode, and it did. */
2276 else if (target_frameno
== -1)
2278 /* A request for a non-existent trace frame has failed.
2279 Our response will be different, depending on FROM_TTY:
2281 If FROM_TTY is true, meaning that this command was
2282 typed interactively by the user, then give an error
2283 and DO NOT change the state of traceframe_number etc.
2285 However if FROM_TTY is false, meaning that we're either
2286 in a script, a loop, or a user-defined command, then
2287 DON'T give an error, but DO change the state of
2288 traceframe_number etc. to invalid.
2290 The rationalle is that if you typed the command, you
2291 might just have committed a typo or something, and you'd
2292 like to NOT lose your current debugging state. However
2293 if you're in a user-defined command or especially in a
2294 loop, then you need a way to detect that the command
2295 failed WITHOUT aborting. This allows you to write
2296 scripts that search thru the trace buffer until the end,
2297 and then continue on to do something else. */
2300 error (_("Target failed to find requested trace frame."));
2304 printf_filtered ("End of trace buffer.\n");
2305 #if 0 /* dubious now? */
2306 /* The following will not recurse, since it's
2308 trace_find_command ("-1", from_tty
);
2313 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2315 reinit_frame_cache ();
2316 target_dcache_invalidate ();
2318 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2320 if (target_frameno
!= get_traceframe_number ())
2321 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2323 set_current_traceframe (target_frameno
);
2325 if (target_frameno
== -1)
2326 set_traceframe_context (NULL
);
2328 set_traceframe_context (get_current_frame ());
2330 if (traceframe_number
>= 0)
2332 /* Use different branches for MI and CLI to make CLI messages
2334 if (ui_out_is_mi_like_p (uiout
))
2336 ui_out_field_string (uiout
, "found", "1");
2337 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2338 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2342 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2343 traceframe_number
, tracepoint_number
);
2348 if (ui_out_is_mi_like_p (uiout
))
2349 ui_out_field_string (uiout
, "found", "0");
2350 else if (type
== tfind_number
&& num
== -1)
2351 printf_unfiltered (_("No longer looking at any trace frame\n"));
2352 else /* This case may never occur, check. */
2353 printf_unfiltered (_("No trace frame found\n"));
2356 /* If we're in nonstop mode and getting out of looking at trace
2357 frames, there won't be any current frame to go back to and
2360 && (has_stack_frames () || traceframe_number
>= 0))
2362 enum print_what print_what
;
2364 /* NOTE: in imitation of the step command, try to determine
2365 whether we have made a transition from one function to
2366 another. If so, we'll print the "stack frame" (ie. the new
2367 function and it's arguments) -- otherwise we'll just show the
2370 if (frame_id_eq (old_frame_id
,
2371 get_frame_id (get_current_frame ())))
2372 print_what
= SRC_LINE
;
2374 print_what
= SRC_AND_LOC
;
2376 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2381 /* trace_find_command takes a trace frame number n,
2382 sends "QTFrame:<n>" to the target,
2383 and accepts a reply that may contain several optional pieces
2384 of information: a frame number, a tracepoint number, and an
2385 indication of whether this is a trap frame or a stepping frame.
2387 The minimal response is just "OK" (which indicates that the
2388 target does not give us a frame number or a tracepoint number).
2389 Instead of that, the target may send us a string containing
2391 F<hexnum> (gives the selected frame number)
2392 T<hexnum> (gives the selected tracepoint number)
2397 trace_find_command (char *args
, int from_tty
)
2398 { /* This should only be called with a numeric argument. */
2401 if (current_trace_status ()->running
2402 && current_trace_status ()->filename
== NULL
)
2403 error (_("May not look at trace frames while trace is running."));
2405 if (args
== 0 || *args
== 0)
2406 { /* TFIND with no args means find NEXT trace frame. */
2407 if (traceframe_number
== -1)
2408 frameno
= 0; /* "next" is first one. */
2410 frameno
= traceframe_number
+ 1;
2412 else if (0 == strcmp (args
, "-"))
2414 if (traceframe_number
== -1)
2415 error (_("not debugging trace buffer"));
2416 else if (from_tty
&& traceframe_number
== 0)
2417 error (_("already at start of trace buffer"));
2419 frameno
= traceframe_number
- 1;
2421 /* A hack to work around eval's need for fp to have been collected. */
2422 else if (0 == strcmp (args
, "-1"))
2425 frameno
= parse_and_eval_long (args
);
2428 error (_("invalid input (%d is less than zero)"), frameno
);
2430 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2435 trace_find_end_command (char *args
, int from_tty
)
2437 trace_find_command ("-1", from_tty
);
2442 trace_find_start_command (char *args
, int from_tty
)
2444 trace_find_command ("0", from_tty
);
2447 /* tfind pc command */
2449 trace_find_pc_command (char *args
, int from_tty
)
2453 if (current_trace_status ()->running
2454 && current_trace_status ()->filename
== NULL
)
2455 error (_("May not look at trace frames while trace is running."));
2457 if (args
== 0 || *args
== 0)
2458 pc
= regcache_read_pc (get_current_regcache ());
2460 pc
= parse_and_eval_address (args
);
2462 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2465 /* tfind tracepoint command */
2467 trace_find_tracepoint_command (char *args
, int from_tty
)
2470 struct tracepoint
*tp
;
2472 if (current_trace_status ()->running
2473 && current_trace_status ()->filename
== NULL
)
2474 error (_("May not look at trace frames while trace is running."));
2476 if (args
== 0 || *args
== 0)
2478 if (tracepoint_number
== -1)
2479 error (_("No current tracepoint -- please supply an argument."));
2481 tdp
= tracepoint_number
; /* Default is current TDP. */
2484 tdp
= parse_and_eval_long (args
);
2486 /* If we have the tracepoint on hand, use the number that the
2487 target knows about (which may be different if we disconnected
2488 and reconnected). */
2489 tp
= get_tracepoint (tdp
);
2491 tdp
= tp
->number_on_target
;
2493 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2496 /* TFIND LINE command:
2498 This command will take a sourceline for argument, just like BREAK
2499 or TRACE (ie. anything that "decode_line_1" can handle).
2501 With no argument, this command will find the next trace frame
2502 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2505 trace_find_line_command (char *args
, int from_tty
)
2507 static CORE_ADDR start_pc
, end_pc
;
2508 struct symtabs_and_lines sals
;
2509 struct symtab_and_line sal
;
2510 struct cleanup
*old_chain
;
2512 if (current_trace_status ()->running
2513 && current_trace_status ()->filename
== NULL
)
2514 error (_("May not look at trace frames while trace is running."));
2516 if (args
== 0 || *args
== 0)
2518 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2520 sals
.sals
= (struct symtab_and_line
*)
2521 xmalloc (sizeof (struct symtab_and_line
));
2526 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2530 old_chain
= make_cleanup (xfree
, sals
.sals
);
2531 if (sal
.symtab
== 0)
2532 error (_("No line number information available."));
2534 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2536 if (start_pc
== end_pc
)
2538 printf_filtered ("Line %d of \"%s\"",
2540 symtab_to_filename_for_display (sal
.symtab
));
2542 printf_filtered (" is at address ");
2543 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2545 printf_filtered (" but contains no code.\n");
2546 sal
= find_pc_line (start_pc
, 0);
2548 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2549 && start_pc
!= end_pc
)
2550 printf_filtered ("Attempting to find line %d instead.\n",
2553 error (_("Cannot find a good line."));
2557 /* Is there any case in which we get here, and have an address
2558 which the user would want to see? If we have debugging
2559 symbols and no line numbers? */
2560 error (_("Line number %d is out of range for \"%s\"."),
2561 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2563 /* Find within range of stated line. */
2565 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2567 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2568 do_cleanups (old_chain
);
2571 /* tfind range command */
2573 trace_find_range_command (char *args
, int from_tty
)
2575 static CORE_ADDR start
, stop
;
2578 if (current_trace_status ()->running
2579 && current_trace_status ()->filename
== NULL
)
2580 error (_("May not look at trace frames while trace is running."));
2582 if (args
== 0 || *args
== 0)
2583 { /* XXX FIXME: what should default behavior be? */
2584 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2588 if (0 != (tmp
= strchr (args
, ',')))
2590 *tmp
++ = '\0'; /* Terminate start address. */
2591 tmp
= skip_spaces (tmp
);
2592 start
= parse_and_eval_address (args
);
2593 stop
= parse_and_eval_address (tmp
);
2596 { /* No explicit end address? */
2597 start
= parse_and_eval_address (args
);
2598 stop
= start
+ 1; /* ??? */
2601 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2604 /* tfind outside command */
2606 trace_find_outside_command (char *args
, int from_tty
)
2608 CORE_ADDR start
, stop
;
2611 if (current_trace_status ()->running
2612 && current_trace_status ()->filename
== NULL
)
2613 error (_("May not look at trace frames while trace is running."));
2615 if (args
== 0 || *args
== 0)
2616 { /* XXX FIXME: what should default behavior be? */
2617 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2621 if (0 != (tmp
= strchr (args
, ',')))
2623 *tmp
++ = '\0'; /* Terminate start address. */
2624 tmp
= skip_spaces (tmp
);
2625 start
= parse_and_eval_address (args
);
2626 stop
= parse_and_eval_address (tmp
);
2629 { /* No explicit end address? */
2630 start
= parse_and_eval_address (args
);
2631 stop
= start
+ 1; /* ??? */
2634 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2637 /* info scope command: list the locals for a scope. */
2639 scope_info (char *args
, int from_tty
)
2641 struct symtabs_and_lines sals
;
2643 struct minimal_symbol
*msym
;
2644 struct block
*block
;
2645 const char *symname
;
2646 char *save_args
= args
;
2647 struct block_iterator iter
;
2649 struct gdbarch
*gdbarch
;
2652 if (args
== 0 || *args
== 0)
2653 error (_("requires an argument (function, "
2654 "line or *addr) to define a scope"));
2656 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2657 if (sals
.nelts
== 0)
2658 return; /* Presumably decode_line_1 has already warned. */
2660 /* Resolve line numbers to PC. */
2661 resolve_sal_pc (&sals
.sals
[0]);
2662 block
= block_for_pc (sals
.sals
[0].pc
);
2666 QUIT
; /* Allow user to bail out with ^C. */
2667 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2669 QUIT
; /* Allow user to bail out with ^C. */
2671 printf_filtered ("Scope for %s:\n", save_args
);
2674 symname
= SYMBOL_PRINT_NAME (sym
);
2675 if (symname
== NULL
|| *symname
== '\0')
2676 continue; /* Probably botched, certainly useless. */
2678 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2680 printf_filtered ("Symbol %s is ", symname
);
2681 switch (SYMBOL_CLASS (sym
))
2684 case LOC_UNDEF
: /* Messed up symbol? */
2685 printf_filtered ("a bogus symbol, class %d.\n",
2686 SYMBOL_CLASS (sym
));
2687 count
--; /* Don't count this one. */
2690 printf_filtered ("a constant with value %s (%s)",
2691 plongest (SYMBOL_VALUE (sym
)),
2692 hex_string (SYMBOL_VALUE (sym
)));
2694 case LOC_CONST_BYTES
:
2695 printf_filtered ("constant bytes: ");
2696 if (SYMBOL_TYPE (sym
))
2697 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2698 fprintf_filtered (gdb_stdout
, " %02x",
2699 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2702 printf_filtered ("in static storage at address ");
2703 printf_filtered ("%s", paddress (gdbarch
,
2704 SYMBOL_VALUE_ADDRESS (sym
)));
2707 /* GDBARCH is the architecture associated with the objfile
2708 the symbol is defined in; the target architecture may be
2709 different, and may provide additional registers. However,
2710 we do not know the target architecture at this point.
2711 We assume the objfile architecture will contain all the
2712 standard registers that occur in debug info in that
2714 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2717 if (SYMBOL_IS_ARGUMENT (sym
))
2718 printf_filtered ("an argument in register $%s",
2719 gdbarch_register_name (gdbarch
, regno
));
2721 printf_filtered ("a local variable in register $%s",
2722 gdbarch_register_name (gdbarch
, regno
));
2725 printf_filtered ("an argument at stack/frame offset %s",
2726 plongest (SYMBOL_VALUE (sym
)));
2729 printf_filtered ("a local variable at frame offset %s",
2730 plongest (SYMBOL_VALUE (sym
)));
2733 printf_filtered ("a reference argument at offset %s",
2734 plongest (SYMBOL_VALUE (sym
)));
2736 case LOC_REGPARM_ADDR
:
2737 /* Note comment at LOC_REGISTER. */
2738 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2740 printf_filtered ("the address of an argument, in register $%s",
2741 gdbarch_register_name (gdbarch
, regno
));
2744 printf_filtered ("a typedef.\n");
2747 printf_filtered ("a label at address ");
2748 printf_filtered ("%s", paddress (gdbarch
,
2749 SYMBOL_VALUE_ADDRESS (sym
)));
2752 printf_filtered ("a function at address ");
2753 printf_filtered ("%s",
2754 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2756 case LOC_UNRESOLVED
:
2757 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2760 printf_filtered ("Unresolved Static");
2763 printf_filtered ("static storage at address ");
2764 printf_filtered ("%s",
2765 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2768 case LOC_OPTIMIZED_OUT
:
2769 printf_filtered ("optimized out.\n");
2772 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2773 BLOCK_START (block
),
2777 if (SYMBOL_TYPE (sym
))
2778 printf_filtered (", length %d.\n",
2779 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2781 if (BLOCK_FUNCTION (block
))
2784 block
= BLOCK_SUPERBLOCK (block
);
2787 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2791 /* Helper for trace_dump_command. Dump the action list starting at
2792 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2793 actions of the body of a while-stepping action. STEPPING_FRAME is
2794 set if the current traceframe was determined to be a while-stepping
2798 trace_dump_actions (struct command_line
*action
,
2799 int stepping_actions
, int stepping_frame
,
2802 const char *action_exp
, *next_comma
;
2804 for (; action
!= NULL
; action
= action
->next
)
2806 struct cmd_list_element
*cmd
;
2808 QUIT
; /* Allow user to bail out with ^C. */
2809 action_exp
= action
->line
;
2810 action_exp
= skip_spaces_const (action_exp
);
2812 /* The collection actions to be done while stepping are
2813 bracketed by the commands "while-stepping" and "end". */
2815 if (*action_exp
== '#') /* comment line */
2818 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2820 error (_("Bad action list item: %s"), action_exp
);
2822 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2826 for (i
= 0; i
< action
->body_count
; ++i
)
2827 trace_dump_actions (action
->body_list
[i
],
2828 1, stepping_frame
, from_tty
);
2830 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2832 /* Display the collected data.
2833 For the trap frame, display only what was collected at
2834 the trap. Likewise for stepping frames, display only
2835 what was collected while stepping. This means that the
2836 two boolean variables, STEPPING_FRAME and
2837 STEPPING_ACTIONS should be equal. */
2838 if (stepping_frame
== stepping_actions
)
2841 struct cleanup
*old_chain
2842 = make_cleanup (free_current_contents
, &cmd
);
2844 if (*action_exp
== '/')
2845 action_exp
= decode_agent_options (action_exp
);
2848 { /* Repeat over a comma-separated list. */
2849 QUIT
; /* Allow user to bail out with ^C. */
2850 if (*action_exp
== ',')
2852 action_exp
= skip_spaces_const (action_exp
);
2854 next_comma
= strchr (action_exp
, ',');
2856 if (0 == strncasecmp (action_exp
, "$reg", 4))
2857 registers_info (NULL
, from_tty
);
2858 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2860 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2861 locals_info (NULL
, from_tty
);
2862 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2863 args_info (NULL
, from_tty
);
2866 if (next_comma
!= NULL
)
2868 size_t len
= next_comma
- action_exp
;
2870 cmd
= xrealloc (cmd
, len
+ 1);
2871 memcpy (cmd
, action_exp
, len
);
2876 size_t len
= strlen (action_exp
);
2878 cmd
= xrealloc (cmd
, len
+ 1);
2879 memcpy (cmd
, action_exp
, len
+ 1);
2882 printf_filtered ("%s = ", cmd
);
2883 output_command_const (cmd
, from_tty
);
2884 printf_filtered ("\n");
2886 action_exp
= next_comma
;
2888 while (action_exp
&& *action_exp
== ',');
2890 do_cleanups (old_chain
);
2896 /* The tdump command. */
2899 trace_dump_command (char *args
, int from_tty
)
2901 struct regcache
*regcache
;
2902 struct tracepoint
*t
;
2903 int stepping_frame
= 0;
2904 struct bp_location
*loc
;
2905 char *default_collect_line
= NULL
;
2906 struct command_line
*actions
, *default_collect_action
= NULL
;
2907 struct cleanup
*old_chain
= NULL
;
2909 if (tracepoint_number
== -1)
2911 warning (_("No current trace frame."));
2915 t
= get_tracepoint (tracepoint_number
);
2918 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2921 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2922 tracepoint_number
, traceframe_number
);
2924 /* The current frame is a trap frame if the frame PC is equal
2925 to the tracepoint PC. If not, then the current frame was
2926 collected during single-stepping. */
2928 regcache
= get_current_regcache ();
2930 /* If the traceframe's address matches any of the tracepoint's
2931 locations, assume it is a direct hit rather than a while-stepping
2932 frame. (FIXME this is not reliable, should record each frame's
2935 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2936 if (loc
->address
== regcache_read_pc (regcache
))
2939 actions
= breakpoint_commands (&t
->base
);
2941 /* If there is a default-collect list, make up a collect command,
2942 prepend to the tracepoint's commands, and pass the whole mess to
2943 the trace dump scanner. We need to validate because
2944 default-collect might have been junked since the trace run. */
2945 if (*default_collect
)
2947 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2948 old_chain
= make_cleanup (xfree
, default_collect_line
);
2949 validate_actionline (default_collect_line
, &t
->base
);
2950 default_collect_action
= xmalloc (sizeof (struct command_line
));
2951 make_cleanup (xfree
, default_collect_action
);
2952 default_collect_action
->next
= actions
;
2953 default_collect_action
->line
= default_collect_line
;
2954 actions
= default_collect_action
;
2957 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2959 if (*default_collect
)
2960 do_cleanups (old_chain
);
2963 /* Encode a piece of a tracepoint's source-level definition in a form
2964 that is suitable for both protocol and saving in files. */
2965 /* This version does not do multiple encodes for long strings; it should
2966 return an offset to the next piece to encode. FIXME */
2969 encode_source_string (int tpnum
, ULONGEST addr
,
2970 char *srctype
, char *src
, char *buf
, int buf_size
)
2972 if (80 + strlen (srctype
) > buf_size
)
2973 error (_("Buffer too small for source encoding"));
2974 sprintf (buf
, "%x:%s:%s:%x:%x:",
2975 tpnum
, phex_nz (addr
, sizeof (addr
)),
2976 srctype
, 0, (int) strlen (src
));
2977 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2978 error (_("Source string too long for buffer"));
2979 bin2hex (src
, buf
+ strlen (buf
), 0);
2983 /* Free trace file writer. */
2986 trace_file_writer_xfree (void *arg
)
2988 struct trace_file_writer
*writer
= arg
;
2990 writer
->ops
->dtor (writer
);
2994 /* TFILE trace writer. */
2996 struct tfile_trace_file_writer
2998 struct trace_file_writer base
;
3000 /* File pointer to tfile trace file. */
3002 /* Path name of the tfile trace file. */
3006 /* This is the implementation of trace_file_write_ops method
3007 target_save. We just call the generic target
3008 target_save_trace_data to do target-side saving. */
3011 tfile_target_save (struct trace_file_writer
*self
,
3012 const char *filename
)
3014 int err
= target_save_trace_data (filename
);
3019 /* This is the implementation of trace_file_write_ops method
3023 tfile_dtor (struct trace_file_writer
*self
)
3025 struct tfile_trace_file_writer
*writer
3026 = (struct tfile_trace_file_writer
*) self
;
3028 xfree (writer
->pathname
);
3030 if (writer
->fp
!= NULL
)
3031 fclose (writer
->fp
);
3034 /* This is the implementation of trace_file_write_ops method
3035 start. It creates the trace file FILENAME and registers some
3039 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3041 struct tfile_trace_file_writer
*writer
3042 = (struct tfile_trace_file_writer
*) self
;
3044 writer
->pathname
= tilde_expand (filename
);
3045 writer
->fp
= fopen (writer
->pathname
, "wb");
3046 if (writer
->fp
== NULL
)
3047 error (_("Unable to open file '%s' for saving trace data (%s)"),
3048 filename
, safe_strerror (errno
));
3051 /* This is the implementation of trace_file_write_ops method
3052 write_header. Write the TFILE header. */
3055 tfile_write_header (struct trace_file_writer
*self
)
3057 struct tfile_trace_file_writer
*writer
3058 = (struct tfile_trace_file_writer
*) self
;
3061 /* Write a file header, with a high-bit-set char to indicate a
3062 binary file, plus a hint as what this file is, and a version
3063 number in case of future needs. */
3064 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3066 perror_with_name (writer
->pathname
);
3069 /* This is the implementation of trace_file_write_ops method
3070 write_regblock_type. Write the size of register block. */
3073 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3075 struct tfile_trace_file_writer
*writer
3076 = (struct tfile_trace_file_writer
*) self
;
3078 fprintf (writer
->fp
, "R %x\n", size
);
3081 /* This is the implementation of trace_file_write_ops method
3085 tfile_write_status (struct trace_file_writer
*self
,
3086 struct trace_status
*ts
)
3088 struct tfile_trace_file_writer
*writer
3089 = (struct tfile_trace_file_writer
*) self
;
3091 fprintf (writer
->fp
, "status %c;%s",
3092 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3093 if (ts
->stop_reason
== tracepoint_error
)
3095 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3097 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3098 fprintf (writer
->fp
, ":%s", buf
);
3100 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3101 if (ts
->traceframe_count
>= 0)
3102 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3103 if (ts
->traceframes_created
>= 0)
3104 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3105 if (ts
->buffer_free
>= 0)
3106 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3107 if (ts
->buffer_size
>= 0)
3108 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3109 if (ts
->disconnected_tracing
)
3110 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3111 if (ts
->circular_buffer
)
3112 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3113 if (ts
->notes
!= NULL
)
3115 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3117 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3118 fprintf (writer
->fp
, ";notes:%s", buf
);
3120 if (ts
->user_name
!= NULL
)
3122 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3124 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3125 fprintf (writer
->fp
, ";username:%s", buf
);
3127 fprintf (writer
->fp
, "\n");
3130 /* This is the implementation of trace_file_write_ops method
3131 write_uploaded_tsv. */
3134 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3135 struct uploaded_tsv
*utsv
)
3138 struct tfile_trace_file_writer
*writer
3139 = (struct tfile_trace_file_writer
*) self
;
3143 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3144 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3147 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3148 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3149 utsv
->builtin
, buf
);
3155 #define MAX_TRACE_UPLOAD 2000
3157 /* This is the implementation of trace_file_write_ops method
3158 write_uploaded_tp. */
3161 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3162 struct uploaded_tp
*utp
)
3164 struct tfile_trace_file_writer
*writer
3165 = (struct tfile_trace_file_writer
*) self
;
3168 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3170 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3171 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3172 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3173 if (utp
->type
== bp_fast_tracepoint
)
3174 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3176 fprintf (writer
->fp
,
3177 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3179 fprintf (writer
->fp
, "\n");
3180 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3181 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3182 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3183 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3184 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3185 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3188 encode_source_string (utp
->number
, utp
->addr
,
3189 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3190 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3192 if (utp
->cond_string
)
3194 encode_source_string (utp
->number
, utp
->addr
,
3195 "cond", utp
->cond_string
,
3196 buf
, MAX_TRACE_UPLOAD
);
3197 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3199 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3201 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3202 buf
, MAX_TRACE_UPLOAD
);
3203 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3205 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3206 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3208 phex_nz (utp
->traceframe_usage
,
3209 sizeof (utp
->traceframe_usage
)));
3212 /* This is the implementation of trace_file_write_ops method
3213 write_definition_end. */
3216 tfile_write_definition_end (struct trace_file_writer
*self
)
3218 struct tfile_trace_file_writer
*writer
3219 = (struct tfile_trace_file_writer
*) self
;
3221 fprintf (writer
->fp
, "\n");
3224 /* This is the implementation of trace_file_write_ops method
3228 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3231 struct tfile_trace_file_writer
*writer
3232 = (struct tfile_trace_file_writer
*) self
;
3234 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3235 perror_with_name (writer
->pathname
);
3238 /* This is the implementation of trace_file_write_ops method
3242 tfile_end (struct trace_file_writer
*self
)
3244 struct tfile_trace_file_writer
*writer
3245 = (struct tfile_trace_file_writer
*) self
;
3246 uint32_t gotten
= 0;
3248 /* Mark the end of trace data. */
3249 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3250 perror_with_name (writer
->pathname
);
3253 /* Operations to write trace buffers into TFILE format. */
3255 static const struct trace_file_write_ops tfile_write_ops
=
3261 tfile_write_regblock_type
,
3263 tfile_write_uploaded_tsv
,
3264 tfile_write_uploaded_tp
,
3265 tfile_write_definition_end
,
3266 tfile_write_raw_data
,
3271 /* Helper macros. */
3273 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3274 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3275 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3276 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3278 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3279 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3281 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3282 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3284 extern int trace_regblock_size
;
3286 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3287 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3288 the save is performed on the target, otherwise GDB obtains all trace
3289 data and saves it locally. */
3292 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3293 int target_does_save
)
3295 struct trace_status
*ts
= current_trace_status ();
3297 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3298 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3300 ULONGEST offset
= 0;
3301 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3303 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3305 /* If the target is to save the data to a file on its own, then just
3306 send the command and be done with it. */
3307 if (target_does_save
)
3309 if (!writer
->ops
->target_save (writer
, filename
))
3310 error (_("Target failed to save trace data to '%s'."),
3315 /* Get the trace status first before opening the file, so if the
3316 target is losing, we can get out without touching files. */
3317 status
= target_get_trace_status (ts
);
3319 writer
->ops
->start (writer
, filename
);
3321 writer
->ops
->write_header (writer
);
3323 /* Write descriptive info. */
3325 /* Write out the size of a register block. */
3326 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3328 /* Write out status of the tracing run (aka "tstatus" info). */
3329 writer
->ops
->write_status (writer
, ts
);
3331 /* Note that we want to upload tracepoints and save those, rather
3332 than simply writing out the local ones, because the user may have
3333 changed tracepoints in GDB in preparation for a future tracing
3334 run, or maybe just mass-deleted all types of breakpoints as part
3335 of cleaning up. So as not to contaminate the session, leave the
3336 data in its uploaded form, don't make into real tracepoints. */
3338 /* Get trace state variables first, they may be checked when parsing
3339 uploaded commands. */
3341 target_upload_trace_state_variables (&uploaded_tsvs
);
3343 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3344 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3346 free_uploaded_tsvs (&uploaded_tsvs
);
3348 target_upload_tracepoints (&uploaded_tps
);
3350 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3351 target_get_tracepoint_status (NULL
, utp
);
3353 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3354 writer
->ops
->write_uploaded_tp (writer
, utp
);
3356 free_uploaded_tps (&uploaded_tps
);
3358 /* Mark the end of the definition section. */
3359 writer
->ops
->write_definition_end (writer
);
3361 /* Get and write the trace data proper. */
3366 /* The writer supports writing the contents of trace buffer
3367 directly to trace file. Don't parse the contents of trace
3369 if (writer
->ops
->write_trace_buffer
!= NULL
)
3371 /* We ask for big blocks, in the hopes of efficiency, but
3372 will take less if the target has packet size limitations
3374 gotten
= target_get_raw_trace_data (buf
, offset
,
3377 error (_("Failure to get requested trace buffer data"));
3378 /* No more data is forthcoming, we're done. */
3382 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3390 /* Parse the trace buffers according to how data are stored
3391 in trace buffer in GDBserver. */
3393 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3398 /* Read the first six bytes in, which is the tracepoint
3399 number and trace frame size. */
3401 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3403 tf_size
= (uint32_t)
3404 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3406 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3415 for (block
= 0; block
< tf_size
; )
3417 gdb_byte block_type
;
3419 /* We'll fetch one block each time, in order to
3420 handle the extremely large 'M' block. We first
3421 fetch one byte to get the type of the block. */
3422 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3424 error (_("Failure to get requested trace buffer data"));
3430 block_type
= buf
[0];
3435 = target_get_raw_trace_data (buf
, offset
,
3436 trace_regblock_size
);
3437 if (gotten
< trace_regblock_size
)
3438 error (_("Failure to get requested trace"
3441 TRACE_WRITE_R_BLOCK (writer
, buf
,
3442 trace_regblock_size
);
3446 unsigned short mlen
;
3451 t
= target_get_raw_trace_data (buf
,offset
, 10);
3453 error (_("Failure to get requested trace"
3461 extract_unsigned_integer (buf
, 8,
3463 mlen
= (unsigned short)
3464 extract_unsigned_integer (&buf
[8], 2,
3467 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3470 /* The memory contents in 'M' block may be
3471 very large. Fetch the data from the target
3472 and write them into file one by one. */
3473 for (j
= 0; j
< mlen
; )
3475 unsigned int read_length
;
3477 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3478 read_length
= MAX_TRACE_UPLOAD
;
3480 read_length
= mlen
- j
;
3482 t
= target_get_raw_trace_data (buf
,
3485 if (t
< read_length
)
3486 error (_("Failure to get requested"
3487 " trace buffer data"));
3489 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3493 gotten
+= read_length
;
3504 = target_get_raw_trace_data (buf
, offset
,
3507 error (_("Failure to get requested"
3508 " trace buffer data"));
3510 vnum
= (int) extract_signed_integer (buf
,
3514 = extract_signed_integer (&buf
[4], 8,
3517 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3521 error (_("Unknown block type '%c' (0x%x) in"
3523 block_type
, block_type
);
3533 writer
->ops
->frame_ops
->end (writer
);
3537 writer
->ops
->end (writer
);
3540 /* Return a trace writer for TFILE format. */
3542 static struct trace_file_writer
*
3543 tfile_trace_file_writer_new (void)
3545 struct tfile_trace_file_writer
*writer
3546 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3548 writer
->base
.ops
= &tfile_write_ops
;
3550 writer
->pathname
= NULL
;
3552 return (struct trace_file_writer
*) writer
;
3556 trace_save_command (char *args
, int from_tty
)
3558 int target_does_save
= 0;
3560 char *filename
= NULL
;
3561 struct cleanup
*back_to
;
3562 int generate_ctf
= 0;
3563 struct trace_file_writer
*writer
= NULL
;
3566 error_no_arg (_("file in which to save trace data"));
3568 argv
= gdb_buildargv (args
);
3569 back_to
= make_cleanup_freeargv (argv
);
3571 for (; *argv
; ++argv
)
3573 if (strcmp (*argv
, "-r") == 0)
3574 target_does_save
= 1;
3575 if (strcmp (*argv
, "-ctf") == 0)
3577 else if (**argv
== '-')
3578 error (_("unknown option `%s'"), *argv
);
3584 error_no_arg (_("file in which to save trace data"));
3587 writer
= ctf_trace_file_writer_new ();
3589 writer
= tfile_trace_file_writer_new ();
3591 make_cleanup (trace_file_writer_xfree
, writer
);
3593 trace_save (filename
, writer
, target_does_save
);
3596 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3597 generate_ctf
? "directory" : "file", filename
);
3599 do_cleanups (back_to
);
3602 /* Save the trace data to file FILENAME of tfile format. */
3605 trace_save_tfile (const char *filename
, int target_does_save
)
3607 struct trace_file_writer
*writer
;
3608 struct cleanup
*back_to
;
3610 writer
= tfile_trace_file_writer_new ();
3611 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3612 trace_save (filename
, writer
, target_does_save
);
3613 do_cleanups (back_to
);
3616 /* Save the trace data to dir DIRNAME of ctf format. */
3619 trace_save_ctf (const char *dirname
, int target_does_save
)
3621 struct trace_file_writer
*writer
;
3622 struct cleanup
*back_to
;
3624 writer
= ctf_trace_file_writer_new ();
3625 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3627 trace_save (dirname
, writer
, target_does_save
);
3628 do_cleanups (back_to
);
3631 /* Tell the target what to do with an ongoing tracing run if GDB
3632 disconnects for some reason. */
3635 set_disconnected_tracing (char *args
, int from_tty
,
3636 struct cmd_list_element
*c
)
3638 target_set_disconnected_tracing (disconnected_tracing
);
3642 set_circular_trace_buffer (char *args
, int from_tty
,
3643 struct cmd_list_element
*c
)
3645 target_set_circular_trace_buffer (circular_trace_buffer
);
3649 set_trace_buffer_size (char *args
, int from_tty
,
3650 struct cmd_list_element
*c
)
3652 target_set_trace_buffer_size (trace_buffer_size
);
3656 set_trace_user (char *args
, int from_tty
,
3657 struct cmd_list_element
*c
)
3661 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3664 warning (_("Target does not support trace notes, user ignored"));
3668 set_trace_notes (char *args
, int from_tty
,
3669 struct cmd_list_element
*c
)
3673 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3676 warning (_("Target does not support trace notes, note ignored"));
3680 set_trace_stop_notes (char *args
, int from_tty
,
3681 struct cmd_list_element
*c
)
3685 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3688 warning (_("Target does not support trace notes, stop note ignored"));
3691 /* Convert the memory pointed to by mem into hex, placing result in buf.
3692 * Return a pointer to the last char put in buf (null)
3693 * "stolen" from sparc-stub.c
3696 static const char hexchars
[] = "0123456789abcdef";
3699 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3707 *buf
++ = hexchars
[ch
>> 4];
3708 *buf
++ = hexchars
[ch
& 0xf];
3717 get_traceframe_number (void)
3719 return traceframe_number
;
3722 /* Make the traceframe NUM be the current trace frame. Does nothing
3723 if NUM is already current. */
3726 set_current_traceframe (int num
)
3730 if (traceframe_number
== num
)
3732 /* Nothing to do. */
3736 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3739 warning (_("could not change traceframe"));
3741 set_traceframe_num (newnum
);
3743 /* Changing the traceframe changes our view of registers and of the
3745 registers_changed ();
3747 clear_traceframe_info ();
3750 /* Make the traceframe NUM be the current trace frame, and do nothing
3754 set_traceframe_number (int num
)
3756 traceframe_number
= num
;
3759 /* A cleanup used when switching away and back from tfind mode. */
3761 struct current_traceframe_cleanup
3763 /* The traceframe we were inspecting. */
3764 int traceframe_number
;
3768 do_restore_current_traceframe_cleanup (void *arg
)
3770 struct current_traceframe_cleanup
*old
= arg
;
3772 set_current_traceframe (old
->traceframe_number
);
3776 restore_current_traceframe_cleanup_dtor (void *arg
)
3778 struct current_traceframe_cleanup
*old
= arg
;
3784 make_cleanup_restore_current_traceframe (void)
3786 struct current_traceframe_cleanup
*old
;
3788 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3789 old
->traceframe_number
= traceframe_number
;
3791 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3792 restore_current_traceframe_cleanup_dtor
);
3796 make_cleanup_restore_traceframe_number (void)
3798 return make_cleanup_restore_integer (&traceframe_number
);
3801 /* Given a number and address, return an uploaded tracepoint with that
3802 number, creating if necessary. */
3804 struct uploaded_tp
*
3805 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3807 struct uploaded_tp
*utp
;
3809 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3810 if (utp
->number
== num
&& utp
->addr
== addr
)
3812 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3813 memset (utp
, 0, sizeof (struct uploaded_tp
));
3816 utp
->actions
= NULL
;
3817 utp
->step_actions
= NULL
;
3818 utp
->cmd_strings
= NULL
;
3825 free_uploaded_tps (struct uploaded_tp
**utpp
)
3827 struct uploaded_tp
*next_one
;
3831 next_one
= (*utpp
)->next
;
3837 /* Given a number and address, return an uploaded tracepoint with that
3838 number, creating if necessary. */
3840 static struct uploaded_tsv
*
3841 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3843 struct uploaded_tsv
*utsv
;
3845 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3846 if (utsv
->number
== num
)
3848 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3849 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3851 utsv
->next
= *utsvp
;
3857 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3859 struct uploaded_tsv
*next_one
;
3863 next_one
= (*utsvp
)->next
;
3869 /* FIXME this function is heuristic and will miss the cases where the
3870 conditional is semantically identical but differs in whitespace,
3871 such as "x == 0" vs "x==0". */
3874 cond_string_is_same (char *str1
, char *str2
)
3876 if (str1
== NULL
|| str2
== NULL
)
3877 return (str1
== str2
);
3879 return (strcmp (str1
, str2
) == 0);
3882 /* Look for an existing tracepoint that seems similar enough to the
3883 uploaded one. Enablement isn't compared, because the user can
3884 toggle that freely, and may have done so in anticipation of the
3885 next trace run. Return the location of matched tracepoint. */
3887 static struct bp_location
*
3888 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3890 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3892 struct breakpoint
*b
;
3893 struct bp_location
*loc
;
3895 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3897 struct tracepoint
*t
= (struct tracepoint
*) b
;
3899 if (b
->type
== utp
->type
3900 && t
->step_count
== utp
->step
3901 && t
->pass_count
== utp
->pass
3902 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3903 /* FIXME also test actions. */
3906 /* Scan the locations for an address match. */
3907 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3909 if (loc
->address
== utp
->addr
)
3917 /* Given a list of tracepoints uploaded from a target, attempt to
3918 match them up with existing tracepoints, and create new ones if not
3922 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3924 struct uploaded_tp
*utp
;
3925 /* A set of tracepoints which are modified. */
3926 VEC(breakpoint_p
) *modified_tp
= NULL
;
3928 struct breakpoint
*b
;
3930 /* Look for GDB tracepoints that match up with our uploaded versions. */
3931 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3933 struct bp_location
*loc
;
3934 struct tracepoint
*t
;
3936 loc
= find_matching_tracepoint_location (utp
);
3941 /* Mark this location as already inserted. */
3943 t
= (struct tracepoint
*) loc
->owner
;
3944 printf_filtered (_("Assuming tracepoint %d is same "
3945 "as target's tracepoint %d at %s.\n"),
3946 loc
->owner
->number
, utp
->number
,
3947 paddress (loc
->gdbarch
, utp
->addr
));
3949 /* The tracepoint LOC->owner was modified (the location LOC
3950 was marked as inserted in the target). Save it in
3951 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3952 observers will be notified later once for each tracepoint
3953 saved in MODIFIED_TP. */
3955 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3957 if (b
== loc
->owner
)
3963 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3967 t
= create_tracepoint_from_upload (utp
);
3969 printf_filtered (_("Created tracepoint %d for "
3970 "target's tracepoint %d at %s.\n"),
3971 t
->base
.number
, utp
->number
,
3972 paddress (get_current_arch (), utp
->addr
));
3974 printf_filtered (_("Failed to create tracepoint for target's "
3975 "tracepoint %d at %s, skipping it.\n"),
3977 paddress (get_current_arch (), utp
->addr
));
3979 /* Whether found or created, record the number used by the
3980 target, to help with mapping target tracepoints back to their
3981 counterparts here. */
3983 t
->number_on_target
= utp
->number
;
3986 /* Notify 'breakpoint-modified' observer that at least one of B's
3987 locations was changed. */
3988 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3989 observer_notify_breakpoint_modified (b
);
3991 VEC_free (breakpoint_p
, modified_tp
);
3992 free_uploaded_tps (uploaded_tps
);
3995 /* Trace state variables don't have much to identify them beyond their
3996 name, so just use that to detect matches. */
3998 static struct trace_state_variable
*
3999 find_matching_tsv (struct uploaded_tsv
*utsv
)
4004 return find_trace_state_variable (utsv
->name
);
4007 static struct trace_state_variable
*
4008 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4010 const char *namebase
;
4013 struct trace_state_variable
*tsv
;
4014 struct cleanup
*old_chain
;
4018 namebase
= utsv
->name
;
4019 buf
= xstrprintf ("%s", namebase
);
4024 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4027 /* Fish for a name that is not in use. */
4028 /* (should check against all internal vars?) */
4029 while (find_trace_state_variable (buf
))
4032 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4035 old_chain
= make_cleanup (xfree
, buf
);
4037 /* We have an available name, create the variable. */
4038 tsv
= create_trace_state_variable (buf
);
4039 tsv
->initial_value
= utsv
->initial_value
;
4040 tsv
->builtin
= utsv
->builtin
;
4042 observer_notify_tsv_created (tsv
);
4044 do_cleanups (old_chain
);
4049 /* Given a list of uploaded trace state variables, try to match them
4050 up with existing variables, or create additional ones. */
4053 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4056 struct uploaded_tsv
*utsv
;
4057 struct trace_state_variable
*tsv
;
4060 /* Most likely some numbers will have to be reassigned as part of
4061 the merge, so clear them all in anticipation. */
4062 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4065 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4067 tsv
= find_matching_tsv (utsv
);
4071 printf_filtered (_("Assuming trace state variable $%s "
4072 "is same as target's variable %d.\n"),
4073 tsv
->name
, utsv
->number
);
4077 tsv
= create_tsv_from_upload (utsv
);
4079 printf_filtered (_("Created trace state variable "
4080 "$%s for target's variable %d.\n"),
4081 tsv
->name
, utsv
->number
);
4083 /* Give precedence to numberings that come from the target. */
4085 tsv
->number
= utsv
->number
;
4088 /* Renumber everything that didn't get a target-assigned number. */
4090 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4091 if (tsv
->number
> highest
)
4092 highest
= tsv
->number
;
4095 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4096 if (tsv
->number
== 0)
4097 tsv
->number
= highest
++;
4099 free_uploaded_tsvs (uploaded_tsvs
);
4102 /* target tfile command */
4104 static struct target_ops tfile_ops
;
4106 /* Fill in tfile_ops with its defined operations and properties. */
4108 #define TRACE_HEADER_SIZE 8
4110 static char *trace_filename
;
4111 static int trace_fd
= -1;
4112 static off_t trace_frames_offset
;
4113 static off_t cur_offset
;
4114 static int cur_data_size
;
4115 int trace_regblock_size
;
4117 static void tfile_interp_line (char *line
,
4118 struct uploaded_tp
**utpp
,
4119 struct uploaded_tsv
**utsvp
);
4121 /* Read SIZE bytes into READBUF from the trace frame, starting at
4122 TRACE_FD's current position. Note that this call `read'
4123 underneath, hence it advances the file's seek position. Throws an
4124 error if the `read' syscall fails, or less than SIZE bytes are
4128 tfile_read (gdb_byte
*readbuf
, int size
)
4132 gotten
= read (trace_fd
, readbuf
, size
);
4134 perror_with_name (trace_filename
);
4135 else if (gotten
< size
)
4136 error (_("Premature end of file while reading trace file"));
4140 tfile_open (char *filename
, int from_tty
)
4142 volatile struct gdb_exception ex
;
4144 struct cleanup
*old_chain
;
4147 char header
[TRACE_HEADER_SIZE
];
4148 char linebuf
[1000]; /* Should be max remote packet size or so. */
4151 struct trace_status
*ts
;
4152 struct uploaded_tp
*uploaded_tps
= NULL
;
4153 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4155 target_preopen (from_tty
);
4157 error (_("No trace file specified."));
4159 filename
= tilde_expand (filename
);
4160 if (!IS_ABSOLUTE_PATH(filename
))
4162 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4167 old_chain
= make_cleanup (xfree
, filename
);
4169 flags
= O_BINARY
| O_LARGEFILE
;
4171 scratch_chan
= open (filename
, flags
, 0);
4172 if (scratch_chan
< 0)
4173 perror_with_name (filename
);
4175 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4177 discard_cleanups (old_chain
); /* Don't free filename any more. */
4178 unpush_target (&tfile_ops
);
4180 trace_filename
= xstrdup (filename
);
4181 trace_fd
= scratch_chan
;
4184 /* Read the file header and test for validity. */
4185 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4187 bytes
+= TRACE_HEADER_SIZE
;
4188 if (!(header
[0] == 0x7f
4189 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4190 error (_("File is not a valid trace file."));
4192 push_target (&tfile_ops
);
4194 trace_regblock_size
= 0;
4195 ts
= current_trace_status ();
4196 /* We know we're working with a file. Record its name. */
4197 ts
->filename
= trace_filename
;
4198 /* Set defaults in case there is no status line. */
4199 ts
->running_known
= 0;
4200 ts
->stop_reason
= trace_stop_reason_unknown
;
4201 ts
->traceframe_count
= -1;
4202 ts
->buffer_free
= 0;
4203 ts
->disconnected_tracing
= 0;
4204 ts
->circular_buffer
= 0;
4206 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4208 /* Read through a section of newline-terminated lines that
4209 define things like tracepoints. */
4213 tfile_read (&byte
, 1);
4218 /* Empty line marks end of the definition section. */
4223 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4226 linebuf
[i
++] = byte
;
4228 error (_("Excessively long lines in trace file"));
4231 /* Record the starting offset of the binary trace data. */
4232 trace_frames_offset
= bytes
;
4234 /* If we don't have a blocksize, we can't interpret the
4236 if (trace_regblock_size
== 0)
4237 error (_("No register block size recorded in trace file"));
4241 /* Pop the partially set up target. */
4243 throw_exception (ex
);
4246 inferior_appeared (current_inferior (), TFILE_PID
);
4247 inferior_ptid
= pid_to_ptid (TFILE_PID
);
4248 add_thread_silent (inferior_ptid
);
4250 if (ts
->traceframe_count
<= 0)
4251 warning (_("No traceframes present in this file."));
4253 /* Add the file's tracepoints and variables into the current mix. */
4255 /* Get trace state variables first, they may be checked when parsing
4256 uploaded commands. */
4257 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4259 merge_uploaded_tracepoints (&uploaded_tps
);
4261 post_create_inferior (&tfile_ops
, from_tty
);
4264 /* Interpret the given line from the definitions part of the trace
4268 tfile_interp_line (char *line
,
4269 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
4273 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4276 trace_regblock_size
= strtol (p
, &p
, 16);
4278 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4280 p
+= strlen ("status ");
4281 parse_trace_status (p
, current_trace_status ());
4283 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4285 p
+= strlen ("tp ");
4286 parse_tracepoint_definition (p
, utpp
);
4288 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4290 p
+= strlen ("tsv ");
4291 parse_tsv_definition (p
, utsvp
);
4294 warning (_("Ignoring trace file definition \"%s\""), line
);
4297 /* Parse the part of trace status syntax that is shared between
4298 the remote protocol and the trace file reader. */
4301 parse_trace_status (char *line
, struct trace_status
*ts
)
4303 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4307 ts
->running_known
= 1;
4308 ts
->running
= (*p
++ == '1');
4309 ts
->stop_reason
= trace_stop_reason_unknown
;
4310 xfree (ts
->stop_desc
);
4311 ts
->stop_desc
= NULL
;
4312 ts
->traceframe_count
= -1;
4313 ts
->traceframes_created
= -1;
4314 ts
->buffer_free
= -1;
4315 ts
->buffer_size
= -1;
4316 ts
->disconnected_tracing
= 0;
4317 ts
->circular_buffer
= 0;
4318 xfree (ts
->user_name
);
4319 ts
->user_name
= NULL
;
4322 ts
->start_time
= ts
->stop_time
= 0;
4326 p1
= strchr (p
, ':');
4328 error (_("Malformed trace status, at %s\n\
4329 Status line: '%s'\n"), p
, line
);
4330 p3
= strchr (p
, ';');
4332 p3
= p
+ strlen (p
);
4333 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4335 p
= unpack_varlen_hex (++p1
, &val
);
4336 ts
->stop_reason
= trace_buffer_full
;
4338 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4340 p
= unpack_varlen_hex (++p1
, &val
);
4341 ts
->stop_reason
= trace_never_run
;
4343 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4346 p
= unpack_varlen_hex (++p1
, &val
);
4347 ts
->stop_reason
= tracepoint_passcount
;
4348 ts
->stopping_tracepoint
= val
;
4350 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4352 p2
= strchr (++p1
, ':');
4360 ts
->stop_desc
= xmalloc (strlen (line
));
4361 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
4362 ts
->stop_desc
[end
] = '\0';
4365 ts
->stop_desc
= xstrdup ("");
4367 p
= unpack_varlen_hex (++p2
, &val
);
4368 ts
->stop_reason
= tstop_command
;
4370 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4372 p
= unpack_varlen_hex (++p1
, &val
);
4373 ts
->stop_reason
= trace_disconnected
;
4375 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4377 p2
= strchr (++p1
, ':');
4380 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4381 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
4382 ts
->stop_desc
[end
] = '\0';
4385 ts
->stop_desc
= xstrdup ("");
4387 p
= unpack_varlen_hex (++p2
, &val
);
4388 ts
->stopping_tracepoint
= val
;
4389 ts
->stop_reason
= tracepoint_error
;
4391 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4393 p
= unpack_varlen_hex (++p1
, &val
);
4394 ts
->traceframe_count
= val
;
4396 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4398 p
= unpack_varlen_hex (++p1
, &val
);
4399 ts
->traceframes_created
= val
;
4401 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4403 p
= unpack_varlen_hex (++p1
, &val
);
4404 ts
->buffer_free
= val
;
4406 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4408 p
= unpack_varlen_hex (++p1
, &val
);
4409 ts
->buffer_size
= val
;
4411 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4413 p
= unpack_varlen_hex (++p1
, &val
);
4414 ts
->disconnected_tracing
= val
;
4416 else if (strncmp (p
, "circular", p1
- p
) == 0)
4418 p
= unpack_varlen_hex (++p1
, &val
);
4419 ts
->circular_buffer
= val
;
4421 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4423 p
= unpack_varlen_hex (++p1
, &val
);
4424 ts
->start_time
= val
;
4426 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4428 p
= unpack_varlen_hex (++p1
, &val
);
4429 ts
->stop_time
= val
;
4431 else if (strncmp (p
, "username", p1
- p
) == 0)
4434 ts
->user_name
= xmalloc (strlen (p
) / 2);
4435 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
4436 ts
->user_name
[end
] = '\0';
4439 else if (strncmp (p
, "notes", p1
- p
) == 0)
4442 ts
->notes
= xmalloc (strlen (p
) / 2);
4443 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
4444 ts
->notes
[end
] = '\0';
4449 /* Silently skip unknown optional info. */
4450 p_temp
= strchr (p1
+ 1, ';');
4454 /* Must be at the end. */
4461 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4462 struct uploaded_tp
*utp
)
4465 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4467 p
= unpack_varlen_hex (p
, &uval
);
4469 tp
->base
.hit_count
+= uval
;
4471 utp
->hit_count
+= uval
;
4472 p
= unpack_varlen_hex (p
+ 1, &uval
);
4474 tp
->traceframe_usage
+= uval
;
4476 utp
->traceframe_usage
+= uval
;
4477 /* Ignore any extra, allowing for future extensions. */
4480 /* Given a line of text defining a part of a tracepoint, parse it into
4481 an "uploaded tracepoint". */
4484 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4488 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4491 char *cond
, *srctype
, *buf
;
4492 struct uploaded_tp
*utp
= NULL
;
4495 /* Both tracepoint and action definitions start with the same number
4496 and address sequence. */
4498 p
= unpack_varlen_hex (p
, &num
);
4499 p
++; /* skip a colon */
4500 p
= unpack_varlen_hex (p
, &addr
);
4501 p
++; /* skip a colon */
4504 enabled
= (*p
++ == 'E');
4505 p
++; /* skip a colon */
4506 p
= unpack_varlen_hex (p
, &step
);
4507 p
++; /* skip a colon */
4508 p
= unpack_varlen_hex (p
, &pass
);
4509 type
= bp_tracepoint
;
4511 /* Thumb through optional fields. */
4514 p
++; /* skip a colon */
4517 type
= bp_fast_tracepoint
;
4519 p
= unpack_varlen_hex (p
, &orig_size
);
4523 type
= bp_static_tracepoint
;
4529 p
= unpack_varlen_hex (p
, &xlen
);
4530 p
++; /* skip a comma */
4531 cond
= (char *) xmalloc (2 * xlen
+ 1);
4532 strncpy (cond
, p
, 2 * xlen
);
4533 cond
[2 * xlen
] = '\0';
4537 warning (_("Unrecognized char '%c' in tracepoint "
4538 "definition, skipping rest"), *p
);
4540 utp
= get_uploaded_tp (num
, addr
, utpp
);
4542 utp
->enabled
= enabled
;
4547 else if (piece
== 'A')
4549 utp
= get_uploaded_tp (num
, addr
, utpp
);
4550 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4552 else if (piece
== 'S')
4554 utp
= get_uploaded_tp (num
, addr
, utpp
);
4555 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4557 else if (piece
== 'Z')
4559 /* Parse a chunk of source form definition. */
4560 utp
= get_uploaded_tp (num
, addr
, utpp
);
4562 p
= strchr (p
, ':');
4563 p
++; /* skip a colon */
4564 p
= unpack_varlen_hex (p
, &start
);
4565 p
++; /* skip a colon */
4566 p
= unpack_varlen_hex (p
, &xlen
);
4567 p
++; /* skip a colon */
4569 buf
= alloca (strlen (line
));
4571 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4574 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4575 utp
->at_string
= xstrdup (buf
);
4576 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4577 utp
->cond_string
= xstrdup (buf
);
4578 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4579 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4581 else if (piece
== 'V')
4583 utp
= get_uploaded_tp (num
, addr
, utpp
);
4585 parse_tracepoint_status (p
, NULL
, utp
);
4589 /* Don't error out, the target might be sending us optional
4590 info that we don't care about. */
4591 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4595 /* Convert a textual description of a trace state variable into an
4599 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4602 ULONGEST num
, initval
, builtin
;
4604 struct uploaded_tsv
*utsv
= NULL
;
4606 buf
= alloca (strlen (line
));
4609 p
= unpack_varlen_hex (p
, &num
);
4610 p
++; /* skip a colon */
4611 p
= unpack_varlen_hex (p
, &initval
);
4612 p
++; /* skip a colon */
4613 p
= unpack_varlen_hex (p
, &builtin
);
4614 p
++; /* skip a colon */
4615 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4618 utsv
= get_uploaded_tsv (num
, utsvp
);
4619 utsv
->initial_value
= initval
;
4620 utsv
->builtin
= builtin
;
4621 utsv
->name
= xstrdup (buf
);
4624 /* Close the trace file and generally clean up. */
4627 tfile_close (int quitting
)
4634 pid
= ptid_get_pid (inferior_ptid
);
4635 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4636 exit_inferior_silent (pid
);
4640 xfree (trace_filename
);
4641 trace_filename
= NULL
;
4645 tfile_files_info (struct target_ops
*t
)
4647 printf_filtered ("\t`%s'\n", trace_filename
);
4650 /* The trace status for a file is that tracing can never be run. */
4653 tfile_get_trace_status (struct trace_status
*ts
)
4655 /* Other bits of trace status were collected as part of opening the
4656 trace files, so nothing to do here. */
4662 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4664 /* Other bits of trace status were collected as part of opening the
4665 trace files, so nothing to do here. */
4668 /* Given the position of a traceframe in the file, figure out what
4669 address the frame was collected at. This would normally be the
4670 value of a collected PC register, but if not available, we
4674 tfile_get_traceframe_address (off_t tframe_offset
)
4678 struct tracepoint
*tp
;
4679 off_t saved_offset
= cur_offset
;
4681 /* FIXME dig pc out of collected registers. */
4683 /* Fall back to using tracepoint address. */
4684 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4685 tfile_read ((gdb_byte
*) &tpnum
, 2);
4686 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4688 (target_gdbarch ()));
4690 tp
= get_tracepoint_by_number_on_target (tpnum
);
4691 /* FIXME this is a poor heuristic if multiple locations. */
4692 if (tp
&& tp
->base
.loc
)
4693 addr
= tp
->base
.loc
->address
;
4695 /* Restore our seek position. */
4696 cur_offset
= saved_offset
;
4697 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4701 /* Given a type of search and some parameters, scan the collection of
4702 traceframes in the file looking for a match. When found, return
4703 both the traceframe and tracepoint number, otherwise -1 for
4707 tfile_trace_find (enum trace_find_type type
, int num
,
4708 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4711 int tfnum
= 0, found
= 0;
4712 unsigned int data_size
;
4713 struct tracepoint
*tp
;
4714 off_t offset
, tframe_offset
;
4724 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4725 offset
= trace_frames_offset
;
4728 tframe_offset
= offset
;
4729 tfile_read ((gdb_byte
*) &tpnum
, 2);
4730 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4732 (target_gdbarch ()));
4736 tfile_read ((gdb_byte
*) &data_size
, 4);
4737 data_size
= (unsigned int) extract_unsigned_integer
4738 ((gdb_byte
*) &data_size
, 4,
4739 gdbarch_byte_order (target_gdbarch ()));
4742 if (type
== tfind_number
)
4744 /* Looking for a specific trace frame. */
4750 /* Start from the _next_ trace frame. */
4751 if (tfnum
> traceframe_number
)
4756 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4757 if (tfaddr
== addr1
)
4761 tp
= get_tracepoint (num
);
4762 if (tp
&& tpnum
== tp
->number_on_target
)
4766 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4767 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4771 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4772 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4776 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4785 cur_offset
= offset
;
4786 cur_data_size
= data_size
;
4790 /* Skip past the traceframe's data. */
4791 lseek (trace_fd
, data_size
, SEEK_CUR
);
4792 offset
+= data_size
;
4793 /* Update our own count of traceframes. */
4796 /* Did not find what we were looking for. */
4802 /* Prototype of the callback passed to tframe_walk_blocks. */
4803 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4805 /* Callback for traceframe_walk_blocks, used to find a given block
4806 type in a traceframe. */
4809 match_blocktype (char blocktype
, void *data
)
4811 char *wantedp
= data
;
4813 if (*wantedp
== blocktype
)
4819 /* Walk over all traceframe block starting at POS offset from
4820 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4821 unmodified. If CALLBACK returns true, this returns the position in
4822 the traceframe where the block is found, relative to the start of
4823 the traceframe (cur_offset). Returns -1 if no callback call
4824 returned true, indicating that all blocks have been walked. */
4827 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4828 int pos
, void *data
)
4830 /* Iterate through a traceframe's blocks, looking for a block of the
4833 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4834 while (pos
< cur_data_size
)
4836 unsigned short mlen
;
4839 tfile_read (&block_type
, 1);
4843 if ((*callback
) (block_type
, data
))
4849 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4850 pos
+= trace_regblock_size
;
4853 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4854 tfile_read ((gdb_byte
*) &mlen
, 2);
4855 mlen
= (unsigned short)
4856 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4858 (target_gdbarch ()));
4859 lseek (trace_fd
, mlen
, SEEK_CUR
);
4860 pos
+= (8 + 2 + mlen
);
4863 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4867 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4868 block_type
, block_type
);
4876 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4877 position offset of a block of type TYPE_WANTED in the current trace
4878 frame, starting at POS. Returns -1 if no such block was found. */
4881 traceframe_find_block_type (char type_wanted
, int pos
)
4883 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4886 /* Look for a block of saved registers in the traceframe, and get the
4887 requested register from it. */
4890 tfile_fetch_registers (struct target_ops
*ops
,
4891 struct regcache
*regcache
, int regno
)
4893 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4894 int offset
, regn
, regsize
, pc_regno
;
4897 /* An uninitialized reg size says we're not going to be
4898 successful at getting register blocks. */
4899 if (!trace_regblock_size
)
4902 regs
= alloca (trace_regblock_size
);
4904 if (traceframe_find_block_type ('R', 0) >= 0)
4906 tfile_read (regs
, trace_regblock_size
);
4908 /* Assume the block is laid out in GDB register number order,
4909 each register with the size that it has in GDB. */
4911 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4913 regsize
= register_size (gdbarch
, regn
);
4914 /* Make sure we stay within block bounds. */
4915 if (offset
+ regsize
>= trace_regblock_size
)
4917 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4921 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4924 else if (regno
== -1)
4926 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4934 /* We get here if no register data has been found. Mark registers
4936 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4937 regcache_raw_supply (regcache
, regn
, NULL
);
4939 /* We can often usefully guess that the PC is going to be the same
4940 as the address of the tracepoint. */
4941 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4942 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4944 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4946 if (tp
&& tp
->base
.loc
)
4948 /* But don't try to guess if tracepoint is multi-location... */
4949 if (tp
->base
.loc
->next
)
4951 warning (_("Tracepoint %d has multiple "
4952 "locations, cannot infer $pc"),
4956 /* ... or does while-stepping. */
4957 if (tp
->step_count
> 0)
4959 warning (_("Tracepoint %d does while-stepping, "
4960 "cannot infer $pc"),
4965 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4966 gdbarch_byte_order (gdbarch
),
4967 tp
->base
.loc
->address
);
4968 regcache_raw_supply (regcache
, pc_regno
, regs
);
4974 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4975 const char *annex
, gdb_byte
*readbuf
,
4976 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4978 /* We're only doing regular memory for now. */
4979 if (object
!= TARGET_OBJECT_MEMORY
)
4982 if (readbuf
== NULL
)
4983 error (_("tfile_xfer_partial: trace file is read-only"));
4985 if (traceframe_number
!= -1)
4989 /* Iterate through the traceframe's blocks, looking for
4991 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4993 ULONGEST maddr
, amt
;
4994 unsigned short mlen
;
4995 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
4997 tfile_read ((gdb_byte
*) &maddr
, 8);
4998 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5000 tfile_read ((gdb_byte
*) &mlen
, 2);
5001 mlen
= (unsigned short)
5002 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5004 /* If the block includes the first part of the desired
5005 range, return as much it has; GDB will re-request the
5006 remainder, which might be in a different block of this
5008 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5010 amt
= (maddr
+ mlen
) - offset
;
5014 if (maddr
!= offset
)
5015 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5016 tfile_read (readbuf
, amt
);
5020 /* Skip over this block. */
5021 pos
+= (8 + 2 + mlen
);
5025 /* It's unduly pedantic to refuse to look at the executable for
5026 read-only pieces; so do the equivalent of readonly regions aka
5028 /* FIXME account for relocation at some point. */
5035 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5037 if ((s
->flags
& SEC_LOAD
) == 0
5038 || (s
->flags
& SEC_READONLY
) == 0)
5042 size
= bfd_get_section_size (s
);
5043 if (vma
<= offset
&& offset
< (vma
+ size
))
5047 amt
= (vma
+ size
) - offset
;
5051 amt
= bfd_get_section_contents (exec_bfd
, s
,
5052 readbuf
, offset
- vma
, amt
);
5058 /* Indicate failure to find the requested memory block. */
5062 /* Iterate through the blocks of a trace frame, looking for a 'V'
5063 block with a matching tsv number. */
5066 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5071 /* Iterate over blocks in current frame and find the last 'V'
5072 block in which tsv number is TSVNUM. In one trace frame, there
5073 may be multiple 'V' blocks created for a given trace variable,
5074 and the last matched 'V' block contains the updated value. */
5076 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5080 tfile_read ((gdb_byte
*) &vnum
, 4);
5081 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5083 (target_gdbarch ()));
5086 tfile_read ((gdb_byte
*) val
, 8);
5087 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5089 (target_gdbarch ()));
5099 tfile_has_all_memory (struct target_ops
*ops
)
5105 tfile_has_memory (struct target_ops
*ops
)
5111 tfile_has_stack (struct target_ops
*ops
)
5113 return traceframe_number
!= -1;
5117 tfile_has_registers (struct target_ops
*ops
)
5119 return traceframe_number
!= -1;
5123 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
5128 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5129 object for the tfile target's current traceframe. */
5132 build_traceframe_info (char blocktype
, void *data
)
5134 struct traceframe_info
*info
= data
;
5140 struct mem_range
*r
;
5142 unsigned short mlen
;
5144 tfile_read ((gdb_byte
*) &maddr
, 8);
5145 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5147 (target_gdbarch ()));
5148 tfile_read ((gdb_byte
*) &mlen
, 2);
5149 mlen
= (unsigned short)
5150 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5151 2, gdbarch_byte_order
5152 (target_gdbarch ()));
5154 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5167 warning (_("Unhandled trace block type (%d) '%c ' "
5168 "while building trace frame info."),
5169 blocktype
, blocktype
);
5176 static struct traceframe_info
*
5177 tfile_traceframe_info (void)
5179 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5181 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5186 init_tfile_ops (void)
5188 tfile_ops
.to_shortname
= "tfile";
5189 tfile_ops
.to_longname
= "Local trace dump file";
5191 = "Use a trace file as a target. Specify the filename of the trace file.";
5192 tfile_ops
.to_open
= tfile_open
;
5193 tfile_ops
.to_close
= tfile_close
;
5194 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5195 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5196 tfile_ops
.to_files_info
= tfile_files_info
;
5197 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5198 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5199 tfile_ops
.to_trace_find
= tfile_trace_find
;
5200 tfile_ops
.to_get_trace_state_variable_value
5201 = tfile_get_trace_state_variable_value
;
5202 tfile_ops
.to_stratum
= process_stratum
;
5203 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5204 tfile_ops
.to_has_memory
= tfile_has_memory
;
5205 tfile_ops
.to_has_stack
= tfile_has_stack
;
5206 tfile_ops
.to_has_registers
= tfile_has_registers
;
5207 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5208 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
5209 tfile_ops
.to_magic
= OPS_MAGIC
;
5213 free_current_marker (void *arg
)
5215 struct static_tracepoint_marker
**marker_p
= arg
;
5217 if (*marker_p
!= NULL
)
5219 release_static_tracepoint_marker (*marker_p
);
5226 /* Given a line of text defining a static tracepoint marker, parse it
5227 into a "static tracepoint marker" object. Throws an error is
5228 parsing fails. If PP is non-null, it points to one past the end of
5229 the parsed marker definition. */
5232 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5233 struct static_tracepoint_marker
*marker
)
5240 p
= unpack_varlen_hex (p
, &addr
);
5241 p
++; /* skip a colon */
5243 marker
->gdbarch
= target_gdbarch ();
5244 marker
->address
= (CORE_ADDR
) addr
;
5246 endp
= strchr (p
, ':');
5248 error (_("bad marker definition: %s"), line
);
5250 marker
->str_id
= xmalloc (endp
- p
+ 1);
5251 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5252 marker
->str_id
[end
] = '\0';
5255 p
++; /* skip a colon */
5257 marker
->extra
= xmalloc (strlen (p
) + 1);
5258 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5259 marker
->extra
[end
] = '\0';
5265 /* Release a static tracepoint marker's contents. Note that the
5266 object itself isn't released here. There objects are usually on
5270 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5272 xfree (marker
->str_id
);
5273 marker
->str_id
= NULL
;
5276 /* Print MARKER to gdb_stdout. */
5279 print_one_static_tracepoint_marker (int count
,
5280 struct static_tracepoint_marker
*marker
)
5282 struct command_line
*l
;
5285 char wrap_indent
[80];
5286 char extra_field_indent
[80];
5287 struct ui_out
*uiout
= current_uiout
;
5288 struct cleanup
*bkpt_chain
;
5289 VEC(breakpoint_p
) *tracepoints
;
5291 struct symtab_and_line sal
;
5295 sal
.pc
= marker
->address
;
5297 tracepoints
= static_tracepoints_here (marker
->address
);
5299 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5301 /* A counter field to help readability. This is not a stable
5303 ui_out_field_int (uiout
, "count", count
);
5305 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5307 ui_out_field_fmt (uiout
, "enabled", "%c",
5308 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5309 ui_out_spaces (uiout
, 2);
5311 strcpy (wrap_indent
, " ");
5313 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5314 strcat (wrap_indent
, " ");
5316 strcat (wrap_indent
, " ");
5318 strcpy (extra_field_indent
, " ");
5320 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5322 sal
= find_pc_line (marker
->address
, 0);
5323 sym
= find_pc_sect_function (marker
->address
, NULL
);
5326 ui_out_text (uiout
, "in ");
5327 ui_out_field_string (uiout
, "func",
5328 SYMBOL_PRINT_NAME (sym
));
5329 ui_out_wrap_hint (uiout
, wrap_indent
);
5330 ui_out_text (uiout
, " at ");
5333 ui_out_field_skip (uiout
, "func");
5335 if (sal
.symtab
!= NULL
)
5337 ui_out_field_string (uiout
, "file",
5338 symtab_to_filename_for_display (sal
.symtab
));
5339 ui_out_text (uiout
, ":");
5341 if (ui_out_is_mi_like_p (uiout
))
5343 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5345 ui_out_field_string (uiout
, "fullname", fullname
);
5348 ui_out_field_skip (uiout
, "fullname");
5350 ui_out_field_int (uiout
, "line", sal
.line
);
5354 ui_out_field_skip (uiout
, "fullname");
5355 ui_out_field_skip (uiout
, "line");
5358 ui_out_text (uiout
, "\n");
5359 ui_out_text (uiout
, extra_field_indent
);
5360 ui_out_text (uiout
, _("Data: \""));
5361 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5362 ui_out_text (uiout
, "\"\n");
5364 if (!VEC_empty (breakpoint_p
, tracepoints
))
5366 struct cleanup
*cleanup_chain
;
5368 struct breakpoint
*b
;
5370 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5373 ui_out_text (uiout
, extra_field_indent
);
5374 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5375 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5378 ui_out_text (uiout
, ", ");
5379 ui_out_text (uiout
, "#");
5380 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5383 do_cleanups (cleanup_chain
);
5385 if (ui_out_is_mi_like_p (uiout
))
5386 ui_out_field_int (uiout
, "number-of-tracepoints",
5387 VEC_length(breakpoint_p
, tracepoints
));
5389 ui_out_text (uiout
, "\n");
5391 VEC_free (breakpoint_p
, tracepoints
);
5393 do_cleanups (bkpt_chain
);
5397 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5399 VEC(static_tracepoint_marker_p
) *markers
;
5400 struct cleanup
*old_chain
;
5401 struct static_tracepoint_marker
*marker
;
5402 struct ui_out
*uiout
= current_uiout
;
5405 /* We don't have to check target_can_use_agent and agent's capability on
5406 static tracepoint here, in order to be compatible with older GDBserver.
5407 We don't check USE_AGENT is true or not, because static tracepoints
5408 don't work without in-process agent, so we don't bother users to type
5409 `set agent on' when to use static tracepoint. */
5412 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5413 "StaticTracepointMarkersTable");
5415 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5417 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5419 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5420 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5421 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5423 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5424 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5426 ui_out_table_body (uiout
);
5428 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5429 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5432 VEC_iterate (static_tracepoint_marker_p
,
5433 markers
, i
, marker
);
5436 print_one_static_tracepoint_marker (i
+ 1, marker
);
5437 release_static_tracepoint_marker (marker
);
5440 do_cleanups (old_chain
);
5443 /* The $_sdata convenience variable is a bit special. We don't know
5444 for sure type of the value until we actually have a chance to fetch
5445 the data --- the size of the object depends on what has been
5446 collected. We solve this by making $_sdata be an internalvar that
5447 creates a new value on access. */
5449 /* Return a new value with the correct type for the sdata object of
5450 the current trace frame. Return a void value if there's no object
5453 static struct value
*
5454 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5460 /* We need to read the whole object before we know its size. */
5461 size
= target_read_alloc (¤t_target
,
5462 TARGET_OBJECT_STATIC_TRACE_DATA
,
5469 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5471 v
= allocate_value (type
);
5472 memcpy (value_contents_raw (v
), buf
, size
);
5477 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5480 #if !defined(HAVE_LIBEXPAT)
5482 struct traceframe_info
*
5483 parse_traceframe_info (const char *tframe_info
)
5485 static int have_warned
;
5490 warning (_("Can not parse XML trace frame info; XML support "
5491 "was disabled at compile time"));
5497 #else /* HAVE_LIBEXPAT */
5499 #include "xml-support.h"
5501 /* Handle the start of a <memory> element. */
5504 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5505 const struct gdb_xml_element
*element
,
5506 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5508 struct traceframe_info
*info
= user_data
;
5509 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5510 ULONGEST
*start_p
, *length_p
;
5512 start_p
= xml_find_attribute (attributes
, "start")->value
;
5513 length_p
= xml_find_attribute (attributes
, "length")->value
;
5515 r
->start
= *start_p
;
5516 r
->length
= *length_p
;
5519 /* Discard the constructed trace frame info (if an error occurs). */
5522 free_result (void *p
)
5524 struct traceframe_info
*result
= p
;
5526 free_traceframe_info (result
);
5529 /* The allowed elements and attributes for an XML memory map. */
5531 static const struct gdb_xml_attribute memory_attributes
[] = {
5532 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5533 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5534 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5537 static const struct gdb_xml_element traceframe_info_children
[] = {
5538 { "memory", memory_attributes
, NULL
,
5539 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5540 traceframe_info_start_memory
, NULL
},
5541 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5544 static const struct gdb_xml_element traceframe_info_elements
[] = {
5545 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5547 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5550 /* Parse a traceframe-info XML document. */
5552 struct traceframe_info
*
5553 parse_traceframe_info (const char *tframe_info
)
5555 struct traceframe_info
*result
;
5556 struct cleanup
*back_to
;
5558 result
= XCNEW (struct traceframe_info
);
5559 back_to
= make_cleanup (free_result
, result
);
5561 if (gdb_xml_parse_quick (_("trace frame info"),
5562 "traceframe-info.dtd", traceframe_info_elements
,
5563 tframe_info
, result
) == 0)
5565 /* Parsed successfully, keep the result. */
5566 discard_cleanups (back_to
);
5571 do_cleanups (back_to
);
5575 #endif /* HAVE_LIBEXPAT */
5577 /* Returns the traceframe_info object for the current traceframe.
5578 This is where we avoid re-fetching the object from the target if we
5579 already have it cached. */
5581 static struct traceframe_info
*
5582 get_traceframe_info (void)
5584 if (traceframe_info
== NULL
)
5585 traceframe_info
= target_traceframe_info ();
5587 return traceframe_info
;
5590 /* If the target supports the query, return in RESULT the set of
5591 collected memory in the current traceframe, found within the LEN
5592 bytes range starting at MEMADDR. Returns true if the target
5593 supports the query, otherwise returns false, and RESULT is left
5597 traceframe_available_memory (VEC(mem_range_s
) **result
,
5598 CORE_ADDR memaddr
, ULONGEST len
)
5600 struct traceframe_info
*info
= get_traceframe_info ();
5604 struct mem_range
*r
;
5609 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5610 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5612 ULONGEST lo1
, hi1
, lo2
, hi2
;
5613 struct mem_range
*nr
;
5616 hi1
= memaddr
+ len
;
5619 hi2
= r
->start
+ r
->length
;
5621 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5623 nr
->start
= max (lo1
, lo2
);
5624 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5627 normalize_mem_ranges (*result
);
5634 /* Implementation of `sdata' variable. */
5636 static const struct internalvar_funcs sdata_funcs
=
5643 /* module initialization */
5645 _initialize_tracepoint (void)
5647 struct cmd_list_element
*c
;
5649 /* Explicitly create without lookup, since that tries to create a
5650 value with a void typed value, and when we get here, gdbarch
5651 isn't initialized yet. At this point, we're quite sure there
5652 isn't another convenience variable of the same name. */
5653 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5655 traceframe_number
= -1;
5656 tracepoint_number
= -1;
5658 if (tracepoint_list
.list
== NULL
)
5660 tracepoint_list
.listsize
= 128;
5661 tracepoint_list
.list
= xmalloc
5662 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5664 if (tracepoint_list
.aexpr_list
== NULL
)
5666 tracepoint_list
.aexpr_listsize
= 128;
5667 tracepoint_list
.aexpr_list
= xmalloc
5668 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5671 if (stepping_list
.list
== NULL
)
5673 stepping_list
.listsize
= 128;
5674 stepping_list
.list
= xmalloc
5675 (stepping_list
.listsize
* sizeof (struct memrange
));
5678 if (stepping_list
.aexpr_list
== NULL
)
5680 stepping_list
.aexpr_listsize
= 128;
5681 stepping_list
.aexpr_list
= xmalloc
5682 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5685 add_info ("scope", scope_info
,
5686 _("List the variables local to a scope"));
5688 add_cmd ("tracepoints", class_trace
, NULL
,
5689 _("Tracing of program execution without stopping the program."),
5692 add_com ("tdump", class_trace
, trace_dump_command
,
5693 _("Print everything collected at the current tracepoint."));
5695 add_com ("tsave", class_trace
, trace_save_command
, _("\
5696 Save the trace data to a file.\n\
5697 Use the '-ctf' option to save the data to CTF format.\n\
5698 Use the '-r' option to direct the target to save directly to the file,\n\
5699 using its own filesystem."));
5701 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5702 Define a trace state variable.\n\
5703 Argument is a $-prefixed name, optionally followed\n\
5704 by '=' and an expression that sets the initial value\n\
5705 at the start of tracing."));
5706 set_cmd_completer (c
, expression_completer
);
5708 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5709 Delete one or more trace state variables.\n\
5710 Arguments are the names of the variables to delete.\n\
5711 If no arguments are supplied, delete all variables."), &deletelist
);
5712 /* FIXME add a trace variable completer. */
5714 add_info ("tvariables", tvariables_info
, _("\
5715 Status of trace state variables and their values.\n\
5718 add_info ("static-tracepoint-markers",
5719 info_static_tracepoint_markers_command
, _("\
5720 List target static tracepoints markers.\n\
5723 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5724 Select a trace frame;\n\
5725 No argument means forward by one frame; '-' means backward by one frame."),
5726 &tfindlist
, "tfind ", 1, &cmdlist
);
5728 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5729 Select a trace frame whose PC is outside the given range (exclusive).\n\
5730 Usage: tfind outside addr1, addr2"),
5733 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5734 Select a trace frame whose PC is in the given range (inclusive).\n\
5735 Usage: tfind range addr1,addr2"),
5738 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5739 Select a trace frame by source line.\n\
5740 Argument can be a line number (with optional source file),\n\
5741 a function name, or '*' followed by an address.\n\
5742 Default argument is 'the next source line that was traced'."),
5745 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5746 Select a trace frame by tracepoint number.\n\
5747 Default is the tracepoint for the current trace frame."),
5750 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5751 Select a trace frame by PC.\n\
5752 Default is the current PC, or the PC of the current trace frame."),
5755 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5756 De-select any trace frame and resume 'live' debugging."),
5759 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5761 add_cmd ("start", class_trace
, trace_find_start_command
,
5762 _("Select the first trace frame in the trace buffer."),
5765 add_com ("tstatus", class_trace
, trace_status_command
,
5766 _("Display the status of the current trace data collection."));
5768 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5769 Stop trace data collection.\n\
5770 Usage: tstop [ <notes> ... ]\n\
5771 Any arguments supplied are recorded with the trace as a stop reason and\n\
5772 reported by tstatus (if the target supports trace notes)."));
5774 add_com ("tstart", class_trace
, trace_start_command
, _("\
5775 Start trace data collection.\n\
5776 Usage: tstart [ <notes> ... ]\n\
5777 Any arguments supplied are recorded with the trace as a note and\n\
5778 reported by tstatus (if the target supports trace notes)."));
5780 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5781 Ends a list of commands or actions.\n\
5782 Several GDB commands allow you to enter a list of commands or actions.\n\
5783 Entering \"end\" on a line by itself is the normal way to terminate\n\
5785 Note: the \"end\" command cannot be used at the gdb prompt."));
5787 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5788 Specify single-stepping behavior at a tracepoint.\n\
5789 Argument is number of instructions to trace in single-step mode\n\
5790 following the tracepoint. This command is normally followed by\n\
5791 one or more \"collect\" commands, to specify what to collect\n\
5792 while single-stepping.\n\n\
5793 Note: this command can only be used in a tracepoint \"actions\" list."));
5795 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5796 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5798 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5799 Specify one or more data items to be collected at a tracepoint.\n\
5800 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5801 collect all data (variables, registers) referenced by that expression.\n\
5802 Also accepts the following special arguments:\n\
5803 $regs -- all registers.\n\
5804 $args -- all function arguments.\n\
5805 $locals -- all variables local to the block/function scope.\n\
5806 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5807 Note: this command can only be used in a tracepoint \"actions\" list."));
5809 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5810 Specify one or more expressions to be evaluated at a tracepoint.\n\
5811 Accepts a comma-separated list of (one or more) expressions.\n\
5812 The result of each evaluation will be discarded.\n\
5813 Note: this command can only be used in a tracepoint \"actions\" list."));
5815 add_com ("actions", class_trace
, trace_actions_command
, _("\
5816 Specify the actions to be taken at a tracepoint.\n\
5817 Tracepoint actions may include collecting of specified data,\n\
5818 single-stepping, or enabling/disabling other tracepoints,\n\
5819 depending on target's capabilities."));
5821 default_collect
= xstrdup ("");
5822 add_setshow_string_cmd ("default-collect", class_trace
,
5823 &default_collect
, _("\
5824 Set the list of expressions to collect by default"), _("\
5825 Show the list of expressions to collect by default"), NULL
,
5827 &setlist
, &showlist
);
5829 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5830 &disconnected_tracing
, _("\
5831 Set whether tracing continues after GDB disconnects."), _("\
5832 Show whether tracing continues after GDB disconnects."), _("\
5833 Use this to continue a tracing run even if GDB disconnects\n\
5834 or detaches from the target. You can reconnect later and look at\n\
5835 trace data collected in the meantime."),
5836 set_disconnected_tracing
,
5841 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5842 &circular_trace_buffer
, _("\
5843 Set target's use of circular trace buffer."), _("\
5844 Show target's use of circular trace buffer."), _("\
5845 Use this to make the trace buffer into a circular buffer,\n\
5846 which will discard traceframes (oldest first) instead of filling\n\
5847 up and stopping the trace run."),
5848 set_circular_trace_buffer
,
5853 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5854 &trace_buffer_size
, _("\
5855 Set requested size of trace buffer."), _("\
5856 Show requested size of trace buffer."), _("\
5857 Use this to choose a size for the trace buffer. Some targets\n\
5858 may have fixed or limited buffer sizes. A value of -1 disables\n\
5859 any attempt to set the buffer size and lets the target choose."),
5860 set_trace_buffer_size
, NULL
,
5861 &setlist
, &showlist
);
5863 add_setshow_string_cmd ("trace-user", class_trace
,
5865 Set the user name to use for current and future trace runs"), _("\
5866 Show the user name to use for current and future trace runs"), NULL
,
5867 set_trace_user
, NULL
,
5868 &setlist
, &showlist
);
5870 add_setshow_string_cmd ("trace-notes", class_trace
,
5872 Set notes string to use for current and future trace runs"), _("\
5873 Show the notes string to use for current and future trace runs"), NULL
,
5874 set_trace_notes
, NULL
,
5875 &setlist
, &showlist
);
5877 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5878 &trace_stop_notes
, _("\
5879 Set notes string to use for future tstop commands"), _("\
5880 Show the notes string to use for future tstop commands"), NULL
,
5881 set_trace_stop_notes
, NULL
,
5882 &setlist
, &showlist
);
5886 add_target (&tfile_ops
);